Add feature to manage random-set contest

migration/20260102144900_add_random_set.py

@@ -0,0 +1,29 @@
+import json
+
+async def dochange(db, rs):
+    await db.execute("ALTER TABLE contest ADD COLUMN start_ip character varying(64) DEFAULT '0.0.0.0';")
+    await db.execute("ALTER TABLE contest ADD COLUMN end_ip character varying(64) DEFAULT '0.0.0.0';")
+
+    await db.execute(
+    '''
+        CREATE TABLE contest_ip_joints (
+            contest_id integer NOT NULL,
+            ip character varying(64) NOT NULL,
+            pro_id integer NOT NULL
+        );
+    '''
+    )
+
+    await db.execute(
+    '''
+        ALTER TABLE ONLY contest_ip_joints ADD CONSTRAINT contest_problem_joints_forkey_contest_id
+            FOREIGN KEY (contest_id) REFERENCES contest(contest_id) ON DELETE CASCADE;
+    '''
+    )
+
+    await db.execute(
+    '''
+        ALTER TABLE ONLY contest_ip_joints ADD CONSTRAINT contest_problem_joints_forkey_pro_id
+            FOREIGN KEY (pro_id) REFERENCES problem(pro_id) ON DELETE CASCADE;
+    '''
+    )

src/handlers/contests/manage/acct.py

@@ -4,6 +4,8 @@
 from services.user import UserService
 from utils.numeric import parse_str_to_list
 
+from ipaddress import IPv4Address, AddressValueError
+
 contest_manage_acct_dispatcher = ActionDispatcher()
 
 
@@ -26,6 +28,8 @@ async def get(self):
             contest_id=self.contest.contest_id,
             acct_list=acct_list,
             admin_list=admin_list,
+            start_ip=str(self.contest.start_ip),
+            end_ip=str(self.contest.end_ip)
         )
 
     @contest_manage_acct_dispatcher.action("add")
@@ -145,6 +149,30 @@ async def multi_remove_action(self):
             ("S", f"Accounts(#{acct_list} successfully removed from user list.")
         )
 
+    @contest_manage_acct_dispatcher.action("update_ip")
+    async def update_ip_action(self):
+        start_ip = self.get_argument("start_ip")
+        end_ip = self.get_argument("end_ip")
+
+        try:
+            start_ip = IPv4Address(start_ip)
+            end_ip = IPv4Address(end_ip)
+        except AddressValueError:
+            return self.error(("Eparam", "Invalid IP address format."))
+
+        if start_ip > end_ip:
+            return self.error(('Eparam', 'Invalid IP range'))
+
+        self.contest.start_ip = start_ip
+        self.contest.end_ip = end_ip
+        await ContestService.inst.update_ip(
+            self.contest
+        )
+
+        return self.error(
+            ("S", f"Contest IP range successfully updated.")
+        )
+
     @reqenv
     @contest_require_permission("admin")
     async def post(self):

src/handlers/contests/manage/general.py

@@ -90,6 +90,10 @@ async def update_action(self):
         if err:
             return self.error(err)
 
+        if contest_mode != self.contest.contest_mode and ContestMode.RANDOM_SET in (contest_mode, self.contest.contest_mode):
+            if len(self.contest.pro_list) != 0:
+                return self.error(('Echmod', 'Cannot change contest mode when problem list is not empty'))
+
         self.contest.name = name
 
         self.contest.contest_mode = contest_mode

src/handlers/contests/manage/pro.py

@@ -3,7 +3,7 @@
 from handlers.base import reqenv, RequestHandler, ActionDispatcher
 from handlers.contests.base import contest_require_permission
 from services.chal import ChalConst, ChalService
-from services.contests import ContestService, ProblemScoreType
+from services.contests import ContestService, ProblemScoreType, ContestMode
 from services.judge import JudgeServerClusterService
 from services.pro import ProService, ProConst
 from utils.numeric import parse_str_to_list
@@ -24,16 +24,28 @@ async def get(self):
                 continue
             pro_list.append(pro)
 
