ernestophone.ens.fr/calendrier/views.py

from collections import defaultdict
from datetime import date, datetime
import string
import random
from django.db.models import Q

from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.sites.shortcuts import get_current_site
from django.db.models import Count
from django.utils.safestring import mark_safe
from django.views.generic import UpdateView, DeleteView
from django.urls import reverse, reverse_lazy
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.core.mail import send_mail
from django.http import Http404

from gestion.models import ErnestoUser
from actu.models import Actu
from calendrier.calend import EventCalendar
from calendar import monthrange
from calendrier.forms import ModifEventForm, EventForm, ParticipantsForm, ChangeDoodleName
from calendrier.models import Event, Participants
from partitions.decorators import chef_required



def generer(*args):
    caracteres = string.ascii_letters + string.digits
    aleatoire = [random.choice(caracteres) for _ in range(6)]
    return ''.join(aleatoire)

def liste(request):
    if request.user.is_authenticated :
        return redirect('calendrier:home')
    lToday = datetime.today()
    events_a_venir = Event.objects.filter(date__gte = lToday).exclude(calendrier__iexact = 'F')
    events_passe = Event.objects.filter(date__lt = lToday).filter(calendrier__iexact = 'H')
    return render(request, 'calendrier/agenda.html', {"events_a_venir": events_a_venir,"events_passe":events_passe})


def named_month(pMonthNumber):
    return date(1900, pMonthNumber, 1).strftime('%B')

@login_required
def home(request):
    lToday = datetime.now()
    return calendar(request, lToday.year, lToday.month)

@login_required
def calendar(request, pYear, pMonth):
    actu = Actu.objects.all()
    lToday = datetime.now()
    lYear = int(pYear)
    lMonth = int(pMonth)
    lCalendarFromMonth = datetime(lYear, lMonth, 1)
    lCalendarToMonth = datetime(lYear, lMonth, monthrange(lYear, lMonth)[1])
    lEvents = Event.objects.filter(date__gte=lCalendarFromMonth,
                                   date__lte=lCalendarToMonth,
                                   calendrier=True)
    if request.user.is_authenticated:
        lEvents = Event.objects.filter(date__gte=lCalendarFromMonth,
                                       date__lte=lCalendarToMonth)
    lCalendar = EventCalendar(lEvents).formatmonth(lYear, lMonth)
    lPreviousYear = lYear
    lPreviousMonth = lMonth - 1
    if lPreviousMonth == 0:
        lPreviousMonth = 12
        lPreviousYear -= 1
    lNextYear = lYear
    lNextMonth = lMonth + 1
    if lNextMonth == 13:
        lNextMonth = 1
        lNextYear = lYear + 1
    lYearAfterThis = lYear + 1
    lYearBeforeThis = lYear - 1
    try:
        events_a_venir_not_answered = Event.objects.filter(date__gte = lToday).exclude(participants__participant=request.user.profile)
        events_a_venir_answered = Event.objects.filter(date__gte = lToday).filter(participants__participant=request.user.profile)
        events_a_venir_answered_yes = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant=request.user.profile )& Q(participants__reponse= 'oui'))
        events_a_venir_answered_no = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant=request.user.profile) & Q(participants__reponse= 'non'))
        events_a_venir_answered_pe = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant=request.user.profile)& Q(participants__reponse= 'pe'))
    except:
        events_a_venir_not_answered = Event.objects.filter(date__gte = lToday).exclude(participants__participant__user__username=request.user)
        events_a_venir_answered = Event.objects.filter(date__gte = lToday).filter(participants__participant__user__username=request.user)
        events_a_venir_answered_yes = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant__user__username=request.user )& Q(participants__reponse= 'oui'))
        events_a_venir_answered_no = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant__user__username=request.user) & Q(participants__reponse= 'non'))
        events_a_venir_answered_pe = Event.objects.filter(date__gte = lToday).filter(Q(participants__participant__user__username=request.user)& Q(participants__reponse= 'pe'))
    return render(request, 'calendrier/home.html', {
        'Calendar': mark_safe(lCalendar),
        'Month': lMonth,
        'MonthName': named_month(lMonth),
        'Year': lYear,
        'PreviousMonth': lPreviousMonth,
        'PreviousMonthName': named_month(lPreviousMonth),
        'PreviousYear': lPreviousYear,
        'NextMonth': lNextMonth,
        'NextMonthName': named_month(lNextMonth),
        'NextYear': lNextYear,
        'YearBeforeThis': lYearBeforeThis,
        'YearAfterThis': lYearAfterThis,
        "events_a_venir_answered_yes": events_a_venir_answered_yes,
        "events_a_venir_answered_no": events_a_venir_answered_no,
        "events_a_venir_answered_pe": events_a_venir_answered_pe,
        "events_a_venir_not_answered": events_a_venir_not_answered,
        "actu" : actu,

    })

