gestioCOF/gestioncof/views.py

# coding: utf-8
from django.shortcuts import redirect, get_object_or_404
from django.http import Http404
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_required
from django import forms
from django.forms.widgets import RadioSelect, CheckboxSelectMultiple
from django.utils.translation import ugettext_lazy as _

from gestioncof.models import Survey, SurveyQuestion, SurveyQuestionAnswer, SurveyAnswer
from gestioncof.models import Event, EventOption, EventOptionChoice, EventRegistration
from gestioncof.models import CofProfile
from gestioncof.shared import render_page
from gestioncof.decorators import buro_required, cof_required
from gestioncof.widgets import TriStateCheckbox

@login_required
def home(request):
    data = {"surveys": Survey.objects.filter(survey_open = True).all(),
            "events": Event.objects.filter(registration_open = True).all()}
    return render_page(request, data, "home.html")

def login(request):
    if request.user.is_authenticated():
        return redirect("gestioncof.views.home")
    return render_page(request, {}, "login_switch.html")

@login_required
def logout(request):
    try:
        profile = request.user.get_profile()
    except CofProfile.DoesNotExist:
        profile, created = CofProfile.objects.get_or_create(user = request.user)
    if profile.login_clipper:
        return redirect("django_cas.views.logout")
    else:
        return redirect("django.contrib.auth.views.logout")

class SurveyForm(forms.Form):
    def __init__(self, *args, **kwargs):
        survey = kwargs.pop("survey")
        current_answers = kwargs.pop("current_answers", None)
        super(SurveyForm, self).__init__(*args, **kwargs)
        answers = {}
        if current_answers:
            for answer in current_answers.all():
                if answer.survey_question.id not in answers:
                    answers[answer.survey_question.id] = [answer.id]
                else:
                    answers[answer.survey_question.id].append(answer.id)
        for question in survey.questions.all():
            choices = [(answer.id, answer.answer) for answer in question.answers.all()]
            if question.multi_answers:
                initial = [] if question.id not in answers else answers[question.id]
                field = forms.MultipleChoiceField(label = question.question,
                                                  choices = choices,
                                                  widget = CheckboxSelectMultiple,
                                                  required = False,
                                                  initial = initial)
            else:
                initial = None if question.id not in answers else answers[question.id][0]
                field = forms.ChoiceField(label = question.question,
                                          choices = choices,
                                          widget = RadioSelect,
                                          required = False,
                                          initial = initial)
            field.question_id = question.id
            self.fields["question_%d" % question.id] = field

    def answers(self):
        for name, value in self.cleaned_data.items():
            if name.startswith('question_'):
                yield (self.fields[name].question_id, value)

@login_required
def survey(request, survey_id):
    survey = get_object_or_404(Survey, id = survey_id)
    if not survey.survey_open:
        raise Http404
    success = False
    deleted = False
    if request.method == "POST":
        form = SurveyForm(request.POST, survey = survey)
        if request.POST.get('delete'):
            try:
                current_answer = SurveyAnswer.objects.get(user = request.user, survey = survey)
                current_answer.delete()
                current_answer = None
            except SurveyAnswer.DoesNotExist:
                current_answer = None
            form = SurveyForm(survey = survey)
            success = True
            deleted = True
        else:
            if form.is_valid():
                all_answers = []
                for question_id, answers_ids in form.answers():
                    question = get_object_or_404(SurveyQuestion, id = question_id,
                                                 survey = survey)
                    if type(answers_ids) != list:
                        answers_ids = [answers_ids]
                    if not question.multi_answers and len(answers_ids) > 1:
                        raise Http404
                    for answer_id in answers_ids:
                        if not answer_id:
                            continue
                        answer_id = int(answer_id)
                        answer = SurveyQuestionAnswer.objects.get(
                                                   id = answer_id,
                                                   survey_question = question)
                        all_answers.append(answer)
                try:
                    current_answer = SurveyAnswer.objects.get(user = request.user, survey = survey)
                except SurveyAnswer.DoesNotExist:
                    current_answer = SurveyAnswer(user = request.user, survey = survey)
                    current_answer.save()
                current_answer.answers = all_answers
                current_answer.save()
                success = True
    else:
        try:
            current_answer = SurveyAnswer.objects.get(user = request.user, survey = survey)
            form = SurveyForm(survey = survey, current_answers = current_answer.answers)
        except SurveyAnswer.DoesNotExist:
            current_answer = None
            form = SurveyForm(survey = survey)
    return render_page(request, {"survey": survey, "form": form, "success": success, "deleted": deleted, "current_answer": current_answer}, "survey.html")

