services.py 8.74 KB
Newer Older
1
2
from collections import OrderedDict

3
4
5
6
7
8
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _, get_language

from events import emails
from events.exceptions import RegistrationError
from events.models import Registration, RegistrationInformationField
9
from payments.models import Payment
10
11


12
def is_user_registered(member, event):
13
14
    """
    Returns if the user is registered for the specified event
15

16
17
18
19
    :param member: the user
    :param event: the event
    :return: None if registration is not required or no member else True/False
    """
20
    if not event.registration_required or not member.is_authenticated:
21
22
23
        return None

    return event.registrations.filter(
24
        member=member,
25
26
27
        date_cancelled=None).count() > 0


28
def event_permissions(member, event):
29
30
    """
    Returns a dictionary with the available event permissions of the user
31

32
33
34
35
    :param member: the user
    :param event: the event
    :return: the permission dictionary
    """
36
37
38
39
40
    perms = {
        "create_registration": False,
        "cancel_registration": False,
        "update_registration": False,
    }
41
    if member and member.is_authenticated:
42
43
44
45
        registration = None
        try:
            registration = Registration.objects.get(
                event=event,
46
                member=member
47
48
49
50
51
52
            )
        except Registration.DoesNotExist:
            pass

        perms["create_registration"] = (
            (registration is None or registration.date_cancelled is not None)
53
54
            and event.registration_allowed and
            member.can_attend_events)
55
56
57
58
59
60
        perms["cancel_registration"] = (
            registration is not None and
            registration.date_cancelled is None and
            event.cancellation_allowed)
        perms["update_registration"] = (
            registration is not None and
61
62
63
64
            registration.date_cancelled is None and
            event.has_fields() and
            event.registration_allowed and
            member.can_attend_events)
65
66
67
68

    return perms


69
def is_organiser(member, event):
70
71
72
    if member and member.is_authenticated:
        if member.is_superuser or member.has_perm("events.override_organiser"):
            return True
73

74
        if event and member.has_perm('events.change_event'):
75
            return member.get_member_groups().filter(
76
                    pk=event.organiser.pk).count() != 0
77
78
79
80

    return False


81
def create_registration(member, event):
82
83
    """
    Creates a new user registration for an event
84

85
86
87
88
    :param member: the user
    :param event: the event
    :return: returns the registration if successful
    """
89
    if event_permissions(member, event)["create_registration"]:
90
91
92
93
        registration = None
        try:
            registration = Registration.objects.get(
                event=event,
94
                member=member
95
96
97
98
99
100
101
            )
        except Registration.DoesNotExist:
            pass

        if registration is None:
            return Registration.objects.create(
                event=event,
102
                member=member
103
104
105
106
107
108
109
110
111
112
113
114
            )
        elif registration.date_cancelled is not None:
            if registration.is_late_cancellation():
                raise RegistrationError(_("You cannot re-register anymore "
                                          "since you've cancelled after the "
                                          "deadline."))
            else:
                registration.date = timezone.now()
                registration.date_cancelled = None
                registration.save()

        return registration
115
    elif event_permissions(member, event)["cancel_registration"]:
116
117
118
119
120
        raise RegistrationError(_("You were already registered."))
    else:
        raise RegistrationError(_("You may not register."))


121
def cancel_registration(request, member, event):
122
123
    """
    Cancel a user registration for an event
124

125
126
127
128
    :param request: the request object
    :param member: the user
    :param event: the event
    """
129
130
131
132
    registration = None
    try:
        registration = Registration.objects.get(
            event=event,
133
            member=member
134
135
136
137
        )
    except Registration.DoesNotExist:
        pass

138
139
    if (event_permissions(member, event)["cancel_registration"] and
            registration):
140
141
142
        if registration.queue_position == 0:
            emails.notify_first_waiting(request, event)

143
144
145
146
            if (event.send_cancel_email and
                    event.after_cancel_deadline):
                emails.notify_organiser(event, registration)

147
148
149
150
151
152
153
154
155
156
        # Note that this doesn"t remove the values for the
        # information fields that the user entered upon registering.
        # But this is regarded as a feature, not a bug. Especially
        # since the values will still appear in the backend.
        registration.date_cancelled = timezone.now()
        registration.save()
    else:
        raise RegistrationError(_("You are not registered for this event."))


157
def update_registration(member, event, field_values):
158
159
    """
    Updates a user registration of an event
160

161
162
163
164
    :param member: the user
    :param event: the event
    :param field_values: values for the information fields
    """
165
166
167
168
    registration = None
    try:
        registration = Registration.objects.get(
            event=event,
169
            member=member
170
171
172
173
174
175
176
        )
    except Registration.DoesNotExist:
        pass

    if not registration:
        raise RegistrationError(_("You are not registered for this event."))

177
    if not event_permissions(member, event)["update_registration"]:
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
        return

    for field_id, field_value in field_values:
        field = RegistrationInformationField.objects.get(
            id=field_id.replace("info_field_", ""))

        if (field.type == RegistrationInformationField.INTEGER_FIELD
                and field_value is None):
            field_value = 0
        elif (field.type == RegistrationInformationField.BOOLEAN_FIELD
                and field_value is None):
            field_value = False
        elif (field.type == RegistrationInformationField.TEXT_FIELD
              and field_value is None):
            field_value = ''

        field.set_value_for(registration, field_value)


197
def registration_fields(request, member, event):
198
199
    """
    Returns information about the registration fields of a registration
200

201
202
203
204
    :param member: the user
    :param event: the event
    :return: the fields
    """
205
206
207
    try:
        registration = Registration.objects.get(
            event=event,
208
            member=member
209
        )
210
211
212
    except Registration.DoesNotExist as error:
        raise RegistrationError(
            _("You are not registered for this event.")) from error
213

214
215
216
    perms = (event_permissions(member, event)["update_registration"] or
             is_organiser(request.member, event))
    if perms and registration:
217
        information_fields = registration.information_fields
218
        fields = OrderedDict()
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

        for information_field in information_fields:
            field = information_field["field"]

            fields["info_field_{}".format(field.id)] = {
                "type": field.type,
                "label": getattr(field, "{}_{}".format(
                    "name",  get_language())),
                "description": getattr(field, "{}_{}".format(
                    "description", get_language())),
                "value": information_field["value"],
                "required": field.required
            }

        return fields
    else:
235
236
        raise RegistrationError(
            _("You are not allowed to update this registration."))
237
238
239
240
241
242
243
244


def update_registration_by_organiser(registration, member, data):
    if not is_organiser(member, registration.event):
        raise RegistrationError(
            _("You are not allowed to update this registration."))

    if 'payment' in data:
245
246
247
248
249
250
251
252
253
254
        if (data['payment']['type'] == Payment.NONE
                and registration.payment is not None):
            p = registration.payment
            registration.payment = None
            registration.save()
            p.delete()
        elif (data['payment']['type'] != Payment.NONE
              and registration.payment is not None):
            registration.payment.type = data['payment']['type']
            registration.payment.save()
Sébastiaan Versteeg's avatar
Sébastiaan Versteeg committed
255
        elif (data['payment']['type'] != Payment.NONE
256
257
258
259
              and registration.payment is None):
            registration.payment = Payment.objects.create(
                amount=registration.event.price,
                paid_by=registration.member,
260
261
262
                notes=(f'Event registration {registration.event.title_en}'
                       f'{registration.event.start}. '
                       f'Registration date: {registration.date}.'),
263
264
265
                processed_by=member,
                type=data['payment']['type']
            )
266
267
268
269
270

    if 'present' in data:
        registration.present = data['present']

    registration.save()