views.py

from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse
from django.forms.models import inlineformset_factory, BaseInlineFormSet
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import get_object_or_404, render_to_response
from django.template import RequestContext
from django.utils.translation import ugettext_lazy as _
from nuages_base.views import email_notify
from meetingpoll.forms import PollForm, ChoiceForm, VoteForm, BulletinForm
from meetingpoll.models import Poll, Choice, Vote, Bulletin


def new(request):
    if request.method == 'POST':
        form = PollForm(request.POST)
        if form.is_valid():
            poll = Poll(**form.cleaned_data)
            if request.user.is_authenticated():
                poll.user = request.user
            poll.save()
            key = 'is_' + poll.id + '_author'
            request.session[key] = True  # This writes cookie
            return HttpResponseRedirect(reverse('choices',
                                                args=(str(poll.id),)))
    else:
        form = PollForm()
        if request.user.is_anonymous():
            request.session.clear()
            messages.warning(request, _('You are not logged so you will not \
be able to modify your poll after creation or recieve notifications.'))
    return render_to_response('meetingpoll/poll_form.html',
                              {'form': form},
                              context_instance=RequestContext(request))


def get_ordereditem_formset(form, formset=BaseInlineFormSet, **kwargs):
    return inlineformset_factory(Poll, Choice, form, formset, **kwargs)


def editchoices(request, poll_id):

    poll = get_object_or_404(Poll.objects.all(), id=poll_id)
    language_code = request.LANGUAGE_CODE
    key = 'is_' + poll_id + '_author'  # Anonymous wants to edit his new poll?
    if request.user != poll.user and not request.session.get(key, False):
        return HttpResponseRedirect(reverse('home'))

    OrderedItemFormset = get_ordereditem_formset(ChoiceForm,
                                                 extra=0, can_delete=True)

    if request.method == "POST":
        #Should we set a maximum of choices here?
        instances = OrderedItemFormset(request.POST, instance=poll)
        if instances.is_valid():
            for instance in instances.cleaned_data:
                this_choice = instance['choice']
                if not instance.get('DELETE'):
                    try:
                        choice = Choice.objects.get(poll=poll, choice=instance['choice'])
                        choice.details = instance['details']
                        choice.save()
                    except ObjectDoesNotExist:
                        choice = Choice(poll=poll, choice=instance['choice'], details=instance['details'])
                        choice.save()
                        # If bulletins for this poll existed before edition
                        # add an 'false' vote child to them for newly created choice.
                        # This makes template computation easier
                        for bulletin in Bulletin.objects.filter(poll=poll):
                            nvote = Vote(choice=choice, bulletin=bulletin, voice=False)
                            nvote.save()
                else:
                    try:
                        choice = Choice.objects.get(poll=poll, choice=this_choice)
                        choice.delete()  #Removing a Choice will remove all childeren Vote objects.
                    except :
                        pass
            return HttpResponseRedirect(poll.link)
        else:
            messages.error(request, _("There are some errors in the form you posted."))
            vforms = instances

    else:
        if Choice.objects.filter(poll=poll_id).count() == 0:
            # Sall we replace next line with something like OrderedItemFormset(extra=2)
            OrderedItemFormset = get_ordereditem_formset(
                ChoiceForm, extra=1, can_delete=True)
            vforms = OrderedItemFormset(instance=poll)
        else:
            vforms = OrderedItemFormset(instance=poll)

    return render_to_response('meetingpoll/choice_form.html',
                              {'object': poll,
                               'vforms': vforms,
                               'language_code': language_code},
                              context_instance=RequestContext(request))


@login_required
def delete(request, poll_id):

    poll = get_object_or_404(Poll.objects.all(), id=poll_id)

    if poll.user == request.user:
        poll.delete()

    return HttpResponseRedirect('/')


def make_buletin_form(poll, **kwargs):
    return [[VoteForm(prefix=choice)] for choice in Choice.objects.filter(poll=poll.id)]