class EventForm(forms.Form):
    def __init__(self, *args, **kwargs):
        event = kwargs.pop("event")
        current_choices = kwargs.pop("current_choices", None)
        super(EventForm, self).__init__(*args, **kwargs)
        choices = {}
        if current_choices:
            for choice in current_choices.all():
                if choice.event_option.id not in choices:
                    choices[choice.event_option.id] = [choice.id]
                else:
                    choices[choice.event_option.id].append(choice.id)
        all_choices = choices
        for option in event.options.all():
            choices = [(choice.id, choice.value) for choice in option.choices.all()]
            if option.multi_choices:
                initial = [] if option.id not in all_choices else all_choices[option.id]
                field = forms.MultipleChoiceField(label = option.name,
                                                  choices = choices,
                                                  widget = CheckboxSelectMultiple,
                                                  required = False,
                                                  initial = initial)
            else:
                initial = None if option.id not in all_choices else all_choices[option.id][0]
                field = forms.ChoiceField(label = option.name,
                                          choices = choices,
                                          widget = RadioSelect,
                                          required = False,
                                          initial = initial)
            field.option_id = option.id
            self.fields["option_%d" % option.id] = field

    def choices(self):
        for name, value in self.cleaned_data.items():
            if name.startswith('option_'):
                yield (self.fields[name].option_id, value)

@login_required
def event(request, event_id):
    event = get_object_or_404(Event, id = event_id)
    if not event.registration_open:
        raise Http404
    success = False
    if request.method == "POST":
        form = EventForm(request.POST, event = event)
        if form.is_valid():
            all_choices = []
            for option_id, choices_ids in form.choices():
                option = get_object_or_404(EventOption, id = option_id,
                                             event = event)
                if type(choices_ids) != list:
                    choices_ids = [choices_ids]
                if not option.multi_choices and len(choices_ids) > 1:
                    raise Http404
                for choice_id in choices_ids:
                    if not choice_id:
                        continue
                    choice_id = int(choice_id)
                    choice = EventOptionChoice.objects.get(
                                               id = choice_id,
                                               event_option = option)
                    all_choices.append(choice)
            try:
                current_registration = EventRegistration.objects.get(user = request.user, event = event)
            except EventRegistration.DoesNotExist:
                current_registration = EventRegistration(user = request.user, event = event)
                current_registration.save()
            current_registration.options = all_choices
            current_registration.save()
            success = True
    else:
        try:
            current_registration = EventRegistration.objects.get(user = request.user, event = event)
            form = EventForm(event = event, current_choices = current_registration.options)
        except EventRegistration.DoesNotExist:
            form = EventForm(event = event)
    return render_page(request, {"event": event, "form": form, "success": success}, "event.html")

@buro_required()
def event_status(request, event_id):
    event = get_object_or_404(Event, id = event_id)
    registrants = EventRegistration.objects.filter(event = event).all()
    return render_page(request, {"event": event, "registrants": registrants}, "event_status.html")

class SurveyStatusFilterForm(forms.Form):
    def __init__(self, *args, **kwargs):
        survey = kwargs.pop("survey")
        super(SurveyStatusFilterForm, self).__init__(*args, **kwargs)
        answers = {}
        for question in survey.questions.all():
            for answer in question.answers.all():
                name = "question_%d_answer_%d" % (question.id, answer.id)
                if self.is_bound and self.data.get(self.add_prefix(name), None):
                    initial = self.data.get(self.add_prefix(name), None)
                else:
                    initial = "none"
                field = forms.ChoiceField(label = "%s : %s" % (question.question, answer.answer),
                                          choices = [("yes", "yes"),("no","no"),("none","none")],
                                          widget = TriStateCheckbox,
                                          required = False,
                                          initial = initial)
                field.question_id = question.id
                field.answer_id = answer.id
                self.fields[name] = field

    def filters(self):
        for name, value in self.cleaned_data.items():
            if name.startswith('question_'):
                yield (self.fields[name].question_id, self.fields[name].answer_id, value)

class EventStatusFilterForm(forms.Form):
    def __init__(self, *args, **kwargs):
        event = kwargs.pop("event")
        super(EventStatusFilterForm, self).__init__(*args, **kwargs)
        choices = {}
        for option in event.options.all():
            for choice in option.choices.all():
                name = "option_%d_choice_%d" % (option.id, choice.id)
                if self.is_bound and self.data.get(self.add_prefix(name), None):
                    initial = self.data.get(self.add_prefix(name), None)
                else:
                    initial = "none"
                field = forms.ChoiceField(label = "%s : %s" % (option.name, choice.value),
                                          choices = [("yes", "yes"),("no","no"),("none","none")],
                                          widget = TriStateCheckbox,
                                          required = False,
                                          initial = initial)
                field.option_id = option.id
                field.choice_id = choice.id
                self.fields[name] = field

    def filters(self):
        for name, value in self.cleaned_data.items():
            if name.startswith('option_'):
                yield (self.fields[name].option_id, self.fields[name].choice_id, value)

