class Submission(models.Model):
problem_instance = models.ForeignKey(ProblemInstance,
verbose_name=_("problem"))
user = models.ForeignKey(User, blank=True, null=True,
verbose_name=_("user"))
date = models.DateTimeField(default=datetime.datetime.now, blank=True,
verbose_name=_("date"))
kind = EnumField(submission_kinds, default='NORMAL',
verbose_name=_("kind"))
score = ScoreField(blank=True, null=True,
verbose_name=_("score"))
status = EnumField(submission_statuses, default='?',
verbose_name=_("status"))
comment = models.TextField(blank=True,
verbose_name=_("comment"))
class Meta:
verbose_name = _("submission")
verbose_name_plural = _("submissions")
get_latest_by = 'id'
def get_date_display(self):
return self.problem_instance.contest.controller \
.render_submission_date(self)
def get_score_display(self):
if self.score is None:
return None
return self.problem_instance.contest.controller \
.render_submission_score(self)
class SubmissionReport(models.Model):
submission = models.ForeignKey(Submission)
creation_date = models.DateTimeField(auto_now_add=True)
kind = EnumField(submission_report_kinds, default='FINAL')
status = EnumField(submission_report_statuses, default='INACTIVE')
class Meta:
get_latest_by = 'creation_date'
unique_together = ('submission', 'creation_date')
def test_enum_field(self):
registry = EnumRegistry()
field = EnumField(registry)
registry.register('OK', 'OK')
registry.register('OK', 'Should be ignored (duplicate)')
registry.register('ERR', 'Error')
self.assertEqual(sorted(list(field.choices)),
[('ERR', 'Error'), ('OK', 'OK')])
with self.assertRaises(ValidationError):
field.validate('FOO', None)
def test_serialization(self):
"""Test if choices aren't serialized by migration."""
first_field = EnumField(self.registry)
first_serialized = first_field.deconstruct()
self.registry.register('MAYBE', "You tell me if it's wrong or not")
second_field = EnumField(self.registry)
second_serialized = second_field.deconstruct()
self.assertEqual(first_serialized, second_serialized)
def test_enum_field(self):
registry = EnumRegistry()
field = EnumField(registry)
registry.register('OK', 'OK')
registry.register('OK', 'Should be ignored (duplicate)')
registry.register('ERR', 'Error')
self.assertEqual(sorted(list(field.choices)),
[('ERR', 'Error'), ('OK', 'OK')])
with self.assertRaises(ValidationError):
field.validate('FOO', None)
class Submission(models.Model):
problem_instance = models.ForeignKey(ProblemInstance,
verbose_name=_("problem"),
on_delete=models.CASCADE)
user = models.ForeignKey(User,
blank=True,
null=True,
verbose_name=_("user"),
on_delete=models.CASCADE)
date = models.DateTimeField(default=timezone.now,
blank=True,
verbose_name=_("date"),
db_index=True)
kind = EnumField(submission_kinds,
default='NORMAL',
verbose_name=_("kind"))
score = ScoreField(blank=True, null=True, verbose_name=_("score"))
status = EnumField(submission_statuses,
default='?',
verbose_name=_("status"))
comment = models.TextField(blank=True, verbose_name=_("comment"))
@property
def problem(self):
return self.problem_instance.problem
class Meta(object):
verbose_name = _("submission")
verbose_name_plural = _("submissions")
get_latest_by = 'date'
def is_scored(self):
return self.score is not None
def get_date_display(self, shortened=False):
return self.problem_instance.controller.render_submission_date(
self, shortened)
def get_date_display_shortened(self):
return self.get_date_display(True)
def get_score_display(self):
if self.score is None:
return None
return self.problem_instance.controller.render_submission_score(self)
def __str__(self):
return u"Submission(%d, %s, %s, %s, %s, %s)" % (
self.id,
self.problem_instance.problem.name,
self.user.username if self.user else None,
self.date,
self.kind,
self.status,
)
class Test(models.Model):
problem = models.ForeignKey(Problem)
name = models.CharField(max_length=30, verbose_name=_("name"))
input_file = FileField(upload_to=make_problem_filename,
verbose_name=_("input"),
null=True,
blank=True)
output_file = FileField(upload_to=make_problem_filename,
verbose_name=_("output/hint"),
null=True,
blank=True)
kind = EnumField(test_kinds, verbose_name=_("kind"))
group = models.CharField(max_length=30, verbose_name=_("group"))
time_limit = models.IntegerField(verbose_name=_("time limit (ms)"),
null=True,
blank=True)
memory_limit = models.IntegerField(verbose_name=_("memory limit (KiB)"),
null=True,
blank=True)
max_score = models.IntegerField(verbose_name=_("score"), default=10)
order = models.IntegerField(default=0)
class Meta:
ordering = ['order']
verbose_name = _("test")
verbose_name_plural = _("tests")
class TestRunReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport)
status = EnumField(submission_statuses)
comment = models.CharField(max_length=255, blank=True)
time_used = models.IntegerField(blank=True)
test_time_limit = models.IntegerField(null=True, blank=True)
output_file = FileField(upload_to=make_custom_output_filename)
class Message(models.Model):
contest = models.ForeignKey(Contest, null=True, blank=True)
problem_instance = models.ForeignKey(ProblemInstance,
null=True,
blank=True)
problem = models.ForeignKey(Problem, null=True, blank=True)
top_reference = models.ForeignKey('self', null=True, blank=True)
author = models.ForeignKey(User)
kind = EnumField(message_kinds, default='QUESTION')
topic = models.CharField(max_length=255,
validators=[MaxLengthValidator(255)])
content = models.TextField()
date = models.DateTimeField(auto_now_add=True, editable=False)
def save(self):
if self.top_reference:
self.contest = self.top_reference.contest
self.problem_instance = self.top_reference.problem_instance
self.problem = self.top_reference.problem
if bool(self.contest) == bool(self.problem):
raise ValueError("Exactly one of contest or problem must "
"be set")
if self.problem_instance:
self.contest = self.problem_instance.contest
super(Message, self).save()
class GroupReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport,
on_delete=models.CASCADE)
group = models.CharField(max_length=30)
score = ScoreField(null=True, blank=True)
max_score = ScoreField(null=True, blank=True)
status = EnumField(submission_statuses)
class UserOutGenStatus(models.Model):
testreport = models.OneToOneField(TestReport,
primary_key=True,
related_name='userout_status',
on_delete=models.CASCADE)
status = EnumField(submission_statuses, default='?')
visible_for_user = models.BooleanField(default=True)
class Message(models.Model):
contest = models.ForeignKey(Contest, null=True, blank=True)
round = models.ForeignKey(Round, null=True, blank=True)
problem_instance = models.ForeignKey(ProblemInstance,
null=True,
blank=True)
top_reference = models.ForeignKey('self', null=True, blank=True)
author = models.ForeignKey(User)
kind = EnumField(message_kinds, default='QUESTION', verbose_name=_("kind"))
topic = models.CharField(
max_length=255,
verbose_name=_("topic"),
validators=[MaxLengthValidator(255), validate_whitespaces])
content = models.TextField(verbose_name=_("content"))
date = models.DateTimeField(default=timezone.now,
editable=False,
verbose_name=_("date"))
def save(self, *args, **kwargs):
if self.top_reference:
self.contest = self.top_reference.contest
self.round = self.top_reference.round
self.problem_instance = self.top_reference.problem_instance
if self.problem_instance:
self.round = self.problem_instance.round
self.contest = self.round.contest
super(Message, self).save(*args, **kwargs)
def can_have_replies(self):
return self.kind == 'QUESTION'
class PAProblemInstanceData(models.Model):
problem_instance = models.OneToOneField(ProblemInstance, primary_key=True)
division = EnumField(division_registry, verbose_name=_("Division"))
class Meta(object):
verbose_name = _("Division")
verbose_name_plural = _("Divisions")
class SubmissionReport(models.Model):
submission = models.ForeignKey(Submission, on_delete=models.CASCADE)
creation_date = models.DateTimeField(auto_now_add=True)
kind = EnumField(submission_report_kinds, default='FINAL')
status = EnumField(submission_report_statuses, default='INACTIVE')
@property
def score_report(self):
try:
return self.scorereport_set.all()[0]
except (ScoreReport.DoesNotExist, IndexError):
return None
class Meta(object):
get_latest_by = 'creation_date'
ordering = ('-creation_date', )
index_together = (('submission', 'creation_date'), )
class ScoreReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport)
status = EnumField(submission_statuses, blank=True, null=True)
score = ScoreField(blank=True, null=True)
comment = models.TextField(blank=True, null=True)
def get_score_display(self):
if self.score is None:
return ''
return unicode(self.score)
class ProblemStatementConfig(models.Model):
contest = models.OneToOneField('contests.Contest', on_delete=models.CASCADE)
visible = EnumField(statements_visibility_options, default='AUTO',
verbose_name=_("statements visibility"),
help_text=_("If set to Auto, the visibility is determined "
"according to the type of the contest."))
class Meta(object):
verbose_name = _("problem statement config")
verbose_name_plural = _("problem statement configs")
class PostReaction(models.Model):
"""PostReaction - represents a reaction to a post on the forum."""
post = models.ForeignKey(
Post,
verbose_name=_("post"),
related_name='reactions',
on_delete=models.CASCADE,
)
author = models.ForeignKey(User, on_delete=models.CASCADE)
type_of_reaction = EnumField(post_reaction_types)
class ScoreReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport, on_delete=models.CASCADE)
status = EnumField(submission_statuses, blank=True, null=True)
score = ScoreField(blank=True, null=True)
max_score = ScoreField(blank=True, null=True)
comment = models.TextField(blank=True, null=True)
def get_score_display(self):
if self.score is None:
return ''
return six.text_type(self.score)
class ModelSolution(models.Model):
objects = ModelSolutionsManager()
problem = models.ForeignKey(Problem)
name = models.CharField(max_length=30, verbose_name=_("name"))
source_file = FileField(upload_to=make_problem_filename,
verbose_name=_("source"))
kind = EnumField(model_solution_kinds, verbose_name=_("kind"))
@property
def short_name(self):
return self.name.rsplit('.', 1)[0]
class ProgramsConfig(models.Model):
contest = models.OneToOneField(Contest, related_name='programs_config')
execuction_mode = EnumField(
execuction_mode_options,
default='AUTO',
verbose_name=_("execution mode"),
help_text=_("If set to Auto, the execution mode is determined "
"according to the type of the contest."))
class Meta(object):
verbose_name = _("programs configuration")
verbose_name_plural = _("programs configurations")
class UserResultForProblem(models.Model):
"""User result (score) for the problem.
Each user can have only one class:`UserResultForProblem` per problem
instance.
"""
user = models.ForeignKey(User)
problem_instance = models.ForeignKey(ProblemInstance)
score = ScoreField(blank=True, null=True)
status = EnumField(submission_statuses, blank=True, null=True)
class Meta:
unique_together = ('user', 'problem_instance')
class TestReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport)
status = EnumField(submission_statuses)
comment = models.CharField(max_length=255, blank=True)
score = ScoreField(blank=True)
time_used = models.IntegerField(blank=True)
test = models.ForeignKey(Test, blank=True, null=True,
on_delete=models.SET_NULL)
test_name = models.CharField(max_length=30)
test_group = models.CharField(max_length=30)
test_time_limit = models.IntegerField(null=True, blank=True)
test_max_score = models.IntegerField(null=True, blank=True)
class ContestPermission(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
contest = models.ForeignKey(Contest, on_delete=models.CASCADE)
permission = EnumField(contest_permissions,
default='contests.contest_admin', verbose_name=_("permission"))
class Meta(object):
unique_together = ('user', 'contest', 'permission')
verbose_name = _("contest permission")
verbose_name_plural = _("contest permissions")
def __unicode__(self):
return u'%s/%s: %s' % (self.contest, self.permission, self.user)
class QueuedJob(models.Model):
job_id = models.CharField(max_length=50, primary_key=True)
state = EnumField(job_states, default='QUEUED')
creation_date = models.DateTimeField(default=timezone.now)
# Optional information about queued jobs.
submission = models.ForeignKey(Submission, null=True)
celery_task_id = models.CharField(max_length=50, unique=True, null=True,
blank=True)
class Meta(object):
verbose_name = _("Queued job")
verbose_name_plural = _("Queued jobs")
ordering = ['pk']
class QueuedSubmit(models.Model):
submission = models.ForeignKey(Submission)
state = EnumField(submission_states, default='QUEUED')
creation_date = models.DateTimeField(default=timezone.now)
celery_task_id = models.CharField(max_length=50,
unique=True,
null=True,
blank=True)
creation_date.short_description = _("Creation date")
class Meta(object):
verbose_name = _("Queued Submit")
ordering = ['pk']
class QuestionReport(models.Model):
submission_report = models.ForeignKey(SubmissionReport,
verbose_name=_("Submission report"))
comment = models.TextField(blank=True, null=True,
verbose_name=_("Comment"))
score = ScoreField(verbose_name=_("Score"))
question = models.ForeignKey(QuizQuestion, blank=True, null=True,
on_delete=models.SET_NULL, verbose_name=_("Question"))
question_max_score = models.IntegerField(verbose_name=_("Question max score"))
status = EnumField(submission_statuses, default='WA', verbose_name=_("Status"))
class Meta(object):
verbose_name = _("Question report")
verbose_name_plural = _("Question reports")
class RankingVisibilityConfig(models.Model):
contest = models.OneToOneField('contests.Contest',
on_delete=models.CASCADE)
visible = EnumField(ranking_visibility_options,
default='AUTO',
verbose_name=_("ranking visibility"),
help_text=_(
"If set to Auto, the visibility is determined "
"according to the type of the contest.\n"
"Until the date of publication of the results, "
"the ranking is visible only to administrators."))
class Meta(object):
verbose_name = _("ranking visibility config")
verbose_name_plural = _("ranking visibility configs")
def test_serialization(self):
"""Test if choices aren't serialized by migration."""
first_field = EnumField(self.registry)
first_serialized = first_field.deconstruct()
self.registry.register('MAYBE', "You tell me if it's wrong or not")
second_field = EnumField(self.registry)
second_serialized = second_field.deconstruct()
self.assertEqual(first_serialized, second_serialized)
class TeamsConfig(models.Model):
contest = models.OneToOneField(Contest)
enabled = models.BooleanField(default=False)
max_team_size = models.IntegerField(default=3,
validators=[MinValueValidator(1)])
modify_begin_date = models.DateTimeField(
verbose_name=_("team modification begin date"), blank=True, null=True)
modify_end_date = models.DateTimeField(
verbose_name=_("team modification end date"), blank=True, null=True)
teams_list_visible = EnumField(teams_list_visibility_options,
default='NO',
verbose_name=_("teams list visibility"))
class Meta(object):
verbose_name = _("teams configuration")
verbose_name_plural = _("teams configurations")
class Test(models.Model):
__test__ = False
problem_instance = models.ForeignKey(ProblemInstance,
on_delete=models.CASCADE)
name = models.CharField(max_length=30, verbose_name=_("name"))
input_file = FileField(upload_to=make_problem_filename,
verbose_name=_("input"),
null=True,
blank=True)
output_file = FileField(
upload_to=make_problem_filename,
verbose_name=_("output/hint"),
null=True,
blank=True,
)
kind = EnumField(test_kinds, verbose_name=_("kind"))
group = models.CharField(max_length=30, verbose_name=_("group"))
time_limit = models.IntegerField(
verbose_name=_("time limit (ms)"),
null=True,
blank=False,
validators=[validate_time_limit],
)
memory_limit = models.IntegerField(
verbose_name=_("memory limit (KiB)"),
null=True,
blank=True,
validators=[validate_memory_limit],
)
max_score = models.IntegerField(verbose_name=_("score"), default=10)
order = models.IntegerField(default=0)
is_active = models.BooleanField(default=True)
@property
def problem(self):
return self.problem_instance.problem
def __str__(self):
return six.text_type(self.name)
class Meta(object):
ordering = ['order']
verbose_name = _("test")
verbose_name_plural = _("tests")
unique_together = ('problem_instance', 'name')
class Participant(models.Model):
contest = models.ForeignKey(Contest)
user = models.ForeignKey(User)
status = EnumField(participant_statuses, default='ACTIVE')
@property
def registration_model(self):
rcontroller = self.contest.controller.registration_controller()
model_class = rcontroller.get_model_class()
try:
return model_class.objects.get(participant=self)
except model_class.DoesNotExist:
raise ObjectDoesNotExist
class Meta:
unique_together = ('contest', 'user')
def __unicode__(self):
return unicode(self.user)
class TestReport(models.Model):
__test__ = False
submission_report = models.ForeignKey(SubmissionReport,
on_delete=models.CASCADE)
status = EnumField(submission_statuses)
comment = models.CharField(max_length=255, blank=True)
score = ScoreField(null=True, blank=True)
max_score = ScoreField(null=True, blank=True)
time_used = models.IntegerField(blank=True)
output_file = FileField(upload_to=make_output_filename,
null=True,
blank=True)
test = models.ForeignKey(Test,
blank=True,
null=True,
on_delete=models.SET_NULL)
test_name = models.CharField(max_length=30)
test_group = models.CharField(max_length=30)
test_time_limit = models.IntegerField(null=True, blank=True)
def test_basic_usage(self):
field = EnumField(self.registry)
self.assertEqual(sorted(list(field.choices)),
[('ERR', 'Error'), ('OK', 'OK')])
with self.assertRaises(ValidationError):
field.validate('FOO', None)
