Add support for archiving a submission

Author: int-y1

judge/admin/submission.py

@@ -120,8 +120,8 @@ def get_formset(self, request, obj=None, **kwargs):
 
 class SubmissionAdmin(VersionAdmin):
     readonly_fields = ('user', 'problem', 'date', 'judged_date')
-    fields = ('user', 'problem', 'date', 'judged_date', 'locked_after', 'time', 'memory', 'points', 'language',
-              'status', 'result', 'case_points', 'case_total', 'judged_on', 'error')
+    fields = ('user', 'problem', 'date', 'judged_date', 'locked_after', 'is_archived', 'time', 'memory', 'points',
+              'language', 'status', 'result', 'case_points', 'case_total', 'judged_on', 'error')
     actions = ('judge', 'recalculate_score')
     list_display = ('id', 'problem_code', 'problem_name', 'user_column', 'execution_time', 'pretty_memory',
                     'points', 'language_column', 'status', 'result', 'judge_column')
@@ -135,6 +135,8 @@ def get_readonly_fields(self, request, obj=None):
         fields = self.readonly_fields
         if not request.user.has_perm('judge.lock_submission'):
             fields += ('locked_after',)
+        if not request.user.has_perm('judge.archive_submission'):
+            fields += ('is_archived',)
         return fields
 
     def get_queryset(self, request):

judge/migrations/0151_submission_is_archived.py

@@ -0,0 +1,35 @@
+# Generated by Django 4.2.17 on 2025-03-02 10:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('judge', '0150_add_performance_ceiling'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='submission',
+            options={
+                'permissions': (
+                    ('abort_any_submission', 'Abort any submission'),
+                    ('rejudge_submission', 'Rejudge the submission'),
+                    ('rejudge_submission_lot', 'Rejudge a lot of submissions'),
+                    ('spam_submission', 'Submit without limit'),
+                    ('view_all_submission', 'View all submission'),
+                    ('resubmit_other', "Resubmit others' submission"),
+                    ('lock_submission', 'Change lock status of submission'),
+                    ('archive_submission', 'Archive any submission'),
+                ),
+                'verbose_name': 'submission',
+                'verbose_name_plural': 'submissions',
+            },
+        ),
+        migrations.AddField(
+            model_name='submission',
+            name='is_archived',
+            field=models.BooleanField(default=False, verbose_name='is archived'),
+        ),
+    ]

judge/models/problem.py

@@ -394,8 +394,8 @@ def submission_source_visibility(self):
         return self.submission_source_visibility_mode
 
     def update_stats(self):
-        all_queryset = self.submission_set.filter(user__is_unlisted=False)
-        ac_queryset = all_queryset.filter(points__gte=self.points, result='AC')
+        all_queryset = self.submission_set.filter(user__is_unlisted=False, is_archived=False)
+        ac_queryset = all_queryset.filter(result='AC', case_points__gte=F('case_total'))
         self.user_count = ac_queryset.values('user').distinct().count()
         submissions = all_queryset.count()
         if submissions:
@@ -466,7 +466,8 @@ def save(self, *args, **kwargs):
 
     def is_solved_by(self, user):
         # Return true if a full AC submission to the problem from the user exists.
-        return self.submission_set.filter(user=user.profile, result='AC', points__gte=F('problem__points')).exists()
+        return self.submission_set.filter(
+            user=user.profile, is_archived=False, result='AC', case_points__gte=F('case_total')).exists()
 
     def vote_permission_for_user(self, user):
         if not user.is_authenticated:

judge/models/profile.py

@@ -224,7 +224,7 @@ def display_name(self):
 
     @cached_property
     def has_any_solves(self):
-        return self.submission_set.filter(result='AC', case_points__gte=F('case_total')).exists()
+        return self.submission_set.filter(is_archived=False, result='AC', case_points__gte=F('case_total')).exists()
 
     @cached_property
     def resolved_ace_theme(self):
@@ -243,15 +243,16 @@ def calculate_points(self, table=_pp_table):
         from judge.models import Problem
         public_problems = Problem.get_public_problems()
         data = (
-            public_problems.filter(submission__user=self, submission__points__isnull=False)
+            public_problems.filter(submission__user=self, submission__is_archived=False,
+                                   submission__points__isnull=False)
                            .annotate(max_points=Max('submission__points')).order_by('-max_points')
                            .values_list('max_points', flat=True).filter(max_points__gt=0)
         )
         bonus_function = settings.DMOJ_PP_BONUS_FUNCTION
         points = sum(data)
         entries = min(len(data), len(table))
         problems = (
-            public_problems.filter(submission__user=self, submission__result='AC',
+            public_problems.filter(submission__user=self, submission__is_archived=False, submission__result='AC',
                                    submission__case_points__gte=F('submission__case_total'))
             .values('id').distinct().count()
         )

judge/models/submission.py

@@ -88,6 +88,7 @@ class Submission(models.Model):
     contest_object = models.ForeignKey('Contest', verbose_name=_('contest'), null=True, blank=True,
                                        on_delete=models.SET_NULL, related_name='+', db_index=False)
     locked_after = models.DateTimeField(verbose_name=_('submission lock'), null=True, blank=True)
+    is_archived = models.BooleanField(verbose_name=_('is archived'), default=False)
 
     @classmethod
     def result_class_from_code(cls, result, case_points, case_total):
@@ -132,6 +133,12 @@ def judge(self, *args, rejudge=False, force_judge=False, rejudge_user=None, **kw
 
     judge.alters_data = True
 
+    def archive(self):
+        self.is_archived = True
+        self.save(update_fields=['is_archived'])
+
+    archive.alters_data = True
+
     def abort(self):
         abort_submission(self)
 
@@ -227,6 +234,7 @@ class Meta:
             ('view_all_submission', _('View all submission')),
             ('resubmit_other', _("Resubmit others' submission")),
             ('lock_submission', _('Change lock status of submission')),
+            ('archive_submission', _('Archive any submission')),
         )
         verbose_name = _('submission')
         verbose_name_plural = _('submissions')

judge/models/tests/test_problem.py

@@ -251,6 +251,8 @@ def give_basic_problem_ac(self, user, points=None):
             problem=self.basic_problem,
             result='AC',
             points=self.basic_problem.points if points is None else points,
+            case_points=(self.basic_problem.points if points is None else points) * 100,
+            case_total=self.basic_problem.points * 100,
             language=Language.get_python3(),
         )
 
