Skip to content

Models

hypha.apply.activity.models

COMMENT module-attribute 

COMMENT = 'comment'

ACTION module-attribute 

ACTION = 'action'

ACTIVITY_TYPES module-attribute 

ACTIVITY_TYPES = {COMMENT: gettext('Comment'), ACTION: gettext('Action')}

APPLICANT module-attribute 

APPLICANT = gettext('applicant')

TEAM module-attribute 

TEAM = gettext('team')

REVIEWER module-attribute 

REVIEWER = gettext('reviewers')

PARTNER module-attribute 

PARTNER = gettext('partners')

ALL module-attribute 

ALL = gettext('all')

APPLICANT_PARTNERS module-attribute 

APPLICANT_PARTNERS = f'{APPLICANT} {PARTNER}'

VISIBILITY module-attribute 

VISIBILITY = {APPLICANT: gettext('Applicants'), TEAM: gettext('Staff only'), REVIEWER: gettext('Reviewers'), PARTNER: gettext('Partners'), ALL: gettext('All'), APPLICANT_PARTNERS: gettext('Applicants & Partners')}

BaseActivityQuerySet

Bases: QuerySet

visible_to 

visible_to(user)

Get a QuerySet of all items that are visible to the given user.

Parameters:

  • user –

    User to filter visibility of

Returns:

  • QuerySet –

    A QuerySet containing all items visible to the specified user

Source code in hypha/apply/activity/models.py 
 51
 52
 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
 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
def visible_to(self, user) -> models.QuerySet:
    """Get a QuerySet of all items that are visible to the given user.

    Args:
        user:
            [`User`][hypha.apply.users.models.User] to filter visibility of

    Returns:
        A QuerySet containing all items visible to the specified user
    """

    # To hide reviews from the applicant's activity feed
    # Todo: It is just for historic data and not be needed for new data after this.
    from .messaging import ActivityAdapter

    messages = ActivityAdapter.messages

    user_qs = Q(user=user)

    # There are scenarios where users will have activities in which they
    # wouldn't have visibility just using Activity.visibility_for. Thus,
    # the queryset should include activity in which they author via
    # `user_qs` (ie. A comment made only to staff from a partner).
    if user.is_applicant:
        # Handle the edge case where a partner or reviewer is also an
        # applicant. Ensures that any applications/projects the user
        # authored will have comment visibility of applicant while others
        # will get the appropriate role.
        if user.is_partner or user.is_reviewer:
            ApplicationSubmission = apps.get_model("funds", "ApplicationSubmission")
            Project = apps.get_model("application_projects", "Project")

            app_content_type = ContentType.objects.get_for_model(
                ApplicationSubmission
            )
            proj_content_type = ContentType.objects.get_for_model(Project)

            authored_apps = ApplicationSubmission.objects.filter(user_qs).values(
                "id"
            )
            authored_projs = Project.objects.filter(user_qs).values("id")

            proj_app_qs = (
                Q(source_content_type=app_content_type)
                & Q(source_object_id__in=authored_apps)
            ) | (
                Q(source_content_type=proj_content_type)
                & Q(source_object_id__in=authored_projs)
            )

            # Activities the user is the author of the source submission
            applicant_activity = self.filter(
                proj_app_qs
                & Q(
                    Q(visibility__in=self.model.visibility_for(user, True))
                    | user_qs
                )
            )
            # All other activities
            other_activity = self.exclude(
                Q(message=messages.get(MESSAGES.NEW_REVIEW)) | proj_app_qs
            ).filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)
            return applicant_activity | other_activity
        else:
            return self.exclude(message=messages.get(MESSAGES.NEW_REVIEW)).filter(
                Q(visibility__in=self.model.visibility_for(user)) | user_qs
            )

    return self.filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)

newer 

newer(activity)
Source code in hypha/apply/activity/models.py 
121
122
def newer(self, activity):
    return self.filter(timestamp__gt=activity.timestamp)

ActivityQuerySet

Bases: BaseActivityQuerySet

visible_to 

visible_to(user)

Get a QuerySet of all items that are visible to the given user.

