views.py 11.4 KB
Newer Older
1
"""Views provided by the registrations package"""
2
from django.conf import settings
3
4
5
6
7
8
from django.contrib import messages
from django.contrib.admin.utils import model_ngettext
from django.contrib.admin.views.decorators import staff_member_required
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import ValidationError
9
10
from django.http import Http404
from django.shortcuts import redirect, get_object_or_404
11
12
13
14
15
16
from django.template.defaultfilters import floatformat
from django.urls import reverse
from django.utils import timezone
from django.utils.decorators import method_decorator
from django.utils.translation import ugettext_lazy as _
from django.views import View
17
from django.views.generic import FormView, CreateView
18
19
from django.views.generic.base import TemplateResponseMixin, TemplateView

20
from members.decorators import membership_required
21
from members.models import Membership
Thom Wiggers's avatar
Thom Wiggers committed
22
from . import emails, forms, services
23
from .models import Entry, Registration, Renewal, Reference
Thom Wiggers's avatar
Thom Wiggers committed
24

25
26

class BecomeAMemberView(TemplateView):
27
    """View that render a HTML template with context data"""
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    template_name = 'registrations/become_a_member.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['year_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                               Entry.MEMBERSHIP_YEAR], 2)
        context['study_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                                Entry.MEMBERSHIP_STUDY], 2)
        return context


@method_decorator(staff_member_required, name='dispatch')
@method_decorator(permission_required('registrations.review_entries'),
                  name='dispatch', )
class EntryAdminView(View):
43
    """
44
    View that handles the processing of entries
45
    """
46

47
48
    def post(self, request, *args, **kwargs):
        action = request.POST.get('action')
49
50
51
52
53
54
        entry_qs = Entry.objects.filter(pk=kwargs['pk'])
        try:
            entry = entry_qs.get()
        except Entry.DoesNotExist:
            return redirect('admin:index')

55
        if action == 'accept':
56
57
58
59
            if not services.check_unique_user(entry):
                messages.error(request, _('Could not accept %s. '
                                          'Username is not unique.') %
                               model_ngettext(entry, 1))
60
            elif services.accept_entries(request.user.pk, entry_qs) > 0:
61
62
63
64
65
                messages.success(request, _('Successfully accepted %s.') %
                                 model_ngettext(entry, 1))
            else:
                messages.error(request, _('Could not accept %s.') %
                               model_ngettext(entry, 1))
66
        elif action == 'reject':
67
            if services.reject_entries(request.user.pk, entry_qs) > 0:
68
69
70
71
72
                messages.success(request, _('Successfully rejected %s.') %
                                 model_ngettext(entry, 1))
            else:
                messages.error(request, _('Could not reject %s.') %
                               model_ngettext(entry, 1))
73
74
75
76
77
        elif action == 'resend':
            try:
                emails.send_registration_email_confirmation(entry.registration)
            except Registration.DoesNotExist:
                pass
78
        elif action == 'revert':
79
            services.revert_entry(request.user.pk, entry)
80
81
82
83
84
85
86
87
88
89
90
91

        if entry_qs.filter(renewal=None).exists():
            content_type = ContentType.objects.get_for_model(Registration)
        else:
            content_type = ContentType.objects.get_for_model(Renewal)

        return redirect("admin:%s_%s_change" %
                        (content_type.app_label, content_type.model),
                        kwargs['pk'])


class ConfirmEmailView(View, TemplateResponseMixin):
92
93
94
95
    """
    View that renders an HTML template and confirms the email address
    of the provided registration
    """
96
97
98
    template_name = 'registrations/confirm_email.html'

    def get(self, request, *args, **kwargs):
99
        queryset = Registration.objects.filter(pk=kwargs['pk'])
100

101
        processed = 0
102
        try:
103
            processed = services.confirm_entry(queryset)
104
105
106
        except ValidationError:
            pass

107
        if processed == 0:
108
            return redirect('registrations:register-member')
109

110
111
112
113
114
115
116
        registration = queryset.get()

        if (registration.membership_type == Membership.BENEFACTOR
                and not registration.no_references):
            emails.send_references_information_message(registration)

        emails.send_new_registration_board_message(registration)
117
118
119
120

        return self.render_to_response({})


121
class BaseRegistrationFormView(FormView):
122
    """
123
    View that renders a membership registration form
124
    """
125
126
127
128
129
    form_class = forms.MemberRegistrationForm
    template_name = 'registrations/register_member.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
Thalia Technicie's avatar
Thalia Technicie committed
130
        context['google_api_key'] = settings.GOOGLE_PLACES_API_KEY
131
132
133
134
135
136
137
138
139
140
141
        context['year_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                               Entry.MEMBERSHIP_YEAR], 2)
        context['study_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                                Entry.MEMBERSHIP_STUDY], 2)
        return context

    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated:
            return redirect('registrations:renew')
        return super().get(request, args, kwargs)

142
143
144
145
146
147
148
149
150
151
152
153
    def form_valid(self, form):
        form.save()
        return redirect('registrations:register-success')


class MemberRegistrationFormView(BaseRegistrationFormView):
    """
    View that renders the `member` membership registration form
    """
    form_class = forms.MemberRegistrationForm
    template_name = 'registrations/register_member.html'

154
155
156
157
158
159
160
    def post(self, request, *args, **kwargs):
        request.POST = request.POST.dict()
        request.POST['language'] = request.LANGUAGE_CODE
        request.POST['membership_type'] = Membership.MEMBER
        return super().post(request, *args, **kwargs)

    def form_valid(self, form):
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
        response = super().form_valid(form)
        emails.send_registration_email_confirmation(form.instance)
        return response


class BenefactorRegistrationFormView(BaseRegistrationFormView):
    """
    View that renders the `benefactor` membership registration form
    """
    form_class = forms.BenefactorRegistrationForm
    template_name = 'registrations/register_benefactor.html'

    def post(self, request, *args, **kwargs):
        request.POST = request.POST.dict()
        request.POST['language'] = request.LANGUAGE_CODE
        request.POST['membership_type'] = Membership.BENEFACTOR
        request.POST['length'] = Entry.MEMBERSHIP_YEAR
        request.POST['remarks'] = ('Registered as iCIS employee'
                                   if 'icis_employee' in request.POST else '')
        request.POST['no_references'] = 'icis_employee' in request.POST
        return super().post(request, *args, **kwargs)
182
183
184
185


@method_decorator(login_required, name='dispatch')
class RenewalFormView(FormView):
186
187
188
    """
    View that renders the membership renewal form
    """
189
    form_class = forms.RenewalForm
190
191
192
193
194
195
196
197
    template_name = 'registrations/renewal.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['year_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                               Entry.MEMBERSHIP_YEAR], 2)
        context['study_fees'] = floatformat(settings.MEMBERSHIP_PRICES[
                                                Entry.MEMBERSHIP_STUDY], 2)
198
        context['latest_membership'] = self.request.member.latest_membership
Thom Wiggers's avatar
Thom Wiggers committed
199
200
        context['was_member'] = Membership.objects.filter(
            user=self.request.member, type=Membership.MEMBER).exists()
201
        context['benefactor_type'] = Membership.BENEFACTOR
202
203
204
205
206
        return context

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        member = self.request.member
207
        if member is not None and member.latest_membership is not None:
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
            latest_membership = member.latest_membership
            # If latest membership has not ended or does not ends
            # within 1 month: do not show 'year' length
            hide_year_choice = not (latest_membership is not None and
                                    latest_membership.until is not None and
                                    (latest_membership.until -
                                     timezone.now().date()).days <= 31)

            if hide_year_choice:
                form.fields['length'].choices = [
                    c for c in form.fields['length'].choices
                    if c[0] != Entry.MEMBERSHIP_YEAR
                ]

        return form

    def post(self, request, *args, **kwargs):
        request.POST = request.POST.dict()
226
227
        if request.member.latest_membership.type == Membership.BENEFACTOR:
            request.POST['membership_type'] = Membership.BENEFACTOR
228
            request.POST['length'] = Entry.MEMBERSHIP_YEAR
229
        request.POST['member'] = request.member.pk
230
231
232
233
234
235
236
237
238
239
240
241
        request.POST['remarks'] = ''
        request.POST['no_references'] = False

        if request.POST['membership_type'] == Membership.BENEFACTOR:
            if Membership.objects.filter(user=request.member,
                                         type=Membership.MEMBER).exists():
                request.POST['remarks'] = 'Was a Thalia member in the past.'
                request.POST['no_references'] = True
            if 'icis_employee' in request.POST:
                request.POST['remarks'] = 'Registered as iCIS employee.'
                request.POST['no_references'] = True

242
243
244
245
        return super().post(request, *args, **kwargs)

    def form_valid(self, form):
        renewal = form.save()
246
247
        if not renewal.no_references:
            emails.send_references_information_message(renewal)
248
249
        emails.send_new_renewal_board_message(renewal)
        return redirect('registrations:renew-success')
250
251
252
253
254
255
256
257
258
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


@method_decorator(login_required, name='dispatch')
@method_decorator(membership_required, name='dispatch')
class ReferenceCreateView(CreateView):
    """
    View that renders a reference creation form
    """
    model = Reference
    fields = '__all__'
    template_name = 'registrations/reference.html'
    entry = None
    success = False

    def get_success_url(self):
        return reverse('registrations:reference-success',
                       args=(self.entry.pk,))

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        context['success'] = self.success
        try:
            context['name'] = self.entry.registration.get_full_name()
        except Registration.DoesNotExist:
            context['name'] = self.entry.renewal.member.get_full_name()

        return context

    def dispatch(self, request, *args, **kwargs):
        self.entry = get_object_or_404(Entry, pk=kwargs.get('pk'))

        if (self.entry.no_references or
                self.entry.membership_type != Membership.BENEFACTOR):
            raise Http404

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

    def post(self, request, *args, **kwargs):
        request.POST = request.POST.dict()
        request.POST['member'] = request.member.pk
        request.POST['entry'] = kwargs['pk']
        return super().post(request, *args, **kwargs)