Skip to content

Views

hypha.apply.determinations.views

BatchDeterminationCreateView

Bases: BaseStreamForm, CreateView

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

submission_form_class class-attribute instance-attribute 

submission_form_class = BatchDeterminationForm

template_name class-attribute instance-attribute 

template_name = 'determinations/batch_determination_form.html'

from_db classmethod 

from_db(db, field_names, values)

Deserialize form data when loading from database.

Parameters:

  • db –

    Database connection

  • field_names –

    List of field names being loaded

  • values –

    Values for the fields

Returns:

  • –

    Instance with deserialized form data

Source code in hypha/apply/stream_forms/models.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@classmethod
def from_db(cls, db, field_names, values):
    """Deserialize form data when loading from database.

    Args:
        db: Database connection
        field_names: List of field names being loaded
        values: Values for the fields

    Returns:
        Instance with deserialized form data
    """
    instance = super().from_db(db, field_names, values)
    if "form_data" in field_names:
        instance.form_data = cls.deserialize_form_data(
            instance, instance.form_data, instance.form_fields
        )
    return instance

deserialize_form_data classmethod 

deserialize_form_data(instance, form_data, form_fields)

Convert stored form data back into Python objects.

Parameters:

  • instance –

    Form instance

  • form_data –

    Raw form data from database

  • form_fields –

    Form field definitions

Returns:

  • –

    Deserialized form data

Source code in hypha/apply/stream_forms/models.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@classmethod
def deserialize_form_data(cls, instance, form_data, form_fields):
    """Convert stored form data back into Python objects.

    Args:
        instance: Form instance
        form_data: Raw form data from database
        form_fields: Form field definitions

    Returns:
        Deserialized form data
    """
    data = form_data.copy()
    # PERFORMANCE NOTE:
    # Do not attempt to iterate over form_fields - that will fully instantiate the form_fields
    # including any sub queries that they do
    for _i, field_data in enumerate(form_fields.raw_data):
        block = form_fields.stream_block.child_blocks[field_data["type"]]
        field_id = field_data.get("id")
        try:
            value = data[field_id]
        except KeyError:
            pass
        else:
            data[field_id] = block.decode(value)
    return data

get_form_fields 

get_form_fields(draft=False, form_data=None, user=None)

Generate form fields with applied logic and grouping.

Parameters:

  • draft –

    Whether this is a draft form. When True, fields that are not marked as ApplicationMustIncludeFieldBlock will have their required flag set to False, allowing incomplete form submissions to be saved as drafts.

  • form_data –

    Existing form data

  • user –

    User completing the form

Returns:

  • –

    OrderedDict of form fields

Source code in hypha/apply/stream_forms/models.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
def get_form_fields(self, draft=False, form_data=None, user=None):
    """Generate form fields with applied logic and grouping.

    Args:
        draft: Whether this is a draft form. When True, fields that are not
              marked as ApplicationMustIncludeFieldBlock will have their
              required flag set to False, allowing incomplete form submissions
              to be saved as drafts.
        form_data: Existing form data
        user: User completing the form

    Returns:
        OrderedDict of form fields
    """
    if form_data is None:
        form_data = {}

    form_fields = OrderedDict()
    field_blocks = self.get_defined_fields()
    group_counter = 1
    is_in_group = False

    # If true option 1 is selected
    grouped_fields_visible = False
    for struct_child in field_blocks:
        block = struct_child.block
        struct_value = struct_child.value
        if isinstance(block, FormFieldBlock):
            field_from_block = block.get_field(struct_value)
            disabled_help_text = _(
                "You are logged in so this information is fetched from your user account."
            )
            if isinstance(block, FullNameBlock) and user and user.is_authenticated:
                if user.full_name:
                    field_from_block.disabled = True
                    field_from_block.initial = user.full_name
                    field_from_block.help_text = disabled_help_text
                else:
                    field_from_block.help_text = _(
                        "You are logged in but your user account does not have a "
                        "full name. We'll update your user account with the name you provide here."
                    )
            if isinstance(block, EmailBlock) and user and user.is_authenticated:
                field_from_block.disabled = True
                field_from_block.initial = user.email
                field_from_block.help_text = disabled_help_text
            if draft and not issubclass(
                block.__class__, ApplicationMustIncludeFieldBlock
            ):
                field_from_block.required = False
            field_from_block.group_number = group_counter if is_in_group else 1
            if isinstance(block, GroupToggleBlock) and not is_in_group:
                field_from_block.group_number = 1
                field_from_block.grouper_for = group_counter + 1
                group_counter += 1
                is_in_group = True
                grouped_fields_visible = (
                    form_data.get(struct_child.id) == field_from_block.choices[0][0]
                )
            if isinstance(block, TextFieldBlock):
                field_from_block.word_limit = struct_value.get("word_limit")
            if isinstance(block, MultiInputCharFieldBlock):
                number_of_inputs = struct_value.get("number_of_inputs")
                for index in range(number_of_inputs):
                    form_fields[struct_child.id + "_" + str(index)] = (
                        field_from_block
                    )
                    field_from_block.multi_input_id = struct_child.id
                    field_from_block.add_button_text = struct_value.get(
                        "add_button_text"
                    )
                    if (
                        index == number_of_inputs - 1
                    ):  # Add button after last input field
                        field_from_block.multi_input_add_button = True
                        # Index for field until which fields will be visible to applicant.
                        # Initially only the first field with id UUID_0 will be visible.
                        field_from_block.visibility_index = 0
                        field_from_block.max_index = index
                    if index != 0:
                        field_from_block.multi_input_field = True
                        field_from_block.required = False
                        field_from_block.initial = None
                    field_from_block = copy.copy(field_from_block)
            else:
                if is_in_group and not isinstance(block, GroupToggleBlock):
                    field_from_block.required_when_visible = (
                        field_from_block.required
                    )
                    field_from_block.required = (
                        field_from_block.required & grouped_fields_visible
                    )
                    field_from_block.visible = grouped_fields_visible
                form_fields[struct_child.id] = field_from_block
        elif isinstance(block, GroupToggleEndBlock):
            # Group toggle end block is used only to group fields and not used in actual form.
            # Todo: Use streamblock to create nested form field blocks, a more elegant method to group form fields.
            is_in_group = False
        else:
            field_wrapper = BlockFieldWrapper(struct_child)
            field_wrapper.group_number = group_counter if is_in_group else 1
            form_fields[struct_child.id] = field_wrapper

    return form_fields