@login_required
def view_event(request, id):
    event = get_object_or_404(Event, id=id)
    participants = event.participants_set.all()
    multi_instrumentistes = event.participants_set.filter(Q(participant__multi_instrumentiste = 'Oui')& ~Q(reponse = 'non'))

    # Restricted event, only erneso users can see it
    if not request.user.is_authenticated and not event.calendrier:
        return redirect(reverse('calendrier:home'))

    # Count the number of occurences of each instrument
    instrument_count = defaultdict(lambda: (0, 0,[],[],[]))
    for participant in participants:
        instrument = participant.participant.instru
        if (instrument == "Autre"):
            instrument = participant.participant.instru_autre

        sure, maybe, namesoui, namespe, namesnon = instrument_count[instrument]

        if participant.reponse == "oui":

            namesoui += [participant.participant.get_doodlename()]
            instrument_count[instrument] = (sure + 1, maybe,namesoui,namespe,namesnon)
        elif participant.reponse == "pe":
            namespe += [participant.participant.get_doodlename()]
            instrument_count[instrument] = (sure, maybe + 1,namesoui,namespe,namesnon)
        else:
            namesnon += [participant.participant.get_doodlename()]
            instrument_count[instrument] = (sure, maybe,namesoui,namespe,namesnon)

    instrument_count = [
        (instrument, sure, maybe,namesoui, namespe ,namesnon)
        for instrument, (sure, maybe,namesoui,namespe,namesnon) in instrument_count.items()
    ]

    context = {
        "event": event,
        "instrument_count": instrument_count,
        "participants": participants,
        "nboui": len(participants.filter(reponse="oui")),
        "nbpe": len(participants.filter(reponse="pe")),
        "nbnon": len(participants.filter(reponse="non")),
        "multi_instrumentistes":multi_instrumentistes,
    }
    return render(request, 'calendrier/view_event.html', context=context)






@login_required
def changename(request,id):
    if request.method == 'POST':
        requbis = request.POST.copy()
        form = ChangeDoodleName(requbis, instance=request.user)
        if form.is_valid():
            form.save()
            success = True
            return redirect('calendrier:view-event',id=id)
    else:
        form = ChangeDoodleName(instance=request.user)
    return render(request, 'calendrier/changename.html',locals())


@chef_required
def create_event(request):
    if request.method == "POST":
        form = EventForm(request.POST)
        if form.is_valid():
            temp = True
            while temp:
                code = generer()
                try:
                    Event.objects.get(slug=code)
                except:
                    temp = False
            nom = form.cleaned_data["nom"]
            date = form.cleaned_data["date"]
            date = date.strftime('%d/%m/%Y')
            debut = form.cleaned_data["debut"]
            obj = form.save(commit=False)
            obj.slug = code
            obj.save()
            id = obj.id
            envoi = True
            return redirect('calendrier:view-event',id=id)

    else:
        form = EventForm()

    return render(request, "calendrier/create.html", locals())




@login_required
def reponse(request, id):
    part = request.user.profile
    ev = get_object_or_404(Event, id=id)
    if request.method == "POST":
        form = ParticipantsForm(request.POST)
        if form.is_valid():
            try:
                p = Participants.objects.get(event=ev, participant=part)
                p.delete()
            except Participants.DoesNotExist:
                pass
            obj = form.save(commit=False)
            obj.event = ev
            obj.participant = part
            obj.save()
            envoi = True
            return redirect('calendrier:view-event',id=id)
    else:
        form = ParticipantsForm()
    return render(request, "calendrier/reponse.html", locals())




class EventUpdate(UpdateView):
    model = Event
    template_name = "calendrier/update.html"
    form_class = ModifEventForm

    def get_context_data(self, **kwargs):
        ctx = super(EventUpdate, self).get_context_data(**kwargs)
        ctx['id'] = self.get_object().id
        return ctx

    def get_success_url(self):
        return reverse('calendrier:view-event', kwargs={'id' : self.get_object().id})

    @method_decorator(chef_required)
    def dispatch(self, *args, **kwargs):
        return super(EventUpdate, self).dispatch(*args, **kwargs)


class EventDelete(DeleteView):
    model = Event
    template_name = "calendrier/delete.html"
    success_url = reverse_lazy("calendrier:home")

    def get_context_data(self, **kwargs):
        ctx = super(EventDelete, self).get_context_data(**kwargs)
        ctx['id'] = self.get_object().id
        return ctx

    @method_decorator(chef_required)
    def dispatch(self, *args, **kwargs):
        return super(EventDelete,self).dispatch(*args, **kwargs)