Parameters:

  • user –

    User to filter visibility of

Returns:

  • QuerySet –

    A QuerySet containing all items visible to the specified user

Source code in hypha/apply/activity/models.py 
 51
 52
 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
 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
def visible_to(self, user) -> models.QuerySet:
    """Get a QuerySet of all items that are visible to the given user.

    Args:
        user:
            [`User`][hypha.apply.users.models.User] to filter visibility of

    Returns:
        A QuerySet containing all items visible to the specified user
    """

    # To hide reviews from the applicant's activity feed
    # Todo: It is just for historic data and not be needed for new data after this.
    from .messaging import ActivityAdapter

    messages = ActivityAdapter.messages

    user_qs = Q(user=user)

    # There are scenarios where users will have activities in which they
    # wouldn't have visibility just using Activity.visibility_for. Thus,
    # the queryset should include activity in which they author via
    # `user_qs` (ie. A comment made only to staff from a partner).
    if user.is_applicant:
        # Handle the edge case where a partner or reviewer is also an
        # applicant. Ensures that any applications/projects the user
        # authored will have comment visibility of applicant while others
        # will get the appropriate role.
        if user.is_partner or user.is_reviewer:
            ApplicationSubmission = apps.get_model("funds", "ApplicationSubmission")
            Project = apps.get_model("application_projects", "Project")

            app_content_type = ContentType.objects.get_for_model(
                ApplicationSubmission
            )
            proj_content_type = ContentType.objects.get_for_model(Project)

            authored_apps = ApplicationSubmission.objects.filter(user_qs).values(
                "id"
            )
            authored_projs = Project.objects.filter(user_qs).values("id")

            proj_app_qs = (
                Q(source_content_type=app_content_type)
                & Q(source_object_id__in=authored_apps)
            ) | (
                Q(source_content_type=proj_content_type)
                & Q(source_object_id__in=authored_projs)
            )

            # Activities the user is the author of the source submission
            applicant_activity = self.filter(
                proj_app_qs
                & Q(
                    Q(visibility__in=self.model.visibility_for(user, True))
                    | user_qs
                )
            )
            # All other activities
            other_activity = self.exclude(
                Q(message=messages.get(MESSAGES.NEW_REVIEW)) | proj_app_qs
            ).filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)
            return applicant_activity | other_activity
        else:
            return self.exclude(message=messages.get(MESSAGES.NEW_REVIEW)).filter(
                Q(visibility__in=self.model.visibility_for(user)) | user_qs
            )

    return self.filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)

newer 

newer(activity)
Source code in hypha/apply/activity/models.py 
121
122
def newer(self, activity):
    return self.filter(timestamp__gt=activity.timestamp)

comments 

comments()
Source code in hypha/apply/activity/models.py 
126
127
def comments(self):
    return self.filter(type=COMMENT)

actions 

actions()
Source code in hypha/apply/activity/models.py 
129
130
def actions(self):
    return self.filter(type=ACTION)

latest 

latest()
Source code in hypha/apply/activity/models.py 
132
133
134
135
def latest(self):
    return self.filter(
        timestamp__gte=(timezone.now() - timezone.timedelta(days=30))
    )

ActivityBaseManager

Bases: Manager

create 

create(**kwargs)
Source code in hypha/apply/activity/models.py 
139
140
141
def create(self, **kwargs):
    kwargs.update(type=self.type)
    return super().create(**kwargs)

get_queryset 

get_queryset()
Source code in hypha/apply/activity/models.py 
143
144
145
146
147
148
149
150
151
def get_queryset(self):
    return (
        super()
        .get_queryset()
        .filter(
            type=self.type,
            current=True,
        )
    )

CommentQueryset

Bases: BaseActivityQuerySet

visible_to 

visible_to(user)

Get a QuerySet of all items that are visible to the given user.

Parameters:

  • user –

    User to filter visibility of

Returns:

  • QuerySet –

    A QuerySet containing all items visible to the specified user

Source code in hypha/apply/activity/models.py 
 51
 52
 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
 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