dispatch 

dispatch(*args, **kwargs)
Source code in hypha/apply/determinations/views.py 
108
109
110
111
112
113
114
115
116
def dispatch(self, *args, **kwargs):
    self._submissions = None
    if not self.get_action() or not self.get_submissions():
        messages.warning(
            self.request, _("Improperly configured request, please try again.")
        )
        return HttpResponseRedirect(self.get_success_url())

    return super().dispatch(*args, **kwargs)

get_action 

get_action()
Source code in hypha/apply/determinations/views.py 
118
119
def get_action(self):
    return self.request.GET.get("action", "")

get_submissions 

get_submissions()
Source code in hypha/apply/determinations/views.py 
121
122
123
124
125
126
127
128
129
130
131
132
def get_submissions(self):
    if not self._submissions:
        try:
            submission_ids = self.request.GET.get("submissions").split(",")
        except AttributeError:
            return None
        try:
            ids = [int(pk) for pk in submission_ids]
        except ValueError:
            return None
        self._submissions = ApplicationSubmission.objects.filter(id__in=ids)
    return self._submissions

get_form_kwargs 

get_form_kwargs()
Source code in hypha/apply/determinations/views.py 
134
135
136
137
138
139
140
141
def get_form_kwargs(self):
    kwargs = super().get_form_kwargs()
    kwargs["user"] = self.request.user
    kwargs["submissions"] = self.get_submissions()
    kwargs["action"] = self.get_action()
    kwargs["site"] = Site.find_for_request(self.request)
    kwargs.pop("instance")
    return kwargs

check_all_submissions_are_of_same_type 

check_all_submissions_are_of_same_type(submissions)

Checks if all the submission as the new determination form attached to it.

Or all should be using the old determination forms.

We can not create batch determination with submissions using two different type of forms.

Source code in hypha/apply/determinations/views.py 
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
def check_all_submissions_are_of_same_type(self, submissions):
    """
    Checks if all the submission as the new determination form attached to it.

    Or all should be using the old determination forms.

    We can not create batch determination with submissions using two different
    type of forms.
    """
    return (
        len(
            {
                submission.is_determination_form_attached
                for submission in submissions
            }
        )
        == 1
    )

get_form_class 

get_form_class()
Source code in hypha/apply/determinations/views.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
def get_form_class(self):
    submissions = self.get_submissions()
    if not self.check_all_submissions_are_of_same_type(submissions):
        raise ValueError(
            "All selected submissions expects determination forms attached"
            " - please contact admin"
        )
    if not submissions[0].is_determination_form_attached:
        # If all the submission has same type of forms but they are not the
        # new streamfield forms then use the old determination forms.
        return get_form_for_stages(submissions)
    form_fields = self.get_form_fields()
    field_blocks = self.get_defined_fields()
    for field_block in field_blocks:
        if isinstance(field_block.block, DeterminationBlock):
            # Outcome is already set in case of batch determinations so we do
            # not need to render this field.
            form_fields.pop(field_block.id)
    return type("WagtailStreamForm", (self.submission_form_class,), form_fields)

get_defined_fields 

get_defined_fields()
Source code in hypha/apply/determinations/views.py 
182
183
def get_defined_fields(self):
    return get_fields_for_stages(self.get_submissions())

get_context_data 

get_context_data(**kwargs)
Source code in hypha/apply/determinations/views.py 
185
186
187
188
189
190
191
192
193
194
def get_context_data(self, **kwargs):
    outcome = TRANSITION_DETERMINATION[self.get_action()]
    submission = self.get_submissions()[0]
    transition = transition_from_outcome(outcome, submission)
    action_name = submission.workflow[transition].display_name
    return super().get_context_data(
        action_name=action_name,
        submissions=self.get_submissions(),
        **kwargs,
    )

form_valid 

form_valid(form)
Source code in hypha/apply/determinations/views.py 
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
def form_valid(self, form):
    submissions = self.get_submissions()
    response = super().form_valid(form)
    determinations = {
        determination.submission.id: determination
        for determination in form.instances
    }
    sources = submissions.filter(id__in=list(determinations))

    base_message = _("Successfully determined as {outcome}: ").format(
        outcome=determinations[sources[0].id].clean_outcome
    )
    submissions_text = [submission.title_text_display for submission in sources]
    messages.success(self.request, base_message + ", ".join(submissions_text))

    messenger(
        MESSAGES.BATCH_DETERMINATION_OUTCOME,
        request=self.request,
        user=self.request.user,
        sources=sources,
        related=determinations,
    )

    for submission in submissions:
        try:
            determination = determinations[submission.id]
        except KeyError:
            messages.warning(
                self.request,
                _(
                    'Unable to determine submission "{title}" as already determined'
                ).format(title=submission.title_text_display),
            )
        else:
            if submission.is_determination_form_attached:
                determination.form_fields = self.get_defined_fields()
                determination.message = form.cleaned_data[
                    determination.message_field.id
                ]
                determination.save()
            transition = transition_from_outcome(
                form.cleaned_data.get("outcome"), submission
            )

            if determination.outcome == NEEDS_MORE_INFO:
                # We keep a record of the message sent to the user in the comment
                Activity.comments.create(
                    message=determination.stripped_message,
                    timestamp=timezone.now(),
                    user=self.request.user,
                    source=submission,
                    related_object=determination,
                )

            submission.perform_transition(
                transition, self.request.user, request=self.request, notify=False
            )
    return response

