Merge remote-tracking branch 'zawadzki/new-design'
[wolnelektury.git] / src / club / models.py
1 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
2 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
3 #
4 from datetime import datetime, timedelta
5 import os
6 import tempfile
7 from django.apps import apps
8 from django.conf import settings
9 from django.contrib.sites.models import Site
10 from django.core.mail import send_mail, EmailMessage
11 from django.urls import reverse
12 from django.db import models
13 from django import template
14 from django.utils.timezone import now
15 from django.utils.translation import ugettext_lazy as _, ungettext, ugettext, get_language
16 from django_countries.fields import CountryField
17 from catalogue.utils import get_random_hash
18 from messaging.states import Level
19 from reporting.utils import render_to_pdf
20 from .payment_methods import methods
21 from .payu import models as payu_models
22 from .civicrm import report_activity
23 from . import utils
24
25
26 class Club(models.Model):
27     min_amount = models.IntegerField(_('minimum amount'))
28     min_for_year = models.IntegerField(_('minimum amount for year'))
29     single_amounts = models.CharField(_('proposed amounts for single payment'), max_length=255)
30     default_single_amount = models.IntegerField(_('default single amount'))
31     monthly_amounts = models.CharField(_('proposed amounts for monthly payments'), max_length=255)
32     default_monthly_amount = models.IntegerField(_('default monthly amount'))
33
34     class Meta:
35         verbose_name = _('club')
36         verbose_name_plural = _('clubs')
37     
38     def __str__(self):
39         return 'Klub'
40     
41     def proposed_single_amounts(self):
42         return [int(x) for x in self.single_amounts.split(',')]
43
44     def proposed_monthly_amounts(self):
45         return [int(x) for x in self.monthly_amounts.split(',')]
46
47
48 class Consent(models.Model):
49     order = models.IntegerField()
50     active = models.BooleanField(default=True)
51     text = models.CharField(max_length=2048)
52     required = models.BooleanField()
53
54     class Meta:
55         ordering = ['order']
56     
57     def __str__(self):
58         return self.text
59
60
61 class Schedule(models.Model):
62     """ Represents someone taking up a plan. """
63     key = models.CharField(_('key'), max_length=255, unique=True)
64     email = models.EmailField(_('email'))
65     membership = models.ForeignKey('Membership', verbose_name=_('membership'), null=True, blank=True, on_delete=models.SET_NULL)
66     amount = models.DecimalField(_('amount'), max_digits=10, decimal_places=2)
67     method = models.CharField(_('method'), max_length=32, choices=[
68         (m.slug, m.name) for m in methods
69         ])
70     monthly = models.BooleanField(_('monthly'), default=True)
71     yearly = models.BooleanField(_('yearly'), default=False)
72
73     source = models.CharField(_('source'), max_length=255, blank=True)
74
75     is_cancelled = models.BooleanField(_('cancelled'), default=False)
76     payed_at = models.DateTimeField(_('payed at'), null=True, blank=True)
77     started_at = models.DateTimeField(_('started at'), auto_now_add=True)
78     expires_at = models.DateTimeField(_('expires_at'), null=True, blank=True)
79     email_sent = models.BooleanField(default=False)
80
81     first_name = models.CharField(max_length=255, blank=True)
82     last_name = models.CharField(max_length=255, blank=True)
83     phone = models.CharField(max_length=255, blank=True)
84     postal = models.CharField(max_length=255, blank=True)
85     postal_code = models.CharField(max_length=255, blank=True)
86     postal_town = models.CharField(max_length=255, blank=True)
87     postal_country = CountryField(default='PL', blank=True)
88
89     consent = models.ManyToManyField(Consent)
90     
91     class Meta:
92         verbose_name = _('schedule')
93         verbose_name_plural = _('schedules')
94
95     def __str__(self):
96         return self.key
97
98     def save(self, *args, **kwargs):
99         if not self.key:
100             self.key = get_random_hash(self.email)
101         super(Schedule, self).save(*args, **kwargs)
102         self.update_contact()
103
104     def initiate_payment(self, request):
105         return self.get_payment_method().initiate(request, self)
106
107     def pay(self, request):
108         return self.get_payment_method().pay(request, self)
109
110     def get_absolute_url(self):
111         return reverse('club_schedule', args=[self.key])
112
113     def get_thanks_url(self):
114         return reverse('club_thanks', args=[self.key])
115
116     def get_payment_method(self):
117         return [m for m in methods if m.slug == self.method][0]
118
119     def is_expired(self):
120         return self.expires_at is not None and self.expires_at <= now()
121
122     def is_active(self):
123         return self.payed_at is not None and (self.expires_at is None or self.expires_at > now())
124
125     def is_recurring(self):
126         return self.monthly or self.yearly
127
128     def set_payed(self):
129         since = self.expires_at
130         n = now()
131         if since is None or since < n:
132             since = n
133         new_exp = self.get_next_installment(since)
134         if self.payed_at is None:
135             self.payed_at = n
136         if self.expires_at is None or self.expires_at < new_exp:
137             self.expires_at = new_exp
138             self.save()
139
140         if not self.email_sent:
141             self.send_email()
142     
143     def get_next_installment(self, date):
144         if self.yearly:
145             return utils.add_year(date)
146         if self.monthly:
147             return utils.add_month(date)
148         club = Club.objects.first()
149         if club is not None and self.amount >= club.min_for_year:
150             return utils.add_year(date)
151         return utils.add_month(date)
152
153     def send_email(self):
154         ctx = {'schedule': self}
155         send_mail(
156             template.loader.render_to_string('club/email/thanks_subject.txt', ctx).strip(),
157             template.loader.render_to_string('club/email/thanks.txt', ctx),
158             settings.CONTACT_EMAIL, [self.email], fail_silently=False)
159         self.email_sent = True
160         self.save()
161
162     def update_contact(self):
163         Contact = apps.get_model('messaging', 'Contact')
164         if not self.payed_at:
165             level = Level.TRIED
166             since = self.started_at
167         else:
168             since = self.payed_at
169             if self.is_recurring():
170                 level = Level.RECURRING
171             else:
172                 level = Level.SINGLE
173         Contact.update(self.email, level, since, self.expires_at)
174
175
176
177
178
179 class Membership(models.Model):
180     """ Represents a user being recognized as a member of the club. """
181     user = models.OneToOneField(settings.AUTH_USER_MODEL, verbose_name=_('user'), on_delete=models.CASCADE)
182     created_at = models.DateTimeField(_('created at'), auto_now_add=True)
183     name = models.CharField(_('name'), max_length=255, blank=True)
184     manual = models.BooleanField(_('manual'), default=False)
185     notes = models.CharField(_('notes'), max_length=2048, blank=True)
186     updated_at = models.DateField(_('updated at'), auto_now=True, blank=True)
187
188     class Meta:
189         verbose_name = _('membership')
190         verbose_name_plural = _('memberships')
191
192     def __str__(self):
193         return str(self.user)
194
195     def save(self, *args, **kwargs):
196         super().save(*args, **kwargs)
197         self.update_contact()
198
199     def update_contact(self):
200         email = self.user.email
201         if not email:
202             return
203
204         Contact = apps.get_model('messaging', 'Contact')
205         if self.manual:
206             Contact.update(email, Level.MANUAL_MEMBER, self.updated_at)
207         else:
208             Contact.reset(email)
209
210     @classmethod
211     def is_active_for(cls, user):
212         if user.is_anonymous:
213             return False
214         try:
215             membership = user.membership
216         except cls.DoesNotExist:
217             return False
218         if membership.manual:
219             return True
220         return Schedule.objects.filter(
221                 expires_at__gt=now(),
222                 membership__user=user,
223             ).exists()
224
225
226 class ReminderEmail(models.Model):
227     days_before = models.SmallIntegerField(_('days before'))
228     subject = models.CharField(_('subject'), max_length=1024)
229     body = models.TextField(_('body'))
230
231     class Meta:
232         verbose_name = _('reminder email')
233         verbose_name_plural = _('reminder emails')
234         ordering = ['days_before']
235
236     def __str__(self):
237         if self.days_before >= 0:
238             return ungettext('a day before expiration', '%d days before expiration', n=self.days_before)
239         else:
240             return ungettext('a day after expiration', '%d days after expiration', n=-self.days_before)
241
242
243 class Ambassador(models.Model):
244     name = models.CharField(_('name'), max_length=255)
245     photo = models.ImageField(_('photo'), blank=True)
246     text = models.CharField(_('text'), max_length=1024)
247
248     class Meta:
249         verbose_name = _('ambassador')
250         verbose_name_plural = _('ambassadors')
251         ordering = ['name']
252     
253     def __str__(self):
254         return self.name
255
256         
257 ########
258 #      #
259 # PayU #
260 #      #
261 ########
262
263 class PayUOrder(payu_models.Order):
264     schedule = models.ForeignKey(Schedule, on_delete=models.CASCADE)
265
266     def get_amount(self):
267         return self.schedule.amount
268
269     def get_buyer(self):
270         return {
271             "email": self.schedule.email,
272             "language": get_language(),
273         }
274
275     def get_continue_url(self):
276         return "https://{}{}".format(
277             Site.objects.get_current().domain,
278             self.schedule.get_thanks_url())
279
280     def get_description(self):
281         return ugettext('Towarzystwo Przyjaciół Wolnych Lektur')
282
283     def is_recurring(self):
284         return self.schedule.get_payment_method().is_recurring
285
286     def get_card_token(self):
287         return self.schedule.payucardtoken_set.order_by('-created_at').first()
288
289     def get_notify_url(self):
290         return "https://{}{}".format(
291             Site.objects.get_current().domain,
292             reverse('club_payu_notify', args=[self.pk]))
293
294     def status_updated(self):
295         if self.status == 'COMPLETED':
296             self.schedule.set_payed()
297         self.report_activity()
298
299     @property
300     def updated_at(self):
301         try:
302             return self.notification_set.all().order_by('-received_at')[0].received_at
303         except IndexError:
304             return None
305     
306     def report_activity(self):
307         if self.status not in ['COMPLETED', 'CANCELED', 'REJECTED']:
308             return
309
310         if self.status != 'COMPLETED':
311             name = settings.CIVICRM_ACTIVITIES['Failed contribution']
312         elif self.is_recurring():
313             name = settings.CIVICRM_ACTIVITIES['Recurring contribution']
314         else:
315             name = settings.CIVICRM_ACTIVITIES['Contribution']
316
317         report_activity.delay(
318             self.schedule.email,
319             self.schedule.key,
320             f'payu:{self.id}',
321             name,
322             self.updated_at,
323             {
324                 'kwota': self.schedule.amount,
325             }
326         )            
327
328     @classmethod
329     def send_receipt(cls, email, year):
330         Contact = apps.get_model('messaging', 'Contact')
331         Funding = apps.get_model('funding', 'Funding')
332         BillingAgreement = apps.get_model('paypal', 'BillingAgreement')
333         payments = []
334
335         try:
336             contact = Contact.objects.get(email=email)
337         except Contact.DoesNotExist:
338             funding = Funding.objects.filter(
339                 email=email,
340                 payed_at__year=year,
341                 notifications=True).order_by('payed_at').first()
342             if funding is None:
343                 print('no notifications')
344                 return
345             optout = funding.wl_optout_url()
346         else:
347             if contact.level == Level.OPT_OUT:
348                 print('opt-out')
349                 return
350             optout = contact.wl_optout_url()
351
352         qs = cls.objects.filter(status='COMPLETED', schedule__email=email, completed_at__year=year).order_by('completed_at')
353         for order in qs:
354             payments.append({
355                 'timestamp': order.completed_at,
356                 'amount': order.get_amount(),
357             })
358
359         for ba in BillingAgreement.objects.filter(schedule__email=email):
360             payments.extend(ba.get_donations(year))
361
362         fundings = Funding.objects.filter(
363             email=email,
364             payed_at__year=year
365         ).order_by('payed_at')
366         for funding in fundings:
367             payments.append({
368                 'timestamp': funding.payed_at,
369                 'amount': funding.amount,
370             })
371
372         if not payments: return
373
374         payments.sort(key=lambda x: x['timestamp'])
375
376         ctx = {
377             "email": email,
378             "year": year,
379             "next_year": year + 1,
380             "total": sum(x['amount'] for x in payments),
381             "payments": payments,
382             "optout": optout,
383         }
384         temp = tempfile.NamedTemporaryFile(prefix='receipt-', suffix='.pdf', delete=False)
385         temp.close()
386         render_to_pdf(temp.name, 'club/receipt.texml', ctx, {
387             "fnp.eps": os.path.join(settings.STATIC_ROOT, "img/fnp.eps"),
388             })
389
390         message = EmailMessage(
391                 'Odlicz darowiznę na Wolne Lektury od podatku',
392                 template.loader.render_to_string('club/receipt_email.txt', ctx),
393                 settings.CONTACT_EMAIL, [email]
394             )
395         with open(temp.name, 'rb') as f:
396             message.attach('wolnelektury-darowizny.pdf', f.read(), 'application/pdf')
397         message.send()
398         os.unlink(f.name)
399
400
401 class PayUCardToken(payu_models.CardToken):
402     schedule = models.ForeignKey(Schedule, on_delete=models.CASCADE)
403
404
405 class PayUNotification(payu_models.Notification):
406     order = models.ForeignKey(PayUOrder, models.CASCADE, related_name='notification_set')