from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import User
from django.db.models.signals import post_save
from django.core.exceptions import ValidationError
from datetime import datetime
from django.conf import settings
import one.models
import logging
LANGUAGE_CODE = settings.LANGUAGE_CODE
LANGUAGE_CHOICES = (('hu', _('Hungarian')), ('en', _('English')))
logger = logging.getLogger(__name__)
def create_user_profile(sender, instance, created, **kwargs):
"""
User creation hook.
Ensure that the specified user has an associated profile.
@param sender: The model class.
@type instance: User
@param instance: The user to create a profile for (if necessary).
@type created: Boolean
@param created: True if a new record was created.
"""
if created:
try:
p = Person.objects.get(code=instance.username)
except Person.DoesNotExist:
p = Person.objects.create(code=instance.username)
except Exception as e: # pragma: no cover
logger.warning("Couldn't create profile for user: %(username)s"
"\nReason: %(exception)s",
{"username": instance.username, "exception": e})
return
p.clean()
p.save()
post_save.connect(create_user_profile, sender=User)
class Person(models.Model):
"""
Personal settings and attributes of a user.
"""
user = models.ForeignKey(User, null=True, blank=True, unique=True)
language = models.CharField(verbose_name=_('language'), blank=False,
max_length=10, choices=LANGUAGE_CHOICES,
default=LANGUAGE_CODE)
code = models.CharField(_('code'), max_length=30, unique=True)
def get_owned_shares(self):
"""Get the shares of the groups which the person owns."""
return one.models.Share.objects.filter(
group__in=self.owned_groups.all())
def get_shares(self):
"""Get the shares of the groups which the person is a member of."""
return one.models.Share.objects.filter(
group__in=self.course_groups.all())
def short_name(self):
if self.user:
if self.user.last_name:
return self.user.last_name
else:
return self.user.username
else:
return self.code
def __unicode__(self):
if self.user:
if self.user.last_name and self.user.first_name:
# TRANSLATORS: full name format used in enumerations
return _("%(first)s %(last)s") % {
'first': self.user.first_name,
'last': self.user.last_name}
else:
return self.user.username
else:
return self.code
def save(self, *args, **kwargs):
self.full_clean()
super(Person, self).save(*args, **kwargs)
class Meta:
verbose_name = _('person')
verbose_name_plural = _('persons')
class Course(models.Model):
code = models.CharField(max_length=20, unique=True,
verbose_name=_('course code'))
name = models.CharField(max_length=80, null=True, blank=True,
verbose_name=_('name'))
short_name = models.CharField(max_length=10, null=True, blank=True,
verbose_name=_('name'))
default_group = models.ForeignKey(
'Group', null=True, blank=True, related_name='default_group_of',
verbose_name=_('default group'), help_text=_('New users will be '
'automatically assigned to this group.'))
owners = models.ManyToManyField(Person, blank=True, null=True,
verbose_name=_('owners'))
class Meta:
verbose_name = _('course')
verbose_name_plural = _('courses')
def get_or_create_default_group(self):
if self.default_group:
return self.default_group
else:
default_group = Group(name=_("%s (auto)") % self.short(),
semester=Semester.get_current(),
course=self)
default_group.save()
self.default_group_id = default_group.id
self.save()
return default_group
def save(self, *args, **kwargs):
if self.default_group:
self.default_group.course = self
self.default_group.save()
self.full_clean()
super(Course, self).save(*args, **kwargs)
def __unicode__(self):
if self.name:
return u"%s (%s)" % (self.code, self.name)
else:
return self.code
def short(self):
if self.short_name:
return self.short_name
else:
return self.code
short.verbose_name = _('short name')
def owner_list(self):
if self.owners and self.owners.count() > 0:
return ", ".join([p.short_name() for p in self.owners.all()])
else:
return _("(none)")
owner_list.verbose_name = _('owners')
class Semester(models.Model):
name = models.CharField(max_length=20, unique=True, null=False,
verbose_name=_('name'))
start = models.DateField(verbose_name=_('start'))
end = models.DateField(verbose_name=_('end'))
class Meta:
verbose_name = _('semester')
verbose_name_plural = _('semesters')
def is_on(self, time):
return self.start <= time.date() and self.end >= time.date()
is_on.boolean = True
@classmethod
def get_current(cls):
n = datetime.now()
current = [s for s in Semester.objects.all() if s.is_on(n)]
try:
return current[0]
except:
raise ValidationError(_('There is no current semester.'))
def __unicode__(self):
return self.name
class Group(models.Model):
name = models.CharField(max_length=80, verbose_name=_('name'))
course = models.ForeignKey('Course', null=True, blank=True,
verbose_name=_('course'))
semester = models.ForeignKey('Semester', null=False, blank=False,
verbose_name=_('semester'))
owners = models.ManyToManyField(Person, blank=True, null=True,
related_name='owned_groups',
verbose_name=_('owners'))
members = models.ManyToManyField(Person, blank=True, null=True,
related_name='course_groups',
verbose_name=_('members'))
class Meta:
unique_together = (('name', 'course', 'semester', ), )
verbose_name = _('group')
verbose_name_plural = _('groups')
def owner_list(self):
if self.owners and self.owners.count() > 0:
return ", ".join([p.short_name() for p in self.owners.all()])
else:
return _("(none)")
owner_list.verbose_name = _('owners')
def member_count(self):
return self.members.count()
def __unicode__(self):
if self.course:
return "%s (%s)" % (self.name, self.course.short())
else:
return "%s (%s)" % (self.name, self.owner_list())
@models.permalink
def get_absolute_url(self):
return ('group_show', None, {'gid': self.id})