get_success_url 

get_success_url()
Source code in hypha/apply/determinations/views.py 
255
256
257
258
259
def get_success_url(self):
    try:
        return self.request.GET["next"]
    except KeyError:
        return reverse_lazy("apply:submissions:list")

DeterminationCreateOrUpdateView

Bases: BaseStreamForm, CreateOrUpdateView

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

submission_form_class class-attribute instance-attribute 

submission_form_class = DeterminationModelForm

model class-attribute instance-attribute 

model = Determination

template_name class-attribute instance-attribute 

template_name = 'determinations/determination_form.html'

get 

get(request, *args, **kwargs)
Source code in hypha/apply/utils/views.py 
229
230
231
232
233
234
235
def get(self, request, *args, **kwargs):
    try:
        self.object = self.get_object()
    except self.model.DoesNotExist:
        self.object = None

    return super().get(request, *args, **kwargs)

post 

post(request, *args, **kwargs)
Source code in hypha/apply/utils/views.py 
237
238
239
240
241
242
243
def post(self, request, *args, **kwargs):
    try:
        self.object = self.get_object()
    except self.model.DoesNotExist:
        self.object = None

    return super().post(request, *args, **kwargs)

from_db classmethod 

from_db(db, field_names, values)

Deserialize form data when loading from database.

Parameters:

  • db –

    Database connection

  • field_names –

    List of field names being loaded

  • values –

    Values for the fields

Returns:

  • –

    Instance with deserialized form data

Source code in hypha/apply/stream_forms/models.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@classmethod
def from_db(cls, db, field_names, values):
    """Deserialize form data when loading from database.

    Args:
        db: Database connection
        field_names: List of field names being loaded
        values: Values for the fields

    Returns:
        Instance with deserialized form data
    """
    instance = super().from_db(db, field_names, values)
    if "form_data" in field_names:
        instance.form_data = cls.deserialize_form_data(
            instance, instance.form_data, instance.form_fields
        )
    return instance

deserialize_form_data classmethod 

deserialize_form_data(instance, form_data, form_fields)

Convert stored form data back into Python objects.

Parameters:

  • instance –

    Form instance

  • form_data –

    Raw form data from database

  • form_fields –

    Form field definitions

Returns:

  • –

    Deserialized form data

Source code in hypha/apply/stream_forms/models.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@classmethod
def deserialize_form_data(cls, instance, form_data, form_fields):
    """Convert stored form data back into Python objects.

    Args:
        instance: Form instance
        form_data: Raw form data from database
        form_fields: Form field definitions

    Returns:
        Deserialized form data
    """
    data = form_data.copy()
    # PERFORMANCE NOTE:
    # Do not attempt to iterate over form_fields - that will fully instantiate the form_fields
    # including any sub queries that they do
    for _i, field_data in enumerate(form_fields.raw_data):
        block = form_fields.stream_block.child_blocks[field_data["type"]]
        field_id = field_data.get("id")
        try:
            value = data[field_id]
        except KeyError:
            pass
        else:
            data[field_id] = block.decode(value)
    return data

get_form_fields 

get_form_fields(draft=False, form_data=None, user=None)

Generate form fields with applied logic and grouping.

Parameters:

  • draft –

    Whether this is a draft form. When True, fields that are not marked as ApplicationMustIncludeFieldBlock will have their required flag set to False, allowing incomplete form submissions to be saved as drafts.

  • form_data –

    Existing form data

  • user –

    User completing the form

Returns:

  • –

    OrderedDict of form fields

