Skip to content

Admin forms

hypha.apply.funds.admin_forms

WorkflowFormAdminForm

Bases: WagtailAdminPageForm

clean 

clean()
Source code in hypha/apply/funds/admin_forms.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def clean(self):
    cleaned_data = super().clean()

    workflow = WORKFLOWS[cleaned_data["workflow_name"]]
    application_forms = self.formsets["forms"]
    review_forms = self.formsets["review_forms"]
    external_review_forms = self.formsets["external_review_forms"]
    determination_forms = self.formsets["determination_forms"]
    paf_forms = self.formsets["approval_forms"]
    number_of_stages = len(workflow.stages)

    self.validate_application_forms(workflow, application_forms)
    if number_of_stages == 1:
        self.validate_stages_equal_forms(workflow, application_forms)
    self.validate_stages_equal_forms(
        workflow, review_forms, form_type="Review form"
    )
    self.validate_stages_equal_forms(
        workflow, external_review_forms, form_type="External Review form"
    )
    self.validate_stages_equal_forms(
        workflow, determination_forms, form_type="Determination form"
    )
    self.validate_paf_form(paf_forms)

    return cleaned_data

validate_application_forms 

validate_application_forms(workflow, forms)

Application forms are not equal to the number of stages like review forms. Now, staff can select a proposal form from multiple forms list in stage 2.

Source code in hypha/apply/funds/admin_forms.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def validate_application_forms(self, workflow, forms):
    """
    Application forms are not equal to the number of stages like review forms.
    Now, staff can select a proposal form from multiple forms list in stage 2.
    """
    if forms.is_valid():
        valid_forms = [form for form in forms if not form.cleaned_data["DELETE"]]
        forms_stages = [form.cleaned_data["stage"] for form in valid_forms]
        stages_counter = Counter(forms_stages)

        number_of_stages = len(workflow.stages)
        error_list = []

        for stage in range(1, number_of_stages + 1):
            is_form_present = True if stages_counter.get(stage, 0) > 0 else False
            if not is_form_present:
                error_list.append(f"Please provide form for Stage {stage}.")

            if stage == 1 and stages_counter.get(stage, 0) > 1:
                error_list.append("Only 1 form can be selected for 1st Stage.")

        if error_list:
            self.add_error(
                None,
                error_list,
            )

validate_stages_equal_forms 

validate_stages_equal_forms(workflow, forms, form_type='form')
Source code in hypha/apply/funds/admin_forms.py 
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def validate_stages_equal_forms(self, workflow, forms, form_type="form"):
    if forms.is_valid():
        valid_forms = [form for form in forms if not form.cleaned_data["DELETE"]]
        number_of_forms = len(valid_forms)
        plural_form = "s" if number_of_forms > 1 else ""

        number_of_stages = len(workflow.stages)
        plural_stage = "s" if number_of_stages > 1 else ""

        # External Review Form is optional and should be single if provided
        if form_type == "External Review form":
            if number_of_forms > 1:
                self.add_error(
                    None,
                    f"Number of {form_type}s should not be more than one: "
                    f"{number_of_forms} {form_type}{plural_form} provided",
                )
                return
            else:
                return

        if number_of_forms != number_of_stages:
            self.add_error(
                None,
                f"Number of {form_type}s does not match number of stages: "
                f"{number_of_stages} stage{plural_stage} and {number_of_forms} "
                f"{form_type}{plural_form} provided",
            )

            for form in valid_forms[number_of_stages:]:
                form.add_error(
                    "form",
                    "Exceeds required number of forms for stage, please remove.",
                )

validate_paf_form 

validate_paf_form(forms)
Source code in hypha/apply/funds/admin_forms.py 
102
103
104
105
106
def validate_paf_form(self, forms):
    if forms.is_valid():
        valid_forms = [form for form in forms if not form.cleaned_data["DELETE"]]
        if settings.PROJECTS_ENABLED and not valid_forms:
            self.add_error(None, _("Please provide Project Form."))

RoundBasePageAdminForm

Bases: WagtailAdminPageForm

clean 

clean()
Source code in hypha/apply/funds/admin_forms.py 
110
111
112
113
114
115
116
117
def clean(self):
    cleaned_data = super().clean()

    start_date = cleaned_data["start_date"]
    if not start_date:
        self.add_error("start_date", "Please select start date.")

    return cleaned_data

ScreeningStatusAdminForm

Bases: WagtailAdminModelForm

save 

save(commit=True)
Source code in hypha/apply/funds/admin_forms.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def save(self, commit=True):
    default = self.cleaned_data["default"]
    yes = self.cleaned_data["yes"]
    ScreeningStatus = apps.get_model("funds", "ScreeningStatus")
    if default:
        try:
            default_screening = ScreeningStatus.objects.get(
                default=default, yes=yes
            )
        except ScreeningStatus.DoesNotExist:
            pass
        else:
            screening = super().save(commit)
            if default_screening.id != screening.id:
                submissions = ApplicationSubmission.objects.filter(
                    screening_statuses__id=default_screening.id
                )
                for submission in submissions:
                    submission.screening_statuses.remove(default_screening)
                    submission.screening_statuses.add(screening)
                default_screening.default = False
                default_screening.save()
            return screening
    return super().save(commit)