if loginform.is_valid():
            #make usernames caseinsensitive
            try:
                u = User.objects.get(username__iexact=loginform.cleaned_data['username'])
                username = u.username
            except User.DoesNotExist:
                username = loginform.cleaned_data['username']
            user = authenticate(username=username,password=loginform.cleaned_data['password'])

from django import template
register = template.Library()

def dict_get(value, arg):
    #custom template tag used like so:
    #{{dictionary|dict_get:var}}
    #where dictionary is duh a dictionary and var is a variable representing
    #one of it's keys

    return value[arg]

register.filter('dict_get',dict_get)

#this app started on 7/14/09

from django.db import models
from django.contrib.auth.models import User, Group
from django.contrib.localflavor.us import models as usmodels
from datetime import datetime

class Client(models.Model):
    #choices for the time_zone
    TIME_ZONES = [
        (1,'Eastern'),
        (2,'Central'),
        (3,'Mountain'),
        (4,'Pacific'),
        (5,'Alaska'),
        (6,'Hawaii'),
    ]

    clientID = models.IntegerField(unique=True) #the main account number
    name = models.CharField(max_length=255)
    location = models.CharField(max_length=255,blank=True,null=True)
    contact_number = usmodels.PhoneNumberField(null=True,blank=True)
    contact_email = models.EmailField(max_length=255,null=True,blank=True)
    time_zone = models.IntegerField(choices=TIME_ZONES,blank=True,null=True)
    active = models.BooleanField()
    
    def unicode(self):
        return "%s - %s" % (self.clientID,self.name)
    
    class Meta:
        ordering = ['clientID',]

# Create your models here.    
class Answer(models.Model):
    answer = models.CharField(max_length=255)
    active = models.BooleanField()
    """
    weight will be a percentage of the related topic's value
    (ie a weight of .5 on a topic with a value of 10 = a score of 5/10)
    with the exception of these hard-coded weights
    -3 will give Fail behavior (0/possible)
    -2 will give Pass behavior (scored/possible i.e. ignored)
    -1 will give NA behavior (0/0 i.e. ignored)
    """
    weight = models.FloatField(help_text="Percentage of Topic Value <br/>\n-3=auto zero, -2=ignored, -1=ignored")
    
    def unicode(self):
        return "%s : %s" % (self.answer,self.weight)
        
    class Meta:
        ordering = ['-weight',]
    
class Section(models.Model):
    name = models.CharField(max_length=255)
    
    def unicode(self):
        return self.name
    
    class Meta:
        ordering = ['name',]
    
class Topic(models.Model):
    section = models.ForeignKey(Section)
    topic = models.CharField(max_length=255)
    description = models.TextField(null=True,blank=True)
    value = models.FloatField()
    active = models.BooleanField()
    possible_answers = models.ManyToManyField(Answer,related_name='possible_answers')
    default_answer = models.ForeignKey(Answer,related_name='default_answer')
    
    def unicode(self):
        answers, div = '', ''
        for answer in self.possible_answers.all():
            answers = answers + div + answer.answer
            div = '/'
        return "%s: %s - %s (%s)" % (self.section.name, self.topic, self.value, answers)
        
    class Meta:
        ordering = ['section','-value','topic',]
    
class Questionnaire(models.Model):
    name = models.CharField(max_length=255,unique=True)
    active = models.BooleanField()
    topics = models.ManyToManyField(Topic)
    
    def unicode(self):
        return self.name
        
    class Meta:
        ordering = ['name',]
    
class TopicOrder(models.Model):
    questionnaire = models.ForeignKey(Questionnaire)
    priority = models.IntegerField(help_text="'1' is first listed")
    section = models.ForeignKey(Section)
    
    def unicode(self):
        return "%s: %s" % (self.priority,self.section)
        
    class Meta:
        ordering = ['questionnaire','priority']
    
class ScoreCard(models.Model):
    operator = models.ForeignKey(User,related_name='Operator')
    evaluator = models.ForeignKey(User,related_name='Evaluator')
    client = models.ForeignKey(Client)
    call_time = models.DateTimeField()
    input_time = models.DateTimeField()
    notes = models.TextField()
    possible = models.FloatField()
    scored = models.FloatField()
    percentage = models.FloatField()
    questionnaire = models.ForeignKey(Questionnaire)
        
    def unicode(self):
        return "%s - %s/%s" % (self.operator.name,self.scored,self.possible)
        
class SelectedAnswer(models.Model):
    scorecard = models.ForeignKey(ScoreCard)
    topic = models.ForeignKey(Topic)
    answer = models.ForeignKey(Answer)
    
    def unicode(self):
        return "%s - %s" % (self.topic,self.answer)