Source code in hypha/apply/stream_forms/models.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
def get_form_fields(self, draft=False, form_data=None, user=None):
    """Generate form fields with applied logic and grouping.

    Args:
        draft: Whether this is a draft form. When True, fields that are not
              marked as ApplicationMustIncludeFieldBlock will have their
              required flag set to False, allowing incomplete form submissions
              to be saved as drafts.
        form_data: Existing form data
        user: User completing the form

    Returns:
        OrderedDict of form fields
    """
    if form_data is None:
        form_data = {}

    form_fields = OrderedDict()
    field_blocks = self.get_defined_fields()
    group_counter = 1
    is_in_group = False

    # If true option 1 is selected
    grouped_fields_visible = False
    for struct_child in field_blocks:
        block = struct_child.block
        struct_value = struct_child.value
        if isinstance(block, FormFieldBlock):
            field_from_block = block.get_field(struct_value)
            disabled_help_text = _(
                "You are logged in so this information is fetched from your user account."
            )
            if isinstance(block, FullNameBlock) and user and user.is_authenticated:
                if user.full_name:
                    field_from_block.disabled = True
                    field_from_block.initial = user.full_name
                    field_from_block.help_text = disabled_help_text
                else:
                    field_from_block.help_text = _(
                        "You are logged in but your user account does not have a "
                        "full name. We'll update your user account with the name you provide here."
                    )
            if isinstance(block, EmailBlock) and user and user.is_authenticated:
                field_from_block.disabled = True
                field_from_block.initial = user.email
                field_from_block.help_text = disabled_help_text
            if draft and not issubclass(
                block.__class__, ApplicationMustIncludeFieldBlock
            ):
                field_from_block.required = False
            field_from_block.group_number = group_counter if is_in_group else 1
            if isinstance(block, GroupToggleBlock) and not is_in_group:
                field_from_block.group_number = 1
                field_from_block.grouper_for = group_counter + 1
                group_counter += 1
                is_in_group = True
                grouped_fields_visible = (
                    form_data.get(struct_child.id) == field_from_block.choices[0][0]
                )
            if isinstance(block, TextFieldBlock):
                field_from_block.word_limit = struct_value.get("word_limit")
            if isinstance(block, MultiInputCharFieldBlock):
                number_of_inputs = struct_value.get("number_of_inputs")
                for index in range(number_of_inputs):
                    form_fields[struct_child.id + "_" + str(index)] = (
                        field_from_block
                    )
                    field_from_block.multi_input_id = struct_child.id
                    field_from_block.add_button_text = struct_value.get(
                        "add_button_text"
                    )
                    if (
                        index == number_of_inputs - 1
                    ):  # Add button after last input field
                        field_from_block.multi_input_add_button = True
                        # Index for field until which fields will be visible to applicant.
                        # Initially only the first field with id UUID_0 will be visible.
                        field_from_block.visibility_index = 0
                        field_from_block.max_index = index
                    if index != 0:
                        field_from_block.multi_input_field = True
                        field_from_block.required = False
                        field_from_block.initial = None
                    field_from_block = copy.copy(field_from_block)
            else:
                if is_in_group and not isinstance(block, GroupToggleBlock):
                    field_from_block.required_when_visible = (
                        field_from_block.required
                    )
                    field_from_block.required = (
                        field_from_block.required & grouped_fields_visible
                    )
                    field_from_block.visible = grouped_fields_visible
                form_fields[struct_child.id] = field_from_block
        elif isinstance(block, GroupToggleEndBlock):
            # Group toggle end block is used only to group fields and not used in actual form.
            # Todo: Use streamblock to create nested form field blocks, a more elegant method to group form fields.
            is_in_group = False
        else:
            field_wrapper = BlockFieldWrapper(struct_child)
            field_wrapper.group_number = group_counter if is_in_group else 1
            form_fields[struct_child.id] = field_wrapper

    return form_fields

get_object 

get_object(queryset=None)
Source code in hypha/apply/determinations/views.py 
268
269
def get_object(self, queryset=None):
    return self.model.objects.get(submission=self.submission, is_draft=True)

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, id=self.kwargs["submission_pk"]
    )

    if not can_create_determination(request.user, self.submission):
        return self.back_to_submission(
            _("You do not have permission to create that determination.")
        )

    if has_final_determination(self.submission):
        return self.back_to_submission(
            _("A final determination has already been submitted.")
        )

    try:
        self.determination = self.get_object()
    except Determination.DoesNotExist:
        pass
    else:
        if not can_edit_determination(
            request.user, self.determination, self.submission
        ):
            return self.back_to_detail(
                _(
                    "There is a draft determination you do not have permission to edit."
                )
            )

    return super().dispatch(request, *args, **kwargs)

back_to_submission 

back_to_submission(message)
Source code in hypha/apply/determinations/views.py 
302
303
304
def back_to_submission(self, message):
    messages.warning(self.request, message)
    return HttpResponseRedirect(self.submission.get_absolute_url())

back_to_detail 

back_to_detail(message)
Source code in hypha/apply/determinations/views.py 
306
307
308
def back_to_detail(self, message):
    messages.warning(self.request, message)
    return HttpResponseRedirect(self.determination.get_absolute_url())

get_context_data 

get_context_data(**kwargs)
Source code in hypha/apply/determinations/views.py 
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
def get_context_data(self, **kwargs):
    site = Site.find_for_request(self.request)
    determination_messages = DeterminationMessageSettings.for_site(site)

    # Pass blocks ids to identify block types(determination & message) in determination message template js.
    field_blocks_ids = {}
    if self.submission.is_determination_form_attached:
        for field_block in self.get_defined_fields():
            if isinstance(field_block.block, DeterminationBlock) or isinstance(
                field_block.block, DeterminationMessageBlock
            ):
                field_blocks_ids[field_block.block_type] = field_block.id

    return super().get_context_data(
        submission=self.submission,
        message_templates=determination_messages.get_for_stage(
            self.submission.stage.name
        ),
        field_blocks_ids=field_blocks_ids,
        **kwargs,
    )

get_defined_fields 

get_defined_fields()
Source code in hypha/apply/determinations/views.py 
332
333
def get_defined_fields(self):
    return get_fields_for_stage(self.submission)

get_form_kwargs 

get_form_kwargs()
Source code in hypha/apply/determinations/views.py 
335
336
337
338
339
340
341
def get_form_kwargs(self):
    kwargs = super().get_form_kwargs()
    kwargs["user"] = self.request.user
    kwargs["submission"] = self.submission
    kwargs["action"] = self.request.GET.get("action")
    kwargs["site"] = Site.find_for_request(self.request)
    return kwargs

get_form_class 

get_form_class()
Source code in hypha/apply/determinations/views.py 
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
def get_form_class(self):
    action = self.request.GET.get("action")
    if not self.submission.is_determination_form_attached:
        # If new determination forms are not attached use the old ones.
        return get_form_for_stage(self.submission)
    form_fields = self.get_form_fields()
    field_blocks = self.get_defined_fields()
    for field_block in field_blocks:
        if isinstance(field_block.block, DeterminationBlock):
            outcome_choices = outcome_choices_for_phase(
                self.submission, self.request.user
            )
            # Outcome field choices need to be set according to the phase.
            form_fields[field_block.id].choices = outcome_choices
            if action:
                # Set initial outcome based on action.
                form_fields[field_block.id].initial = TRANSITION_DETERMINATION[
                    action
                ]
    form_fields = self.add_proposal_form_field(form_fields, action)
    return type("WagtailStreamForm", (self.submission_form_class,), form_fields)

