kpsul/bda/admin.py

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

from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

from django.core.mail import send_mail
from django.contrib import admin
from django.db.models import Sum, Count
from django.template.defaultfilters import pluralize
from django.utils import timezone
from django import forms
from bda.models import Spectacle, Salle, Participant, ChoixSpectacle,\
    Attribution, Tirage, Quote, CategorieSpectacle, SpectacleRevente

from datetime import timedelta

import autocomplete_light


class ChoixSpectacleInline(admin.TabularInline):
    model = ChoixSpectacle
    sortable_field_name = "priority"


class AttributionInline(admin.TabularInline):
    model = Attribution
    extra = 0

    def get_queryset(self, request):
        qs = super(AttributionInline, self).get_queryset(request)
        return qs.filter(spectacle__listing=False)


class AttributionInlineListing(admin.TabularInline):
    model = Attribution
    exclude = ('given', )
    extra = 0

    def get_queryset(self, request):
        qs = super(AttributionInlineListing, self).get_queryset(request)
        return qs.filter(spectacle__listing=True)


class ParticipantAdmin(admin.ModelAdmin):
    inlines = [AttributionInline, AttributionInlineListing]

    def get_queryset(self, request):
        return Participant.objects.annotate(nb_places=Count('attributions'),
                                            total=Sum('attributions__price'))

    def nb_places(self, obj):
        return obj.nb_places
    nb_places.admin_order_field = "nb_places"
    nb_places.short_description = "Nombre de places"

    def total(self, obj):
        tot = obj.total
        if tot:
            return "%.02f €" % tot
        else:
            return "0 €"
    total.admin_order_field = "total"
    total.short_description = "Total à payer"
    list_display = ("user", "nb_places", "total", "paid", "paymenttype",
                    "tirage")
    list_filter = ("paid", "tirage")
    search_fields = ('user__username', 'user__first_name', 'user__last_name')
    actions = ['send_attribs', ]
    actions_on_bottom = True
    list_per_page = 400
    readonly_fields = ("total",)

    def send_attribs(self, request, queryset):
        for member in queryset.all():
            attribs = member.attributions.all()
            if len(attribs) == 0:
                mail = """Cher-e %s,

Tu t'es inscrit-e pour le tirage au sort du BdA. Malheureusement, tu n'as
obtenu aucune place.

Nous proposons cependant de nombreuses offres hors-tirage tout au long de
l'année, et nous t'invitons à nous contacter si l'une d'entre elles
t'intéresse !
--
Le Bureau des Arts

"""
                name = member.user.get_full_name()
                mail = mail % name
            else:
                mail = """Cher-e %s,

Tu t'es inscrit-e pour le tirage au sort du BdA. Tu as été sélectionné-e
pour les spectacles suivants :

%s

*Paiement*
L'intégralité de ces places de spectacles est à régler dès maintenant et AVANT
le %s, au bureau du COF pendant les heures de permanences (du lundi au vendredi
entre 12h et 14h, et entre 18h et 20h). Des facilités de paiement sont bien
évidemment possibles : nous pouvons ne pas encaisser le chèque immédiatement,
ou bien découper votre paiement en deux fois. Pour ceux qui ne pourraient pas
venir payer au bureau, merci de nous contacter par mail.

*Mode de retrait des places*
Au moment du paiement, certaines places vous seront remises directement,
d'autres seront à récupérer au cours de l'année, d'autres encore seront
nominatives et à retirer le soir même dans les theâtres correspondants.
Pour chaque spectacle, vous recevrez un mail quelques jours avant la
représentation vous indiquant le mode de retrait.

Nous vous rappelons que l'obtention de places du BdA vous engage à
respecter les règles de fonctionnement :
http://www.cof.ens.fr/bda/?page_id=1370
Le système de revente des places via les mails BdA-revente sera très
prochainement disponible, directement sur votre compte GestioCOF.

En vous souhaitant de très beaux spectacles tout au long de l'année,
--
Le Bureau des Arts
"""
                attribs_text = ""
                name = member.user.get_full_name()
                for attrib in attribs:
                    attribs_text += "- 1 place pour %s\n" % attrib
                deadline = member.tirage.fermeture + timedelta(days=7)
                mail = mail % (name, attribs_text,
                               deadline.strftime('%d %b %Y'))
                send_mail("Résultats du tirage au sort", mail,
                          "bda@ens.fr", [member.user.email],
                          fail_silently=True)
        count = len(queryset.all())
        if count == 1:
            message_bit = "1 membre a"
            plural = ""
        else:
            message_bit = "%d membres ont" % count
            plural = "s"
        self.message_user(request, "%s été informé%s avec succès."
                          % (message_bit, plural))
    send_attribs.short_description = "Envoyer les résultats par mail"