def vote(request, poll_id):
    poll = get_object_or_404(Poll.objects.all(), id=poll_id)
    has_voted, is_updated = False, False

    if request.method == 'POST':
        form = BulletinForm(request.POST, initial={'poll': poll.id})
        vforms = [[VoteForm(request.POST, prefix=choice, instance=choice) ] for choice in Choice.objects.filter(poll=poll.id)]

        if form.is_valid():
            if request.user.is_authenticated():
                voter = str(request.user)
            else:
                voter = form.cleaned_data['voter']
                if request.session.get('name'):
                    voter = request.session.get('name')

            if voter != 'your name':
                if not Bulletin.objects.filter(poll=poll.id, voter=voter):
                    bulletin = Bulletin(poll=poll, voter=voter)
                    bulletin.save()
                else:
                    bulletin = Bulletin.objects.get(poll=poll.id, voter=voter)

                for forms in vforms:
                    for vorm in forms:
                        if vorm.is_valid():
                            try:
                                choice = Choice.objects.get(choice=vorm.cleaned_data['choice'], poll=poll)
                            except:
                                return HttpResponse(vorm.cleaned_data['choice'])

                            if not Vote.objects.filter(choice=choice, bulletin=bulletin):
                                new = Vote(choice=choice, bulletin=bulletin, comment=vorm.cleaned_data['comment'])
                                if vorm.cleaned_data['voice']:
                                    new.voice = vorm.cleaned_data['voice']
                                new.save()
                                if new.voice:
                                    choice.votecount += 1
                                    choice.save()
                                if request.user.is_anonymous():  # Anonymous has voted...
                                    key = 'has_voted-' + poll.id
                                    request.session[key] = True  # This writes cookie
                                    request.session['name'] = voter  # This writes cookie
                                    has_voted = True  # Used to show "Forget me"
                            else:
                                old = Vote.objects.get(choice=choice, bulletin=bulletin)

                                if old.voice:
                                    if not vorm.cleaned_data['voice']:
                                        choice.votecount -= 1
                                        choice.save()
                                else:
                                    if vorm.cleaned_data['voice']:
                                        choice.votecount += 1
                                        choice.save()

                                old.voice = vorm.cleaned_data['voice']
                                old.comment = vorm.cleaned_data['comment']
                                old.save()
                                is_updated = True
                if has_voted:
                    messages.success(request, _("Your vote has been counted, thank you."))
                if is_updated:
                    messages.success(request, _("Your vote has been updated, thank you."))
                if has_voted and poll.user:
                    try:
                        if poll.user.userprofile.email_notifications:
                            email_notify(poll, voter)
                    except:
                        pass
            else:
                messages.error(request, _('Did you forget to provide your name?'))
        else:
            messages.error(request, _('Did you forget to provide your name?'))
            voter = _('your name')

    else: # request.method = 'GET'

        key = 'is_' + poll.id + '_author'
        if request.session.get(key, False):
            # Assume author is positive for all choices, when he votes for the first time.
            vforms = [ [ VoteForm(initial={'choice': choice,'voice': True,}, prefix=choice) ] for choice in Choice.objects.filter(poll=poll_id) ]
        else:
            # Default formset for unknown user
            vforms = [ [ VoteForm(initial={'choice': choice,}, prefix=choice) ] for choice in Choice.objects.filter(poll=poll_id) ]
        if request.user.is_authenticated():
            voter = str(request.user)
            try:
                bulletin = Bulletin.objects.get(poll=poll,voter=voter)
                messages.info(request, _("You have voted."))
                diff = len(vforms) - len(Vote.objects.filter(bulletin=bulletin))
                if diff == 0:
                    """
                    Hum, previously bulletin has not the same amount of vote objects,
                    we should concatenate the existing votes with empty remaing ones...
                    Give an empty bulletin for now.
                    """
                    vforms = [ [ VoteForm(initial={'choice': vote.choice,'voice': vote.voice, 'comment': vote.comment}, prefix=vote.choice) ] for vote in Vote.objects.filter(bulletin=bulletin).order_by('choice__choice') ]

            except:
                pass
        else:
            voter = request.session.get('name')
            if voter:
                has_voted = True  # Used to show "Forget me"
            else:
                messages.info(request, _("Login let you modify your vote anytime."))
            key = 'has_voted-' + poll.id
            if request.session.get(key, False):
                #error_message = 'Modify your vote? (clear cookie if you are not ' + voter + ')'
                try:
                    bulletin = Bulletin.objects.get(poll=poll, voter=voter)
                    messages.success(request, _('%s has voted and can still modify its vote.') % voter)
                    messages.info(request, _('Not %s? Click Forget me.') % voter)
                    diff = len(vforms) - len(Vote.objects.filter(bulletin=bulletin))
                    if diff == 0:
                        """
                        Hum, previously bulletin has not the same amount of vote objects,
                        we should concatenate the existing votes with empty remaing ones...
                        Give an empty bulletin for now.
                        """
                        vforms = [ [ VoteForm(initial={'choice': vote.choice,'voice': vote.voice, 'comment': vote.comment,}, prefix=vote.choice) ] for vote in Vote.objects.filter(bulletin=bulletin).order_by('choice__choice') ]

                except:
                    pass
            else:
                if voter:
                    messages.info(request, _('Not %s? Click Forget me.') % voter)

    form = BulletinForm(instance=poll, initial={'voter': voter})
    return render_to_response('meetingpoll/poll_detail.html',
                              {'object': poll, 'form': form, 'vforms':vforms, 'has_voted': has_voted},
                              context_instance=RequestContext(request))


def exp_csv(request, poll_id):
    import csv

    # Create the HttpResponse object with the appropriate CSV header.
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=nuages.csv'

    poll = get_object_or_404(Poll.objects.all(), id=poll_id)
    choices = Choice.objects.filter(poll=poll)
    bulletins = Bulletin.objects.filter(poll=poll)
    writer = csv.writer(response, quotechar='"', quoting=csv.QUOTE_ALL)
    fr = ["",]
    for c in choices:
        fr.append(c)
    writer.writerow(fr)
    for b in bulletins:
        r = [b.voter.encode("utf-8"),]
        for v in Vote.objects.filter(bulletin=b):
            r.append(v)
        writer.writerow(r)
    return response

def clear_cookie(request, poll_id):
    request.session.clear()
    return HttpResponseRedirect(reverse('vote', args=(poll_id,)))