def visible_to(self, user) -> models.QuerySet:
    """Get a QuerySet of all items that are visible to the given user.

    Args:
        user:
            [`User`][hypha.apply.users.models.User] to filter visibility of

    Returns:
        A QuerySet containing all items visible to the specified user
    """

    # To hide reviews from the applicant's activity feed
    # Todo: It is just for historic data and not be needed for new data after this.
    from .messaging import ActivityAdapter

    messages = ActivityAdapter.messages

    user_qs = Q(user=user)

    # There are scenarios where users will have activities in which they
    # wouldn't have visibility just using Activity.visibility_for. Thus,
    # the queryset should include activity in which they author via
    # `user_qs` (ie. A comment made only to staff from a partner).
    if user.is_applicant:
        # Handle the edge case where a partner or reviewer is also an
        # applicant. Ensures that any applications/projects the user
        # authored will have comment visibility of applicant while others
        # will get the appropriate role.
        if user.is_partner or user.is_reviewer:
            ApplicationSubmission = apps.get_model("funds", "ApplicationSubmission")
            Project = apps.get_model("application_projects", "Project")

            app_content_type = ContentType.objects.get_for_model(
                ApplicationSubmission
            )
            proj_content_type = ContentType.objects.get_for_model(Project)

            authored_apps = ApplicationSubmission.objects.filter(user_qs).values(
                "id"
            )
            authored_projs = Project.objects.filter(user_qs).values("id")

            proj_app_qs = (
                Q(source_content_type=app_content_type)
                & Q(source_object_id__in=authored_apps)
            ) | (
                Q(source_content_type=proj_content_type)
                & Q(source_object_id__in=authored_projs)
            )

            # Activities the user is the author of the source submission
            applicant_activity = self.filter(
                proj_app_qs
                & Q(
                    Q(visibility__in=self.model.visibility_for(user, True))
                    | user_qs
                )
            )
            # All other activities
            other_activity = self.exclude(
                Q(message=messages.get(MESSAGES.NEW_REVIEW)) | proj_app_qs
            ).filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)
            return applicant_activity | other_activity
        else:
            return self.exclude(message=messages.get(MESSAGES.NEW_REVIEW)).filter(
                Q(visibility__in=self.model.visibility_for(user)) | user_qs
            )

    return self.filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)

newer 

newer(activity)
Source code in hypha/apply/activity/models.py 
121
122
def newer(self, activity):
    return self.filter(timestamp__gt=activity.timestamp)

CommentManger

Bases: ActivityBaseManager

type class-attribute instance-attribute 

type = COMMENT

create 

create(**kwargs)
Source code in hypha/apply/activity/models.py 
139
140
141
def create(self, **kwargs):
    kwargs.update(type=self.type)
    return super().create(**kwargs)

get_queryset 

get_queryset()
Source code in hypha/apply/activity/models.py 
143
144
145
146
147
148
149
150
151
def get_queryset(self):
    return (
        super()
        .get_queryset()
        .filter(
            type=self.type,
            current=True,
        )
    )

ActionQueryset

Bases: BaseActivityQuerySet

visible_to 

visible_to(user)

Get a QuerySet of all items that are visible to the given user.

Parameters:

  • user –

    User to filter visibility of

Returns:

  • QuerySet –

    A QuerySet containing all items visible to the specified user

Source code in hypha/apply/activity/models.py 
 51
 52
 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
 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