add_proposal_form_field 

add_proposal_form_field(fields, action)
Source code in hypha/apply/determinations/views.py 
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
def add_proposal_form_field(self, fields, action):
    stages_num = len(self.submission.workflow.stages)
    if stages_num > 1 and self.submission.stage == Concept:
        second_stage_forms = self.submission.get_from_parent("forms").filter(
            stage=2
        )
        if second_stage_forms.count() > 1:
            proposal_form_choices = [
                (index, form.form.name)
                for index, form in enumerate(second_stage_forms)
            ]
            proposal_form_choices.insert(
                0, ("", _("-- No proposal form selected -- "))
            )
            proposal_form_help_text = _(
                "Select the proposal form only for determination approval"
            )
            if action == "invited_to_proposal":
                proposal_form_help_text = _(
                    "Select the proposal form to use for proposal stage."
                )
            fields["proposal_form"] = forms.ChoiceField(
                label=_("Proposal Form"),
                choices=proposal_form_choices,
                help_text=proposal_form_help_text,
                required=True if action == "invited_to_proposal" else False,
            )
            fields.move_to_end("proposal_form", last=False)
    return fields

get_success_url 

get_success_url()
Source code in hypha/apply/determinations/views.py 
395
396
def get_success_url(self):
    return self.submission.get_absolute_url()

form_valid 

form_valid(form)
Source code in hypha/apply/determinations/views.py 
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
def form_valid(self, form):
    if self.submission.is_determination_form_attached:
        form.instance.form_fields = self.get_defined_fields()

    super().form_valid(form)
    if self.object.is_draft:
        add_task_to_user(
            code=DETERMINATION_DRAFT,
            user=self.object.author,
            related_obj=self.object,
        )
        return HttpResponseRedirect(self.submission.get_absolute_url())

    with transaction.atomic():
        messenger(
            MESSAGES.DETERMINATION_OUTCOME,
            request=self.request,
            user=self.object.author,
            submission=self.object.submission,
            related=self.object,
        )
        proposal_form = form.cleaned_data.get("proposal_form")
        transition = transition_from_outcome(
            int(self.object.outcome), self.submission
        )

        if self.object.outcome == NEEDS_MORE_INFO:
            # We keep a record of the message sent to the user in the comment
            Activity.comments.create(
                message=self.object.stripped_message,
                timestamp=timezone.now(),
                user=self.request.user,
                source=self.submission,
                related_object=self.object,
            )
        self.submission.perform_transition(
            transition,
            self.request.user,
            request=self.request,
            notify=False,
            proposal_form=proposal_form,
        )

        if self.submission.accepted_for_funding and settings.PROJECTS_AUTO_CREATE:
            Project.create_from_submission(self.submission)
            messages.success(
                self.request, _("A project was automatically created.")
            )

    # remove current user's task for determination
    remove_tasks_for_user(
        code=DETERMINATION_DRAFT, user=self.object.author, related_obj=self.object
    )

    # remove all current determination tasks for the submission
    remove_tasks_of_related_obj_for_specific_code(
        code=DETERMINATION_DRAFT, related_obj=self.object
    )

    # remove all review draft tasks for the submission's draft reviews
    for review in Review.objects.filter(
        submission=self.object.submission, is_draft=True
    ):
        remove_tasks_of_related_obj_for_specific_code(
            code=REVIEW_DRAFT, related_obj=review
        )

    messenger(
        MESSAGES.DETERMINATION_OUTCOME,
        request=self.request,
        user=self.object.author,
        source=self.object.submission,
        related=self.object,
    )

    return HttpResponseRedirect(self.submission.get_absolute_url())

should_redirect classmethod 

should_redirect(request, submission, action)
Source code in hypha/apply/determinations/views.py 
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
@classmethod
def should_redirect(cls, request, submission, action):
    if has_final_determination(submission):
        determination = submission.determinations.final().first()
        if determination.outcome == TRANSITION_DETERMINATION[action]:
            # We want to progress as normal so don't redirect through form
            return False
        else:
            if request:
                # Add a helpful message to prompt them to select the correct option
                messages.warning(
                    request,
                    _(
                        'A determination of "{current}" exists but you tried to progress as "{target}"'
                    ).format(
                        current=determination.get_outcome_display(),
                        target=action,
                    ),
                )

    if action in DETERMINATION_OUTCOMES:
        return HttpResponseRedirect(
            reverse_lazy(
                "apply:submissions:determinations:form", args=(submission.id,)
            )
            + "?action="
            + action
        )

AdminDeterminationDetailView

Bases: DetailView

model class-attribute instance-attribute 

model = Determination

get_object 

get_object(queryset=None)
Source code in hypha/apply/determinations/views.py 
509
510
511
512
def get_object(self, queryset=None):
    return get_object_or_404(
        self.model, submission=self.submission, id=self.kwargs["pk"]
    )

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, id=self.kwargs["submission_pk"]
    )
    determination = self.get_object()

    if (
        can_edit_determination(request.user, determination, self.submission)
        and determination.is_draft
    ):
        return HttpResponseRedirect(
            reverse_lazy(
                "apply:submissions:determinations:form", args=(self.submission.id,)
            )
        )

    return super().dispatch(request, *args, **kwargs)

ReviewerDeterminationDetailView