class AttributionAdminForm(forms.ModelForm):
    def clean(self):
        cleaned_data = super(AttributionAdminForm, self).clean()
        participant = cleaned_data.get("participant")
        spectacle = cleaned_data.get("spectacle")
        if participant and spectacle:
            if participant.tirage != spectacle.tirage:
                raise forms.ValidationError(
                    "Erreur : le participant et le spectacle n'appartiennent"
                    "pas au même tirage")
        return cleaned_data


class AttributionAdmin(admin.ModelAdmin):
    def paid(self, obj):
        return obj.participant.paid
    paid.short_description = 'A payé'
    paid.boolean = True
    list_display = ("id", "spectacle", "participant", "given", "paid")
    search_fields = ('spectacle__title', 'participant__user__username',
                     'participant__user__first_name',
                     'participant__user__last_name')
    form = AttributionAdminForm


class ChoixSpectacleAdmin(admin.ModelAdmin):
    form = autocomplete_light.modelform_factory(ChoixSpectacle, exclude=[])

    def tirage(self, obj):
        return obj.participant.tirage
    list_display = ("participant", "tirage", "spectacle", "priority",
                    "double_choice")
    list_filter = ("double_choice", "participant__tirage")
    search_fields = ('participant__user__username',
                     'participant__user__first_name',
                     'participant__user__last_name',
                     'spectacle__title')


class QuoteInline(admin.TabularInline):
    model = Quote


class SpectacleAdmin(admin.ModelAdmin):
    inlines = [QuoteInline]
    model = Spectacle
    list_display = ("title", "date", "tirage", "location", "slots", "price",
                    "listing")
    list_filter = ("location", "tirage",)
    search_fields = ("title", "location__name")
    readonly_fields = ("rappel_sent", )


class TirageAdmin(admin.ModelAdmin):
    model = Tirage
    list_display = ("title", "ouverture", "fermeture", "active",
                    "enable_do_tirage")
    readonly_fields = ("tokens", )
    list_filter = ("active", )
    search_fields = ("title", )


class SalleAdmin(admin.ModelAdmin):
    model = Salle
    search_fields = ('name', 'address')


class SpectacleReventeAdmin(admin.ModelAdmin):
    """
    Administration des reventes de spectacles
    """
    model = SpectacleRevente

    def spectacle(self, obj):
        """
        Raccourci vers le spectacle associé à la revente.
        """
        return obj.attribution.spectacle

    list_display = ("spectacle", "seller", "date", "soldTo")
    raw_id_fields = ("attribution",)
    readonly_fields = ("shotgun", "expiration_time")
    search_fields = ['attribution__spectacle__title',
                     'seller__user__username',
                     'seller__user__first_name',
                     'seller__user__last_name']

    actions = ['transfer', 'reinit']
    actions_on_bottom = True

    def transfer(self, request, queryset):
        """
        Effectue le transfert des reventes pour lesquels on connaît l'acheteur.
        """
        reventes = queryset.exclude(soldTo__isnull=True).all()
        count = reventes.count()
        for revente in reventes:
            attrib = revente.attribution
            attrib.participant = revente.soldTo
            attrib.save()
        self.message_user(
            request,
            "%d attribution%s %s été transférée%s avec succès." % (
                count, pluralize(count),
                pluralize(count, "a,ont"), pluralize(count))
            )
    transfer.short_description = "Transférer les reventes sélectionnées"

    def reinit(self, request, queryset):
        """
        Réinitialise les reventes.
        """
        count = queryset.count()
        for revente in queryset.filter(
                attribution__spectacle__date__gte=timezone.now()):
            revente.date = timezone.now() - timedelta(hours=1)
            revente.soldTo = None
            revente.notif_sent = False
            revente.tirage_done = False
            if revente.answered_mail:
                revente.answered_mail.clear()
            revente.save()
        self.message_user(
            request,
            "%d attribution%s %s été réinitialisée%s avec succès." % (
                count, pluralize(count),
                pluralize(count, "a,ont"), pluralize(count))
            )
    reinit.short_description = "Réinitialiser les reventes sélectionnées"


admin.site.register(CategorieSpectacle)
admin.site.register(Spectacle, SpectacleAdmin)
admin.site.register(Salle, SalleAdmin)
admin.site.register(Participant, ParticipantAdmin)
admin.site.register(Attribution, AttributionAdmin)
admin.site.register(ChoixSpectacle, ChoixSpectacleAdmin)
admin.site.register(Tirage, TirageAdmin)
admin.site.register(SpectacleRevente, SpectacleReventeAdmin)