X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/967eed676fc83d15b26149047f353ac61faa8217..e2a460b0a960df9482701ab10ec135a5cc3c69ac:/src/club/models.py diff --git a/src/club/models.py b/src/club/models.py index 17771742c..92d62c3bd 100644 --- a/src/club/models.py +++ b/src/club/models.py @@ -1,75 +1,92 @@ -# -*- coding: utf-8 -from __future__ import unicode_literals - -from datetime import timedelta +# This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later. +# Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information. +# +from datetime import datetime, timedelta +import os +import tempfile +from django.apps import apps from django.conf import settings +from django.contrib.sites.models import Site +from django.core.mail import send_mail, EmailMessage from django.urls import reverse from django.db import models +from django import template from django.utils.timezone import now -from django.utils.translation import ugettext_lazy as _, ungettext +from django.utils.translation import ugettext_lazy as _, ungettext, ugettext, get_language +from django_countries.fields import CountryField from catalogue.utils import get_random_hash -from .payment_methods import methods, method_by_slug - +from messaging.states import Level +from reporting.utils import render_to_pdf +from .payment_methods import methods +from .payu import models as payu_models +from . import utils -class Plan(models.Model): - """ Plans are set up by administrators. """ - MONTH = 30 - YEAR = 365 - PERPETUAL = 999 - intervals = [ - (MONTH, _('a month')), - (YEAR, _('a year')), - (PERPETUAL, _('in perpetuity')), - ] - interval = models.SmallIntegerField(_('inteval'), choices=intervals) - min_amount = models.DecimalField(_('min_amount'), max_digits=10, decimal_places=2) - allow_recurring = models.BooleanField(_('allow recurring')) - allow_one_time = models.BooleanField(_('allow one time')) +class Club(models.Model): + min_amount = models.IntegerField(_('minimum amount')) + min_for_year = models.IntegerField(_('minimum amount for year')) + single_amounts = models.CharField(_('proposed amounts for single payment'), max_length=255) + default_single_amount = models.IntegerField(_('default single amount')) + monthly_amounts = models.CharField(_('proposed amounts for monthly payments'), max_length=255) + default_monthly_amount = models.IntegerField(_('default monthly amount')) class Meta: - verbose_name = _('plan') - verbose_name_plural = _('plans') - + verbose_name = _('club') + verbose_name_plural = _('clubs') + def __str__(self): - return "%s %s" % (self.min_amount, self.get_interval_display()) + return 'Klub' - class Meta: - ordering = ('interval',) + def proposed_single_amounts(self): + return [int(x) for x in self.single_amounts.split(',')] - def payment_methods(self): - for method in methods: - if self.allow_recurring and method.is_recurring or self.allow_one_time and not method.is_recurring: - yield method + def proposed_monthly_amounts(self): + return [int(x) for x in self.monthly_amounts.split(',')] - def get_next_installment(self, date): - if self.interval == self.PERPETUAL: - return None - elif self.interval == self.YEAR: - return date.replace(year=date.year + 1) - elif self.interval == self.MONTH: - day = date.day - date = (date.replace(day=1) + timedelta(31)).replace(day=1) + timedelta(day - 1) - if date.day != day: - date = date.replace(day=1) - return date - + +class Consent(models.Model): + order = models.IntegerField() + active = models.BooleanField(default=True) + text = models.CharField(max_length=2048) + required = models.BooleanField() + + class Meta: + ordering = ['order'] + + def __str__(self): + return self.text class Schedule(models.Model): """ Represents someone taking up a plan. """ key = models.CharField(_('key'), max_length=255, unique=True) email = models.EmailField(_('email')) - membership = models.ForeignKey('Membership', verbose_name=_('membership'), null=True, blank=True, on_delete=models.PROTECT) - plan = models.ForeignKey(Plan, verbose_name=_('plan'), on_delete=models.PROTECT) + membership = models.ForeignKey('Membership', verbose_name=_('membership'), null=True, blank=True, on_delete=models.SET_NULL) amount = models.DecimalField(_('amount'), max_digits=10, decimal_places=2) - method = models.CharField(_('method'), max_length=255, choices=[(method.slug, method.name) for method in methods]) - is_active = models.BooleanField(_('active'), default=False) + method = models.CharField(_('method'), max_length=32, choices=[ + (m.slug, m.name) for m in methods + ]) + monthly = models.BooleanField(_('monthly'), default=True) + yearly = models.BooleanField(_('yearly'), default=False) + + source = models.CharField(_('source'), max_length=255, blank=True) + is_cancelled = models.BooleanField(_('cancelled'), default=False) + payed_at = models.DateTimeField(_('payed at'), null=True, blank=True) started_at = models.DateTimeField(_('started at'), auto_now_add=True) expires_at = models.DateTimeField(_('expires_at'), null=True, blank=True) - # extra info? + email_sent = models.BooleanField(default=False) + first_name = models.CharField(max_length=255, blank=True) + last_name = models.CharField(max_length=255, blank=True) + phone = models.CharField(max_length=255, blank=True) + postal = models.CharField(max_length=255, blank=True) + postal_code = models.CharField(max_length=255, blank=True) + postal_town = models.CharField(max_length=255, blank=True) + postal_country = CountryField(default='PL', blank=True) + + consent = models.ManyToManyField(Consent) + class Meta: verbose_name = _('schedule') verbose_name_plural = _('schedules') @@ -80,50 +97,129 @@ class Schedule(models.Model): def save(self, *args, **kwargs): if not self.key: self.key = get_random_hash(self.email) - return super(Schedule, self).save(*args, **kwargs) + super(Schedule, self).save(*args, **kwargs) + self.update_contact() + + def initiate_payment(self, request): + return self.get_payment_method().initiate(request, self) + + def pay(self, request): + return self.get_payment_method().pay(request, self) def get_absolute_url(self): return reverse('club_schedule', args=[self.key]) - def get_payment_method(self): - return method_by_slug[self.method] + def get_thanks_url(self): + return reverse('club_thanks', args=[self.key]) + def get_payment_method(self): + return [m for m in methods if m.slug == self.method][0] def is_expired(self): - return self.expires_at is not None and self.expires_at < now() + return self.expires_at is not None and self.expires_at <= now() + + def is_active(self): + return self.payed_at is not None and (self.expires_at is None or self.expires_at > now()) - def create_payment(self): + def is_recurring(self): + return self.monthly or self.yearly + + def set_payed(self): + since = self.expires_at n = now() - self.expires_at = self.plan.get_next_installment(n) - self.is_active = True + if since is None or since < n: + since = n + new_exp = self.get_next_installment(since) + if self.payed_at is None: + self.payed_at = n + if self.expires_at is None or self.expires_at < new_exp: + self.expires_at = new_exp + self.save() + + if not self.email_sent: + self.send_email() + + def get_next_installment(self, date): + if self.yearly: + return utils.add_year(date) + if self.monthly: + return utils.add_month(date) + club = Club.objects.first() + if club is not None and self.amount >= club.min_for_year: + return utils.add_year(date) + return utils.add_month(date) + + def send_email(self): + ctx = {'schedule': self} + send_mail( + template.loader.render_to_string('club/email/thanks_subject.txt', ctx).strip(), + template.loader.render_to_string('club/email/thanks.txt', ctx), + settings.CONTACT_EMAIL, [self.email], fail_silently=False) + self.email_sent = True self.save() - self.payment_set.create(payed_at=n) + def update_contact(self): + Contact = apps.get_model('messaging', 'Contact') + if not self.payed_at: + level = Level.TRIED + since = self.started_at + else: + since = self.payed_at + if self.is_recurring(): + level = Level.RECURRING + else: + level = Level.SINGLE + Contact.update(self.email, level, since, self.expires_at) -class Payment(models.Model): - schedule = models.ForeignKey(Schedule, verbose_name=_('schedule'), on_delete=models.PROTECT) - created_at = models.DateTimeField(_('created at'), auto_now_add=True) - payed_at = models.DateTimeField(_('payed at'), null=True, blank=True) - class Meta: - verbose_name = _('payment') - verbose_name_plural = _('payments') - def __str__(self): - return "%s %s" % (self.schedule, self.payed_at) class Membership(models.Model): """ Represents a user being recognized as a member of the club. """ user = models.OneToOneField(settings.AUTH_USER_MODEL, verbose_name=_('user'), on_delete=models.CASCADE) created_at = models.DateTimeField(_('created at'), auto_now_add=True) + name = models.CharField(_('name'), max_length=255, blank=True) + manual = models.BooleanField(_('manual'), default=False) + notes = models.CharField(_('notes'), max_length=2048, blank=True) + updated_at = models.DateField(_('updated at'), auto_now=True, blank=True) class Meta: verbose_name = _('membership') verbose_name_plural = _('memberships') def __str__(self): - return u'tow. ' + str(self.user) + return str(self.user) + + def save(self, *args, **kwargs): + super().save(*args, **kwargs) + self.update_contact() + + def update_contact(self): + email = self.user.email + if not email: + return + + Contact = apps.get_model('messaging', 'Contact') + if self.manual: + Contact.update(email, Level.MANUAL_MEMBER, self.updated_at) + else: + Contact.reset(email) + + @classmethod + def is_active_for(cls, user): + if user.is_anonymous: + return False + try: + membership = user.membership + except cls.DoesNotExist: + return False + if membership.manual: + return True + return Schedule.objects.filter( + expires_at__gt=now(), + membership__user=user, + ).exists() class ReminderEmail(models.Model): @@ -142,3 +238,135 @@ class ReminderEmail(models.Model): else: return ungettext('a day after expiration', '%d days after expiration', n=-self.days_before) + +class Ambassador(models.Model): + name = models.CharField(_('name'), max_length=255) + photo = models.ImageField(_('photo'), blank=True) + text = models.CharField(_('text'), max_length=1024) + + class Meta: + verbose_name = _('ambassador') + verbose_name_plural = _('ambassadors') + ordering = ['name'] + + def __str__(self): + return self.name + + +######## +# # +# PayU # +# # +######## + +class PayUOrder(payu_models.Order): + schedule = models.ForeignKey(Schedule, on_delete=models.CASCADE) + + def get_amount(self): + return self.schedule.amount + + def get_buyer(self): + return { + "email": self.schedule.email, + "language": get_language(), + } + + def get_continue_url(self): + return "https://{}{}".format( + Site.objects.get_current().domain, + self.schedule.get_thanks_url()) + + def get_description(self): + return ugettext('Towarzystwo Przyjaciół Wolnych Lektur') + + def is_recurring(self): + return self.schedule.get_payment_method().is_recurring + + def get_card_token(self): + return self.schedule.payucardtoken_set.order_by('-created_at').first() + + def get_notify_url(self): + return "https://{}{}".format( + Site.objects.get_current().domain, + reverse('club_payu_notify', args=[self.pk])) + + def status_updated(self): + if self.status == 'COMPLETED': + self.schedule.set_payed() + + + @classmethod + def send_receipt(cls, email, year): + Contact = apps.get_model('messaging', 'Contact') + Funding = apps.get_model('funding', 'Funding') + payments = [] + + try: + contact = Contact.objects.get(email=email) + except Contact.DoesNotExist: + funding = Funding.objects.filter( + email=email, + payed_at__year=year, + notifications=True).order_by('payed_at').first() + if funding is None: + print('no notifications') + return + optout = funding.wl_optout_url() + else: + if contact.level == Level.OPT_OUT: + print('opt-out') + return + optout = contact.wl_optout_url() + + qs = cls.objects.filter(status='COMPLETED', schedule__email=email, completed_at__year=year).order_by('completed_at') + for order in qs: + payments.append({ + 'timestamp': order.completed_at, + 'amount': order.get_amount(), + }) + + fundings = Funding.objects.filter( + email=email, + payed_at__year=year + ).order_by('payed_at') + for funding in fundings: + payments.append({ + 'timestamp': funding.payed_at, + 'amount': funding.amount, + }) + + if not payments: return + + payments.sort(key=lambda x: x['timestamp']) + + ctx = { + "email": email, + "year": year, + "next_year": year + 1, + "total": sum(x['amount'] for x in payments), + "payments": payments, + "optout": optout, + } + temp = tempfile.NamedTemporaryFile(prefix='receipt-', suffix='.pdf', delete=False) + temp.close() + render_to_pdf(temp.name, 'club/receipt.texml', ctx, { + "fnp.eps": os.path.join(settings.STATIC_ROOT, "img/fnp.eps"), + }) + + message = EmailMessage( + f'Odlicz od podatku swoje darowizny przekazane dla Wolnych Lektur', + template.loader.render_to_string('club/receipt_email.txt', ctx), + settings.CONTACT_EMAIL, [email] + ) + with open(temp.name, 'rb') as f: + message.attach('wolnelektury-darowizny.pdf', f.read(), 'application/pdf') + message.send() + os.unlink(f.name) + + +class PayUCardToken(payu_models.CardToken): + schedule = models.ForeignKey(Schedule, on_delete=models.CASCADE) + + +class PayUNotification(payu_models.Notification): + order = models.ForeignKey(PayUOrder, models.CASCADE, related_name='notification_set')