Skip to content

Views

hypha.apply.api.v1.review.views

SubmissionReviewViewSet

Bases: BaseStreamForm, WagtailSerializer, SubmissionNestedMixin, GenericViewSet

submission_form_class class-attribute instance-attribute 

submission_form_class = PageStreamBaseForm

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

permission_classes class-attribute instance-attribute 

permission_classes = (IsAuthenticated, IsApplyStaffUser)

permission_classes_by_action class-attribute instance-attribute 

permission_classes_by_action = {'create': [IsAuthenticated, HasReviewCreatePermission, IsApplyStaffUser], 'retrieve': [IsAuthenticated, HasReviewDetailPermission, IsApplyStaffUser], 'update': [IsAuthenticated, HasReviewEditPermission, IsApplyStaffUser], 'delete': [IsAuthenticated, HasReviewDeletePermission, IsApplyStaffUser], 'opinions': [IsAuthenticated, HasReviewOpinionPermission, IsApplyStaffUser], 'fields': [IsAuthenticated, HasReviewCreatePermission, IsApplyStaffUser], 'draft': [IsAuthenticated, HasReviewDraftPermission, IsApplyStaffUser]}

serializer_class class-attribute instance-attribute 

serializer_class = SubmissionReviewSerializer

get_submission_object 

get_submission_object()
Source code in hypha/apply/api/v1/mixin.py 
8
9
def get_submission_object(self):
    return get_object_or_404(ApplicationSubmission, id=self.kwargs["submission_pk"])

get_serializer_fields 

get_serializer_fields(draft=False)

Get the respective serializer fields for all the form fields.

Source code in hypha/apply/api/v1/stream_serializers.py 
16
17
18
19
20
21
22
23
24
25
26
def get_serializer_fields(self, draft=False):
    """
    Get the respective serializer fields for all the form fields.
    """
    serializer_fields = OrderedDict()
    form_fields = self.get_form_fields()
    for field_id, field in form_fields.items():
        serializer_fields[field_id] = self._get_field(
            field, self.get_serializer_field_class(field), draft
        )
    return serializer_fields

find_function_args 

find_function_args(func)

Get the list of parameter names which function accepts.

Source code in hypha/apply/api/v1/stream_serializers.py 
59
60
61
62
63
64
65
66
67
68
69
70
71
def find_function_args(self, func):
    """
    Get the list of parameter names which function accepts.
    """
    try:
        spec = (
            inspect.getfullargspec(func)
            if hasattr(inspect, "getfullargspec")
            else inspect.getargspec(func)
        )
        return [i for i in spec[0] if i not in IGNORE_ARGS]
    except TypeError:
        return []

find_class_args 

find_class_args(klass)

Find all class arguments (parameters) which can be passed in __init__.

Source code in hypha/apply/api/v1/stream_serializers.py 
73
74
75
76
77
78
79
80
81
82
83
def find_class_args(self, klass):
    """
    Find all class arguments (parameters) which can be passed in ``__init__``.
    """
    args = set()
    for i in klass.mro():
        if i is object or not hasattr(i, "__init__"):
            continue
        args |= set(self.find_function_args(i.__init__))

    return list(args)

find_matching_class_kwargs 

find_matching_class_kwargs(reference_object, klass)
Source code in hypha/apply/api/v1/stream_serializers.py 
85
86
87
88
89
90
def find_matching_class_kwargs(self, reference_object, klass):
    return {
        i: getattr(reference_object, i)
        for i in self.find_class_args(klass)
        if hasattr(reference_object, i)
    }

get_serializer_field_class 

get_serializer_field_class(field)

Assumes that a serializer field exist with the same name as form field.

TODO: In case there are form fields not existing in serializer fields, we would have to create mapping b/w form fields and serializer fields to get the respective classes. But for now this works.

Source code in hypha/apply/api/v1/stream_serializers.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def get_serializer_field_class(self, field):
    """
    Assumes that a serializer field exist with the same name as form field.

    TODO:
    In case there are form fields not existing in serializer fields, we would
    have to create mapping b/w form fields and serializer fields to get the
    respective classes. But for now this works.
    """
    if isinstance(field, BlockFieldWrapper):
        return serializers.CharField
    if isinstance(field, ScoredAnswerField):
        return ScoredAnswerListField
    if isinstance(field, TypedChoiceField):
        return serializers.ChoiceField
    class_name = field.__class__.__name__
    return getattr(serializers, class_name)

from_db classmethod 

from_db(db, field_names, values)
Source code in hypha/apply/stream_forms/models.py 
28
29
30
31
32
33
34
35
@classmethod
def from_db(cls, db, field_names, values):
    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)
Source code in hypha/apply/stream_forms/models.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@classmethod
def deserialize_form_data(cls, instance, form_data, form_fields):
    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)
Source code in hypha/apply/stream_forms/models.py 
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 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
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
def get_form_fields(self, draft=False, form_data=None, user=None):
    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.help_link = struct_value.get("help_link")
            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_form_class 