def visible_to(self, user) -> models.QuerySet:
    """Get a QuerySet of all items that are visible to the given user.

    Args:
        user:
            [`User`][hypha.apply.users.models.User] to filter visibility of

    Returns:
        A QuerySet containing all items visible to the specified user
    """

    # To hide reviews from the applicant's activity feed
    # Todo: It is just for historic data and not be needed for new data after this.
    from .messaging import ActivityAdapter

    messages = ActivityAdapter.messages

    user_qs = Q(user=user)

    # There are scenarios where users will have activities in which they
    # wouldn't have visibility just using Activity.visibility_for. Thus,
    # the queryset should include activity in which they author via
    # `user_qs` (ie. A comment made only to staff from a partner).
    if user.is_applicant:
        # Handle the edge case where a partner or reviewer is also an
        # applicant. Ensures that any applications/projects the user
        # authored will have comment visibility of applicant while others
        # will get the appropriate role.
        if user.is_partner or user.is_reviewer:
            ApplicationSubmission = apps.get_model("funds", "ApplicationSubmission")
            Project = apps.get_model("application_projects", "Project")

            app_content_type = ContentType.objects.get_for_model(
                ApplicationSubmission
            )
            proj_content_type = ContentType.objects.get_for_model(Project)

            authored_apps = ApplicationSubmission.objects.filter(user_qs).values(
                "id"
            )
            authored_projs = Project.objects.filter(user_qs).values("id")

            proj_app_qs = (
                Q(source_content_type=app_content_type)
                & Q(source_object_id__in=authored_apps)
            ) | (
                Q(source_content_type=proj_content_type)
                & Q(source_object_id__in=authored_projs)
            )

            # Activities the user is the author of the source submission
            applicant_activity = self.filter(
                proj_app_qs
                & Q(
                    Q(visibility__in=self.model.visibility_for(user, True))
                    | user_qs
                )
            )
            # All other activities
            other_activity = self.exclude(
                Q(message=messages.get(MESSAGES.NEW_REVIEW)) | proj_app_qs
            ).filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)
            return applicant_activity | other_activity
        else:
            return self.exclude(message=messages.get(MESSAGES.NEW_REVIEW)).filter(
                Q(visibility__in=self.model.visibility_for(user)) | user_qs
            )

    return self.filter(Q(visibility__in=self.model.visibility_for(user)) | user_qs)

newer 

newer(activity)
Source code in hypha/apply/activity/models.py 
121
122
def newer(self, activity):
    return self.filter(timestamp__gt=activity.timestamp)

ActionManager

Bases: ActivityBaseManager

type class-attribute instance-attribute 

type = ACTION

create 

create(**kwargs)
Source code in hypha/apply/activity/models.py 
139
140
141
def create(self, **kwargs):
    kwargs.update(type=self.type)
    return super().create(**kwargs)

get_queryset 

get_queryset()
Source code in hypha/apply/activity/models.py 
143
144
145
146
147
148
149
150
151
def get_queryset(self):
    return (
        super()
        .get_queryset()
        .filter(
            type=self.type,
            current=True,
        )
    )

ActivityAttachment

Bases: Model

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

uuid class-attribute instance-attribute 

uuid = UUIDField(unique=True, default=uuid4, editable=False)

activity class-attribute instance-attribute 

activity = ForeignKey('Activity', on_delete=CASCADE, related_name='attachments')

file class-attribute instance-attribute 

file = FileField(upload_to=get_attachment_upload_path, storage=PrivateStorage())

filename property 

filename

get_absolute_url 

get_absolute_url()
Source code in hypha/apply/activity/models.py 
193
194
def get_absolute_url(self):
    return reverse("activity:attachment", kwargs={"file_pk": str(self.uuid)})

Activity

Bases: Model

timestamp class-attribute instance-attribute 

timestamp = DateTimeField()

type class-attribute instance-attribute 

type = CharField(choices=items(), max_length=30)

user class-attribute instance-attribute 

user = ForeignKey(AUTH_USER_MODEL, on_delete=PROTECT)

source_content_type class-attribute instance-attribute 

source_content_type = ForeignKey(ContentType, blank=True, null=True, on_delete=CASCADE, related_name='activity_source')

source_object_id class-attribute instance-attribute 

source_object_id = PositiveIntegerField(blank=True, null=True, db_index=True)

source class-attribute instance-attribute 

source = GenericForeignKey('source_content_type', 'source_object_id')

message class-attribute instance-attribute 

message = TextField()

visibility class-attribute instance-attribute 

visibility = CharField(choices=list(items()), default=APPLICANT, max_length=30)

edited class-attribute instance-attribute 

edited = DateTimeField(default=None, null=True)

current class-attribute instance-attribute 

current = BooleanField(default=True)

previous class-attribute instance-attribute 

previous = ForeignKey('self', on_delete=CASCADE, null=True)

