Add script to parse notes in Google Sheets

Signed-off-by: Emmy D'Anello <emmy.danello@animath.fr>

participation/management/commands/parse_notation_sheets.py

@@ -0,0 +1,39 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+from time import sleep
+
+from django.core.management import BaseCommand
+from participation.models import Tournament
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--tournament', '-t', help="Tournament name to update (if not set, all tournaments will be updated)",
+        )
+        parser.add_argument(
+            '--round', '-r', type=int, help="Round number to update (if not set, all rounds will be updated)",
+        )
+        parser.add_argument(
+            '--letter', '-l', help="Letter of the pool to update (if not set, all pools will be updated)",
+        )
+
+    def handle(self, *args, **options):
+        tournaments = Tournament.objects.all() if not options['tournament'] \
+            else Tournament.objects.filter(name=options['tournament']).all()
+
+        for tournament in tournaments:
+            if options['verbosity'] >= 1:
+                self.stdout.write(f"Parsing notation sheet for {tournament}")
+
+            pools = tournament.pools.all()
+            if options['round']:
+                pools = pools.filter(round=options['round'])
+            if options['letter']:
+                pools = pools.filter(letter=ord(options['letter']) - 64)
+            for pool in pools.all():
+                if options['verbosity'] >= 1:
+                    self.stdout.write(f"Parsing notation sheet for pool {pool.short_name} for {tournament}")
+                pool.parse_spreadsheet()
+
+            sleep(1)

participation/management/commands/update_notation_sheets.py

@@ -0,0 +1,37 @@
+# Copyright (C) 2024 by Animath
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from django.core.management import BaseCommand
+from participation.models import Tournament
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--tournament', '-t', help="Tournament name to update (if not set, all tournaments will be updated)",
+        )
+        parser.add_argument(
+            '--round', '-r', type=int, help="Round number to update (if not set, all rounds will be updated)",
+        )
+        parser.add_argument(
+            '--letter', '-l', help="Letter of the pool to update (if not set, all pools will be updated)",
+        )
+
+    def handle(self, *args, **options):
+        tournaments = Tournament.objects.all() if not options['tournament'] \
+            else Tournament.objects.filter(name=options['tournament']).all()
+
+        for tournament in tournaments:
+            if options['verbosity'] >= 1:
+                self.stdout.write(f"Updating notation sheet for {tournament}")
+            tournament.create_spreadsheet()
+
+            pools = tournament.pools.all()
+            if options['round']:
+                pools = pools.filter(round=options['round'])
+            if options['letter']:
+                pools = pools.filter(letter=ord(options['letter']) - 64)
+            for pool in pools.all():
+                if options['verbosity'] >= 1:
+                    self.stdout.write(f"Updating notation sheet for pool {pool.short_name} for {tournament}")
+                pool.update_spreadsheet()

participation/migrations/0010_tournament_notes_sheet_id_alter_note_defender_oral_and_more.py

@@ -0,0 +1,93 @@
+# Generated by Django 5.0.3 on 2024-03-29 22:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("participation", "0009_pool_jury_president"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="tournament",
+            name="notes_sheet_id",
+            field=models.CharField(
+                blank=True, default="", max_length=64, verbose_name="Google Sheet ID"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="defender_oral",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                    (11, 11),
+                    (12, 12),
+                    (13, 13),
+                    (14, 14),
+                    (15, 15),
+                    (16, 16),
+                    (17, 17),
+                    (18, 18),
+                    (19, 19),
+                    (20, 20),
+                ],
+                default=0,
+                verbose_name="defender oral note",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="opponent_writing",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                ],
+                default=0,
+                verbose_name="opponent writing note",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="note",
+            name="reporter_writing",
+            field=models.PositiveSmallIntegerField(
+                choices=[
+                    (0, 0),
+                    (1, 1),
+                    (2, 2),
+                    (3, 3),
+                    (4, 4),
+                    (5, 5),
+                    (6, 6),
+                    (7, 7),
+                    (8, 8),
+                    (9, 9),
+                    (10, 10),
+                ],
+                default=0,
+                verbose_name="reporter writing note",
+            ),
+        ),
+    ]

