models.py 6.87 KB
Newer Older
Dudás Ádám committed
1 2 3 4
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
5 6
from django.core.exceptions import ValidationError
from datetime import datetime
7
from django.conf import settings
tarokkk committed
8
import one.models
Dudás Ádám committed
9
import logging
10 11 12 13


LANGUAGE_CODE = settings.LANGUAGE_CODE
LANGUAGE_CHOICES = (('hu', _('Hungarian')), ('en', _('English')))
Dudás Ádám committed
14

Dudás Ádám committed
15 16
logger = logging.getLogger(__name__)

Dudás Ádám committed
17
def create_user_profile(sender, instance, created, **kwargs):
Dudás Ádám committed
18 19 20 21 22 23 24
    """
    User creation hook.

    Ensure that the specified user has an associated profile.

    @param sender: The model class.
    @type  instance: User
25
    @param instance: The user to create a profile for (if necessary).
Dudás Ádám committed
26 27 28
    @type  created: Boolean
    @param created: True if a new record was created.
    """
Dudás Ádám committed
29
    if created:
30
        try:
Őry Máté committed
31
            p = Person.objects.get(code=instance.username)
Dudás Ádám committed
32
        except Person.DoesNotExist:
Őry Máté committed
33
            p = Person.objects.create(code=instance.username)
34
        except Exception as e:  # pragma: no cover
Dudás Ádám committed
35 36 37 38
            logger.warning("Couldn't create profile for user: %(username)s"
                    "\nReason: %(exception)s",
                    {"username": instance.username,
                     "exception": e})
Őry Máté committed
39
            return
Dudás Ádám committed
40
        p.clean()
Őry Máté committed
41
        p.save()
Dudás Ádám committed
42 43 44
post_save.connect(create_user_profile, sender=User)

class Person(models.Model):
45 46 47
    """
    Personal settings and attributes of a user.
    """
Őry Máté committed
48
    user = models.ForeignKey(User, null=True, blank=True, unique=True)
Dudás Ádám committed
49 50
    language = models.CharField(verbose_name=_('language'), blank=False,
            max_length=10, choices=LANGUAGE_CHOICES, default=LANGUAGE_CODE)
Őry Máté committed
51
    code = models.CharField(_('code'), max_length=30, unique=True)
52

53
    def get_owned_shares(self):
54 55 56
        """Get the shares of the groups which the person owns."""
        return one.models.Share.objects.filter(
                group__in=self.owned_groups.all())
57

tarokkk committed
58
    def get_shares(self):
59 60 61
        """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())
tarokkk committed
62

63
    def short_name(self):
64
        if self.user:
65
            if self.user.last_name:
66
                return self.user.last_name
67
            else:
68
                return self.user.username
69
        else:
70
            return self.code
71

Dudás Ádám committed
72
    def __unicode__(self):
73 74 75 76 77 78 79 80
        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
81
        else:
82
            return self.code
Dudás Ádám committed
83

84 85 86 87
    class Meta:
        verbose_name = _('person')
        verbose_name_plural = _('persons')

88
class Course(models.Model):
89 90 91 92 93 94
    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'))
95
    default_group = models.ForeignKey('Group', null=True, blank=True,
96
            related_name='default_group_of', verbose_name=_('default group'),
97
            help_text=_('New users will be automatically assigned to this group.'))
98 99 100 101 102 103 104
    owners = models.ManyToManyField(Person, blank=True, null=True,
            verbose_name=_('owners'))

    class Meta:
        verbose_name = _('course')
        verbose_name_plural = _('courses')

105
    def get_or_create_default_group(self):
106 107 108
        if self.default_group:
            return self.default_group
        else:
109
            default_group = Group(name=_("%s (auto)") % self.short(),
110 111 112 113 114
                    semester=Semester.get_current(), course=self)
            default_group.save()
            self.default_group_id = default_group.id
            self.save()
            return default_group
115

116 117 118 119 120 121
    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)
Dudás Ádám committed
122

Őry Máté committed
123
    def __unicode__(self):
124
        if self.name:
Őry Máté committed
125 126 127
            return u"%s (%s)" % (self.code, self.name)
        else:
            return self.code
128

Őry Máté committed
129 130 131 132 133
    def short(self):
        if self.short_name:
            return self.short_name
        else:
            return self.code
134 135
    short.verbose_name = _('short name')

Őry Máté committed
136
    def owner_list(self):
137
        if self.owners and self.owners.count() > 0:
138
            return ", ".join([p.short_name() for p in self.owners.all()])
Őry Máté committed
139
        else:
140 141
            return _("(none)")
    owner_list.verbose_name = _('owners')
Őry Máté committed
142

Dudás Ádám committed
143

144
class Semester(models.Model):
145 146 147 148 149 150 151 152
    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')
Dudás Ádám committed
153

154 155
    def is_on(self, time):
        return self.start <= time.date() and self.end >= time.date()
156
    is_on.boolean = True
Dudás Ádám committed
157

158 159 160 161 162 163 164 165
    @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.'))
Dudás Ádám committed
166

Őry Máté committed
167 168 169 170
    def __unicode__(self):
        return self.name


171
class Group(models.Model):
172
    name = models.CharField(max_length=80, verbose_name=_('name'))
173 174 175 176 177 178 179 180
    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'))
Dudás Ádám committed
181

182 183
    class Meta:
        unique_together = (('name', 'course', 'semester', ), )
184 185
        verbose_name = _('group')
        verbose_name_plural = _('groups')
Őry Máté committed
186

187
    def owner_list(self):
188
        if self.owners and self.owners.count() > 0:
189
            return ", ".join([p.short_name() for p in self.owners.all()])
190
        else:
191
            return _("(none)")
192
    owner_list.verbose_name = _('owners')
193 194 195 196

    def member_count(self):
        return self.members.count()

Őry Máté committed
197 198 199 200
    def __unicode__(self):
        if self.course:
            return "%s (%s)" % (self.name, self.course.short())
        else:
201
            return "%s (%s)" % (self.name, self.owner_list())
202 203 204

    @models.permalink
    def get_absolute_url(self):
205
        return ('group_show', None, {'gid': self.id})