Bases: DetailView

model class-attribute instance-attribute 

model = Determination

get_object 

get_object(queryset=None)
Source code in hypha/apply/determinations/views.py 
537
538
539
540
def get_object(self, queryset=None):
    return get_object_or_404(
        self.model, submission=self.submission, id=self.kwargs["pk"]
    )

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
542
543
544
545
546
547
548
549
550
551
552
553
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, id=self.kwargs["submission_pk"]
    )
    determination = self.get_object()

    if not determination.submitted:
        return HttpResponseRedirect(
            reverse_lazy("apply:submissions:detail", args=(self.submission.id,))
        )

    return super().dispatch(request, *args, **kwargs)

PartnerDeterminationDetailView

Bases: DetailView

model class-attribute instance-attribute 

model = Determination

get_queryset 

get_queryset()
Source code in hypha/apply/determinations/views.py 
560
561
def get_queryset(self):
    return super().get_queryset().filter(submission=self.submission)

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, pk=self.kwargs["submission_pk"]
    )

    if self.submission.user == request.user:
        return ApplicantDeterminationDetailView.as_view()(request, *args, **kwargs)

    # Only allow partners in the submission they are added as partners
    partner_has_access = self.submission.partners.filter(
        pk=request.user.pk
    ).exists()
    if not partner_has_access:
        raise PermissionDenied

    return super().dispatch(request, *args, **kwargs)

CommunityDeterminationDetailView

Bases: DetailView

model class-attribute instance-attribute 

model = Determination

get_queryset 

get_queryset()
Source code in hypha/apply/determinations/views.py 
585
586
def get_queryset(self):
    return super().get_queryset().filter(submission=self.submission)

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
588
589
590
591
592
593
594
595
596
597
598
599
600
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, pk=self.kwargs["submission_pk"]
    )

    if self.submission.user == request.user:
        return ApplicantDeterminationDetailView.as_view()(request, *args, **kwargs)

    # Only allow community reviewers in submission with a community review state.
    if not self.submission.community_review:
        raise PermissionDenied

    return super().dispatch(request, *args, **kwargs)

ApplicantDeterminationDetailView

Bases: DetailView

model class-attribute instance-attribute 

model = Determination

get_object 

get_object(queryset=None)
Source code in hypha/apply/determinations/views.py 
607
608
609
610
def get_object(self, queryset=None):
    return get_object_or_404(
        self.model, submission=self.submission, id=self.kwargs["pk"]
    )

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/determinations/views.py 
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
def dispatch(self, request, *args, **kwargs):
    self.submission = get_object_or_404(
        ApplicationSubmission, id=self.kwargs["submission_pk"]
    )
    determination = self.get_object()

    if request.user != self.submission.user:
        raise PermissionDenied

    if determination.is_draft:
        return HttpResponseRedirect(
            reverse_lazy(
                "apply:submissions:determinations:detail",
                args=(self.submission.id,),
            )
        )

    return super().dispatch(request, *args, **kwargs)

DeterminationDetailView

Bases: ViewDispatcher

finance_view class-attribute instance-attribute 

finance_view = None

contracting_view class-attribute instance-attribute 

contracting_view = None

admin_view class-attribute instance-attribute 

admin_view = AdminDeterminationDetailView

reviewer_view class-attribute instance-attribute 

reviewer_view = ReviewerDeterminationDetailView

partner_view class-attribute instance-attribute 

partner_view = PartnerDeterminationDetailView

community_view class-attribute instance-attribute 

community_view = CommunityDeterminationDetailView

applicant_view class-attribute instance-attribute 

applicant_view = ApplicantDeterminationDetailView

admin_check 

admin_check(request)
Source code in hypha/apply/utils/views.py 
29
30
def admin_check(self, request):
    return request.user.is_apply_staff

reviewer_check 

reviewer_check(request)
Source code in hypha/apply/utils/views.py 
32
33
def reviewer_check(self, request):
    return request.user.is_reviewer

partner_check 

partner_check(request)
Source code in hypha/apply/utils/views.py 
35
36
def partner_check(self, request):
    return request.user.is_partner

community_check 

community_check(request)
Source code in hypha/apply/utils/views.py 
38
39
def community_check(self, request):
    return request.user.is_community_reviewer

finance_check 

finance_check(request)
Source code in hypha/apply/utils/views.py 
41
42
def finance_check(self, request):
    return request.user.is_finance

contracting_check 

contracting_check(request)
Source code in hypha/apply/utils/views.py 
44
45
def contracting_check(self, request):
    return request.user.is_contracting

applicant_check 

applicant_check(request)
Source code in hypha/apply/utils/views.py 
47
48
def applicant_check(self, request):
    return request.user.is_applicant

dispatch 

dispatch(request, *args, **kwargs)
Source code in hypha/apply/utils/views.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
def dispatch(self, request, *args, **kwargs):
    view = None

    if self.admin_check(request):
        view = self.admin_view
    elif self.reviewer_check(request):
        view = self.reviewer_view
    elif self.partner_check(request):
        view = self.partner_view
    elif self.community_check(request):
        view = self.community_view
    elif settings.PROJECTS_ENABLED and self.finance_check(request):
        view = self.finance_view
    elif settings.PROJECTS_ENABLED and self.contracting_check(request):
        view = self.contracting_view
    elif self.applicant_check(request):
        view = self.applicant_view

    if view:
        return view.as_view()(request, *args, **kwargs)
    return HttpResponseForbidden()

DeterminationEditView

Bases: BaseStreamForm, UpdateView

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

submission_form_class class-attribute instance-attribute 

submission_form_class = DeterminationModelForm

model class-attribute instance-attribute 

model = Determination