-        await self.render(
-            "contests/manage/pro",
-            page="pro",
-            contest_id=self.contest.contest_id,
-            contest=self.contest,
-            pro_list=pro_list,
-        )
+        if self.contest.contest_mode == ContestMode.RANDOM_SET:
+            await self.render(
+                "contests/manage/rand-pro",
+                page="pro",
+                contest_id=self.contest.contest_id,
+                contest=self.contest,
+                pro_sets=self.contest.pro_sets
+            )
+        else:
+            await self.render(
+                "contests/manage/pro",
+                page="pro",
+                contest_id=self.contest.contest_id,
+                contest=self.contest,
+                pro_list=pro_list,
+            )
 
     @contest_manage_pro_dispatcher.action("add")
     async def add_action(self):
+        if self.contest.contest_mode == ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot add problems to random set contests'))
+
         pro_id = int(self.get_argument("pro_id"))
 
         if self.contest.is_pro(pro_id):
@@ -51,6 +63,9 @@ async def add_action(self):
 
     @contest_manage_pro_dispatcher.action("remove")
     async def remove_action(self):
+        if self.contest.contest_mode == ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot remove problems from random set contests'))
+
         pro_id = int(self.get_argument("pro_id"))
 
         if not self.contest.is_pro(pro_id):
@@ -68,6 +83,9 @@ async def remove_action(self):
 
     @contest_manage_pro_dispatcher.action("multi_add")
     async def multi_add_action(self):
+        if self.contest.contest_mode == ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot add problems to random set contests'))
+
         pro_id = self.get_argument("pro_id")
         pro_id = parse_str_to_list(pro_id)
         for p_id in pro_id:
@@ -83,6 +101,9 @@ async def multi_add_action(self):
 
     @contest_manage_pro_dispatcher.action("multi_remove")
     async def multi_remove_action(self):
+        if self.contest.contest_mode == ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot remove problems from random set contests'))
+
         pro_id = self.get_argument("pro_id")
         pro_list = parse_str_to_list(pro_id)
 
@@ -172,6 +193,71 @@ async def public_action(self):
 
         return self.error(("S", ""))
 
+    @contest_manage_pro_dispatcher.action("add_set")
+    async def add_set_action(self):
+        '''
+            Add a problem set in random set mode
+            pro_id should be a list of problem ids separated by comma
+        '''
+        if self.contest.contest_mode != ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot add problem set to non-random set contests'))
+
+        pro_ids = self.get_argument("pro_id")
+        pro_ids = parse_str_to_list(pro_ids)
+
+        if len(pro_ids) < 1:
+            return self.error(('Eparam', 'Problem set must contain at least one problem'))
+
+        pro_set = [(pro_id, ProblemScoreType.IOI2017) for pro_id in pro_ids]
+
+        err, _ = await ContestService.inst.add_pro_set(self.contest, pro_set)
+        if err:
+            return self.error(err)
+
+        return self.error(("S", ""))
+
+    @contest_manage_pro_dispatcher.action("remove_set")
+    async def remove_set_action(self):
+        '''
+            Remove a problem set in random set mode
+            pro_id is the problem set index 
+        '''
+        if self.contest.contest_mode != ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot remove problem set from non-random set contests'))
+
+        pro_set_idx = int(self.get_argument("pro_id"))
+        if pro_set_idx < 0 or pro_set_idx > len(self.contest.pro_sets) - 1:
+            return self.error(('Eparam', 'Problem set index out of range'))
+
+        err, _ = await ContestService.inst.remove_pro_set(self.contest, pro_set_idx)
+        if err:
+            return self.error(err)
+
+        return self.error(("S", ""))
+
+    @contest_manage_pro_dispatcher.action("update_order")
+    async def update_order_action(self):
+        '''
+            Update problem order in random set mode
+            pro_id is a comma separated list of new problem set indices
+        '''
+        if self.contest.contest_mode != ContestMode.RANDOM_SET:
+            return self.error(('Emod', 'Cannot update problem order in non-random set contests'))
+
+        new_idxs = self.get_argument("pro_id")
+        new_idxs = parse_str_to_list(new_idxs)
+
+        pro_set_len = len(self.contest.pro_sets)
+
+        if len(new_idxs) != pro_set_len or sorted(new_idxs) != list(range(pro_set_len)):
+            return self.error(('Eparam', 'Invalid new indexes for problem sets'))
+
+        err, _ = await ContestService.inst.reorder_pro_set(self.contest, new_idxs)
+        if err:
+            return self.error(err)
+
+        return self.error(("S", ""))
+
     @reqenv
     @contest_require_permission("admin")
     async def post(self):