related_content_type class-attribute instance-attribute 

related_content_type = ForeignKey(ContentType, blank=True, null=True, on_delete=CASCADE, related_name='activity_related')

related_object_id class-attribute instance-attribute 

related_object_id = PositiveIntegerField(blank=True, null=True)

related_object class-attribute instance-attribute 

related_object = GenericForeignKey('related_content_type', 'related_object_id')

objects class-attribute instance-attribute 

objects = from_queryset(ActivityQuerySet)()

comments class-attribute instance-attribute 

comments = from_queryset(CommentQueryset)()

actions class-attribute instance-attribute 

actions = from_queryset(ActionQueryset)()

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

priviledged property 

priviledged

private property 

private

Meta

ordering class-attribute instance-attribute 
ordering = ['-timestamp']
base_manager_name class-attribute instance-attribute 
base_manager_name = 'objects'

get_absolute_url 

get_absolute_url()
Source code in hypha/apply/activity/models.py 
243
244
def get_absolute_url(self):
    return f"{self.source.get_absolute_url()}#communications--{self.id}"

visibility_for classmethod 

visibility_for(user, is_submission_author=False)

Gets activity visibility for a specified user

Takes an optional boolean that is used to determine the visibility of an application comment. This was mainly implemented to allow partners also holding the role of applicant to have a proper visibility.

ie. Prevent someone with the role of partner & applicant looking at comments on their own application and seeing partner visibility

Parameters:

  • user –

    User to get visibility for

  • is_submission_author (Optional[bool], default: False ) –

    boolean used when the user is the applicant of the source activity

Returns:

  • List[str] –

    A list of visibility strings

Source code in hypha/apply/activity/models.py 
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
@classmethod
def visibility_for(
    cls, user, is_submission_author: Optional[bool] = False
) -> List[str]:
    """Gets activity visibility for a specified user

    Takes an optional boolean that is used to determine the visibility of
    an application comment. This was mainly implemented to allow partners
    also holding the role of applicant to have a proper visibility.

    ie. Prevent someone with the role of partner & applicant looking at
    comments on their own application and seeing partner visibility

    Args:
        user:
            [`User`][hypha.apply.users.models.User] to get visibility for
        is_submission_author:
            boolean used when the `user` is the applicant of the source activity

    Returns:
        A list of visibility strings
    """
    if user.is_apply_staff:
        return [TEAM, APPLICANT, REVIEWER, APPLICANT_PARTNERS, PARTNER, ALL]
    if user.is_reviewer and not is_submission_author:
        return [REVIEWER, ALL]
    if user.is_finance or user.is_contracting:
        # for project part
        return [TEAM, APPLICANT, REVIEWER, PARTNER, ALL]
    if user.is_partner and not is_submission_author:
        return [PARTNER, ALL, APPLICANT_PARTNERS]
    if user.is_applicant:
        return [APPLICANT, ALL, APPLICANT_PARTNERS]

    return [ALL]

visibility_choices_for classmethod 

visibility_choices_for(user, submission_partner_list=None)

Gets activity visibility choices for the specified user

Uses the given user (and partner query set if provided) to give the specified user activity visibility choices.

Parameters:

  • user –

    The User being given visibility choices

  • submission_has_partner –

    An optional QuerySet of partners (Users)