template_name class-attribute instance-attribute 

template_name = 'determinations/determination_form.html'

raise_exception class-attribute instance-attribute 

raise_exception = True

from_db classmethod 

from_db(db, field_names, values)

Deserialize form data when loading from database.

Parameters:

  • db –

    Database connection

  • field_names –

    List of field names being loaded

  • values –

    Values for the fields

Returns:

  • –

    Instance with deserialized form data

Source code in hypha/apply/stream_forms/models.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@classmethod
def from_db(cls, db, field_names, values):
    """Deserialize form data when loading from database.

    Args:
        db: Database connection
        field_names: List of field names being loaded
        values: Values for the fields

    Returns:
        Instance with deserialized form data
    """
    instance = super().from_db(db, field_names, values)
    if "form_data" in field_names:
        instance.form_data = cls.deserialize_form_data(
            instance, instance.form_data, instance.form_fields
        )
    return instance

deserialize_form_data classmethod 

deserialize_form_data(instance, form_data, form_fields)

Convert stored form data back into Python objects.

Parameters:

  • instance –

    Form instance

  • form_data –

    Raw form data from database

  • form_fields –

    Form field definitions

Returns:

  • –

    Deserialized form data

Source code in hypha/apply/stream_forms/models.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@classmethod
def deserialize_form_data(cls, instance, form_data, form_fields):
    """Convert stored form data back into Python objects.

    Args:
        instance: Form instance
        form_data: Raw form data from database
        form_fields: Form field definitions

    Returns:
        Deserialized form data
    """
    data = form_data.copy()
    # PERFORMANCE NOTE:
    # Do not attempt to iterate over form_fields - that will fully instantiate the form_fields
    # including any sub queries that they do
    for _i, field_data in enumerate(form_fields.raw_data):
        block = form_fields.stream_block.child_blocks[field_data["type"]]
        field_id = field_data.get("id")
        try:
            value = data[field_id]
        except KeyError:
            pass
        else:
            data[field_id] = block.decode(value)
    return data

get_form_fields 

get_form_fields(draft=False, form_data=None, user=None)

Generate form fields with applied logic and grouping.

Parameters:

  • draft –

    Whether this is a draft form. When True, fields that are not marked as ApplicationMustIncludeFieldBlock will have their required flag set to False, allowing incomplete form submissions to be saved as drafts.

  • form_data –

    Existing form data

  • user –

    User completing the form

Returns:

  • –

    OrderedDict of form fields

Source code in hypha/apply/stream_forms/models.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
def get_form_fields(self, draft=False, form_data=None, user=None):
    """Generate form fields with applied logic and grouping.

    Args:
        draft: Whether this is a draft form. When True, fields that are not
              marked as ApplicationMustIncludeFieldBlock will have their
              required flag set to False, allowing incomplete form submissions
              to be saved as drafts.
        form_data: Existing form data
        user: User completing the form

    Returns:
        OrderedDict of form fields
    """
    if form_data is None:
        form_data = {}

    form_fields = OrderedDict()
    field_blocks = self.get_defined_fields()
    group_counter = 1
    is_in_group = False

    # If true option 1 is selected
    grouped_fields_visible = False
    for struct_child in field_blocks:
        block = struct_child.block
        struct_value = struct_child.value
        if isinstance(block, FormFieldBlock):
            field_from_block = block.get_field(struct_value)
            disabled_help_text = _(
                "You are logged in so this information is fetched from your user account."
            )
            if isinstance(block, FullNameBlock) and user and user.is_authenticated:
                if user.full_name:
                    field_from_block.disabled = True
                    field_from_block.initial = user.full_name
                    field_from_block.help_text = disabled_help_text
                else:
                    field_from_block.help_text = _(
                        "You are logged in but your user account does not have a "
                        "full name. We'll update your user account with the name you provide here."
                    )
            if isinstance(block, EmailBlock) and user and user.is_authenticated:
                field_from_block.disabled = True
                field_from_block.initial = user.email
                field_from_block.help_text = disabled_help_text
            if draft and not issubclass(
                block.__class__, ApplicationMustIncludeFieldBlock
            ):
                field_from_block.required = False
            field_from_block.group_number = group_counter if is_in_group else 1
            if isinstance(block, GroupToggleBlock) and not is_in_group:
                field_from_block.group_number = 1
                field_from_block.grouper_for = group_counter + 1
                group_counter += 1
                is_in_group = True
                grouped_fields_visible = (
                    form_data.get(struct_child.id) == field_from_block.choices[0][0]
                )
            if isinstance(block, TextFieldBlock):
                field_from_block.word_limit = struct_value.get("word_limit")
            if isinstance(block, MultiInputCharFieldBlock):
                number_of_inputs = struct_value.get("number_of_inputs")
                for index in range(number_of_inputs):
                    form_fields[struct_child.id + "_" + str(index)] = (
                        field_from_block
                    )
                    field_from_block.multi_input_id = struct_child.id
                    field_from_block.add_button_text = struct_value.get(
                        "add_button_text"
                    )
                    if (
                        index == number_of_inputs - 1
                    ):  # Add button after last input field
                        field_from_block.multi_input_add_button = True
                        # Index for field until which fields will be visible to applicant.
                        # Initially only the first field with id UUID_0 will be visible.
                        field_from_block.visibility_index = 0
                        field_from_block.max_index = index
                    if index != 0:
                        field_from_block.multi_input_field = True
                        field_from_block.required = False
                        field_from_block.initial = None
                    field_from_block = copy.copy(field_from_block)
            else:
                if is_in_group and not isinstance(block, GroupToggleBlock):
                    field_from_block.required_when_visible = (
                        field_from_block.required
                    )
                    field_from_block.required = (
                        field_from_block.required & grouped_fields_visible
                    )
                    field_from_block.visible = grouped_fields_visible
                form_fields[struct_child.id] = field_from_block
        elif isinstance(block, GroupToggleEndBlock):
            # Group toggle end block is used only to group fields and not used in actual form.
            # Todo: Use streamblock to create nested form field blocks, a more elegant method to group form fields.
            is_in_group = False
        else:
            field_wrapper = BlockFieldWrapper(struct_child)
            field_wrapper.group_number = group_counter if is_in_group else 1
            form_fields[struct_child.id] = field_wrapper

    return form_fields