participation/models.py

@@ -1,6 +1,7 @@
 # Copyright (C) 2020 by Animath
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+import asyncio
 from datetime import date
 import os
 
@@ -14,6 +15,9 @@ from django.utils import timezone
 from django.utils.crypto import get_random_string
 from django.utils.text import format_lazy
 from django.utils.translation import gettext_lazy as _
+import gspread
+from django.views.debug import ExceptionReporter
+from gspread.utils import a1_range_to_grid_range, MergeType
 from registration.models import Payment, VolunteerRegistration
 from tfjm.lists import get_sympa_client
 
@@ -337,6 +341,13 @@ class Tournament(models.Model):
         default=False,
     )
 
+    notes_sheet_id = models.CharField(
+        max_length=64,
+        blank=True,
+        default="",
+        verbose_name=_("Google Sheet ID"),
+    )
+
     @property
     def teams_email(self):
         """
@@ -409,6 +420,16 @@ class Tournament(models.Model):
         fmt = [n] if n <= 5 else [3] * (n // 3 - 1) + [3 + n % 3]
         return '+'.join(map(str, sorted(fmt)))
 
+    def create_spreadsheet(self):
+        if self.notes_sheet_id:
+            return self.notes_sheet_id
+
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        spreadsheet = gc.create(f"Feuille de notes - {self.name}", folder_id=settings.NOTES_DRIVE_FOLDER_ID)
+        spreadsheet.update_locale("fr_FR")
+        self.notes_sheet_id = spreadsheet.id
+        self.save()
+
     def get_absolute_url(self):
         return reverse_lazy("participation:tournament_detail", args=(self.pk,))
 
@@ -591,6 +612,378 @@ class Pool(models.Model):
             raise ValidationError({'jury_president': _("The president of the jury must be part of the jury.")})
         return super().validate_constraints()
 
+    def update_spreadsheet(self):  # noqa: C901
+        # Create tournament sheet if it does not exist
+        self.tournament.create_spreadsheet()
+
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        spreadsheet = gc.open_by_key(self.tournament.notes_sheet_id)
+        worksheets = spreadsheet.worksheets()
+        if f"Poule {self.short_name}" not in [ws.title for ws in worksheets]:
+            worksheet = spreadsheet.add_worksheet(f"Poule {self.short_name}", 100, 32)
+        else:
+            worksheet = spreadsheet.worksheet(f"Poule {self.short_name}")
+        if any(ws.title == "Sheet1" for ws in worksheets):
+            spreadsheet.del_worksheet(spreadsheet.worksheet("Sheet1"))
+
+        pool_size = self.participations.count()
+        passage_width = 7 if pool_size == 4 else 6
+        passages = self.passages.all()
+
+        header = [
+            sum(([f"Problème {passage.solution_number}"] + (passage_width - 1) * [""]
+                 for passage in passages), start=["Problème", ""]),
+            sum((["Défenseur⋅se", "", "Opposant⋅e", "", "Rapporteur⋅e", ""]
+                 + (["Observateur⋅rice"] if pool_size == 4 else [])
+                 for _passage in passages), start=["Rôle", ""]),
+            sum((["Écrit (/20)", "Oral (/20)", "Écrit (/10)", "Oral (/10)", "Écrit (/10)", "Oral (/10)"]
+                 + (["Oral (± 4)"] if pool_size == 4 else [])
+                 for _passage in passages), start=["Juré⋅e", ""]),
+        ]
+
+        notes = [[]]  # Begin with empty hidden line to ensure pretty design
+        for jury in self.juries.all():
+            line = [str(jury), jury.id]
+            for passage in passages:
+                note = passage.notes.filter(jury=jury).first()
+                line.extend([note.defender_writing, note.defender_oral, note.opponent_writing, note.opponent_oral,
+                             note.reporter_writing, note.reporter_oral])
+                if pool_size == 4:
+                    line.append(note.observer_oral)
+            notes.append(line)
+        notes.append([])  # Add empty line to ensure pretty design
+
+        def getcol(number: int) -> str:
+            """
+            Translates the given number to the nth column name
+            """
+            if number == 0:
+                return ''
+            return getcol((number - 1) // 26) + chr(65 + (number - 1) % 26)
+
+        average = ["Moyenne", ""]
+        coeffs = sum(([1, 1.6 - 0.4 * passage.defender_penalties, 0.9, 2, 0.9, 1]
+                      + ([1] if pool_size == 4 else []) for passage in passages), start=["Coefficient", ""])
+        subtotal = ["Sous-total", ""]
+        footer = [average, coeffs, subtotal, 32 * [""]]
+
+        min_row = 5
+        max_row = min_row + self.juries.count()
+        min_column = 3
+        for i, passage in enumerate(passages):
+            for j, note in enumerate(passage.averages):
+                column = getcol(min_column + i * passage_width + j)
+                average.append(f"=MOYENNE.SI(${getcol(min_column + i * passage_width)}${min_row - 1}"
+                               f":${getcol(min_column + i * passage_width)}{max_row}; \">0\"; "
+                               f"{column}${min_row - 1}:{column}{max_row})")
+            def_w_col = getcol(min_column + passage_width * i)
+            def_o_col = getcol(min_column + passage_width * i + 1)
+            subtotal.extend([f"={def_w_col}{max_row + 1} * {def_w_col}{max_row + 2}"
+                             f" + {def_o_col}{max_row + 1} * {def_o_col}{max_row + 2}", ""])
+
+            opp_w_col = getcol(min_column + passage_width * i + 2)
+            opp_o_col = getcol(min_column + passage_width * i + 3)
+            subtotal.extend([f"={opp_w_col}{max_row + 1} * {opp_w_col}{max_row + 2}"
+                             f" + {opp_o_col}{max_row + 1} * {opp_o_col}{max_row + 2}", ""])
+
+            rep_w_col = getcol(min_column + passage_width * i + 4)
+            rep_o_col = getcol(min_column + passage_width * i + 5)
+            subtotal.extend([f"={rep_w_col}{max_row + 1} * {rep_w_col}{max_row + 2}"
+                             f" + {rep_o_col}{max_row + 1} * {rep_o_col}{max_row + 2}", ""])
+
+            if pool_size == 4:
+                obs_col = getcol(min_column + passage_width * i + 6)
+                subtotal.append(f"={obs_col}{max_row + 1} * {obs_col}{max_row + 2}")
+
+        ranking = [
+            ["Équipe", "", "Problème", "Total", "Rang"],
+        ]
+        passage_matrix = []
+        match pool_size:
+            case 3:
+                passage_matrix = [
+                    [0, 2, 1],
+                    [1, 0, 2],
+                    [2, 1, 0],
+                ]
+            case 4:
+                passage_matrix = [
+                    [0, 3, 2, 1],
+                    [1, 0, 3, 2],
+                    [2, 1, 0, 3],
+                    [3, 2, 1, 0],
+                ]
+            case 5:
+                passage_matrix = [
+                    [0, 2, 3],
+                    [1, 4, 2],
+                    [2, 0, 4],
+                    [3, 1, 0],
+                    [4, 3, 1],
+                ]
+        for passage in passages:
+            participation = passage.defender
+            passage_line = passage_matrix[passage.position - 1]
+            formula = "="
+            formula += getcol(min_column + passage_line[0] * passage_width) + str(max_row + 3)  # Defender
+            formula += " + " + getcol(min_column + passage_line[1] * passage_width + 2) + str(max_row + 3)  # Opponent
+            formula += " + " + getcol(min_column + passage_line[2] * passage_width + 4) + str(max_row + 3)  # Reporter
+            if pool_size == 4:
+                # Observer
+                formula += " + " + getcol(min_column + passage_line[3] * passage_width + 6) + str(max_row + 3)
+            ranking.append([f"{participation.team.name} ({participation.team.trigram})", "",
+                            f"=${getcol(3 + (passage.position - 1) * passage_width)}$1", formula,
+                            f"=RANG(D{max_row + 5 + passage.position}; "
+                            f"D${max_row + 6}:D${max_row + 5 + pool_size})"])
+
+        all_values = header + notes + footer + ranking
+
+        worksheet.batch_clear([f"A1:AF{max_row + 5 + pool_size}"])
+        worksheet.update("A1:AF", all_values, raw=False)
+
+        format_requests = []
+
+        # Merge cells
+        merge_cells = ["A1:B1", "A2:B2", "A3:B3"]
+        for i, passage in enumerate(passages):
+            merge_cells.append(f"{getcol(3 + i * passage_width)}1:{getcol(2 + passage_width + i * passage_width)}1")
+
+            merge_cells.append(f"{getcol(3 + i * passage_width)}2:{getcol(4 + i * passage_width)}2")
+            merge_cells.append(f"{getcol(5 + i * passage_width)}2:{getcol(6 + i * passage_width)}2")
+            merge_cells.append(f"{getcol(7 + i * passage_width)}2:{getcol(8 + i * passage_width)}2")
+
+            merge_cells.append(f"{getcol(3 + i * passage_width)}{max_row + 3}"
+                               f":{getcol(4 + i * passage_width)}{max_row + 3}")
+            merge_cells.append(f"{getcol(5 + i * passage_width)}{max_row + 3}"
+                               f":{getcol(6 + i * passage_width)}{max_row + 3}")
+            merge_cells.append(f"{getcol(7 + i * passage_width)}{max_row + 3}"
+                               f":{getcol(8 + i * passage_width)}{max_row + 3}")
+        merge_cells.append(f"A{max_row + 1}:B{max_row + 1}")
+        merge_cells.append(f"A{max_row + 2}:B{max_row + 2}")
+        merge_cells.append(f"A{max_row + 3}:B{max_row + 3}")
+
+        for i in range(pool_size + 1):
+            merge_cells.append(f"A{max_row + 5 + i}:B{max_row + 5 + i}")
+
+        format_requests.append({"unmergeCells": {"range": a1_range_to_grid_range("A1:AF", worksheet.id)}})
+        for name in merge_cells:
+            grid_range = a1_range_to_grid_range(name, worksheet.id)
+            format_requests.append({"mergeCells": {"mergeType": MergeType.merge_all, "range": grid_range}})
+
+        # Make titles bold
+        bold_ranges = [("A1:AF", False), ("A1:AF3", True),
+                       (f"A{max_row + 1}:B{max_row + 3}", True), (f"A{max_row + 5}:E{max_row + 5}", True)]
+        for bold_range, bold in bold_ranges:
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(bold_range, worksheet.id),
+                    "cell": {"userEnteredFormat": {"textFormat": {"bold": bold}}},
+                    "fields": "userEnteredFormat(textFormat)",
+                }
+            })
+
+        # Set background color for headers and footers
+        bg_colors = [("A1:AF", (1, 1, 1)),
+                     (f"A1:{getcol(2 + pool_size * passage_width)}3", (0.8, 0.8, 0.8)),
+                     (f"A{min_row - 1}:B{max_row}", (0.95, 0.95, 0.95)),
+                     (f"A{max_row + 1}:B{max_row + 3}", (0.8, 0.8, 0.8)),
+                     (f"C{max_row + 1}:{getcol(2 + pool_size * passage_width)}{max_row + 3}", (0.9, 0.9, 0.9)),
+                     (f"A{max_row + 5}:E{max_row + 5}", (0.8, 0.8, 0.8)),
+                     (f"A{max_row + 6}:E{max_row + 5 + pool_size}", (0.9, 0.9, 0.9)),]
+        for bg_range, bg_color in bg_colors:
+            r, g, b = bg_color
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(bg_range, worksheet.id),
+                    "cell": {"userEnteredFormat": {"backgroundColor": {"red": r, "green": g, "blue": b}}},
+                    "fields": "userEnteredFormat(backgroundColor)",
+                }
+            })
+
+        # Freeze 2 first columns
+        format_requests.append({
+            "updateSheetProperties": {
+                "properties": {
+                    "sheetId": worksheet.id,
+                    "gridProperties": {
+                        "frozenRowCount": 0,
+                        "frozenColumnCount": 2,
+                    },
+                },
+                "fields": "gridProperties/frozenRowCount,gridProperties/frozenColumnCount",
+            }
+        })
+
+        # Set the width of the columns
+        column_widths = [("A", 250), ("B", 30)]
+        for passage in passages:
+            column_widths.append((f"{getcol(3 + passage_width * (passage.position - 1))}"
+                                  f":{getcol(8 + passage_width * (passage.position - 1))}", 75))
+            if pool_size == 4:
+                column_widths.append((getcol(9 + passage_width * (passage.position - 1)), 120))
+        for column, width in column_widths:
+            grid_range = a1_range_to_grid_range(column, worksheet.id)
+            format_requests.append({
+                "updateDimensionProperties": {
+                    "range": {
+                        "sheetId": worksheet.id,
+                        "dimension": "COLUMNS",
+                        "startIndex": grid_range['startColumnIndex'],
+                        "endIndex": grid_range['endColumnIndex'],
+                    },
+                    "properties": {
+                        "pixelSize": width,
+                    },
+                    "fields": "pixelSize",
+                }
+            })
+
+        # Hide second column (Jury ID) and first and last jury rows
+        hidden_dimensions = [(1, "COLUMNS"), (3, "ROWS"), (max_row - 1, "ROWS")]
+        format_requests.append({
+            "updateDimensionProperties": {
+                "range": {
+                    "sheetId": worksheet.id,
+                    "dimension": "ROWS",
+                    "startIndex": 0,
+                    "endIndex": 1000,
+                },
+                "properties": {
+                    "hiddenByUser": False,
+                },
+                "fields": "hiddenByUser",
+            }
+        })
+        for dimension_id, dimension_type in hidden_dimensions:
+            format_requests.append({
+                "updateDimensionProperties": {
+                    "range": {
+                        "sheetId": worksheet.id,
+                        "dimension": dimension_type,
+                        "startIndex": dimension_id,
+                        "endIndex": dimension_id + 1,
+                    },
+                    "properties": {
+                        "hiddenByUser": True,
+                    },
+                    "fields": "hiddenByUser",
+                }
+            })
+
+        # Define borders
+        border_ranges = [("A1:AF", "0000"),
+                         (f"A1:{getcol(2 + pool_size * passage_width)}{max_row + 3}", "1111"),
+                         (f"A{max_row + 5}:E{max_row + pool_size + 5}", "1111"),
+                         (f"A1:B{max_row + 3}", "1113"),
+                         (f"C1:{getcol(2 + (pool_size - 1) * passage_width)}1", "1113")]
+        for i in range(pool_size - 1):
+            border_ranges.append((f"{getcol(1 + (i + 1) * passage_width)}2"
+                                  f":{getcol(2 + (i + 1) * passage_width)}2", "1113"))
+            border_ranges.append((f"{getcol(2 + (i + 1) * passage_width)}3"
+                                  f":{getcol(2 + (i + 1) * passage_width)}{max_row + 2}", "1113"))
+            border_ranges.append((f"{getcol(1 + (i + 1) * passage_width)}{max_row + 3}"
+                                  f":{getcol(2 + (i + 1) * passage_width)}{max_row + 3}", "1113"))
+        sides_names = ['top', 'bottom', 'left', 'right']
+        styles = ["NONE", "SOLID", "SOLID_MEDIUM", "SOLID_THICK", "DOUBLE"]
+        for border_range, sides in border_ranges:
+            borders = {}
+            for side_name, side in zip(sides_names, sides):
+                borders[side_name] = {"style": styles[int(side)]}
+            format_requests.append({
+                "repeatCell": {
+                    "range": a1_range_to_grid_range(border_range, worksheet.id),
+                    "cell": {
+                        "userEnteredFormat": {
+                            "borders": borders,
+                            "horizontalAlignment": "CENTER",
+                        },
+                    },
+                    "fields": "userEnteredFormat(borders,horizontalAlignment)",
+                }
+            })
+
+        # Remove old protected ranges
+        for protected_range in spreadsheet.list_protected_ranges(worksheet.id):
+            format_requests.append({
+                "deleteProtectedRange": {
+                    "protectedRangeId": protected_range["protectedRangeId"],
+                }
+            })
+
+        # Protect the header, the juries list, the footer and the ranking
+        protected_ranges = ["A1:AF4",
+                            f"A{min_row}:B{max_row}",
+                            f"A{max_row}:AF{max_row + 5 + pool_size}"]
+        for protected_range in protected_ranges:
+            format_requests.append({
+                "addProtectedRange": {
+                    "protectedRange": {
+                        "range": a1_range_to_grid_range(protected_range, worksheet.id),
+                        "description": "Structure du tableur à ne pas modifier "
+                                       "pour une meilleure prise en charge automatisée",
+                        "warningOnly": True,
+                    },
+                }
+            })
+
+        body = {"requests": format_requests}
+        worksheet.client.batch_update(spreadsheet.id, body)
+
+    def update_juries_lines_spreadsheet(self):
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        spreadsheet = gc.open_by_key(self.tournament.notes_sheet_id)
+        worksheet = spreadsheet.worksheet(f"Poule {self.short_name}")
+
+        average_cell = worksheet.find("Moyenne")
+        min_row = 5
+        max_row = average_cell.row - 1
+        juries_visible = worksheet.get(f"A{min_row}:B{max_row}")
+        juries_visible = [t for t in juries_visible if t and len(t) == 2]
+        rows_to_delete = []
+        for i, (_jury_name, jury_id) in enumerate(juries_visible):
+            if not jury_id.isnumeric() or int(jury_id) not in self.juries.values_list("id", flat=True):
+                rows_to_delete.append(min_row + i)
+        for row_to_delete in rows_to_delete:
+            worksheet.delete_rows(row_to_delete)
+        max_row -= len(rows_to_delete)
+
+        for jury in self.juries.all():
+            if str(jury.id) not in list(map(lambda x: x[1], juries_visible)):
+                worksheet.insert_row([str(jury), jury.id], max_row)
+                max_row += 1
+
+    def parse_spreadsheet(self):
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        self.tournament.create_spreadsheet()
+        spreadsheet = gc.open_by_key(self.tournament.notes_sheet_id)
+        worksheet = spreadsheet.worksheet(f"Poule {self.short_name}")
+
+        average_cell = worksheet.find("Moyenne")
+        min_row = 5
+        max_row = average_cell.row - 2
+        data = worksheet.get_values(f"A{min_row}:AF{max_row}")
+        if not data or not data[0]:
+            return
+
+        passage_width = 7 if self.participations.count() == 4 else 6
+        for line in data:
+            jury_name = line[0]
+            jury_id = line[1]
+            if not jury_id.isnumeric() or int(jury_id) not in self.juries.values_list("id", flat=True):
+                print(format_lazy(_("The jury {jury} is not part of the jury for this pool."), jury=jury_name))
+                continue
+
+            jury = self.juries.get(id=jury_id)
+            for i, passage in enumerate(self.passages.all()):
+                note = passage.notes.get(jury=jury)
+                note_line = line[2 + i * passage_width:2 + (i + 1) * passage_width]
+                note.set_all(*note_line)
+                note.save()
+
+    def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
+        self.update_juries_lines_spreadsheet()
+        super().save(force_insert, force_update, using, update_fields)
+
     def __str__(self):
         return _("Pool of day {round} for tournament {tournament} with teams {teams}")\
             .format(round=self.round,
@@ -955,6 +1348,31 @@ class Note(models.Model):
         self.reporter_oral = reporter_oral
         self.observer_oral = observer_oral
 
+    def update_spreadsheet(self):
+        if not self.has_any_note():
+            return
+
+        gc = gspread.service_account_from_dict(settings.GOOGLE_SERVICE_CLIENT)
+        passage = Passage.objects.prefetch_related('pool__tournament', 'pool__participations').get(pk=self.passage.pk)
+        spreadsheet_id = passage.pool.tournament.notes_sheet_id
+        spreadsheet = gc.open_by_key(spreadsheet_id)
+        worksheet = spreadsheet.worksheet(f"Poule {passage.pool.short_name}")
+        jury_id_cell = worksheet.find(str(self.jury_id), in_column=2)
+        if not jury_id_cell:
+            raise ValueError("The jury ID cell was not found in the spreadsheet.")
+        jury_row = jury_id_cell.row
+        passage_width = 7 if passage.pool.participations.count() == 4 else 6
+
+        def getcol(number: int) -> str:
+            if number == 0:
+                return ''
+            return getcol((number - 1) // 26) + chr(65 + (number - 1) % 26)
+
+        min_col = getcol(3 + (self.passage.position - 1) * passage_width)
+        max_col = getcol(3 + self.passage.position * passage_width - 1)
+
+        worksheet.update([list(self.get_all())], f"{min_col}{jury_row}:{max_col}{jury_row}")
+
     def get_absolute_url(self):
         return reverse_lazy("participation:passage_detail", args=(self.passage.pk,))
 

participation/views.py

@@ -1035,6 +1035,7 @@ class PoolRemoveJuryView(VolunteerMixin, DetailView):
         jury = pool.juries.get(pk=kwargs['jury_id'])
         pool.juries.remove(jury)
         pool.save()
+        Note.objects.filter(jury=jury, passage__pool=pool).delete()
         messages.success(request, _("The jury {name} has been successfully removed!")
                          .format(name=f"{jury.user.first_name} {jury.user.last_name}"))
         return redirect(reverse_lazy('participation:pool_jury', args=(pool.pk,)))
@@ -1100,7 +1101,7 @@ class PoolUploadNotesView(VolunteerMixin, FormView, DetailView):
             for i, passage in enumerate(pool.passages.all()):
                 note = Note.objects.get_or_create(jury=vr, passage=passage)[0]
                 passage_notes = notes[notes_count * i:notes_count * (i + 1)]
-                note.set_all(*passage_notes)
+                note.set_all(*list(map(int, passage_notes)))
                 note.save()
 
         messages.success(self.request, _("Notes were successfully uploaded."))
@@ -1312,8 +1313,8 @@ class PoolNotesTemplateView(VolunteerMixin, DetailView):
         table.addElement(TableColumn(stylename=jury_id_style))
 
         for i in range(line_length):
-            table.addElement(TableColumn(stylename=obs_col_style if pool_size == 4
+            table.addElement(TableColumn(
-                                                                    and i % passage_width == passage_width - 1 else col_style))
+                stylename=obs_col_style if pool_size == 4 and i % passage_width == passage_width - 1 else col_style))
 
         # Add line for the problems for different passages
         header_pb = TableRow()
@@ -1671,8 +1672,8 @@ class NotationSheetTemplateView(VolunteerMixin, DetailView):
             page = self.request.GET.get('page', '1')
             if not page.isnumeric() or page not in ['1', '2']:
                 page = '1'
-            passages = passages.filter(id__in=[passages[0].id, passages[2].id, passages[4].id]
+            passages = passages.filter(id__in=([passages[0].id, passages[2].id, passages[4].id]
-            if page == '1' else [passages[1].id, passages[3].id])
+                                               if page == '1' else [passages[1].id, passages[3].id]))
             context['page'] = page
 
         context['passages'] = passages
@@ -1761,8 +1762,9 @@ class NotationSheetsArchiveView(VolunteerMixin, DetailView):
 
                             passages = pool.passages.all()
                             if passages.count() == 5:
-                                passages = passages.filter(id__in=[passages[0].id, passages[2].id, passages[4].id]
+                                passages = passages.filter(
-                                if page == '1' else [passages[1].id, passages[3].id])
+                                    id__in=([passages[0].id, passages[2].id, passages[4].id]
+                                            if page == '1' else [passages[1].id, passages[3].id]))
 
                             context['passages'] = passages
                             context['esp'] = passages.count() * '&'
@@ -1965,3 +1967,8 @@ class NoteUpdateView(VolunteerMixin, UpdateView):
             # Set the note of the observer only for 4-teams pools
             del form.fields['observer_oral']
         return form
+
+    def form_valid(self, form):
+        ret = super().form_valid(form)
+        self.object.update_spreadsheet()
+        return ret

requirements.txt

@@ -1,7 +1,7 @@
 channels[daphne]~=4.0.0
 channels-redis~=4.2.0
 crispy-bootstrap5~=2023.10
-Django>=5.0,<6.0
+Django>=5.0.3,<6.0
 django-crispy-forms~=2.1
 django-extensions~=3.2.3
 django-filter~=23.5
@@ -13,6 +13,10 @@ django-polymorphic~=3.1.0
 django-tables2~=2.7.0
 djangorestframework~=3.14.0
 django-rest-polymorphic~=0.1.10
+google-api-python-client~=2.124.0
+google-auth-httplib2~=0.2.0
+google-auth-oauthlib~=1.2.0
+gspread~=6.1.0
 gunicorn~=21.2.0
 odfpy~=1.4.1
 phonenumbers~=8.13.27

tfjm.cron

@@ -15,5 +15,8 @@
 # Send reminders for payments
 30      6       *       *       1       cd /code && python manage.py remind_payments &> /dev/null
 
+# Check notation sheets every 15 minutes from 08:00 to 23:00 on fridays to mondays in april and may
+*/15    8-23    *       4-5   5,6,7,1  cd /code && python manage.py parse_notation_sheets -v 0
+
 # Clean temporary files
 30      *       *       *       *       rm -rf /tmp/*

tfjm/settings.py

@@ -246,6 +246,23 @@ HELLOASSO_CLIENT_ID = os.getenv('HELLOASSO_CLIENT_ID', 'CHANGE_ME_IN_ENV_SETTING
 HELLOASSO_CLIENT_SECRET = os.getenv('HELLOASSO_CLIENT_SECRET', 'CHANGE_ME_IN_ENV_SETTINGS')
 HELLOASSO_TEST_ENDPOINT = False  # Enable custom test endpoint, for unit tests
 
+GOOGLE_SERVICE_CLIENT = {
+  "type": "service_account",
+  "project_id": os.getenv("GOOGLE_PROJECT_ID", "plateforme-tfjm"),
+  "private_key_id": os.getenv("GOOGLE_PRIVATE_KEY_ID", "CHANGE_ME_IN_ENV_SETTINGS"),
+  "private_key": os.getenv("GOOGLE_PRIVATE_KEY", "CHANGE_ME_IN_ENV_SETTINGS").replace("\\n", "\n"),
+  "client_email": os.getenv("GOOGLE_CLIENT_EMAIL", "CHANGE_ME_IN_ENV_SETTINGS"),
+  "client_id": os.getenv("GOOGLE_CLIENT_ID", "CHANGE_ME_IN_ENV_SETTINGS"),
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": os.getenv("GOOGLE_CLIENT_X509_CERT_URL", "CHANGE_ME_IN_ENV_SETTINGS"),
+  "universe_domain": "googleapis.com"
+}
+
+# The ID of the Google Drive folder where to store the notation sheets
+NOTES_DRIVE_FOLDER_ID = os.getenv("NOTES_DRIVE_FOLDER_ID", "CHANGE_ME_IN_ENV_SETTINGS")
+
 # Custom parameters
 PROBLEMS = [
     "Triominos",