get_form_class(draft=False, form_data=None, user=None)
Source code in hypha/apply/stream_forms/models.py 
150
151
152
153
154
155
def get_form_class(self, draft=False, form_data=None, user=None):
    return type(
        "WagtailStreamForm",
        (self.submission_form_class,),
        self.get_form_fields(draft, form_data, user),
    )

get_permissions 

get_permissions()
Source code in hypha/apply/api/v1/review/views.py 
78
79
80
81
82
83
84
85
86
87
def get_permissions(self):
    try:
        # return permission_classes depending on `action`
        return [
            permission()
            for permission in self.permission_classes_by_action[self.action]
        ]
    except KeyError:
        # action is not set return default permission_classes
        return [permission() for permission in self.permission_classes]

get_defined_fields 

get_defined_fields()

Get form fields created for reviewing this submission.

These form fields will be used to get respective serializer fields.

Source code in hypha/apply/api/v1/review/views.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
def get_defined_fields(self):
    """
    Get form fields created for reviewing this submission.

    These form fields will be used to get respective serializer fields.
    """
    if self.action in ["retrieve", "update", "opinions"]:
        # For detail and edit api form fields used while submitting
        # review should be used.
        review = self.get_object()
        return review.form_fields
    if self.action == "draft":
        review = self.get_review_by_reviewer()
        return review.form_fields
    submission = self.get_submission_object()
    return get_review_form_fields_for_stage(submission)

get_serializer_class 

get_serializer_class()

Override get_serializer_class to send draft parameter if the request is to save as draft or the review submitted is saved as draft.

Source code in hypha/apply/api/v1/review/views.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def get_serializer_class(self):
    """
    Override get_serializer_class to send draft parameter
    if the request is to save as draft or the review submitted
    is saved as draft.
    """
    if self.action == "retrieve":
        review = self.get_object()
        draft = review.is_draft
    elif self.action == "draft":
        draft = True
    else:
        draft = self.request.data.get("is_draft", False)
    return super().get_serializer_class(draft)

get_queryset 

get_queryset()
Source code in hypha/apply/api/v1/review/views.py 
121
122
123
def get_queryset(self):
    submission = self.get_submission_object()
    return Review.objects.filter(submission=submission, is_draft=False)

get_object 

get_object()

Get the review object by id. If not found raise 404.

Source code in hypha/apply/api/v1/review/views.py 
125
126
127
128
129
130
131
132
def get_object(self):
    """
    Get the review object by id. If not found raise 404.
    """
    queryset = self.get_queryset()
    obj = get_object_or_404(queryset, id=self.kwargs["pk"])
    self.check_object_permissions(self.request, obj)
    return obj

get_reviewer 

get_reviewer()

Get the AssignedReviewers for the current user on a submission.

Source code in hypha/apply/api/v1/review/views.py 
134
135
136
137
138
139
140
141
142
143
def get_reviewer(self):
    """
    Get the AssignedReviewers for the current user on a submission.
    """
    submission = self.get_submission_object()
    ar, _ = AssignedReviewers.objects.get_or_create_for_user(
        submission=submission,
        reviewer=self.request.user,
    )
    return ar

create 

create(request, *args, **kwargs)

Create a review on a submission.

Accept a post data in form of {field_id: value}. field_id is same id which you get from the /fields api. value should be submitted with html tags, so that response can be displayed with correct formatting, e.g. in case of rich text field, we need to show the data with same formatting user has submitted.

Accepts optional parameter is_draft when a review is to be saved as draft.

Raise ValidationError if a review is already submitted by the user.

Source code in hypha/apply/api/v1/review/views.py 
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
def create(self, request, *args, **kwargs):
    """
    Create a review on a submission.

    Accept a post data in form of `{field_id: value}`.
    `field_id` is same id which you get from the `/fields` api.
    `value` should be submitted with html tags, so that response can
    be displayed with correct formatting, e.g. in case of rich text field,
    we need to show the data with same formatting user has submitted.

    Accepts optional parameter `is_draft` when a review is to be saved as draft.

    Raise ValidationError if a review is already submitted by the user.
    """
    submission = self.get_submission_object()
    ser = self.get_serializer(data=request.data)
    ser.is_valid(raise_exception=True)
    instance, create = ser.Meta.model.objects.get_or_create(
        submission=submission, author=self.get_reviewer()
    )
    if not create and not instance.is_draft:
        raise ValidationError(
            {"detail": "You have already posted a review for this submission"}
        )
    instance.form_fields = self.get_defined_fields()
    instance.save()
    ser.update(instance, ser.validated_data)
    if not instance.is_draft:
        messenger(
            MESSAGES.NEW_REVIEW,
            request=self.request,
            user=self.request.user,
            source=submission,
            related=instance,
        )
        # Automatic workflow actions.
        review_workflow_actions(self.request, submission)
    ser = self.get_serializer(self.get_review_data(instance))
    return Response(ser.data, status=status.HTTP_201_CREATED)

