gestioCOF/bda/forms.py

# -*- coding: utf-8 -*-

from django import forms
from django.forms.models import BaseInlineFormSet
from django.utils import timezone

from bda.models import Attribution, Spectacle, SpectacleRevente


class InscriptionInlineFormSet(BaseInlineFormSet):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # self.instance is a Participant object
        tirage = self.instance.tirage

        # set once for all "spectacle" field choices
        # - restrict choices to the spectacles of this tirage
        # - force_choices avoid many db requests
        spectacles = tirage.spectacle_set.select_related('location')
        choices = [(sp.pk, str(sp)) for sp in spectacles]
        self.force_choices('spectacle', choices)

    def force_choices(self, name, choices):
        """Set choices of a field.

        As ModelChoiceIterator (default use to get choices of a
        ModelChoiceField), it appends an empty selection if requested.

        """
        for form in self.forms:
            field = form.fields[name]
            if field.empty_label is not None:
                field.choices = [('', field.empty_label)] + choices
            else:
                field.choices = choices


class TokenForm(forms.Form):
    token = forms.CharField(widget=forms.widgets.Textarea())


class AttributionModelMultipleChoiceField(forms.ModelMultipleChoiceField):
    def label_from_instance(self, obj):
        return str(obj.spectacle)


class ReventeModelMultipleChoiceField(forms.ModelMultipleChoiceField):
    def __init__(self, *args, own=True, **kwargs):
        super().__init__(*args, **kwargs)
        self.own = own

    def label_from_instance(self, obj):
        label = "{show}{suffix}"
        suffix = ""
        if self.own:
            # C'est notre propre revente : informations sur le statut
            if obj.soldTo is not None:
                suffix = " -- Vendue à {firstname} {lastname}".format(
                            firstname=obj.soldTo.user.first_name,
                            lastname=obj.soldTo.user.last_name,
                        )
            elif obj.shotgun:
                suffix = " -- Tirage infructueux"
            elif obj.notif_sent:
                suffix = " -- Inscriptions au tirage en cours"
        else:
            # Ce n'est pas à nous : on ne voit jamais l'acheteur
            suffix = " -- Vendue par {firstname} {lastname}".format(
                            firstname=obj.seller.user.first_name,
                            lastname=obj.seller.user.last_name,
                        )

        return label.format(show=str(obj.attribution.spectacle),
                            suffix=suffix)


class ResellForm(forms.Form):
    attributions = AttributionModelMultipleChoiceField(
                         label='',
                         queryset=Attribution.objects.none(),
                         widget=forms.CheckboxSelectMultiple,
                         required=False)

    def __init__(self, participant, *args, **kwargs):
        super(ResellForm, self).__init__(*args, **kwargs)
        self.fields['attributions'].queryset = (
            participant.attribution_set
            .filter(spectacle__date__gte=timezone.now())
            .exclude(revente__seller=participant)
            .select_related('spectacle', 'spectacle__location',
                            'participant__user')
        )


class AnnulForm(forms.Form):
    reventes = ReventeModelMultipleChoiceField(
                         own=True,
                         label='',
                         queryset=Attribution.objects.none(),
                         widget=forms.CheckboxSelectMultiple,
                         required=False)

    def __init__(self, participant, *args, **kwargs):
        super(AnnulForm, self).__init__(*args, **kwargs)
        self.fields['reventes'].queryset = (
            participant.original_shows
            .filter(attribution__spectacle__date__gte=timezone.now(),
                    soldTo__isnull=True)
            .select_related('attribution__spectacle',
                            'attribution__spectacle__location')
            .order_by('-date')
        )


class InscriptionReventeForm(forms.Form):
    spectacles = forms.ModelMultipleChoiceField(
                    queryset=Spectacle.objects.none(),
                    widget=forms.CheckboxSelectMultiple,
                    required=False)

    def __init__(self, tirage, *args, **kwargs):
        super(InscriptionReventeForm, self).__init__(*args, **kwargs)
        self.fields['spectacles'].queryset = (
            tirage.spectacle_set
            .select_related('location')
            .filter(date__gte=timezone.now())
        )


class ReventeTirageAnnulForm(forms.Form):
    reventes = ReventeModelMultipleChoiceField(
                  own=False,
                  label='',
                  queryset=SpectacleRevente.objects.none(),
                  widget=forms.CheckboxSelectMultiple,
                  required=False
              )

    def __init__(self, participant, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['reventes'].queryset = (
            participant.entered.filter(soldTo__isnull=True)
                       .select_related('attribution__spectacle',
                                       'seller__user')
        )


class ReventeTirageForm(forms.Form):
    reventes = ReventeModelMultipleChoiceField(
                  own=False,
                  label='',
                  queryset=SpectacleRevente.objects.none(),
                  widget=forms.CheckboxSelectMultiple,
                  required=False
              )

    def __init__(self, participant, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['reventes'].queryset = (
            SpectacleRevente.objects.filter(
                notif_sent=True,
                shotgun=False,
                tirage_done=False
            ).exclude(confirmed_entry=participant)
            .select_related('attribution__spectacle')
        )


class SoldForm(forms.Form):
    reventes = ReventeModelMultipleChoiceField(
                        own=True,
                        label='',
                        queryset=Attribution.objects.none(),
                        widget=forms.CheckboxSelectMultiple)

    def __init__(self, participant, *args, **kwargs):
        super(SoldForm, self).__init__(*args, **kwargs)
        self.fields['reventes'].queryset = (
            participant.original_shows
            .filter(soldTo__isnull=False)
            .exclude(soldTo=participant)
            .select_related('attribution__spectacle',
                            'attribution__spectacle__location')
        )