views.py

from django.http import HttpResponse, HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.shortcuts import  get_object_or_404, render_to_response
from django.core.urlresolvers import reverse
from django.template import RequestContext
from django.forms.formsets import formset_factory
from django.forms.models import inlineformset_factory, BaseInlineFormSet
from django.core.exceptions import ObjectDoesNotExist
from django.views.generic.create_update import update_object
from django.contrib.auth.decorators import login_required
from django.utils.translation import ugettext_lazy as _
from django.contrib.sites.models import get_current_site
from django.conf import settings
from meetingpoll.models import Poll, Choice, Vote, Bulletin
from meetingpoll.forms import PollForm, ChoiceForm, VoteForm, BulletinForm
from account.views import email_notify
from account.forms import UserProfileForm

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()
    return render_to_response(
        'meetingpoll/poll_form.html',
        {'form': form},
        context_instance=RequestContext(request))

@login_required
def secure_update_object(*args, **kwargs):
    """
    Souldn't we provide a better object to the generic view: object_id=poll
    and then simple the template
    # joe = str(request.user)
    # if Poll.objects.get(id=object_id, author=joe):
    """
    return update_object(*args, **kwargs)

def translation(request, lang_id):
    request.session['django_language'] = lang_id
    return HttpResponseRedirect('/nuages')

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
    error_message = ''
    if request.user.is_anonymous(): # Anonymous wants to edit his new poll
        key = 'is_' + poll_id + '_author'
        if not request.session.get(key, False):
            return HttpResponseRedirect(reverse('home'))
    else:
        if request.user != poll.user:
            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 = request.POST.values()
        if len(instances) < 20:
            for selection in instances:
        """
        instances = OrderedItemFormset(request.POST, instance=poll)
        if instances.is_valid():
            for instance in instances.cleaned_data:
                try:
                    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)
                            """
                            Removing a Choice will remove all childeren Vote objects.
                            When Django deletes an object, it emulates the behavior of
                            the SQL constraint ON DELETE CASCADE -- in other words, any
                            objects which had foreign keys pointing at the object to be
                            deleted will be deleted along with it."""
                            choice.delete()
                        except :
                            pass
                except:
                    # probably an empty datefield?
                    pass 
            return HttpResponseRedirect(poll.link)
        else:
            #vforms=OrderedItemFormset(request.POST, instance=poll)
            error_message = _("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, 'error_message' : error_message, '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)
    error_message = None
    has_voted = 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':
                """
                try:
                    Bulletin.objects.get(poll=poll.id,voter=voter)
                    error_message = 'A user with the same name has already voted.'
                    return render_to_response('sondage/poll_detail.html', {'object': poll, 'form': form, 'vforms':vforms, 'error_message':error_message}, context_instance=RequestContext(request))
                except:
                    pass
                """

                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()
                                error_message = "Your vote has been counted, thank you."
                                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()
                                error_message = _("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:
                error_message = _('Did you forget to provide your name?')
        else:
            #error_message = form.errors
            error_message = _('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)
                error_message = " 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 = ''
            error_message = _("Login let you modify your vote anytime.")
            key = 'has_voted-' + poll.id
            if request.session.get(key, False):
                has_voted = True  # Used to show "Forget me"
                voter = request.session.get('name')
                #error_message = 'Modify your vote? (clear cookie if you are not ' + voter + ')'
                try:
                    bulletin = Bulletin.objects.get(poll=poll, voter=voter)
                    error_message = voter + ' has 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

    form = BulletinForm(instance=poll,initial={'voter': voter})
    #form = BulletinForm(instance=poll)
    return render_to_response('meetingpoll/poll_detail.html', {'object': poll, 'form': form, 'vforms':vforms, 'error_message':error_message, '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