get_context_data 

get_context_data(**kwargs)
Source code in hypha/apply/determinations/views.py 
647
648
649
650
651
652
653
654
655
656
657
658
def get_context_data(self, **kwargs):
    site = Site.find_for_request(self.request)
    determination_messages = DeterminationMessageSettings.for_site(site)

    determination = self.get_object()
    return super().get_context_data(
        submission=determination.submission,
        message_templates=determination_messages.get_for_stage(
            determination.submission.stage.name
        ),
        **kwargs,
    )

get_defined_fields 

get_defined_fields()
Source code in hypha/apply/determinations/views.py 
660
661
662
663
664
def get_defined_fields(self):
    determination = self.get_object()
    return determination.form_fields or get_fields_for_stage(
        determination.submission
    )

get_form_kwargs 

get_form_kwargs()
Source code in hypha/apply/determinations/views.py 
666
667
668
669
670
671
672
673
674
675
676
def get_form_kwargs(self):
    determiantion = self.get_object()
    kwargs = super().get_form_kwargs()
    kwargs["user"] = self.request.user
    kwargs["submission"] = determiantion.submission
    kwargs["edit"] = True
    kwargs["action"] = self.request.GET.get("action")
    kwargs["site"] = Site.find_for_request(self.request)
    if self.object:
        kwargs["initial"] = self.object.form_data
    return kwargs

get_form_class 

get_form_class()
Source code in hypha/apply/determinations/views.py 
678
679
680
681
682
683
684
685
686
687
688
689
def get_form_class(self):
    determination = self.get_object()
    if not determination.use_new_determination_form:
        return get_form_for_stage(determination.submission)
    form_fields = self.get_form_fields()
    field_blocks = self.get_defined_fields()
    for field_block in field_blocks:
        if isinstance(field_block.block, DeterminationBlock):
            # Outcome can not be edited after being set once, so we do not
            # need to render this field.
            form_fields.pop(field_block.id)
    return type("WagtailStreamForm", (self.submission_form_class,), form_fields)

form_valid 

form_valid(form)
Source code in hypha/apply/determinations/views.py 
691
692
693
694
695
696
697
698
699
700
701
702
def form_valid(self, form):
    super().form_valid(form)
    determination = self.get_object()
    messenger(
        MESSAGES.DETERMINATION_OUTCOME,
        request=self.request,
        user=self.object.author,
        source=self.object.submission,
        related=self.object,
    )

    return HttpResponseRedirect(determination.submission.get_absolute_url())

get_form_for_stages 

get_form_for_stages(submissions)
Source code in hypha/apply/determinations/views.py 
52
53
54
55
56
57
def get_form_for_stages(submissions):
    forms = [get_form_for_stage(submission, batch=True) for submission in submissions]
    if len(set(forms)) != 1:
        raise ValueError("Submissions expect different forms - please contact admin")

    return forms[0]

get_form_for_stage 

get_form_for_stage(submission, batch=False, edit=False)
Source code in hypha/apply/determinations/views.py 
60
61
62
63
64
65
66
def get_form_for_stage(submission, batch=False, edit=False):
    if batch:
        forms = [BatchConceptDeterminationForm, BatchProposalDeterminationForm]
    else:
        forms = [ConceptDeterminationForm, ProposalDeterminationForm]
    index = submission.workflow.stages.index(submission.stage)
    return forms[index]

get_fields_for_stages 

get_fields_for_stages(submissions)
Source code in hypha/apply/determinations/views.py 
69
70
71
72
73
def get_fields_for_stages(submissions):
    forms_fields = [get_fields_for_stage(submission) for submission in submissions]
    if not all(i == forms_fields[0] for i in forms_fields):
        raise ValueError("Submissions expect different forms - please contact admin")
    return forms_fields[0]

get_fields_for_stage 

get_fields_for_stage(submission)
Source code in hypha/apply/determinations/views.py 
76
77
78
79
80
81
82
def get_fields_for_stage(submission):
    forms = submission.get_from_parent("determination_forms").all()
    index = submission.workflow.stages.index(submission.stage)
    try:
        return forms[index].form.form_fields
    except IndexError:
        return forms[0].form.form_fields

outcome_choices_for_phase 

outcome_choices_for_phase(submission, user)

Outcome choices correspond to Phase transitions. We need to filter out non-matching choices. i.e. a transition to In Review is not a determination, while Needs more info or Rejected are.

Source code in hypha/apply/determinations/views.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def outcome_choices_for_phase(submission, user):
    """
    Outcome choices correspond to Phase transitions.
    We need to filter out non-matching choices.
    i.e. a transition to In Review is not a determination, while Needs more info or Rejected are.
    """
    available_choices = [("", _("-- No determination selected -- "))]
    choices = dict(DETERMINATION_CHOICES)
    for transition_name in determination_actions(user, submission):
        try:
            determination_type = TRANSITION_DETERMINATION[transition_name]
        except KeyError:
            pass
        else:
            available_choices.append((determination_type, choices[determination_type]))
    return available_choices