1 # -*- coding: utf-8 -*-
6 from django.conf import settings
7 from django.core.urlresolvers import reverse
8 from django.db import models
9 from django.db.models.signals import post_save
10 from django.dispatch import receiver
11 from django.utils.html import format_html
12 from django.utils.translation import ugettext_lazy as _
13 from django.utils import timezone
14 from jsonfield import JSONField
16 from contact.models import Contact
19 class Participant(models.Model):
20 contact = models.ForeignKey(Contact, verbose_name=_('contact'), null=True)
21 key = models.CharField(_('key'), max_length=30, unique=True)
22 first_name = models.CharField(_('first name'), max_length=100)
23 last_name = models.CharField(_('last_name'), max_length=100)
24 email = models.EmailField(_('email'), max_length=100, unique=True)
25 key_sent = models.BooleanField(_('key sent'), default=False)
26 complete_set = models.BooleanField(default=False)
29 verbose_name = _('participant')
30 verbose_name_plural = _('participants')
32 def __unicode__(self):
33 return ', '.join((self.last_name, self.first_name, self.email))
35 # copy-paste from wtem
37 def generate_key(cls):
39 while not key or key in [record['key'] for record in cls.objects.values('key')]:
40 key = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits)
44 # copy-paste from wtem
46 def create(cls, first_name, last_name, email, key=None, contact=None):
47 return cls.objects.create(
49 key=key if key else cls.generate_key(),
50 first_name=first_name,
55 return key == self.key
58 return sum(answer.score() for answer in self.answer_set.all())
61 class Assignment(models.Model):
62 title = models.CharField(_('title'), max_length=128)
63 content = models.TextField(_('content'))
64 content_url = models.URLField(_('URL'))
65 deadline = models.DateTimeField(_('deadline'))
66 max_points = models.IntegerField(_('max points'))
67 experts = models.ManyToManyField(
68 settings.AUTH_USER_MODEL, verbose_name=_('experts'), related_name='stage2_assignments')
69 arbiters = models.ManyToManyField(
70 settings.AUTH_USER_MODEL, blank=True, verbose_name=_('arbiters'), related_name='stage2_arbitrated')
71 supervisors = models.ManyToManyField(
72 settings.AUTH_USER_MODEL, verbose_name=_('supervisors'), related_name='stage2_supervised')
73 file_descriptions = JSONField(_('file descriptions'), default=[], blank=True)
74 field_descriptions = JSONField(_('field descriptions'), default=[], blank=True)
77 ordering = ['deadline', 'title']
78 verbose_name = _('assignment')
79 verbose_name_plural = _('assignments')
81 def __unicode__(self):
84 def available_answers(self, expert):
85 answers = self.answer_set.exclude(mark__expert=expert)
86 assigned_to_expert = self.answer_set.filter(expert=expert).exists()
87 is_supervisor = expert in self.supervisors.all()
88 is_arbiter = expert in self.arbiters.all()
89 if assigned_to_expert:
90 expert_answers = answers.filter(expert=expert)
91 if expert_answers or not is_arbiter:
92 answers = expert_answers
93 answers = answers.extra(where=[
94 "field_values::text ~ ': *\"[^\"]+\"' "
95 "OR EXISTS (SELECT id FROM stage2_attachment WHERE answer_id = stage2_answer.id) "
96 "OR EXISTS (SELECT id FROM stage2_fieldoption WHERE answer_id = stage2_answer.id)"])
98 answers = answers.exclude(complete=True)
99 if not is_supervisor or not self.is_active():
100 answers = answers.filter(participant__complete_set=True)
102 answers = answers.filter(need_arbiter=True)
105 def field_counts(self, answers):
106 for field_desc in self.field_descriptions:
107 field_name, params = field_desc
108 if params['type'] == 'options':
109 field_count = FieldOption.objects.filter(answer__in=list(answers), set__name=params['option_set']).count()
111 field_count = sum(1 for answer in answers if answer.field_values.get(field_name))
112 yield field_name, field_count
115 return self.deadline >= timezone.now()
118 class Answer(models.Model):
119 participant = models.ForeignKey(Participant)
120 assignment = models.ForeignKey(Assignment)
121 field_values = JSONField(_('field values'), default={})
122 experts = models.ManyToManyField(
123 settings.AUTH_USER_MODEL, verbose_name=_('experts'), related_name='stage2_assigned_answers')
125 complete = models.BooleanField(default=False)
126 need_arbiter = models.BooleanField(default=False)
129 unique_together = ['participant', 'assignment']
132 for field_desc in self.assignment.field_descriptions:
133 field_name, params = field_desc
134 if params['type'] == 'options':
135 option = self.fieldoption_set.filter(set__name=params['option_set'])
136 value = option.get().value if option else '--------'
138 value = self.field_values.get(field_name, '')
139 if params['type'] == 'link':
140 value = format_html(u'<a href="{url}">{url}</a>', url=value)
141 yield field_name, value
143 def update_complete(self):
144 marks = self.mark_set.all()
148 elif len(marks) == 2:
150 complete = abs(mark1.points - mark2.points) < 0.2 * self.assignment.max_points
151 need_arbiter = not complete
155 self.complete = complete
156 self.need_arbiter = need_arbiter
160 marks = self.mark_set.all()
163 return self.mark_set.aggregate(avg=models.Avg('points'))['avg']
165 # unrelated to `complete' attribute, but whatever
166 def is_complete(self):
167 file_count = len(self.assignment.file_descriptions)
168 field_count = len(self.assignment.field_descriptions)
169 if self.attachment_set.count() < file_count:
171 if self.fieldoption_set.count() + sum(1 for k, v in self.field_values.iteritems() if v) < field_count:
176 class FieldOptionSet(models.Model):
177 name = models.CharField(verbose_name=_('nazwa'), max_length=32, db_index=True)
180 verbose_name = _('option set')
181 verbose_name_plural = _('option sets')
183 def __unicode__(self):
186 def choices(self, answer):
187 return [('', '--------')] + [
188 (option.id, option.value)
189 for option in self.fieldoption_set.extra(
190 where=['answer_id is null or answer_id = %s'],
194 class FieldOption(models.Model):
195 set = models.ForeignKey(FieldOptionSet, verbose_name=_('zestaw'))
196 value = models.CharField(verbose_name=_('value'), max_length=255)
197 answer = models.ForeignKey(Answer, verbose_name=_('answer'), null=True, blank=True)
200 ordering = ['set', 'value']
201 verbose_name = _('option')
202 verbose_name_plural = _('options')
204 def __unicode__(self):
208 def attachment_path(instance, filename):
209 answer = instance.answer
210 return 'stage2/attachment/%s/%s/%s/%s' % (answer.participant_id, answer.assignment_id, instance.file_no, filename)
213 class Attachment(models.Model):
214 answer = models.ForeignKey(Answer)
215 file_no = models.IntegerField()
216 file = models.FileField(upload_to=attachment_path)
219 ordering = ['file_no']
222 return os.path.basename(self.file.name)
224 def download_url(self):
226 'stage2_participant_file',
227 args=(self.answer.assignment_id, self.file_no,
228 self.answer.participant_id, self.answer.participant.key))
230 def expert_download_url(self):
231 return reverse('stage2_expert_download', args=[self.id])
234 class Mark(models.Model):
235 expert = models.ForeignKey(settings.AUTH_USER_MODEL)
236 answer = models.ForeignKey(Answer)
237 points = models.DecimalField(verbose_name=_('points'), max_digits=3, decimal_places=1)
240 unique_together = ['expert', 'answer']
243 @receiver(post_save, sender=Mark, dispatch_uid='update_answer')
244 def update_answer(sender, **kwargs):
245 mark = kwargs['instance']
246 mark.answer.update_complete()