mixins.py

from django.conf import settings
from django.contrib.auth.mixins import PermissionRequiredMixin
from django.core.exceptions import ImproperlyConfigured
from django.http import Http404

from core.models.assemblies import Assembly
from core.models.badges import Badge
from core.models.conference import Conference, ConferenceMember


class ConferenceSlugMixin(PermissionRequiredMixin):
    permission_required = []

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._conference = None
        self._conferencemember = None

    def has_permission(self):
        required = self.get_permission_required()
        if not required:
            return True

        cm = self.conferencemember
        return cm.has_perms(required) if cm else False

    @property
    def conference(self):
        if self._conference is None:
            try:
                conference_id = settings.SELECTED_CONFERENCE_ID
                if not conference_id:
                    raise ImproperlyConfigured('You must specify SELECTED_CONFERENCE_ID for the API endpoints to work.')
                self._conference = Conference.objects.accessible_by_user(self.request.user).get(pk=conference_id)
            except Conference.DoesNotExist:
                raise Http404('The configured conference is not available.')
        return self._conference

    @property
    def conferencemember(self):
        if self._conferencemember is None:
            self._conferencemember = ConferenceMember.get_member(conference=self.conference, user=self.request.user)
            return self._conferencemember if self._conferencemember.is_authenticated else None
        return self._conferencemember


class ConferenceSlugAssemblyMixin(ConferenceSlugMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._assembly = None

    @property
    def assembly(self):
        if self._assembly is None:
            assembly_slug = self.request.resolver_match.kwargs['assembly']
            try:
                self._assembly = Assembly.objects.associated_with_user(self.conference, user=self.request.user).get(slug=assembly_slug)
            except Assembly.DoesNotExist:
                if issuing_token := self.kwargs.get('issuing_token', None):
                    try:
                        self._assembly = Badge.objects.get(issuing_token=issuing_token).issuing_assembly
                    except Badge.DoesNotExist:
                        raise Http404('Issuing Token does not exist')
                else:
                    raise Http404('Assembly does not exist')
        return self._assembly