root/questionnaire/views.py

# Django imports
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response, get_object_or_404
from django.contrib.auth.decorators import login_required

# Local imports
from djangoquest import settings
from models import RegUser, Question, Category, Answer, Choice
from nicepass import nicepass

def check_login(request):
    if request.session.get('logged_in'):
        return request.session['logged_in']
    return False

def logout(request):
    if request.session != False:
        request.session['logged_in'] = False
    return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'login.html', {'error': u"You are logged out."})

@login_required
def send_invitations(request):
    """
    If POSTed, send the users specified by their ids an invitation e-mail.
    If one of these users doesn't have a password, generate one.

    If this isn't a POST request, return the list of users with selection
    options for choosing which users to send an invitation.
    """
    success = []
    failure = []
    sent = False
    if len(request.POST) > 0:
        from email import send_welcome
        for item in request.POST.items():
            users = RegUser.objects.filter(id = int(item[0]))
            if len(users) > 0:
                user = users[0]
                if user.password == "":
                    user.password = nicepass()
                    user.save()
                if send_welcome(user):
                    success += [user]
                else:
                    failure += [user]
            sent = True
        
    return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'email.html', {'users': RegUser.objects.all(), 'success': success, 'failure': failure, 'sent': sent })
        
def login(request):
    if request.session.get('logged_in') and request.session['logged_in'] == True:
        return True
    try:
        if request.POST['email'] != '' and request.POST['password'] != '':
            possible_users = RegUser.objects.filter(email = request.POST['email'], password = request.POST['password'])
            if possible_users.count() == 0:
                request.session['logged_in'] = False
                return False
            else:
                request.session['logged_in'] = True
                request.session['email'] = possible_users[0].email
                return True
    except KeyError:
        request.session['logged_in'] = False
    return True

def delete_answer(question, user):
    answer = Answer.objects.filter(question = question, user = user)
    if len(answer) > 0:
        for a in answer:
            a.delete()

def get_question(id):
    question = Question.objects.filter(id = id)
    if len(question) > 0:
        return question[0]
    return False

def add_answer(question, user, value):
    if value == '':
        return False
    answer = Answer()
    answer.question = question
    answer.user = user
    answer.answer = value
    answer.save()
    return True

def get_user(request):
    user = RegUser.objects.filter(email = request.session['email'])
    if len(user) > 0:
        return user[0]
    return False

def questionnaire(request):
    """
    If this is a POST request, parse the submitted data in order to
    store all submitted answers. Then return the next category of questions,
    or return a completed response.

    If this isn't a POST request, redirect to the main/login page
    """
    user = get_user(request)
    if len(request.POST) > 0 and user:
        multiple_answers = []
        items = request.POST.items()

        for item in items:
            key = item[0]
            value = item[1]
            if key.startswith("question_"):
                answer = key.split("_")
                question = get_question(int(answer[-1]))
                if len(answer) <= 1:
                    continue
                if len(answer) == 2 and question: # A single-choice or open answer
                    delete_answer(question, user)
                    add_answer(question, user, value)
                if len(answer) == 4 and question: # A multiple-selection answer
                    multiple_answers += [ [question, value] ]
                    
        for answer in multiple_answers:
            delete_answer(answer[0], user)
            
        for answer in multiple_answers:
            add_answer(answer[0], user, answer[1])
            
        return get_complete_or_continue_response(user)
    return HttpResponseRedirect('/')

def category_complete(user, category):
    """
    Return if a certain user has completed all questions for this category
    """
    questions = Question.objects.filter(category = category)
    for question in questions:
        answers = Answer.objects.filter(question = question, user = user)
        if len(answers) == 0:
            return False
    return True

def get_complete_or_continue_response(user):
    """
    Determine if the user has completed all questions 
      (in that case return the completed page),
    or if not all questions are completed which category has to be shown
    """
    categories = Category.objects.all()
    for category in categories:
       if not category_complete(user, category):
           last = False
           if category == Category.objects.all().order_by('-id')[0]:
               last = True
           return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'questionnaire.html', {'user': user, 'categories': [category], 'last': last})

    return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'completed.html', {'user': user})
    
def do_login(request):
    if len(request.POST) > 0:
        if login(request) == False and request.POST.get('email'):
            error = ""
            if len(RegUser.objects.filter(email = request.POST['email'])) == 0:
                error = u"Your emailaddress is not known. Please make sure you entered your emailaddress correctly. Note: both your emailaddress and your password are case-sensitive. Use the address as stated in your invitiation."
            else: # emailadres is know, password is incorrect
                error = u"Your password is incorrect. Please make sure you entered your password correctly. Note: both your emailaddress and your password are case-sensitive. Use the password as stated in your invitation."
            return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'login.html', {'error': error})
        return True
    return False

@login_required
def export_csv(request):
    """
    Return a .csv-file containing all the answers submitted by the
    users.
    """
    import csv
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=results_questionnaire.csv'

    writer = csv.writer(response, dialect=csv.excel, delimiter=';')

    question_names = []
    questions = Question.objects.all().order_by('category', 'nr')
    for question in questions:
        question_names += [ u'%s' % (question.text) ]
    writer.writerow(["User"] + question_names)
    writer.writerow([])

    users = RegUser.objects.all()
    for user in users:
        answer_list = [user.email]
        for question in questions:
            answers = Answer.objects.filter(question = question, user = user)
            if len(answers) > 0:
                answer_str = ""
                for answer in answers:
                    answer_str += answer.answer + " "
                answer_list += [answer_str]                
        writer.writerow(answer_list)

    writer.writerow([])
    writer.writerow(["Legend:"])
    choices = Choice.objects.all()
    for choice in choices:
        if choice.question:
            writer.writerow([u'%s: %s = %d' % (str(question), choice.name, choice.nr)])
    return response

def index(request):
    response = do_login(request)
    if response == True and check_login(request):
        user = get_user(request)
        complete = user.check_complete()
        if complete:
            return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'completed.html', {'user': user })

        return get_complete_or_continue_response(user)
    elif response == False:
        return render_to_response(settings.QUESTIONNAIRE_TEMPLATES + 'login.html')
    else:
        return response