@@ -294,8 +296,8 @@ def test_problem_voting_permissions(self):
         self.assertEqual(self.basic_problem.vote_permission_for_user(self.users['normal']), VotePermission.VOTE)
 
         partial_ac = create_user(username='partial_ac')
-        self.give_basic_problem_ac(partial_ac, 0.5)  # ensure this value is not equal to its point value
-        self.assertNotEqual(self.basic_problem.points, 0.5)
+        self.give_basic_problem_ac(partial_ac, 0.5)  # ensure this value is less than its point value
+        self.assertLess(0.5, self.basic_problem.points)
         self.assertEqual(self.basic_problem.vote_permission_for_user(partial_ac), VotePermission.VIEW)
 
     def test_problems_list(self):

judge/performance_points.py

@@ -37,13 +37,15 @@ def get_pp_breakdown(user, start=0, end=settings.DMOJ_PP_ENTRIES):
                 INNER JOIN judge_submission ON (judge_problem.id = judge_submission.problem_id)
                 WHERE (judge_problem.is_public AND
                        NOT judge_problem.is_organization_private AND
+                       NOT judge_submission.is_archived AND
                        judge_submission.points IS NOT NULL AND
                        judge_submission.user_id = %s)
                 GROUP BY judge_problem.id
                 HAVING MAX(judge_submission.points) > 0.0
             ) AS max_points_table
             {join_type} judge_submission ON (
                 judge_submission.problem_id = max_points_table.problem_id AND
+                NOT judge_submission.is_archived AND
                 judge_submission.points = max_points_table.max_points AND
                 judge_submission.user_id = %s
             )

judge/signals.py

@@ -127,6 +127,16 @@ def submission_delete(sender, instance, **kwargs):
     instance.problem.update_stats()
 
 
+@receiver(post_save, sender=Submission)
+def submission_update(sender, instance, update_fields, **kwargs):
+    if update_fields and 'is_archived' in update_fields:
+        finished_submission(instance)
+        instance.user._updating_stats_only = True
+        instance.user.calculate_points()
+        instance.problem._updating_stats_only = True
+        instance.problem.update_stats()
+
+
 @receiver(post_delete, sender=ContestSubmission)
 def contest_submission_delete(sender, instance, **kwargs):
     participation = instance.participation

judge/tasks/submission.py

@@ -10,29 +10,34 @@
 __all__ = ('apply_submission_filter', 'rejudge_problem_filter', 'rescore_problem')
 
 
-def apply_submission_filter(queryset, id_range, languages, results):
+def apply_submission_filter(queryset, id_range, languages, results, archive_locked):
     if id_range:
         start, end = id_range
         queryset = queryset.filter(id__gte=start, id__lte=end)
     if languages:
         queryset = queryset.filter(language_id__in=languages)
     if results:
         queryset = queryset.filter(result__in=results)
-    queryset = queryset.exclude(locked_after__lt=timezone.now()) \
-                       .exclude(status__in=Submission.IN_PROGRESS_GRADING_STATUS)
+    if not archive_locked:
+        queryset = queryset.exclude(locked_after__lt=timezone.now())
+    queryset = queryset.exclude(status__in=Submission.IN_PROGRESS_GRADING_STATUS)
     return queryset
 
 
 @shared_task(bind=True)
-def rejudge_problem_filter(self, problem_id, id_range=None, languages=None, results=None, user_id=None):
+def rejudge_problem_filter(self, problem_id, id_range=None, languages=None, results=None, archive_locked=None,
+                           user_id=None):
     queryset = Submission.objects.filter(problem_id=problem_id)
-    queryset = apply_submission_filter(queryset, id_range, languages, results)
+    queryset = apply_submission_filter(queryset, id_range, languages, results, archive_locked)
     user = User.objects.get(id=user_id)
 
     rejudged = 0
     with Progress(self, queryset.count()) as p:
         for submission in queryset.iterator():
-            submission.judge(rejudge=True, batch_rejudge=True, rejudge_user=user)
+            if not submission.is_locked:
+                submission.judge(rejudge=True, batch_rejudge=True, rejudge_user=user)
+            else:
+                submission.archive()
             rejudged += 1
             if rejudged % 10 == 0:
                 p.done = rejudged

judge/utils/problems.py

@@ -34,7 +34,8 @@ def user_completed_ids(profile):
     key = 'user_complete:%d' % profile.id
     result = cache.get(key)
     if result is None:
-        result = set(Submission.objects.filter(user=profile, result='AC', case_points__gte=F('case_total'))
+        result = set(Submission.objects
+                     .filter(user=profile, is_archived=False, result='AC', case_points__gte=F('case_total'))
                      .values_list('problem_id', flat=True).distinct())
         cache.set(key, result, 86400)
     return result