Add a util to create the session and freeze the choices

Author: PeterJCLaw

code_submitter/utils.py

@@ -1,10 +1,10 @@
-from typing import Dict, Tuple
+from typing import cast, Dict, Tuple
 from zipfile import ZipFile
 
 import databases
 from sqlalchemy.sql import select
 
-from .tables import Archive, ChoiceHistory
+from .tables import Archive, Session, ChoiceHistory, ChoiceForSession
 
 
 async def get_chosen_submissions(
@@ -35,6 +35,49 @@ async def get_chosen_submissions(
     return {x['team']: (x['id'], x['content']) for x in rows}
 
 
+async def create_session(
+    database: databases.Database,
+    name: str,
+    *,
+    by_username: str,
+) -> int:
+    """
+    Return a mapping of teams to their the chosen archive.
+    """
+
+    # Note: Ideally we'd group by team in SQL, however that doesn't seem to work
+    # properly -- we don't get the ordering applied before the grouping.
+
+    async with database.transaction():
+        rows = await database.fetch_all(
+            select([
+                ChoiceHistory.c.id,
+                Archive.c.team,
+            ]).select_from(
+                Archive.join(ChoiceHistory),
+            ).order_by(
+                Archive.c.team,
+                ChoiceHistory.c.created.asc(),
+            ),
+        )
+
+        session_id = cast(int, await database.execute(
+            Session.insert().values(name=name, username=by_username),
+        ))
+
+        # Rely on later keys replacing earlier occurrences of the same key.
+        choice_by_team = {x['team']: x['id'] for x in rows}
+        await database.execute_many(
+            ChoiceForSession.insert(),
+            [
+                {'choice_id': x, 'session_id': session_id}
+                for x in choice_by_team.values()
+            ],
+        )
+
+    return session_id
+
+
 def summarise(submissions: Dict[str, Tuple[int, bytes]]) -> str:
     return "".join(
         "{}: {}\n".format(team, id_)

tests/tests_utils.py

@@ -5,7 +5,7 @@
 import test_utils
 
 from code_submitter import utils
-from code_submitter.tables import Archive, ChoiceHistory
+from code_submitter.tables import Archive, ChoiceHistory, ChoiceForSession
 
 
 class UtilsTests(test_utils.InTransactionTestCase):
@@ -76,6 +76,47 @@ def test_get_chosen_submissions_multiple_chosen(self) -> None:
             result,
         )
 
+    def test_create_session(self) -> None:
+        choice_id_1 = self.await_(self.database.execute(
+            ChoiceHistory.insert().values(
+                archive_id=8888888888,
+                username='someone_else',
+                created=datetime.datetime(2020, 8, 8, 12, 0),
+            ),
+        ))
+        choice_id_2 = self.await_(self.database.execute(
+            ChoiceHistory.insert().values(
+                archive_id=1111111111,
+                username='test_user',
+                created=datetime.datetime(2020, 3, 3, 12, 0),
+            ),
+        ))
+        self.await_(self.database.execute(
+            ChoiceHistory.insert().values(
+                archive_id=2222222222,
+                username='test_user',
+                created=datetime.datetime(2020, 2, 2, 12, 0),
+            ),
+        ))
+
+        session_id = self.await_(utils.create_session(
+            self.database,
+            "Test Session",
+            by_username='the-user',
+        ))
+
+        choices = self.await_(self.database.fetch_all(
+            ChoiceForSession.select(),
+        ))
+
+        self.assertEqual(
+            [
+                {'choice_id': choice_id_1, 'session_id': session_id},
+                {'choice_id': choice_id_2, 'session_id': session_id},
+            ],
+            [dict(x) for x in choices],
+        )
+
     def test_collect_submissions(self) -> None:
         self.await_(self.database.execute(
             ChoiceHistory.insert().values(