Source code in hypha/apply/activity/models.py 
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
@classmethod
def visibility_choices_for(
    cls, user, submission_partner_list: Optional[QuerySet] = None
) -> List[Tuple[str, str]]:
    """Gets activity visibility choices for the specified user

    Uses the given user (and partner query set if provided) to give
    the specified user activity visibility choices.

    Args:
        user:
            The [`User`][hypha.apply.users.models.User] being given
            visibility choices
        submission_has_partner:
            An optional QuerySet of partners
            ([`Users`][hypha.apply.users.models.User])
    Returns:
        A list of tuples in the format of:
        [(<visibility string>, <visibility display string>), ...]
    """
    has_partner = submission_partner_list and len(submission_partner_list) > 0

    if user.is_apply_staff:
        if not has_partner:
            choices = [
                (TEAM, VISIBILITY[TEAM]),
                (APPLICANT, VISIBILITY[APPLICANT]),
                (REVIEWER, VISIBILITY[REVIEWER]),
                (ALL, VISIBILITY[ALL]),
            ]
        else:
            choices = [
                (TEAM, VISIBILITY[TEAM]),
                (APPLICANT, VISIBILITY[APPLICANT]),
                (PARTNER, VISIBILITY[PARTNER]),
                (APPLICANT_PARTNERS, VISIBILITY[APPLICANT_PARTNERS]),
                (REVIEWER, VISIBILITY[REVIEWER]),
                (ALL, VISIBILITY[ALL]),
            ]
        return choices

    if user.is_partner and has_partner and submission_partner_list.contains(user):
        return [
            (APPLICANT_PARTNERS, VISIBILITY[APPLICANT_PARTNERS]),
            (PARTNER, VISIBILITY[PARTNER]),
            (TEAM, VISIBILITY[TEAM]),
        ]

    if user.is_applicant and has_partner:
        return [
            (APPLICANT_PARTNERS, VISIBILITY[PARTNER]),
            (APPLICANT, VISIBILITY[TEAM]),
        ]

    if user.is_applicant:
        return [(APPLICANT, VISIBILITY[APPLICANT])]

    if user.is_reviewer:
        return [(REVIEWER, VISIBILITY[REVIEWER])]

    if user.is_finance or user.is_contracting:
        return [(TEAM, VISIBILITY[TEAM]), (APPLICANT, VISIBILITY[APPLICANT])]

    return [(ALL, VISIBILITY[ALL])]

Event

Bases: Model

Model to track when messages are triggered

wagtail_reference_index_ignore class-attribute instance-attribute 

wagtail_reference_index_ignore = True

when class-attribute instance-attribute 

when = DateTimeField(auto_now_add=True)

type class-attribute instance-attribute 

type = CharField(gettext('verb'), choices=choices, max_length=50)

by class-attribute instance-attribute 

by = ForeignKey(AUTH_USER_MODEL, on_delete=PROTECT, null=True)

content_type class-attribute instance-attribute 

content_type = ForeignKey(ContentType, blank=True, null=True, on_delete=CASCADE)

object_id class-attribute instance-attribute 

object_id = PositiveIntegerField(blank=True, null=True)

source class-attribute instance-attribute 

source = GenericForeignKey('content_type', 'object_id')

MessagesQueryset

Bases: QuerySet

update_status 

update_status(status)
Source code in hypha/apply/activity/models.py 
385
386
387
388
389
390
391
392
393
def update_status(self, status):
    if status:
        return self.update(
            status=Case(
                When(status="", then=Value(status)),
                default=Concat("status", Value("<br />" + status)),
                output_field=models.TextField(),
            ),
        )

Message

Bases: Model

Model to track content of messages sent from an event

type class-attribute instance-attribute 

type = CharField(max_length=15)

content class-attribute instance-attribute 

content = TextField()

recipient class-attribute instance-attribute 

recipient = CharField(max_length=250)

event class-attribute instance-attribute 

event = ForeignKey(Event, on_delete=CASCADE)

status class-attribute instance-attribute 

status = TextField()

external_id class-attribute instance-attribute 

external_id = CharField(max_length=75, null=True, blank=True)

sent_in_email_digest class-attribute instance-attribute 

sent_in_email_digest = BooleanField(default=False)

objects class-attribute instance-attribute 

objects = as_manager()

update_status 

update_status(status)
Source code in hypha/apply/activity/models.py 
415
416
417
418
419
420
421
422
def update_status(self, status):
    if status:
        self.status = Case(
            When(status="", then=Value(status)),
            default=Concat("status", Value("<br />" + status)),
            output_field=models.TextField(),
        )
        self.save()

get_attachment_upload_path 

get_attachment_upload_path(instance, filename)
Source code in hypha/apply/activity/models.py 
170
171
def get_attachment_upload_path(instance, filename):
    return f"activity/attachments/{instance.id}/{get_valid_filename(filename)}"