event_registration.py

from django.db import transaction, IntegrityError
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.utils.text import slugify
from django.utils.translation import gettext as _

import graphene
from graphene_django import DjangoObjectType
from templated_email import send_templated_mail

from aleksis.apps.postbuero.models import MailAddress, MailDomain
from aleksis.apps.postbuero.schema import MailAddressInputType
from aleksis.core.models import Activity, Person
from aleksis.core.schema.base import PermissionsTypeMixin
from aleksis.core.schema.person import PersonInputType
from aleksis.core.schema.user import UserInputType
from aleksis.core.util.core_helpers import get_site_preferences

from ..models import Event, EventRegistration, Terms, Voucher


class EventRegistrationType(PermissionsTypeMixin, DjangoObjectType):
    class Meta:
        model = EventRegistration


class PaymentInputType(graphene.InputObjectType):
    payment_method = graphene.String(required=True)
    voucher_code = graphene.String(required=False)
    amount = graphene.Int(required=False) # FIXME: Fix frontend to allow 0, then make field required again


class EventRegistrationInputType(graphene.InputObjectType):
    email = graphene.Field(MailAddressInputType, required=False)
    person = graphene.Field(PersonInputType, required=False)
    user = graphene.Field(UserInputType, required=False)
    school = graphene.String(required=False)
    school_place = graphene.String(required=False)
    school_class = graphene.String(required=False)
    payment = graphene.Field(PaymentInputType, required=False)
    medical_information = graphene.String(required=False)
    comment = graphene.String(required=False)
    additional_fields = graphene.JSONString(required=False)
    terms = graphene.JSONString(required=False)
    retraction_consent = graphene.Boolean(required=True)


class SendEventRegistrationMutation(graphene.Mutation):
    class Arguments:
        event = graphene.ID(required=True)
        event_registration = EventRegistrationInputType(required=True)

    ok = graphene.Boolean()

    @transaction.atomic
    def mutate(self, info, event: graphene.ID, event_registration: EventRegistrationInputType, **kwargs):
        if not event_registration["retraction_consent"]:
            raise ValidationError(_("Retraction consent is required"))

        event = Event.objects.get(pk=event)

        email = None

        if event_registration["email"] is not None:
            try:
                domain = MailDomain.objects.get(pk=event_registration["email"]["domain"])
            except IntegrityError:
                raise ValidationError(_("Mail domain does not exist."))
            try:
                _mail_address = MailAddress.objects.create(
                    local_part=event_registration["email"]["local_part"],
                    domain=domain,
                )
            except IntegrityError:
                raise ValidationError(_("Mail address already in use."))

            email = str(_mail_address)
        elif event_registration["user"] is not None:
            email = event_registration["user"]["email"]

        # Create user
        if event_registration["user"] is not None:
            try:
                user = User.objects.create(
                    username=event_registration["user"]["username"],
                    email=event_registration["user"]["email"],
                )
            except IntegrityError:
                raise ValidationError(_("A user with this username or e-mail already exists."))

            user.set_password(event_registration["user"]["password"])
            user.save()
        else:
            user = info.context.user

        try:
            person, created = Person.objects.get_or_create(
                user=user,
                defaults={
                    "email": email,
                    "first_name": event_registration["person"]["first_name"],
                    "last_name": event_registration["person"]["last_name"],
                },
            )
        except IntegrityError:
            raise ValidationError(_("A person using the e-mail address %s already exists.") % email)

        # Store contact information in database
        for field_name in ["date_of_birth", "sex", "address", "mobile_number"]:
            if event_registration["person"] is not None and event_registration["person"][field_name] is not None and event_registration["person"][field_name] != "":
                if field_name == "address":
                    for addr_field in ["street", "housenumber", "postal_code", "place"]:
                        setattr(person, addr_field, event_registration["person"]["address"][addr_field])
                else:
                    setattr(person, field_name, event_registration["person"][field_name])
        person.save()

        if event_registration["person"] is not None:
            for guardian_data in event_registration["person"]["guardians"]:
                if "id" in guardian_data:
                    guardian = Person.objects.get(pk=guardian_data["id"])
                    guardian.first_name=guardian_data["first_name"]
                    guardian.last_name=guardian_data["last_name"]
                    guardian.email=guardian_data["email"]
                    guardian.mobile_number=guardian_data["mobile_number"]
                    
                    guardian.save()
                else:
                    try:
                        guardian, created = Person.objects.get_or_create(
                            defaults={
                                "mobile_number": guardian_data["mobile_number"],
                            },
                            first_name=guardian_data["first_name"],
                            last_name=guardian_data["last_name"],
                            email=guardian_data["email"],
                        )
                    except IntegrityError:
                        raise ValidationError(_("A person using the e-mail address %s already exists.") % guardian_data["email"])

                    person.guardians.add(guardian)
            person.save()

        if event_registration["email"] is not None:
            _mail_address.person = person
            _mail_address.save()

        school_details = {}
        for field_name in ["school", "school_class", "school_place"]:
            if event_registration[field_name] is not None:
                school_details[field_name] = event_registration[field_name]

        registration = EventRegistration.objects.create(
            managed_by_app_label="",
            event=event,
            person=person,
            medical_information=event_registration["medical_information"],
            donation=0,
            **school_details,
        )
        for field in event.additional_fields.all():
            if hasattr(event_registration["additional_fields"], str(field.id)):
                registration.extended_data[
                    slugify(field.title).replace("-", "_")
                ] = event_registration["additional_fields"][str(field.id)]

        for field in event_registration["terms"]:
            pk = field
            term = Terms.objects.get(id=pk)
            registration.accepted_terms.add(term)

        registration.cost = event.cost

        if event.max_cost is None or event.max_cost > 0:
            amount = event_registration["payment"]["amount"]
            if amount is None:
                raise ValidationError(_("The field 'Amount paid by you' is required."))

            if amount < event.cost:
                voucher_amount = event.cost - amount
                discount = voucher_amount / event.cost * 100
                voucher = Voucher.objects.create(
                    person=person,
                    event=event,
                    used=True,
                    discount=discount,
                )
                registration.voucher = voucher
            elif amount > event.cost:
                registration.donation = amount - event.cost

            # TODO Implement existing voucher handling

            invoice = registration.get_invoice()
            if amount == 0:
                invoice.variant = "pledge"
            else:
                invoice.variant = event_registration["payment"]["payment_method"]
                if invoice.variant == "" or invoice.variant is None:
                    raise ValidationError(_("The field 'Payment method' is required."))
            invoice.save()

        registration.save()

        context = {}
        context["registration"] = registration

#        send_templated_mail(
#            template_name="event_registered",
#            from_email=get_site_preferences()["mail__address"],
#            recipient_list=[get_site_preferences()["paweljong__event_notification_recipient"]],
#            headers={
#                "reply_to": [
#                    person.email,
#                    person.guardians.first().email,
#                ],
#                "X-Zammad-Customer-Email": person.email,
#            },
#            context=context,
#        )

        _act = Activity(
            title=_("You registered for an event"),
            description=_("You registered for the event %s" % event.display_name),
            app="Paweljong",
            user=person,
        )

        return SendEventRegistrationMutation(ok=True)