get_review_data 

get_review_data(review)

Get review data which will be used for review detail api.

Source code in hypha/apply/api/v1/review/views.py 
185
186
187
188
189
190
191
192
193
194
195
196
197
def get_review_data(self, review):
    """
    Get review data which will be used for review detail api.
    """
    review_data = review.form_data
    review_data["id"] = review.id
    review_data["score"] = review.score
    review_data["opinions"] = review.opinions
    review_data["is_draft"] = review.is_draft
    for field_block in review.form_fields:
        if isinstance(field_block.block, RichTextBlock):
            review_data[field_block.id] = field_block.value.source
    return review_data

retrieve 

retrieve(request, *args, **kwargs)

Get details of a review on a submission

Source code in hypha/apply/api/v1/review/views.py 
199
200
201
202
203
204
205
def retrieve(self, request, *args, **kwargs):
    """
    Get details of a review on a submission
    """
    review = self.get_object()
    ser = self.get_serializer(self.get_review_data(review))
    return Response(ser.data)

update 

update(request, *args, **kwargs)

Update a review submitted on a submission.

Source code in hypha/apply/api/v1/review/views.py 
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
def update(self, request, *args, **kwargs):
    """
    Update a review submitted on a submission.
    """
    review = self.get_object()
    ser = self.get_serializer(data=request.data)
    ser.is_valid(raise_exception=True)
    ser.update(review, ser.validated_data)

    messenger(
        MESSAGES.EDIT_REVIEW,
        user=self.request.user,
        request=self.request,
        source=review.submission,
        related=review,
    )
    # Automatic workflow actions.
    review_workflow_actions(self.request, review.submission)
    ser = self.get_serializer(self.get_review_data(review))
    return Response(ser.data)

destroy 

destroy(request, *args, **kwargs)

Delete a review on a submission

Source code in hypha/apply/api/v1/review/views.py 
228
229
230
231
232
233
234
235
236
237
238
239
def destroy(self, request, *args, **kwargs):
    """Delete a review on a submission"""
    review = self.get_object()
    messenger(
        MESSAGES.DELETE_REVIEW,
        user=request.user,
        request=request,
        source=review.submission,
        related=review,
    )
    review.delete()
    return Response(status=status.HTTP_204_NO_CONTENT)

get_review_by_reviewer 

get_review_by_reviewer()
Source code in hypha/apply/api/v1/review/views.py 
241
242
243
244
245
246
def get_review_by_reviewer(self):
    submission = self.get_submission_object()
    review = Review.objects.get(
        submission=submission, author__reviewer=self.request.user
    )
    return review

draft 

draft(request, *args, **kwargs)

Returns the draft review submitted on a submission by current user.

Source code in hypha/apply/api/v1/review/views.py 
248
249
250
251
252
253
254
255
256
257
258
259
260
@action(detail=False, methods=["get"])
def draft(self, request, *args, **kwargs):
    """
    Returns the draft review submitted on a submission by current user.
    """
    try:
        review = self.get_review_by_reviewer()
    except Review.DoesNotExist:
        return Response({})
    if not review.is_draft:
        return Response({})
    ser = self.get_serializer(self.get_review_data(review))
    return Response(ser.data)

fields 

fields(request, *args, **kwargs)

List details of all the form fields that were created by admin for adding reviews.

These field details will be used in frontend to render the review form.

Source code in hypha/apply/api/v1/review/views.py 
262
263
264
265
266
267
268
269
270
271
@action(detail=False, methods=["get"])
def fields(self, request, *args, **kwargs):
    """
    List details of all the form fields that were created by admin for adding reviews.

    These field details will be used in frontend to render the review form.
    """
    fields = self.get_form_fields()
    fields = FieldSerializer(fields.items(), many=True)
    return Response(fields.data)

opinions 

opinions(request, *args, **kwargs)

Used to add opinions on a review.

Options are 0 and 1. DISAGREE = 0 AGREE = 1

Response is similar to detail api of the review.

Source code in hypha/apply/api/v1/review/views.py 
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
@action(detail=True, methods=["post"])
def opinions(self, request, *args, **kwargs):
    """
    Used to add opinions on a review.

    Options are 0 and 1. DISAGREE = 0 AGREE = 1

    Response is similar to detail api of the review.
    """
    review = self.get_object()
    ser = ReviewOpinionWriteSerializer(data=request.data)
    ser.is_valid(raise_exception=True)
    opinion = ser.validated_data["opinion"]
    try:
        review_opinion = ReviewOpinion.objects.get(
            review=review, author=self.get_reviewer()
        )
    except ReviewOpinion.DoesNotExist:
        ReviewOpinion.objects.create(
            review=review, author=self.get_reviewer(), opinion=opinion
        )
    else:
        review_opinion.opinion = opinion
        review_opinion.save()
    ser = self.get_serializer(self.get_review_data(review))
    return Response(ser.data, status=status.HTTP_201_CREATED)