def clean_post_for_status(initial):
    d = dict(initial)
    for k, v in d.items():
        if k.startswith("id_"):
            del d[k]
            if type(v) == list and len(v) >= 1:
                d[k[3:]] = v[0]
            else:
                d[k[3:]] = v
    return d

@buro_required()
def event_status(request, event_id):
    event = get_object_or_404(Event, id = event_id)
    registrations_query = EventRegistration.objects.filter(event = event)
    post_data = clean_post_for_status(request.POST)
    form = EventStatusFilterForm(post_data or None, event = event)
    if form.is_valid():
        for option_id, choice_id, value in form.filters():
            choice = get_object_or_404(EventOptionChoice, id = choice_id, event_option__id = option_id)
            if value == "none":
                continue
            if value == "yes":
                registrations_query = registrations_query.filter(options__id__exact = choice.id)
            elif value == "no":
                registrations_query = registrations_query.exclude(options__id__exact = choice.id)
    user_choices = registrations_query.prefetch_related("user").all()
    options = EventOption.objects.filter(event = event).all()
    choices_count = {}
    for option in options:
        for choice in option.choices.all():
            choices_count[choice.id] = 0
    for user_choice in user_choices:
        for choice in user_choice.options.all():
            choices_count[choice.id] += 1
    return render_page(request, {"event": event, "user_choices": user_choices, "options": options, "choices_count": choices_count, "form": form}, "event_status.html")

@buro_required()
def survey_status(request, survey_id):
    survey = get_object_or_404(Survey, id = survey_id)
    answers_query = SurveyAnswer.objects.filter(survey = survey)
    post_data = clean_post_for_status(request.POST)
    form = SurveyStatusFilterForm(post_data or None, survey = survey)
    if form.is_valid():
        for question_id, answer_id, value in form.filters():
            answer = get_object_or_404(SurveyQuestionAnswer, id = answer_id, survey_question__id = question_id)
            if value == "none":
                continue
            if value == "yes":
                answers_query = answers_query.filter(answers__id__exact = answer.id)
            elif value == "no":
                answers_query = answers_query.exclude(answers__id__exact = answer.id)
    user_answers = answers_query.prefetch_related("user").all()
    questions = SurveyQuestion.objects.filter(survey = survey).all()
    answers_count = {}
    for question in questions:
        for answer in question.answers.all():
            answers_count[answer.id] = 0
    for user_answer in user_answers:
        for answer in user_answer.answers.all():
            answers_count[answer.id] += 1
    return render_page(request, {"survey": survey, "user_answers": user_answers, "questions": questions, "answers_count": answers_count, "form": form}, "survey_status.html")

class UserProfileForm(forms.ModelForm):
    first_name = forms.CharField(label=_(u'Prénom'), max_length=30)
    last_name = forms.CharField(label=_(u'Nom'), max_length=30)

    def __init__(self, *args, **kw):
        super(UserProfileForm, self).__init__(*args, **kw)
        self.fields['first_name'].initial = self.instance.user.first_name
        self.fields['last_name'].initial = self.instance.user.last_name

        self.fields.keyOrder = [
            'first_name',
            'last_name',
            'phone',
            'mailing_cof',
            'mailing_bda_revente',
            ]

    def save(self, *args, **kw):
        super(UserProfileForm, self).save(*args, **kw)
        self.instance.user.first_name = self.cleaned_data.get('first_name')
        self.instance.user.last_name = self.cleaned_data.get('last_name')
        self.instance.user.save()

    class Meta:
        model = CofProfile
        fields = ("phone", "mailing_cof", "mailing_bda_revente",)

@login_required
def profile(request):
    success = False
    if request.method == "POST":
        form = UserProfileForm(request.POST, instance = request.user.get_profile())
        if form.is_valid():
            form.save()
            success = True
    else:
        form = UserProfileForm(instance = request.user.get_profile())
    return render_page(request, {"form": form, "success": success}, "profile.html")

@login_required
def registration(request):
    data = {"surveys": Survey.objects.filter(survey_open = True).all(),
            "events": Event.objects.filter(registration_open = True).all()}
    return render_page(request, data, "registration.html")