parse email strings

# Conflicts:
#	colloscope/icalexport.py

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "static/unified-navigator"]
-	path = static/unified-navigator
-	url = git@mp2i-vms.fr:mp2i-vms/unified-navigator.git
-    branch = main

colloscope/admin.py

@@ -1,48 +1,17 @@
 from django.contrib import admin
 from colloscope.models import *
 
-
-@admin.register(School)
-class LyceeAdmin(admin.ModelAdmin):
-    list_display = ('uai', 'description', 'vacation')
-
-
-admin.site.register(Class)
-admin.site.register(Term)
-admin.site.register(Subject)
-admin.site.register(GroupType)
-admin.site.register(Group)
-
-
-@admin.register(Student)
-class StudentAdmin(admin.ModelAdmin):
-    list_display = ("cls", "first_name", "last_name")
-    list_filter = ("cls",)
-
-
-admin.site.register(Member)
+admin.site.register(Lycee)
+admin.site.register(Classe)
+admin.site.register(Periode)
+admin.site.register(Matiere)
+admin.site.register(Critere)
+admin.site.register(Groupe)
+admin.site.register(Etudiant)
+admin.site.register(Appartenance)
 admin.site.register(Colleur)
-
-
-class ColleInline(admin.StackedInline):
-    model = Colle
-    raw_id_fields = ("slot",)
-
-
-@admin.register(Slot)
-class SlotAdmin(admin.ModelAdmin):
-    list_display = ('subject', 'colleur', "term", 'view_day', "time", "duration")
-    list_filter = ("subject", "colleur", "term")
-    inlines = [ColleInline]
-
-    def view_day(self, obj):
-        jours = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
-        return jours[obj.day]
-
-    view_day.short_description = 'Day'
-
-
-admin.site.register(Colle)
-admin.site.register(Swap)
-admin.site.register(Profile)
-admin.site.register(CalendarLink)
+admin.site.register(Creneau)
+admin.site.register(Rotation)
+admin.site.register(Amendement)
+admin.site.register(Profil)
+admin.site.register(LienCalendrier)

colloscope/create_calendar.py

@@ -1,335 +0,0 @@
-import pandas
-import datetime
-import icalendar
-import uuid
-from pathlib import Path
-
-
-
-#pd_eleves = pandas.read_csv('Resources/eleves-v2.csv', delimiter=";", header=None)
-#np_eleves = pd_eleves.to_numpy()
-
-pd_colles = pandas.read_csv('static/colloscope-v3.csv', delimiter=";", header=None)
-np_colles = pd_colles.to_numpy()
-
-local_tz = "Europe/Paris"
-
-jour_to_delta = {
-    "lundi": 0,
-    "mardi": 1,
-    "mercredi": 2,
-    "jeudi": 3,
-    "vendredi": 4,
-}
-
-jour_to_byday = {
-    "lundi": "MO",
-    "mardi": "TU",
-    "mercredi": "WE",
-    "jeudi": "TH",
-    "vendredi": "FR",
-}
-
-
-langues = ["Anglais", "Allemand", "Espagnol"]
-
-option_langues = {
-    "EN": ["Anglais LV1"],
-    "EN-DE": ["Anglais LV1", "Allemand LV2"],
-    "EN-ES": ["Anglais LV1", "Espagnol LV2"],
-    "DE-EN": ["Allemand LV1", "Anglais LV2"],
-    "ES-EN": ["Espangol LV1", "Anglais LV2"]
-}
-
-def display(cal):
-   return cal.to_ical().decode("utf-8").replace('\r\n', '\n').strip()
-
-
-def open_ics(filename: str) -> icalendar.Calendar:
-    """
-    Ouvre un fichier .ics et renvoie un objet Calendar
-    """
-    p = Path(__file__).with_name('Resources')
-    p = Path(p, filename)
-    with p.open('r') as f:
-        opened_cal = icalendar.Calendar.from_ical(f.read())
-
-    return opened_cal
-
-
-
-def add_events_from_ics(filename: str, new_cal: icalendar.Calendar):
-    """ 
-    Ajoute des évènements depuis un fichier .ics vers un objet icalendar.Calendar
-    """
-    cal_to_import = open_ics(filename=filename)
-
-    for event in cal_to_import.walk("vevent"):
-        new_cal.add_component(event)
-
-    return new_cal
-
-
-def get_td_groupe(groupe: str) -> str:
-    """
-    Renvoie le groupe de TD d'un groupe de colle (A, B ou SI)
-    """
-    for row in np_eleves[1:]:
-        if row[2] == groupe:
-            return row[3]
-        
-
-def debut_semaine_to_datetime(date_string: str) -> datetime.time:
-    """
-    Transforme un string de debut de semaine au format dd/mm/yyyy en datetime.time 
-    """
-    return datetime.datetime.strptime(date_string, "%d/%m/%y")
-
-
-def heure_to_timedelta(heure: str) -> datetime.timedelta:
-    """
-    Transforme une heure au format "8h30" ou "1h30" ou "2h" en timedelta.
-    """
-    heure = heure.split("h")
-    delta = datetime.timedelta(hours=int(heure[0]))
-    
-    if heure[1] != '':
-        delta += datetime.timedelta(minutes=int(heure[1]))
-
-    return delta
-
-def creer_evenement(titre: str, debut: datetime.datetime, duree: datetime.timedelta, description: str = None, localisation: str = None, rrule: str = None) -> icalendar.Event:
-    """
-    Renvoie un évènement icalendar.Event()
-    
-    titre str: le titre de l'évènement
-    debut datetime.datetime: la date de début
-    duree datetime.timedelta: la durée
-    description str: la description (Optionelle)
-    localisation str: localisation (Optionelle)
-    rrule str: règle de récurrence https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html (Optionelle)
-    """
-    new_event = icalendar.Event()
-    new_event.add("summary", titre)
-    new_event.add("dtstart", debut, parameters={"tzid": local_tz})
-    debut += duree
-    new_event.add("dtend", debut, parameters={"tzid": local_tz})
-
-    if localisation is not None: 
-        new_event.add("location", localisation)
-    if description is not None:
-        new_event.add("description", description)
-    if rrule is not None:
-        new_event.add("rrule", rrule)
-
-    new_event.add("uid", str(uuid.uuid4()))
-    new_event.add("dtstamp", datetime.datetime.now())
-
-    # nécessaire pour se conformer à la norme RFC 5545
-    
-    return new_event
-
-def get_colles_groupe(np_colles, groupe, option_langue):
-    """
-    Renvoie les colles pour un groupe sous la forme d'une liste d'évènements ICS
-
-    np_colles: l'array 2D numpy contenant le colloscope
-    groupe: str, le numéro du groupe
-    option_langue: str, les options de langue
-    """
-    liste_colles = []
-    for row in np_colles[4:40]:
-        if pandas.isnull(row[1])  or row[1] == "pas de colle":
-            # il n'y a pas de colle, on skip !
-            continue
-
-
-        # Si la colle n'est pas la LV1 de l'élève, on skip
-        if row[1] == "Anglais" and not option_langue.startswith("EN"):
-            continue
-        elif row[1] == "Allemand" and not option_langue.startswith("DE"):
-            continue
-        elif row[1] == "Espagnol" and not option_langue.startswith("ES"):
-            continue
-
-        for index, colle in enumerate(row[8:]):
-            if pandas.isnull(colle): 
-                continue
-            # les huit premières cases ne sont pas concernées
-
-            if "," in list(colle):
-                if groupe not in colle.split(","):
-                    continue
-            elif colle != groupe:
-                continue 
-            # dans le cas où plusieurs groupes de colles soient concernés
-
-            duree = heure_to_timedelta(row[4])
-            # transforme la durée en timedelta
-
-            date = debut_semaine_to_datetime(np_colles[1][index+8]) 
-
-            date += datetime.timedelta(days=jour_to_delta[row[2]])
-            date += heure_to_timedelta(row[3])
-            # génère la date à partir de la semaine, du jour et de l'heure
-            
-            localisation = row[7] if not pandas.isnull(row[7]) else None
-
-            new_colle = creer_evenement(
-                titre=f"Colle {row[1]}",
-                description=f"{row[5]}" if not pandas.isnull(row[5]) else None,
-                localisation=localisation,
-                debut=date,
-                duree=duree
-            )
-            
-            liste_colles.append(new_colle)
-
-    return liste_colles
-
-def get_cours(np_colles, groupe):
-    """
-    Renvoie les colles pour un groupe sous la forme d'une liste d'évènements ICS, cad
-    icalendar.Event
-
-    np_colles: l'array 2D numpy contenant le colloscope
-    groupe: str, le numéro du groupe
-    """
-    listes_cours = []
-    groupe_td = get_td_groupe(groupe)
-
-    for row in np_colles[41:66]:
-
-        if pandas.isnull(row[1]):
-            continue 
-        
-        first_date = np_colles[1][8]
-
-        eleves = row[8]
-
-          
-        
-        if "à" in list(eleves):
-    
-            eleves = eleves.split(" ")
-            debut, fin = [grp for grp in eleves if grp.isdigit()]
-
-            if not int(debut) <= int(groupe) <= int(fin):
-                continue 
-        
-        elif "+" in list(eleves):
-            eleves = eleves.split("+")
-
-            if groupe not in [grp for grp in eleves if grp.isdigit()]:
-        
-                if groupe_td not in [grp for grp in eleves]:
-                    if int(row[6]) > 1:
-                        if groupe in [grp for grp in row[9].split("+") if grp.isdigit()]:
-                            first_date = np_colles[1][9]
-                        elif groupe_td in [grp for grp in row[9].split("+")]:
-                            first_date = np_colles[1][9]
-                        else:
-                           
-                            continue
-
-                    else:
-                        continue
-            
-            # si la 1ère occurence du cours est la 1ère ou la 2e semaine
-
-
-        elif groupe != eleves and groupe_td != eleves:
-            if pandas.isnull(row[9]) or (groupe != row[9] and groupe_td != row[9]):
-                continue 
-            else:
-                first_date = np_colles[1][9]
-
-        # vérification que le groupe est concerné par le cours
-
-        first_date = debut_semaine_to_datetime(first_date) 
-
-        first_date += heure_to_timedelta(row[3])
-        first_date += datetime.timedelta(days=jour_to_delta[row[2]])
-
-        duree = heure_to_timedelta(row[4])
-
-        localisation = row[7] if not pandas.isnull(row[7]) else None
-
-        last_date = debut_semaine_to_datetime(np_colles[1][-1]) + datetime.timedelta(days=5)
-
-        rrule = {"FREQ": "WEEKLY", "UNTIL": last_date, "INTERVAL": row[6], "BYDAY": jour_to_byday[row[2]], "WKST": "MO"}
-
-        new_cours = creer_evenement(
-            titre=row[1],
-            description=row[5],
-            localisation=localisation,
-            debut=first_date,
-            duree=duree,
-            rrule=rrule
-        )
-
-        listes_cours.append(new_cours)
-    
-    return listes_cours
-
-def get_langues(langues):
-    """
-    Renvoie la liste de cours de langue associés sous forme de list[icalendar.Event]
-    """
-    liste_cours = []
-    langues = option_langues[langues]
-
-    for row in np_colles[67:]:
-
-        if row[1] in langues:
-
-            debut = debut_semaine_to_datetime(np_colles[1][8])
-            debut += heure_to_timedelta(row[3])
-            debut += datetime.timedelta(days=jour_to_delta[row[2]])
-
-            duree = heure_to_timedelta(row[4])
-
-            last_date = debut_semaine_to_datetime(np_colles[1][-1]) + datetime.timedelta(days=5)
-
-            rrule = {"FREQ": "WEEKLY", "UNTIL": last_date, "INTERVAL": row[6], "BYDAY": jour_to_byday[row[2]], "WKST": "MO"}
-
-            new_cours = creer_evenement(
-                titre=row[1],
-                debut=debut,
-                duree=duree,
-                rrule=rrule
-            )  
-
-            liste_cours.append(new_cours)
-    
-    return liste_cours
-
-
-def get_calendar(groupe: str, langues: str):
-    """"
-    Renvoie un calendrier (icalendar.Calendar) pour un groupe avec des langues donné
-    """
-    
-    new_cal_edt = open_ics("Base_Calendar.ics")
-
-    # if split:
-    #     new_cal_colles = open_ics("Base_Calendar.ics")
-    
-
-    for event in get_langues(langues):
-        new_cal_edt.add_component(event)
-    
-    for event in get_cours(np_colles, groupe):
-        new_cal_edt.add_component(event)
-    
-    # if split:
-    #     for event in get_colles_groupe(np_colles, groupe, langues):
-    #         new_cal_colles.add_component(event)
-    #     return new_cal_edt.to_ical(), new_cal_colles.to_ical()
-
-    # else:
-    #     for event in get_colles_groupe(np_colles, groupe, langues):
-    #         new_cal_edt.add_component(event)
-
-    
-    return new_cal_edt.to_ical()

colloscope/icalexport.py

@@ -1,76 +1,68 @@
-from datetime import date, time, datetime, timedelta
-import pytz
-from uuid import uuid4
+from unidecode import unidecode
 from os import path
 from icalendar import Calendar, Event, vCalAddress, vText
 
 from colloscope.models import *
-from .create_calendar import get_calendar
 
 LOCAL_TZ = "Europe/Paris"
 
 
-def emailize(nom, first_name=None):
-    if first_name is not None:
+def emailize(nom, prenom=None):
+    if prenom is not None:
         return "{}.{}@example.com" \
             .format(
-            first_name.replace(" ", "_").lower(),
-            nom.replace(" ", "_").lower()
+            unidecode(prenom).replace(" ", "_").lower(),
+            unidecode(nom).replace(" ", "_").lower()
         )
     else:
         return "{}@example.com" \
-            .format(nom.replace(" ", "_").lower())
+            .format(unidecode(nom).replace(" ", "_").lower())
 
 
-def to_calendar(student, term, include_EDT: bool = True):
+def to_calendar(etudiant, periode):
     p = path.abspath('./static/Base_Calendar.ics')
 
     with open(p) as f:
         cal = Calendar.from_ical(f.read())
 
-    colles = term.query_colles_of_student(student)
+    rotations = Rotation.objects \
+        .filter(groupes__membres=etudiant, creneau__periode=periode) \
+        .select_related("creneau__periode__classe__lycee") \
+        .select_related("creneau__matiere") \
+        .select_related("creneau__colleur")
 
-    for colle in colles:
+    for rotation in rotations:
         event = Event()
 
-        summary = f"Colle {colle.slot.subject} ({colle.slot.colleur})"
+        summary = f"Colle {rotation.creneau.matiere} ({rotation.creneau.colleur})"
         event.add("summary", summary)
 
-        start = colle.datetime.astimezone(pytz.timezone(LOCAL_TZ))
-        fin = start + colle.slot.duration
+        start = rotation.datetime()
+        fin = start + rotation.creneau.duree
 
-        event.add("dtstart", start)
-        event.add("dtend", fin)
+        event.add("dtstart", start, parameters={"tzid": LOCAL_TZ})
+        event.add("dtend", fin, parameters={"tzid": LOCAL_TZ})
         event.add("dtstamp", datetime.now())
-        event.add("uid", str(uuid4()))
+        event.add("uid", str(rotation.id))
 
-        event.add("location", f"{colle.slot.room} ({colle.slot.term.cls.school})")
-        event.add("categories", "COLLE-" + str(colle.slot.subject))
+        event.add("location", f"{rotation.creneau.salle} ({rotation.creneau.periode.classe.lycee})")
+        event.add("categories", "COLLE-" + str(rotation.creneau.matiere))
 
-        description = f"Groupes: {','.join(str(group) for group in colle.groups.all())}"
+        description = f"Groupes: {','.join(str(groupe) for groupe in rotation.groupes.all())}"
         event.add("description", description)
 
-        organizer = vCalAddress(f"mailto:{emailize(colle.slot.colleur.name)}")
-        organizer.params["cn"] = vText(str(colle.slot.colleur))
+        organizer = vCalAddress(f"mailto:{emailize(rotation.creneau.colleur.nom)}")
+        organizer.params["cn"] = vText(str(rotation.creneau.colleur))
         organizer.params["role"] = vText("Colleur")
         event.add("organizer", organizer)
 
-        for e in colle.final_group():
-            attendee = vCalAddress(f"mailto:{emailize(e.last_name, first_name=e.first_name)}")
-            attendee.params["role"] = vText("Etudiant")
+        for e in rotation.groupe_effectif():
+            attendee = vCalAddress(f"mailto:{emailize(e.nom, prenom=e.prenom)}")
             attendee.params["cn"] = vText(str(e))
+            attendee.params["role"] = vText("Etudiant")
 
             event.add("attendee", attendee, encode=0)
 
         cal.add_component(event)
 
-    """
-    if include_EDT:
-        #TODO: get le groupe de l'étudiant et ses langue
-        edt = get_calendar()
-
-        for event in edt.walk("VEVENT"):
-            cal.add_component(event)
-    """
-
     return cal

colloscope/migrations/0012_rename_lycee_school_rename_creneau_slot_and_more.py

@@ -1,78 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-02 19:09
-
-import django.db.models.deletion
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0011_alter_liencalendrier_code'),
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.RenameModel(
-            old_name='Lycee',
-            new_name='School',
-        ),
-        migrations.RenameModel(
-            old_name='Classe',
-            new_name='Class',
-        ),
-        migrations.RenameModel(
-            old_name='Periode',
-            new_name='Term',
-        ),
-        migrations.RenameModel(
-            old_name='Matiere',
-            new_name='Subject',
-        ),
-        migrations.RenameModel(
-            old_name='Critere',
-            new_name='GroupType',
-        ),
-        migrations.RenameModel(
-            old_name='Groupe',
-            new_name='Group',
-        ),
-        migrations.RenameModel(
-            old_name='Etudiant',
-            new_name='Student',
-        ),
-        migrations.RenameModel(
-            old_name='Appartenance',
-            new_name='Member',
-        ),
-        migrations.RenameModel(
-            old_name='Creneau',
-            new_name='Slot',
-        ),
-        migrations.RenameModel(
-            old_name='Rotation',
-            new_name='Colle',
-        ),
-        migrations.RenameModel(
-            old_name='Amendement',
-            new_name='Swap',
-        ),
-        migrations.RenameModel(
-            old_name='Profil',
-            new_name='Profile',
-        ),
-        migrations.RenameModel(
-            old_name='LienCalendrier',
-            new_name='CalendarLink',
-        ),
-        migrations.AlterField(
-            model_name='colle',
-            name='groupes',
-            field=models.ManyToManyField(to='colloscope.group'),
-        ),
-        migrations.AlterField(
-            model_name='member',
-            name='groupe',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='colloscope.group'),
-        ),
-    ]

colloscope/migrations/0013_alter_colle_options_alter_slot_options_and_more.py

@@ -1,255 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-02 20:00
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0012_rename_lycee_school_rename_creneau_slot_and_more'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='colle',
-            options={'ordering': ['slot__term__cls', 'slot__subject__description', 'slot__colleur__name', 'date', 'slot__time']},
-        ),
-        migrations.AlterModelOptions(
-            name='slot',
-            options={'verbose_name_plural': 'slots'},
-        ),
-        migrations.AlterModelOptions(
-            name='student',
-            options={'ordering': ['cls', 'last_name', 'first_name']},
-        ),
-        migrations.AlterModelOptions(
-            name='term',
-            options={'ordering': ['begin']},
-        ),
-        migrations.RemoveConstraint(
-            model_name='calendarlink',
-            name='unique_etudiant_periode_combination',
-        ),
-        migrations.RenameField(
-            model_name='calendarlink',
-            old_name='code',
-            new_name='key',
-        ),
-        migrations.RenameField(
-            model_name='calendarlink',
-            old_name='etudiant',
-            new_name='student',
-        ),
-        migrations.RenameField(
-            model_name='calendarlink',
-            old_name='periode',
-            new_name='term',
-        ),
-        migrations.RenameField(
-            model_name='class',
-            old_name='jour_zero',
-            new_name='day_zero',
-        ),
-        migrations.RenameField(
-            model_name='class',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='class',
-            old_name='annee',
-            new_name='year',
-        ),
-        migrations.RenameField(
-            model_name='colle',
-            old_name='groupes',
-            new_name='groups',
-        ),
-        migrations.RenameField(
-            model_name='colle',
-            old_name='creneau',
-            new_name='slot',
-        ),
-        migrations.RenameField(
-            model_name='colleur',
-            old_name='civilite',
-            new_name='gender',
-        ),
-        migrations.RenameField(
-            model_name='colleur',
-            old_name='nom',
-            new_name='name',
-        ),
-        migrations.RenameField(
-            model_name='group',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='group',
-            old_name='membres',
-            new_name='members',
-        ),
-        migrations.RenameField(
-            model_name='group',
-            old_name='periode',
-            new_name='term',
-        ),
-        migrations.RenameField(
-            model_name='group',
-            old_name='critere',
-            new_name='type',
-        ),
-        migrations.RenameField(
-            model_name='grouptype',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='grouptype',
-            old_name='periode',
-            new_name='term',
-        ),
-        migrations.RenameField(
-            model_name='member',
-            old_name='groupe',
-            new_name='group',
-        ),
-        migrations.RenameField(
-            model_name='member',
-            old_name='etudiant',
-            new_name='student',
-        ),
-        migrations.RenameField(
-            model_name='profile',
-            old_name='etudiant',
-            new_name='student',
-        ),
-        migrations.RenameField(
-            model_name='profile',
-            old_name='utilisateur',
-            new_name='user',
-        ),
-        migrations.RenameField(
-            model_name='school',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='school',
-            old_name='vacances',
-            new_name='vacation',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='capacite',
-            new_name='capacity',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='jour',
-            new_name='day',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='duree',
-            new_name='duration',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='salle',
-            new_name='room',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='matiere',
-            new_name='subject',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='periode',
-            new_name='term',
-        ),
-        migrations.RenameField(
-            model_name='slot',
-            old_name='heure',
-            new_name='time',
-        ),
-        migrations.RenameField(
-            model_name='student',
-            old_name='nom',
-            new_name='last_name',
-        ),
-        migrations.RenameField(
-            model_name='student',
-            old_name='groupes',
-            new_name='groups',
-        ),
-        migrations.RenameField(
-            model_name='student',
-            old_name='prenom',
-            new_name='first_name',
-        ),
-        migrations.RenameField(
-            model_name='subject',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='swap',
-            old_name='rotation',
-            new_name='colle',
-        ),
-        migrations.RenameField(
-            model_name='swap',
-            old_name='est_positif',
-            new_name='enroll',
-        ),
-        migrations.RenameField(
-            model_name='swap',
-            old_name='etudiant',
-            new_name='student',
-        ),
-        migrations.RenameField(
-            model_name='term',
-            old_name='debut',
-            new_name='begin',
-        ),
-        migrations.RenameField(
-            model_name='term',
-            old_name='libelle',
-            new_name='description',
-        ),
-        migrations.RenameField(
-            model_name='term',
-            old_name='fin',
-            new_name='end',
-        ),
-        migrations.RemoveField(
-            model_name='slot',
-            name='est_colle',
-        ),
-
-        migrations.RenameField(
-            model_name='student',
-            old_name='classe',
-            new_name='cls',
-        ),
-        migrations.RenameField(
-            model_name='subject',
-            old_name='classe',
-            new_name='cls',
-        ),
-        migrations.RenameField(
-            model_name='term',
-            old_name='classe',
-            new_name='cls',
-        ),
-
-
-        migrations.AddConstraint(
-            model_name='calendarlink',
-            constraint=models.UniqueConstraint(fields=('student', 'term'), name='unique_student_term_combination'),
-        ),
-    ]

colloscope/migrations/0014_alter_group_options_slot_type.py

@@ -1,24 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-02 21:40
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0013_alter_colle_options_alter_slot_options_and_more'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='group',
-            options={'ordering': ['term__cls__description', 'term__description', 'description']},
-        ),
-        migrations.AddField(
-            model_name='slot',
-            name='type',
-            field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.CASCADE, to='colloscope.grouptype'),
-            preserve_default=False,
-        ),
-    ]

colloscope/migrations/0015_rename_lycee_class_school.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-02 21:46
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0014_alter_group_options_slot_type'),
-    ]
-
-    operations = [
-        migrations.RenameField(
-            model_name='class',
-            old_name='lycee',
-            new_name='school',
-        ),
-    ]

colloscope/migrations/0016_alter_colle_groups.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-05 07:41
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0015_rename_lycee_class_school'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='colle',
-            name='groups',
-            field=models.ManyToManyField(blank=True, to='colloscope.group'),
-        ),
-    ]

colloscope/migrations/0017_alter_slot_options_alter_subject_options_and_more.py

@@ -1,47 +0,0 @@
-# Generated by Django 5.0.4 on 2024-05-06 20:22
-
-
-from datetime import datetime
-from pytz import timezone
-
-from django.db import migrations, models
-from django.db.migrations import RunPython
-
-
-def replace_date_with_datetime(apps, schema_editor):
-    model = apps.get_model('colloscope', 'Colle')
-
-    for colle in model.objects.all():
-        print(colle.slot.time, end="-->")
-        colle.datetime = datetime.combine(colle.date, colle.slot.time)
-        colle.datetime = timezone("Europe/Paris").localize(colle.datetime)
-        print(colle.datetime)
-        colle.save()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('colloscope', '0016_alter_colle_groups'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='slot',
-            options={'ordering': ['subject', 'colleur', 'day', 'time'], 'verbose_name_plural': 'slots'},
-        ),
-        migrations.AlterModelOptions(
-            name='subject',
-            options={'ordering': ['description']},
-        ),
-        migrations.AddField(
-            model_name='colle',
-            name='datetime',
-            field=models.DateTimeField(default=datetime(1970, 1, 1, 0, 0, 0)),
-        ),
-        migrations.RunPython(replace_date_with_datetime),
-        migrations.RemoveField(
-            model_name='colle',
-            name='date',
-        )
-    ]

colloscope/models.py

@@ -1,65 +1,59 @@
 from datetime import date, datetime, timedelta
-from pprint import pprint
-
 from pytz import timezone
 
-import aiohttp
-
 from django.db import models
-from django.db.models import F, Q, Count, QuerySet, Subquery, OuterRef, Sum
+from django.db.models import F, Q
 from django.contrib.auth.models import User
-from django.conf import settings
 
-from discord import Webhook
 
-calendar = {
-    "C": [
-        (date(2023, 10, 21), date(2023, 11, 6)),
-        (date(2023, 12, 23), date(2024, 1, 8)),
-        (date(2024, 2, 10), date(2024, 2, 26)),
-        (date(2024, 4, 6), date(2024, 4, 22)),
-        (date(2024, 5, 6), date(2024, 5, 11)),  # pont un peu gratté
+calendrier = {
+    "C" : [
+        ( date(2023, 10, 21), date(2023, 11, 6) ),
+        ( date(2023, 12, 23), date(2024, 1, 8) ),
+        ( date(2024, 2, 10), date(2024, 2, 26) ),
+        ( date(2024, 4, 6), date(2024, 4, 22) ),
+        ( date(2024, 5, 6), date(2024, 5, 11) ), # pont un peu gratté
     ]
 }
 
 
-class School(models.Model):
+class Lycee(models.Model):
     uai = models.CharField(max_length=10)
-    description = models.CharField(max_length=100)
-    vacation = models.CharField(max_length=1)
+    libelle = models.CharField(max_length=100)
+    vacances = models.CharField(max_length=1)
 
-    def __str__(self) -> str:
-        return self.description
+    def __str__(self):
+        return self.libelle
 
 
-class Class(models.Model):
-    school = models.ForeignKey(School, on_delete=models.CASCADE)
-    description = models.CharField(max_length=20)
-    year = models.IntegerField()
-    day_zero = models.DateField()
+class Classe(models.Model):
+    lycee = models.ForeignKey(Lycee, on_delete=models.CASCADE)
+    libelle = models.CharField(max_length=20)
+    annee = models.IntegerField()
+    jour_zero = models.DateField()
 
-    def week_number(self, day: date) -> int:
+    def no_semaine(self, jour):
         """
         Entrées :
         - self
-        - day (datetime.date)
+        - jour (datetime.date)
 
         Sortie :
-        - Le numéro de la semaine contenant day, sans compter les vacation.
-        Renvoie un numéro non spécifiée si le day est pendant une période de vacation
+        - Le numéro de la semaine contenant jour, sans compter les vacances.
+        Renvoie un numéro non spécifiée si le jour est pendant une période de vacances
         """
 
-        zone = self.school.vacation
-        vacation = calendar[zone]
-        day0 = self.day_zero
+        zone = self.lycee.vacances
+        vacances = calendrier[zone]
+        jour0 = self.jour_zero
 
-        n = 1 + (day - day0).days // 7
-        for debut, fin in vacation:
-            if day > debut:
-                n -= round((fin - debut) / timedelta(weeks=1))
+        n = 1 + ((jour - jour0).days)//7
+        for debut, fin in vacances:
+            if jour > debut:
+                n -= round( ( fin - debut )/timedelta(weeks=1) )
         return n
 
-    def today_number(self) -> int:
+    def no_aujourdhui(self):
         """
         Entrée:
         - self
@@ -68,9 +62,10 @@ class Class(models.Model):
         - Le numéro de la semaine courante
         """
 
-        return self.week_number(date.today())
+        return self.no_semaine(date.today())
 
-    def week_beginning_date(self, n: int) -> date:
+
+    def date_debut_sem(self, n):
         """
         Entrée:
         - self
@@ -80,57 +75,59 @@ class Class(models.Model):
         - Le date du lundi de la semaine n
         """
         
-        zone = self.school.vacation
-        vacation = calendar[zone]
-        day0 = self.day_zero
+        zone = self.lycee.vacances
+        vacances = calendrier[zone]
+        jour0 = self.jour_zero
 
-        day = day0 + (n - 1) * timedelta(weeks=1)
+        jour = jour0 + (n-1) * timedelta(weeks=1)
         
-        for begin, end in vacation:
-            if day >= begin:
-                day += round((end - begin) / timedelta(weeks=1)) * timedelta(weeks=1)
+        for debut, fin in vacances:
+            if jour >= debut:
+                jour += round( (fin - debut)/timedelta(weeks=1) )*timedelta(weeks=1)
 
-        return day
+        return jour
 
-    def term_of_date(self, day: date):
+    def periode(self, jour):
         """
         Entrées :
         - self
-        - day (datetime.date)
+        - jour (datetime.date)
 
         Sortie :
-        - La période (si elle existe et est unique) contenant day
+        - La période (si elle existe et est unique) contenant jour
 
         Exceptions:
-        - Le day n'est pas dans une période
-        - Le day est au chevauchement de deux périodes
+        - Le jour n'est pas dans une période
+        - Le jour est au chevauchement de deux périodes
         """
-        return Term.objects.get(cls=self, debut__lte=day, fin__gte=day)
+        return Periode.objects.get(classe=self, debut__lte=jour, fin__gte=jour)
 
-    def current_term(self):
+    def periode_actuelle(self):
+        #return self.periode(date.today()) // ne fonctionne pas entre les périodes
         """
         On prend la période non révolue la plus récente
         """
 
-        return (Term.objects
-                .filter(cls=self, end__gte=date.today())
-                .order_by("-begin")
-                .first())
+        return Periode.objects \
+                .filter(classe=self, fin__gte=date.today()) \
+                .order_by("-debut") \
+                .first()
 
     def __str__(self):
-        return f"{self.description} ({self.school.description})"
+        return f"{self.libelle} ({self.lycee.libelle})"
 
 
-class Term(models.Model):
-    cls = models.ForeignKey(Class, on_delete=models.CASCADE)
-    description = models.CharField(max_length=100)
-    begin = models.DateField()
-    end = models.DateField()
+class Periode(models.Model):
+    classe = models.ForeignKey(Classe, on_delete=models.CASCADE)
+    #critere_colle = models.ForeignKey(Critere, on_delete=models.SET_NULL, null=True)
+    libelle = models.CharField(max_length=100)
+    debut = models.DateField()
+    fin = models.DateField()
 
     class Meta:
-        ordering = ["begin"]
+        ordering = ["debut"]
 
-    def range_weeks(self) -> range:
+    def range_semaines(self):
         """
         Entrée:
         - self
@@ -138,312 +135,243 @@ class Term(models.Model):
         Sortie:
         - Un range des numéros de semaine
         """
-        return range(self.cls.week_number(self.begin), self.cls.week_number(self.end) + 1)
+        return range(self.classe.no_semaine(self.debut), self.classe.no_semaine(self.fin)+1)
 
-    def query_colles(self) -> QuerySet:
-        return (Colle.objects
-                .select_related("slot", "slot__term")
-                .prefetch_related("swap_set")
-                .filter(slot__term=self)
-                .annotate(base_vol=Count("groups__members"))
-                .annotate(swap_plus=Count("swap", filter=Q(swap__enroll=1), distinct=True))
-                .annotate(swap_minus=Count("swap", filter=Q(swap__enroll=0), distinct=True))
-                .annotate(volume=F("base_vol") + F("swap_plus") - F("swap_minus"))
-                .order_by("datetime", "slot__time"))
-
-    def query_colles_of_student(self, student) -> QuerySet:
-        has_student = ((Q(groups__student=student)
-                        & ~Q(swap__enroll=0, swap__student=student))
-                       | Q(swap__enroll=1, swap__student=student))
-
-        return (Colle.objects
-                .select_related("slot", "slot__term")
-                .prefetch_related("swap_set")
-                .filter(slot__term=self)
-                .annotate(base_vol=Count("groups__members", distinct=True))
-                .annotate(swap_plus=Count("pk", filter=Q(swap__enroll=1), distinct=True))
-                .annotate(swap_minus=Count("pk", filter=Q(swap__enroll=0), distinct=True))
-                .annotate(volume=F("base_vol") + F("swap_plus") - F("swap_minus"))
-                .filter(has_student)
-                .order_by()
-                )
-
-    def query_colles_not_full_excluding_student(self, student) -> QuerySet:
-        has_student = ((Q(groups__student=student)
-                        & ~Q(swap__enroll=0, swap__student=student))
-                       | Q(swap__enroll=1, swap__student=student))
-
-        return (self.query_colles()
-                .filter(volume__lt=F("slot__capacity"), datetime__gte=date.today())
-                .exclude(has_student))
-
-    def __str__(self) -> str:
-        return self.description
+    def query_rotations(self):
+        return Rotation.objects.filter(creneau__periode=self)
 
 
-class Subject(models.Model):
-    cls = models.ForeignKey(Class, on_delete=models.CASCADE)
-    description = models.CharField(max_length=100)
+    def __str__(self):
+        return self.libelle
+
+
+class Matiere(models.Model):
+    classe = models.ForeignKey(Classe, on_delete=models.CASCADE)
+    libelle = models.CharField(max_length=100)
     code = models.CharField(max_length=20)
 
-    class Meta:
-        ordering = ["description"]
+    def __str__(self):
+        return self.libelle
+
+
+class Critere(models.Model):
+    periode = models.ForeignKey(Periode, on_delete=models.CASCADE)
+    libelle = models.CharField(max_length=100)
 
     def __str__(self):
-        return self.description
+        return self.libelle
 
 
-class GroupType(models.Model):
-    term = models.ForeignKey(Term, on_delete=models.CASCADE)
-    description = models.CharField(max_length=100)
+class Groupe(models.Model):
+    #class Meta:
+    #    ordering=[F("periode").classe.libelle, F("periode").libelle, "libelle"]
+    
+    periode = models.ForeignKey(Periode, on_delete=models.CASCADE)
+    critere = models.ForeignKey(Critere, null=True, on_delete=models.CASCADE)
+    libelle = models.CharField(max_length=100)
+
+    membres = models.ManyToManyField("Etudiant", through="Appartenance")
 
     def __str__(self):
-        return self.description
+        return self.libelle
 
-
-class Group(models.Model):
-    class Meta:
-        ordering = ["term__cls__description", "term__description", "description"]
-
-    term = models.ForeignKey(Term, on_delete=models.CASCADE)
-    type = models.ForeignKey(GroupType, null=True, on_delete=models.CASCADE)
-    description = models.CharField(max_length=100)
-
-    members = models.ManyToManyField("Student", through="Member")
-
-    def __str__(self):
-        return self.description
-
-    """def get_colles(self):
-        return Rotation.objects.filter(slot__term=self.term,
-                                       Q(groupes=self) || Q(a)).order_by("date")
+    def get_colles(self):
+        return Rotation.objects.filter(groupes=self).order_by("date")
 
     def get_colles_par_sem(self):
-        semaines = ((s, self.term.cls.week_beginning_date(s)) for s in self.term.range_semaines())
+        semaines =  ( (s, self.periode.classe.date_debut_sem(s)) for s in self.periode.range_semaines() )
         colles_flat = self.get_colles()
 
         return [
             (sem, lundi,
-             colles_fla.filter(date__gte=lundi, date__lt=lundi + timedelta(weeks=1)))
+             colles_flat.filter(date__gte=lundi, date__lt=lundi+timedelta(weeks=1)))
             for sem, lundi in semaines
-        ]"""
+        ]
 
 
-class Student(models.Model):
+class Etudiant(models.Model):
     class Meta:
-        ordering = ["cls", "last_name", "first_name"]
+        ordering=["classe", "nom", "prenom"]
 
-    cls = models.ForeignKey(Class, on_delete=models.CASCADE)
-    first_name = models.CharField(max_length=100)
-    last_name = models.CharField(max_length=100)
-    groups = models.ManyToManyField("Group", through="Member")
+    classe = models.ForeignKey(Classe, on_delete=models.CASCADE)
+    prenom = models.CharField(max_length=100)
+    nom = models.CharField(max_length=100)
+    groupes = models.ManyToManyField("Groupe", through="Appartenance")
 
-    def is_member(self, group):
+    def appartient(self, groupe):
         """
         Renvoie si self appartient au groupe.
         """
-        return group.members.contains(self)
+        return groupe.membres.contains(self)
 
-    def group_of_type(self, term, type_):
+    def groupe_du_critere(self, periode, critere):
         """
         Renvoie le groupe du critère auquel self appartient.
         """
-        if isinstance(type_, str):
-            type_ = GroupType.objects.get(term=term, description=type_)
+        if isinstance(critere, str):
+            critere = Critere.objects.get(periode=periode, libelle=critere)
 
-        return Member.objects.get(group__term=term, student=self, group__type=type_).group
+        return Appartenance.objects.get(groupe__periode=periode, etudiant=self, groupe__critere=critere).groupe
 
-    def colle_group(self, term):
+    def groupe_de_colle(self, periode):
         """
-        Renvoie le groupe de colle de self pendant term.
+        Renvoie le groupe de colle de self pendant periode.
         """
-        return self.group_of_type(term, "colle")
-
-    def swap_score(self, term):
-        colles = term.query_colles_of_student(self)
+        return self.groupe_du_critere(periode, "colle")
 
     def __str__(self):
-        return f"{self.first_name} {self.last_name}"
+        return f"{self.prenom} {self.nom}"
 
 
-class Member(models.Model):
-    student = models.ForeignKey(Student, on_delete=models.CASCADE)
-    group = models.ForeignKey(Group, on_delete=models.CASCADE)
+class Appartenance(models.Model):
+    etudiant = models.ForeignKey(Etudiant, on_delete=models.CASCADE)
+    groupe = models.ForeignKey(Groupe, on_delete=models.CASCADE)
 
 
 class Colleur(models.Model):
-    gender = models.CharField(max_length=1)
-    name = models.CharField(max_length=100)
+    civilite = models.CharField(max_length=1)
+    nom = models.CharField(max_length=100)
 
     def __str__(self):
-        if self.gender == "M":
-            return f"M. {self.name}"
+        if self.civilite == "M":
+            return f"M. {self.nom}"
         else:
-            return f"Mme {self.name}"
+            return f"Mme {self.nom}"
 
     def get_classes(self):
-        return (x.term_of_date.cls for x in Slot.objects.filter(colleur=self).select_related("term__cls"))
+        return (x.periode.classe for x in Creneau.objects.filter(colleur=self).select_related("periode__classe"))
 
 
-class Slot(models.Model):
-    term = models.ForeignKey(Term, on_delete=models.CASCADE)
-    day = models.IntegerField()
-    time = models.TimeField()
-    duration = models.DurationField()
-    room = models.CharField(max_length=20)
-    subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
+class Creneau(models.Model):
+    periode = models.ForeignKey(Periode, on_delete=models.CASCADE)
+    jour = models.IntegerField()
+    heure = models.TimeField()
+    duree = models.DurationField()
+    salle = models.CharField(max_length=20)
+    matiere = models.ForeignKey(Matiere, on_delete=models.CASCADE)
     colleur = models.ForeignKey(Colleur, on_delete=models.CASCADE)
-    type = models.ForeignKey(GroupType, on_delete=models.CASCADE)
-    capacity = models.IntegerField()
-
-    class Meta:
-        ordering = ["subject", "colleur", "day", "time"]
-        verbose_name_plural = "slots"
+    est_colle = models.BooleanField()
+    capacite = models.IntegerField()
 
     def __str__(self):
-        days = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
+        jours = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
         
-        return f"Colle {self.subject} avec {self.colleur} {days[self.day]} {self.time}"
+        return f"Colle {self.matiere} avec {self.colleur} {jours[self.jour]} {self.heure}"
 
 
-class Colle(models.Model):
-    class Meta:
-        ordering = ["slot__term__cls", "slot__subject__description", "slot__colleur__name", "datetime"]
+class Rotation(models.Model):
+    creneau = models.ForeignKey(Creneau, on_delete=models.CASCADE)
+    groupes = models.ManyToManyField(Groupe)
+    date = models.DateField()
 
-    slot = models.ForeignKey(Slot, on_delete=models.CASCADE)
-    groups = models.ManyToManyField(Group, blank=True)
-    datetime = models.DateTimeField()
-
-    def initial_group(self):
+    def groupe_initial(self):
         """
-        Renvoie les étudiants inscrits à la colle sans prendre en compte les swaps.
+        Renvoie les étudiants inscrits à la colle sans prendre en compte les amendements.
         """
-        return Student.objects.filter(id__in=Member.objects.filter(groupe__in=self.groups.all()))
+        return Etudiant.objects.filter(id__in=Appartenance.objects.filter(groupe__in=self.groupes.all()))
 
-    def final_group(self):
+    def groupe_effectif(self):
         """
-        Renvoie les étudiants inscrits à la colle en tenant compte des swaps.
+        Renvoie les étudiants inscrits à la colle en tenant compte des amendements.
         """
-        swaps = Swap.objects.filter(colle=self)
+        amendements=Amendement.objects.filter(rotation=self)
 
-        return Student.objects.filter(
-            (Q(id__in=Member.objects.filter(group__in=self.groups.all()))
-             | Q(id__in=swaps.filter(enroll=True).values("student_id")))
-            & ~Q(id__in=swaps.filter(enroll=False).values("student_id"))
+        return Etudiant.objects.filter(
+            ( Q(id__in=Appartenance.objects.filter(groupe__in=self.groupes.all()))
+            | Q(id__in=amendements.filter(est_positif=True).values("etudiant_id")) )
+            & ~Q(id__in=amendements.filter(est_positif=False).values("etudiant_id"))
         )
 
-    def is_attendee(self, student):
-        return self.final_group().contains(student)
-
-    def get_volume(self):
+    def effectif(self):
         """
-        Renvoie le nombre d'étudiants inscrits à la colle en tenant compte des swaps.
+        Renvoie le nombre d'étudiants inscrits à la colle en tenant compte des amendements.
         """
-        return (Student.objects
-                .filter(Q(groups__colle=self)
-                        & ~Q(swap__colle=self, swap__enroll=False)
-                        | Q(swap__colle=self, swap__enroll=True))
-                .distinct()
-                .count())
+        n_base = sum(len(groupe.membres.count()) for groupe in self.groupes.all())
+        n_plus = len(Amendement.objects.filter(est_positif=True, rotation=self))
+        n_moins = len(Amendement.objects.filter(est_positif=False, rotation=self))
 
-    def is_full(self):
+        return n_base + n_plus - n_moins
+
+    def est_pleine(self):
         """
         Renvoie si la colle est pleine.
         """
-        return self.get_volume() >= self.slot.capacity
+        eff = self.effectif()
+        return eff>=self.creneau.capacite
 
-    def is_edited(self):
+    def est_modifiee(self):
         """
         Renvoie si la colle a été amendée.
         """
-        return Swap.objects.filter(colle=self).exists()
+        return Amendement.objects.filter(rotation=self).exists()
 
-    def amend(self, student, enroll, notify=False):
+    def amender(self, etudiant, est_positif):
         """
-        Amende la colle en (des)inscrivant student à la colle self, selon enroll.
+        Amende la colle en (des)inscrivant etudiant à la colle self, selon est_positif.
         """
 
-        if Swap.objects.filter(colle=self, student=student, enroll=enroll).exists():
+        if Amendement.objects.filter(rotation=self, etudiant=etudiant, est_positif=est_positif).exists():
             raise Exception("Duplication")
-        elif Swap.objects.filter(colle=self, student=student, enroll=not enroll).exists():
-            # les swaps complémentaires s'annulent
-            Swap.objects.get(colle=self, student=student, enroll=not enroll).delete()
-        elif enroll and any(student.is_member(group) for group in self.groups.all()):
+        elif Amendement.objects.filter(rotation=self, etudiant=etudiant, est_positif=not est_positif).exists():
+            # les amendements complémentaires s'annulent
+            Amendement.objects.get(rotation=self, etudiant=etudiant, est_positif=not est_positif).delete()
+        elif est_positif and any(etudiant.appartient(groupe) for groupe in self.groupes.all()):
             # on ne peut pas s'ajouter si on est dans le groupe de base
             raise Exception("Vous êtes déjà dans le groupe")
-        elif not enroll and all(not student.is_member(group) for group in self.groups.all()):
+        elif not est_positif and all(not etudiant.appartient(groupe) for groupe in self.groupes.all()):
             raise Exception("Vous n'êtes pas dans le groupe")
-        elif enroll and self.is_full():
+        elif est_positif and self.est_pleine():
             raise Exception("Capacité dépassée")
         else:
-            swap = Swap(colle=self, student=student, enroll=enroll)
-            swap.save()
-
-            #if notify:
-            #    func = async_to_sync(swap.notify)
-            #    func()
+            amendement = Amendement(rotation=self, etudiant=etudiant, est_positif=est_positif)
+            amendement.save()
 
     def __str__(self):
-        return f"Colle {self.slot.subject} ({self.slot.colleur}); {self.datetime} {self.slot.time} {self.slot.room}. Groupe(s) {{{'; '.join(str(groupe) for groupe in self.groups.all())}}}"
+        return f"{self.creneau} le {self.date} avec groupes {'+'.join(str(groupe) for groupe in self.groupes.all())}"
 
     
-class Swap(models.Model):
-    enroll = models.BooleanField()
-    colle = models.ForeignKey(Colle, on_delete=models.CASCADE)
-    student = models.ForeignKey(Student, on_delete=models.CASCADE)
-
-    async def notify(self):
-        async with aiohttp.ClientSession() as session:
-            webhook = Webhook.from_url(settings.DISCORD_NOTIFY_WEBHOOK_URL, session=session)
-
-            if self.enroll:
-                await webhook.send(f"Colle réservée : {self.colle}", username=settings.DISCORD_NOTIFY_WEBHOOK_USERNAME)
-            else:
-                await webhook.send(f"Colle libérée : {self.colle}", username=settings.DISCORD_NOTIFY_WEBHOOK_USERNAME)
+    def datetime(self):
+        return datetime.combine( self.date, self.creneau.heure, tzinfo=timezone("Europe/Paris") )
 
 
-class Profile(models.Model):
-    user = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True)
-    student = models.ForeignKey(Student, null=True, blank=True, on_delete=models.SET_NULL)
+class Amendement(models.Model):
+    est_positif = models.BooleanField()
+    rotation = models.ForeignKey(Rotation, on_delete=models.CASCADE)
+    etudiant = models.ForeignKey(Etudiant, on_delete=models.CASCADE)
+
+
+class Profil(models.Model):
+    utilisateur = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True)
+    etudiant = models.ForeignKey(Etudiant, null=True, blank=True, on_delete=models.SET_NULL)
     colleur = models.ForeignKey(Colleur, null=True, blank=True, on_delete=models.SET_NULL)
 
     def __str__(self):
-        return f"Profil {self.user} : {self.student} ; {self.colleur}"
+        return f"Profil {self.utilisateur} : {self.etudiant} ; {self.colleur}"
 
     @staticmethod
     def from_request(request, preprocess=lambda query: query):
         user = request.user
         session = request.session
 
-        match session.get("profile"):
-            case "student":
-                profil = preprocess(Profile.objects.filter(user=user)).get()
-                return profil.student
+        match session.get("profil"):
+            case "etudiant":
+                profil = preprocess(Profil.objects.filter(utilisateur=user)).get()
+                return profil.etudiant
             case "colleur":
-                profil = preprocess(Profile.objects.filter(user=user)).get()
+                profil = preprocess(Profil.objects.filter(utilisateur=user)).get()
                 return profil.colleur
             case _:
                 raise ValueError("profil non choisi")
 
 
-class CalendarLink(models.Model):
-    key = models.CharField(max_length=32, unique=True)
-    student = models.ForeignKey(Student, on_delete=models.CASCADE)
-    term = models.ForeignKey(Term, on_delete=models.CASCADE)
+class LienCalendrier(models.Model):
+    code = models.CharField(max_length=32, unique=True)
+    etudiant = models.ForeignKey(Etudiant, on_delete=models.CASCADE)
+    periode = models.ForeignKey(Periode, on_delete=models.CASCADE)
 
     class Meta:
         constraints = [
             models.UniqueConstraint(
-                fields=['student', 'term'], name='unique_student_term_combination'
+                fields=['etudiant', 'periode'], name='unique_etudiant_periode_combination'
             )
         ]
-
-
-
-def test():
-    valentin = Student.objects.get(pk=25)
-    term = Term.objects.get(pk=3)
-    colles = term.query_colles_of_student(valentin).order_by("-volume")
-
-    for c in colles:
-        print(f"* {c.slot} {c.volume} : {c.base_vol} + {c.swap_plus} - {c.swap_minus}")

colloscope/pdfexport.py

@@ -1,16 +1,14 @@
 from datetime import date, timedelta
 
-from django.shortcuts import redirect
-from django.http import HttpResponse
-from fpdf import FPDF
-
 from colloscope.models import *
 
+from fpdf import FPDF
+
 
 class PDF(FPDF):
-    def liste_eleves(self, term):
-        cls = term.cls
-        students = Student.objects.filter(cls=cls)
+    def liste_eleves(self, periode):
+        classe = periode.classe
+        etudiants = Etudiant.objects.filter(classe=classe)
 
         with self.table(
             align="RIGHT",
@@ -21,27 +19,27 @@ class PDF(FPDF):
             for th in ("Nom", "Prénom", "Grp.", "TD",): #"LV1", "LV2"):
                 header.cell(th)
 
-            for etu in students:
+            for etu in etudiants:
                 row = table.row()
-                row.cell(etu.last_name.upper()) # Nom
-                row.cell(etu.first_name) # Prénom
-                row.cell(etu.colle_group(term).description) # Groupe
-                row.cell(etu.group_of_type(term, "td").description)
+                row.cell(etu.nom.upper()) # Nom
+                row.cell(etu.prenom) # Prénom
+                row.cell(etu.groupe_de_colle(periode).libelle) # Groupe
+                row.cell(etu.groupe_du_critere(periode, "td").libelle)
                 #row.cell("??") # LV1
                 #row.cell("??") # LV2
 
 
-    def table_colloscope(self, term, heading=True, type="colle"):
-        weeks = term.range_weeks()
-        lundis = [term.cls.week_beginning_date(n) for n in weeks]
-        slots = Slot.objects.filter(term=term, type__description=type)
-        weekdays = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
+    def table_colloscope(self, periode, heading=True, est_colle=True):
+        semaines = periode.range_semaines()
+        lundis = [ periode.classe.date_debut_sem(n) for n in semaines ]
+        creneaux = Creneau.objects.filter(periode=periode, est_colle=est_colle)
+        jours = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
         
         with self.table(
             align="LEFT",
             width=190,
             line_height=3,
-            col_widths=(2, 1, 1, 3, 1, *(1,)*len(weeks)),
+            col_widths=(2, 1, 1, 3, 1, *(1,)*len(semaines)),
             num_heading_rows=2 if heading else 0,
             first_row_as_headings=heading) as table:
 
@@ -50,7 +48,7 @@ class PDF(FPDF):
                 for th in ("Matière", "Jour", "Heure", "Colleur", "Salle"):
                     header.cell(th, align="CENTER", rowspan=2)
             
-                for sem in weeks:
+                for sem in semaines:
                     header.cell(str(sem), align="CENTER")
             
                 header2 = table.row()
@@ -58,38 +56,38 @@ class PDF(FPDF):
                     header2.cell(lundi.strftime("%d/%m/%y"), align="CENTER")
 
 
-            for i, c in enumerate(slots):
-                subject = c.subject
-                day = c.day
-                time = c.time
+            for i, c in enumerate(creneaux):
+                matiere = c.matiere
+                jour = c.jour
+                heure = c.heure
                 colleur = c.colleur
-                room = c.room
+                salle = c.salle
                 
                 row = table.row()
-                row.cell(subject.description)
-                row.cell(weekdays[day])
-                row.cell(time.strftime("%H:%M"))
-                row.cell("{} {}".format("M." if colleur.gender=="M" else "Mme", colleur.name.upper()))
-                row.cell(room)
+                row.cell(matiere.libelle)
+                row.cell(jours[jour])
+                row.cell(heure.strftime("%H:%M"))
+                row.cell("{} {}".format("M." if colleur.civilite=="M" else "Mme", colleur.nom.upper()))
+                row.cell(salle)
 
-                for s in weeks:
-                    lundi = term.cls.week_beginning_date(s)
+                for s in semaines:
+                    lundi = periode.classe.date_debut_sem(s)
 
-                    if Colle.objects.filter(slot=c, datetime__gte=lundi, datetime__lt=lundi + timedelta(weeks=1)).exists():
-                        r = Colle.objects.get(slot=c, datetime__gte=lundi, datetime__lt=lundi + timedelta(weeks=1))
-                        groups = r.groups
-                        content = ", ".join(g.description for g in groups.all())
+                    if Rotation.objects.filter(creneau=c, date__gte=lundi, date__lt=lundi+timedelta(weeks=1)).exists():
+                        r = Rotation.objects.get(creneau=c, date__gte=lundi, date__lt=lundi+timedelta(weeks=1))
+                        groupes = r.groupes
+                        content = ", ".join(g.libelle for g in groupes.all())
 
-                        with self.local_context(fill_color=(255, 100, 100) if r.is_edited() else None):
+                        with self.local_context(fill_color=(255, 100, 100) if r.est_modifiee() else None):
                             row.cell(content, align="CENTER")
                     else:
                         row.cell()
 
-def generate(term):
+def generate(periode):
     pdf = PDF(orientation="landscape", format="a4")
     pdf.set_font("helvetica", size=6)
 
-    titre = f"Colloscope {term.cls.description} {term.description}"
+    titre = f"Colloscope {periode.classe.libelle} {periode.libelle}"
 
     pdf.set_title(titre)
     pdf.set_author("colles.mp2i-vms.fr")
@@ -99,39 +97,39 @@ def generate(term):
     pdf.set_line_width(0.1)
     base_y = pdf.t_margin + 10
     pdf.set_y(base_y)
-    pdf.liste_eleves(term)
+    pdf.liste_eleves(periode)
     pdf.set_y(base_y)
-    pdf.table_colloscope(term)
+    pdf.table_colloscope(periode)
     pdf.y += 3
-    pdf.table_colloscope(term, heading=False, type="td")
+    pdf.table_colloscope(periode, heading=False, est_colle=False)
 
     return pdf
 
 
 def handle(request):
     try:
-        student = Profile.from_request(
+        etudiant = Profil.from_request(
                 request,
                 preprocess=lambda query: query \
-                        .select_related("student__cls") \
-                        .prefetch_related("student__cls__term_set")
+                        .select_related("etudiant__classe") \
+                        .prefetch_related("etudiant__classe__periode_set")
             )
     except ValueError:
-        return redirect("colloscope.select_profile")
+        return redirect("colloscope.choix_profil")
 
-    if not isinstance(student, Student):
+    if not isinstance(etudiant, Etudiant):
         return HttpResponse("pas encore supporté")
 
 
-    term_str = request.GET.get("term")
-    if term_str is None:
-        term = student.cls.current_term()
+    periode_str = request.GET.get("periode")
+    if periode_str is None:
+        periode = etudiant.classe.periode_actuelle()
     else:
-        term = Term.objects.get(id=int(term_str), cls=student.cls)
+        periode = Periode.objects.get(id=int(periode_str), classe=etudiant.classe)
 
-    return generate(term)
+    return generate(periode)
 
 
 def main():
-    term = Term.objects.get(id=3)
-    return generate(term)
+    periode = Periode.objects.get(id=3)
+    return generate(periode)

colloscope/serializers.py

@@ -1,85 +0,0 @@
-from rest_framework import serializers
-from rest_framework.serializers import ModelSerializer
-
-from colloscope.models import *
-
-
-class SchoolSerializer(ModelSerializer):
-    class Meta:
-        model = School
-        fields = ["id", "uai", "description", "vacation"]
-
-
-class StudentSerializer(ModelSerializer):
-    class Meta:
-        model = Student
-        fields = ["id", "cls", "first_name", "last_name", "groups"]
-
-
-class ClassSerializer(ModelSerializer):
-    students = StudentSerializer(source="student_set", many=True)
-
-    class Meta:
-        model = Class
-        fields = ["id", "school", "description", "year", "day_zero", "students"]
-
-
-class TermSerializer(ModelSerializer):
-    class Meta:
-        model = Term
-        fields = ["id", "cls", "description", "begin", "end"]
-
-
-class SubjectSerializer(ModelSerializer):
-    class Meta:
-        model = Subject
-        fields = ["id", "cls", "description", "code"]
-
-
-class GroupTypeSerializer(ModelSerializer):
-    class Meta:
-        model = GroupType
-        fields = ["id", "term", "description"]
-
-
-class GroupSerializer(ModelSerializer):
-    class Meta:
-        model = Group
-        fields = ["id", "term", "description", "members"]
-
-
-
-
-class ColleurSerializer(ModelSerializer):
-    class Meta:
-        model = Colleur
-        fields = ["id", "gender", "name"]
-
-
-class SlotSerializer(ModelSerializer):
-    class Meta:
-        model = Slot
-        fields = ["id", "term", "day", "time", "duration", "room", "subject", "colleur", "type", "capacity"]
-
-
-class SwapSerializer(ModelSerializer):
-    class Meta:
-        model = Swap
-        fields = ["enroll", "colle", "student"]
-
-
-class ColleSerializer(ModelSerializer):
-    base_vol = serializers.IntegerField()
-    volume = serializers.IntegerField()
-    slot = SlotSerializer()
-    swaps = SwapSerializer(source="swap_set", many=True)
-
-    class Meta:
-        model = Colle
-        fields = ["id", "slot", "groups", "datetime", "base_vol", "volume", "swaps"]
-
-
-class CalendarLinkSerializer(ModelSerializer):
-    class Meta:
-        model = CalendarLink
-        fields = ["id", "key", "student", "term"]

colloscope/table.py

@@ -2,8 +2,8 @@ from colloscope.models import *
 
 def table_colloscope(periode, heading=True, est_colle=True):
     semaines = periode.range_semaines()
-    lundis = [periode.classe.week_beginning_date(n) for n in semaines]
-    creneaux = Slot.objects.filter(periode=periode, est_colle=est_colle)
+    lundis = [ periode.classe.date_debut_sem(n) for n in semaines ]
+    creneaux = Creneau.objects.filter(periode=periode, est_colle=est_colle)
     jours = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
   
     s = ""
@@ -28,26 +28,26 @@ def table_colloscope(periode, heading=True, est_colle=True):
         s += "</tr>\n"
 
     for i, c in enumerate(creneaux):
-        matiere = c.subject
+        matiere = c.matiere
         jour = c.jour
-        heure = c.time
+        heure = c.heure
         colleur = c.colleur
-        salle = c.room
+        salle = c.salle
         
         s += "<tr>\n"
-        s += f"<td>{matiere.description}</td>\n"
+        s += f"<td>{matiere.libelle}</td>\n"
         s += f"<td>{jours[jour]}</td>\n"
         s += f"<td>{heure.strftime('%H:%M')}</td>\n"
         s += "<td>{} {}</td>\n".format("M." if colleur.civilite=="M" else "Mme", colleur.nom.upper())
         s += f"<td>salle</td>\n"
 
         for sem in semaines:
-            if Colle.objects.filter(creneau=c, semaine=sem).exists():
-                r = Colle.objects.get(creneau=c, semaine=sem)
+            if Rotation.objects.filter(creneau=c, semaine=sem).exists():
+                r = Rotation.objects.get(creneau=c, semaine=sem)
                 groupes = r.groupes
-                content = ", ".join(g.description for g in groupes.all())
+                content = ", ".join(g.libelle for g in groupes.all())
 
-                if r.is_edited():
+                if r.est_modifiee():
                     s += f"<td class='modif'>{content}</td>\n"
                 else:
                     s += f"<td>{content}</td>\n"

colloscope/templates/choix_profil.html

@@ -2,9 +2,11 @@
 
 {% block title %}Sélection du profil{% endblock title %}
 
-{% block main %}
-    
+{% block header %}
 <h1>Sélection du profil</h1>
+{% endblock header %}
+
+{% block main %}
 
 Vous êtes connecté. Votre compte correspond à deux profils :
 <ul>

colloscope/templates/dashboard.html

@@ -1,8 +1,5 @@
 {% extends "base.html" %}
 
-{% load static %}
-{% load extras %}
-
 {% block title %}Tableau de bord{% endblock title %}
 
 {% block main %}
@@ -10,45 +7,23 @@
 <h1>Tableau de bord</h1>
 
 <p>
-Bienvenue {{ student }}. Votre lycée est {{ term.cls.school.description }}, et votre classe est {{ term.cls.description }}.
+Bienvenue {{ etudiant }}. Votre lycée est {{ periode.classe.lycee.libelle }}, et votre classe est {{ periode.classe.libelle }}.
 </p>
 
-<p>Période actuelle : {{ term }}. Votre groupe de colle est {{ group }}. <a href="table.html">Consulter le colloscope</a></p>
+<p>Période actuelle : {{ periode }}. Votre groupe de colle est {{ groupe }}. <a href="table.html">Consulter le colloscope</a></p>
 
 <h2>Mes colles</h2>
+<a href="{{ lien_calendrier }}">Exporter en .ics (ceci est un permalien public)</a>
 
-    <p><a href="{{ calendar_link }}"><i class="fa-regular fa-calendar"></i> Exporter en .ics (ceci est un permalien public)</a></p>
-    
-    <p><a href="{% url "colloscope.marketplace" %}">Accéder au marketplace</a></p>
-
-
-{% for n, lundi, colles in colles_per_sem %}
-
-{% if colles %}
-<h3 class="week">Semaine {{n}} ({{lundi}})</h3>
-    <div class="colle-wrapper">
-    {% for colle in colles %}
-        <div class="colle">
-        <span class="summary">{{ colle.slot.subject }} ({{ colle.slot.colleur }})</span>
+<ul>
+{% for n, lundi, colles in rotations %}
+    <li>Semaine {{n}} ({{lundi}})</li>
     <ul>
-            <li><i class="fa-solid fa-clock"></i> Le {{ colle.datetime|date:"l" }} {{ colle.datetime|date:"DATETIME_FORMAT" }}</li>
-            <li><i class="fa-solid fa-users"></i> {{ colle.groups.all | print_manager | safe }} ({{ colle.volume }} / {{ colle.slot.capacity }})</li>
-            <li><i class="fa-solid fa-earth-americas"></i> {{ colle.slot.room }}</li>
-            <li><i class="fa-solid fa-circle-exclamation"></i>
-                <form
-                        action="{% url "colloscope.withdraw" %}"
-                        method="POST"
-                        onsubmit="return confirm('Êtes-vous sûr de vouloir vous désinscrire de la colle {{ colle }} ');">
-                    {% csrf_token %}
-                    <input type="hidden" name="colle_id" value="{{ colle.id }}">
-                    <button type="submit">Rendre disponible</button>
-                </form>
-            </li>
-        </ul>
-        </div>
+        {% for colle in colles %}
+            <li>{{colle}}</li>
         {% endfor %}
-    </div>
-{% endif %}
+    </ul>
 {% endfor %}
+</ul>
 
 {% endblock main %}

colloscope/templates/marketplace.html

@@ -1,40 +0,0 @@
-{% extends "base.html" %}
-
-{% load static %}
-{% load extras %}
-
-{% block title %}Marketplace{% endblock title %}
-
-{% block main %}
-    <h1>Marketplace</h1>
-
-    Bienvenue sur le marketplace.
-    
-    {% if colles %}
-        Les colles libres sont&nbsp;:
-        <div class="colle-wrapper">
-        {% for colle in colles %}
-            <div class="colle">
-                <span class="summary">{{ colle.slot.subject }} ({{ colle.slot.colleur }})</span>
-                <ul>
-                    <li><i class="fa-solid fa-clock"></i> Le {{ colle.datetime|date:"l" }} {{ colle.datetime|date:"DATETIME_FORMAT" }}</li>
-                    <li><i class="fa-solid fa-users"></i> {{ colle.groups.all | print_manager | safe }} ({{ colle.volume }} / {{ colle.slot.capacity }})</li>
-                    <li><i class="fa-solid fa-earth-americas"></i> {{ colle.slot.room }}</li>
-                    <li><i class="fa-solid fa-circle-exclamation"></i>
-                        <form action="{% url "colloscope.enroll" %}"
-                              method="POST"
-                              onsubmit="return confirm('Êtes-vous sûr de vouloir vous inscrire à la colle {{ colle }} ');">
-                            {% csrf_token %}
-                            <input type="hidden" name="colle_id" value="{{ colle.id }}">
-                            <button type="submit">Réserver</button>
-                        </form>
-                    </li>
-                </ul>
-            </div>
-        {% endfor %}
-        </div>
-    {% else %}
-        Aucune colle n'est disponible
-    {% endif %}
-    
-{% endblock main %}

colloscope/templates/profil_non_associe.html

@@ -2,9 +2,11 @@
 
 {% block title %}Sélection du profil{% endblock title %}
 
-{% block main %}
-    
+{% block header %}
 <h1>Sélection du profil</h1>
+{% endblock header %}
+
+{% block main %}
 
 Vous êtes connecté, mais votre compte n'est associé à aucun profil. Veuillez contacter le webmestre à l'adresse <a href="mailto:valentin@mp2i-vms.fr">valentin@mp2i-vms.fr</a>.
 

colloscope/templates/table.html

@@ -9,20 +9,24 @@
 <link href="{% static 'table.css' %}" rel="stylesheet" type="text/css">
 {% endblock head %}
 
-{% block main %}
+{% block header %}
 <h1>Colloscope</h1>
+{% endblock header %}
+
+
+{% block main %}
 
     <p>
-    Lycée : {{ term.cls.school.description }}. Classe : {{ term.cls.description }}. <a href="dashboard.html">Retour au tableau de bord</a>
+    Lycée : {{ periode.classe.lycee.libelle }}. Classe : {{ periode.classe.libelle }}. <a href="dashboard.html">Retour au tableau de bord</a>
     </p>
 
-    <h2>Colloscope : {{ term.description }}</h2>
+    <h2>Colloscope : {{ periode.libelle }}</h2>
 
     <form method="get" action="{% url "colloscope.table" %}">
     Changer de période&nbsp;:
-        <select name="term" id="term">
-            {% for p in term.cls.term_set.all %}
-            {% if p.id == term.id %}
+        <select name="periode" id="periode">
+            {% for p in periode.classe.periode_set.all %}
+            {% if p.id == periode.id %}
             <option value="{{ p.id }}" selected>{{ p }}</option>
             {% else %}
             <option value="{{ p.id }}" selected>{{ p }}</option>
@@ -32,8 +36,8 @@
         <button type="submit">Valider</button>
     </form>
 
-    {% if request.GET.term %}
-        <a href="export.pdf?term={{ request.GET.term }}" target="_blank">Exporter le colloscope</a>
+    {% if request.GET.periode %}
+        <a href="export.pdf?periode={{ request.GET.periode }}" target="_blank">Exporter le colloscope</a>
     {% else %}
         <a href="export.pdf" target="_blank">Exporter le colloscope</a>
     {% endif %}
@@ -49,7 +53,7 @@
         <col>
     </colgroup>
     <colgroup>
-    {% for _ in weeks %}
+    {% for _ in semaines %}
         <col>
     {% endfor %}
     </colgroup>
@@ -60,32 +64,32 @@
         <th rowspan=2>Heure</th>
         <th rowspan=2>Colleur</th>
         <th rowspan=2>Salle</th>
-    {% for n in weeks %}
+    {% for n in semaines %}
     <th>{{ n }}</th>
     {% endfor %}
     </tr>
 
     <tr>
-    {% for monday in mondays %}
-        <th>{{ monday | strftime:"%d/%m/%y" }}</th>
+    {% for lundi in lundis %}
+        <th>{{ lundi | strftime:"%d/%m/%y" }}</th>
     {% endfor %}
     </tr>
 
 
-    {% for c, rs in colles %}
+    {% for c, rs in rotations %}
         <tr>
-            <td>{{ c.subject.description }}</td>
-            <td>{{ days | getitem:c.day }}</td>
-            <td>{{ c.time | strftime:"%H:%M" }}</td>
+            <td>{{ c.matiere.libelle }}</td>
+            <td>{{ jours | getitem:c.jour }}</td>
+            <td>{{ c.heure | strftime:"%H:%M" }}</td>
             <td>{{ c.colleur }}</td>
-            <td>{{ c.room }}</td>
+            <td>{{ c.salle }}</td>
 
-            {% for sem, exists, r, is_edited, groups in rs %}
+            {% for sem, exists, r, est_modifiee, groupes in rs %}
                 {% if exists %}
-                    {% if is_edited %}
-                        <td class="modif">{{ groups | join:"," }}</td>
+                    {% if est_modifiee %}
+                        <td class="modif">{{ groupes | join:"," }}</td>
                     {% else %}
-                        <td>{{ groups | join:"," }}</td>
+                        <td>{{ groupes | join:"," }}</td>
                     {% endif %}
                 {% else %}
                     <td></td>

colloscope/templatetags/extras.py

@@ -4,25 +4,14 @@ from colloscope.models import *
 
 register = template.Library()
 
-
 @register.filter(name="strftime")
 def strftime(value, arg):
     return value.strftime(arg)
 
-
 @register.filter(name="getitem")
 def getitem(indexable, i):
     return indexable[i]
 
-
-@register.filter(name="print_manager")
-def print_manager(value):
-    if value.exists():
-        return "+".join(str(v) for v in value)
-    else:
-        return "∅"
-
-
 """
 @register.filter(name="exists")
 def exists(queryset):

colloscope/urls.py

@@ -6,9 +6,6 @@ urlpatterns = [
     path("table.html", views.colloscope, name="colloscope.table"),
     path("dashboard.html", views.dashboard, name="colloscope.dashboard"),
     path("export.pdf", views.export, name="colloscope.export"),
-    path("export/calendar/<str:key>/calendar.ics", views.icalendar, name="colloscope.calendar.ics"),
-    path("select_profile", views.select_profile, name="colloscope.select_profile"),
-    path("marketplace.html", views.marketplace, name="colloscope.marketplace"),
-    path("action/enroll", views.enroll, name="colloscope.enroll"),
-    path("action/withdraw", views.withdraw, name="colloscope.withdraw"),
+    path("calendrier.ics", views.icalendar, name="colloscope.calendrier"),
+    path("choix_profil", views.choix_profil, name="colloscope.choix_profil"),
 ]

colloscope/views.py

@@ -1,21 +1,22 @@
+from datetime import date, timedelta
 from uuid import uuid4
 
-from django import forms
-from django.shortcuts import redirect, render
-from django.http import HttpResponse, HttpResponseRedirect
+from django.shortcuts import redirect
+from django.http import HttpResponse
 from django.template import loader
-from django.views.decorators.http import require_POST
 from django.contrib.auth.decorators import login_required
 
 from colloscope.models import *
+from colloscope.table import table_colloscope
 from colloscope.pdfexport import handle
 from colloscope.icalexport import to_calendar
 
 
 def handler404(request):
     template = loader.get_template("404.html")
+    #response.status_code = 404
     context = {}
-    return HttpResponse(template.render(context), status=404)
+    return HttpResponse(template.render(context))
 
 
 def home_redirect(request):
@@ -23,182 +24,143 @@ def home_redirect(request):
 
 
 @login_required
-def select_profile(request):
+def choix_profil(request):
     user = request.user
     session = request.session
 
-    if not Profile.objects.filter(user=user).exists():
-        profile = Profile(user=user)
-        profile.save()
+    if not Profil.objects.filter(utilisateur=user).exists():
+        profil = Profil(utilisateur=user)
+        profil.save()
     else:
-        profile = Profile.objects.get(user=user)
+        profil = Profil.objects.get(utilisateur=user)
 
-    if profile.student is not None and profile.colleur is None:
-        session["profile"] = "student"
+
+    if profil.etudiant is not None and profil.colleur is None:
+        session["profil"] = "etudiant"
         return redirect("/colloscope/")
-    elif profile.colleur is not None and profile.student is None:
-        session["profile"] = "colleur"
+    elif profil.colleur is not None and profil.etudiant is None:
+        session["profil"] = "colleur"
         return redirect("/colloscope/")
     else:
-        if profile.student is not None:
-            template = loader.get_template("select_profile.html")
+        if profil.etudiant is not None:
+            template = loader.get_template("choix_profil.html")
         else:
-            template = loader.get_template("unbound_profile.html")
+            template = loader.get_template("profil_non_associe.html")
 
         context = {
-            "profile": profile,
+            "profil": profil,
         }
         return HttpResponse(template.render(context))
 
 
-def get_lien_calendrier(student, term):
+def get_lien_calendrier(etudiant, periode):
     try:
-        lien = CalendarLink.objects.get(student=student, term=term)
-    except CalendarLink.DoesNotExist:
-        key = uuid4().hex
-        lien = CalendarLink(key=key, student=student, term=term)
+        lien = LienCalendrier.objects.get(etudiant=etudiant, periode=periode)
+    except LienCalendrier.DoesNotExist:
+        code = uuid4().hex
+        lien = LienCalendrier(code=code, etudiant=etudiant, periode=periode)
         lien.save()
     
-    return f"calendrier.ics?key={lien.key}"
+    return f"calendrier.ics?key={lien.code}"
 
 
 @login_required
 def dashboard(request):
+    user = request.user
+    session = request.session
+    
     try:
-        student = Profile.from_request(
+        etudiant = Profil.from_request(
                 request,
-            preprocess=lambda query: (query
-                                      .select_related("student__cls")
-                                      .prefetch_related("student__cls__term_set"))
+                preprocess=lambda query: query \
+                        .select_related("etudiant__classe") \
+                        .prefetch_related("etudiant__classe__periode_set")
             )
     except ValueError:
-        return redirect("colloscope.select_profile")
+        return redirect("colloscope.choix_profil")
 
-    if not isinstance(student, Student):
+    if not isinstance(etudiant, Etudiant):
         return HttpResponse("pas encore supporté")
 
-    term = student.cls.current_term()
-    group = student.colle_group(term)
-
-    colles = term.query_colles_of_student(student)
-
-    colles_per_sem = [None] * len(term.range_weeks())
-    for k, n in enumerate(term.range_weeks()):
-        lundi = term.cls.week_beginning_date(n)
-        colles_per_sem[k] = n, lundi, colles.filter(datetime__gte=max(lundi, date.today()),
-                                                    datetime__lt=lundi + timedelta(weeks=1))
-
+    periode = etudiant.classe.periode_actuelle()
+    groupe = etudiant.groupe_de_colle(periode)
+    rotations = groupe.get_colles_par_sem()
     template = loader.get_template("dashboard.html")
-    calendar_link = get_calendar_link(student, term)
+    lien_calendrier = get_lien_calendrier(etudiant, periode)
 
     context = {
-        "student": student,
-        "term": term,
-        "group": group,
-        "colles_per_sem": colles_per_sem,
-        "calendar_link": calendar_link,
+        "etudiant": etudiant,
+        "periode": periode,
+        "groupe": groupe,
+        "rotations" : rotations,
+        "lien_calendrier": lien_calendrier,
     }
 
     return HttpResponse(template.render(context, request))
 
 
-class AmendForm(forms.Form):
-    colle_id = forms.IntegerField(widget=forms.HiddenInput(), required=True)
-
-
-class EnrollForm(AmendForm):
-    pass
-
-
-class WithdrawForm(AmendForm):
-    pass
-
-
-@login_required
-def marketplace(request):
-    try:
-        student = Profile.from_request(
-            request,
-            preprocess=lambda query: (query
-                                      .select_related("student__cls")
-                                      .prefetch_related("student__cls__term_set"))
-        )
-    except ValueError:
-        return redirect("colloscope.select_profile")
-
-    if not isinstance(student, Student):
-        return HttpResponse("pas encore supporté")
-
-    term = student.cls.current_term()
-    colles = term.query_colles_not_full_excluding_student(student)
-
-    context = {
-        "colles": colles,
-    }
-
-    return render(request, "marketplace.html", context)
-
-
 @login_required
 def colloscope(request):
+    user = request.user
+    session = request.session
+    
     try:
-        student = Profile.from_request(
+        etudiant = Profil.from_request(
                 request,
-            preprocess=lambda query: (query
-                                      .select_related("student__cls")
-                                      .prefetch_related("student__cls__term_set"))
+                preprocess=lambda query: query \
+                        .select_related("etudiant__classe") \
+                        .prefetch_related("etudiant__classe__periode_set")
             )
     except ValueError:
-        return redirect("colloscope.select_profile")
+        return redirect("colloscope.choix_profil")
 
-    if not isinstance(student, Student):
+    if not isinstance(etudiant, Etudiant):
         return HttpResponse("pas encore supporté")
 
-    term_str = request.GET.get("term")
-    if term_str is None:
-        term = student.cls.current_term()
+
+    periode_str = request.GET.get("periode")
+    if periode_str is None:
+        periode = etudiant.classe.periode_actuelle()
     else:
         try:
-            term = Term.objects.get(id=int(term_str), cls=student.cls)
-        except Term.DoesNotExist:
+            periode = Periode.objects.get(id=int(periode_str), classe=etudiant.classe)
+        except Periode.DoesNotExist:
             template = loader.get_template("404.html")
             context = {}
             response = HttpResponse(template.render(context, request))
             response.status_code = 404
 
-            return response
 
-    slots = (Slot.objects
-             .filter(term=term, type__description="colle")
-             .order_by()
-             .prefetch_related("colle_set"))
+    creneaux = Creneau.objects \
+            .filter(periode=periode, est_colle=True) \
+            .prefetch_related("rotation_set")
 
-    weeks = term.range_weeks()
-    colles = [(c, []) for c in slots]
-    for c, l in colles:
-        for sem in weeks:
-            lundi = term.cls.week_beginning_date(sem)
+    semaines = periode.range_semaines()
+    rotations = [ (c, []) for c in creneaux ]
+    for c, l in rotations:
+        for sem in semaines:
+            lundi = periode.classe.date_debut_sem(sem)
 
-            rot = Colle.objects.filter(slot=c, datetime__gte=lundi, datetime__lt=lundi + timedelta(weeks=1))
+            rot = Rotation.objects.filter(creneau=c, date__gte=lundi, date__lt=lundi+timedelta(weeks=1))
             exists = rot.exists()
 
             if exists:
                 r = rot.first()
-                is_edited = r.is_edited()
-                groups = (g.description for g in r.groups.all())
+                est_modifiee = r.est_modifiee()
+                groupes = (g.libelle for g in r.groupes.all())
             else:
-                r = is_edited = groups = None
+                r = est_modifiee = groupes = None
 
-            l.append((sem, exists, r, is_edited, groups))
+            l.append((sem, exists, r, est_modifiee, groupes))
    
     template = loader.get_template("table.html")
 
     context = {
-        "term": term,
-        "weeks": weeks,
-        "mondays": [term.cls.week_beginning_date(n) for n in weeks],
-        "days": ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"],
-        "colles": colles,
+        "periode": periode,
+        "semaines": semaines,
+        "lundis": [periode.classe.date_debut_sem(n) for n in semaines],
+        "jours" : ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"],
+        "rotations" : rotations,
     }
 
     return HttpResponse(template.render(context, request))
@@ -209,82 +171,27 @@ def export(request):
     return HttpResponse(bytes(handle(request).output()), content_type="application/pdf")
 
 
-def get_calendar_link(student, term):
+def get_lien_calendrier(etudiant, periode):
     try:
-        lien = CalendarLink.objects.get(student=student, term=term)
-    except CalendarLink.DoesNotExist:
-        key = uuid4().hex
-        lien = CalendarLink(key=key, student=student, term=term)
+        lien = LienCalendrier.objects.get(etudiant=etudiant, periode=periode)
+    except LienCalendrier.DoesNotExist:
+        code = uuid4().hex
+        lien = LienCalendrier(code=code, etudiant=etudiant, periode=periode)
         lien.save()
     
-    return f"export/calendar/{lien.key}/calendar.ics"
+    return f"calendrier.ics?key={lien.code}"
 
-
-def icalendar(request, key):
+def icalendar(request):
+    if request.GET.get("key") is not None:
         try:
-        link = CalendarLink.objects.get(key=key)
+            lien = LienCalendrier.objects.get(code=request.GET.get("key"))
 
-        if not request.GET.get("edt"):
-            return HttpResponse(to_calendar(link.student, link.term, include_EDT=True).to_ical(),
-                                content_type="text/calendar")
-
-        return HttpResponse(to_calendar(link.student, link.term, include_EDT=True).to_ical(),
-                            content_type="text/calendar")
-
-    except CalendarLink.DoesNotExist:
+            return HttpResponse(to_calendar(lien.etudiant, lien.periode).to_ical(), content_type="text/calendar")
+        except LienCalendrier.DoesNotExist:
             return HttpResponse("Invalid key", status=404)
-
-
-def amend(request, colle_id, do_enroll):
-    try:
-        student = Profile.from_request(
-            request,
-            preprocess=lambda query: (query
-                                      .select_related("student__cls")
-                                      .prefetch_related("student__cls__term_set"))
-        )
-    except ValueError:
-        return redirect("colloscope.choix_profil")
-
-    if not isinstance(student, Student):
-        return HttpResponse("pas encore supporté")
-
-    if do_enroll:
-        (Colle.objects
-         .get(id=colle_id, slot__term__cls=student.cls)
-         .amend(enroll=True, student=student, notify=True))
     else:
-        colle = Colle.objects.get(id=colle_id)
+        return HttpResponse("Unspecified key", status=404)
 
-        if colle.is_attendee(student):
-            colle.amend(enroll=False, student=student, notify=True)
-        else:
-            raise Exception("vous n'êtes pas dans la colle...")
-
-
-@require_POST
-@login_required
-def enroll(request):
-    form = WithdrawForm(request.POST)
-
-    if form.is_valid():
-        colle_id = form.cleaned_data["colle_id"]
-        amend(request, colle_id, True)
-    else:
-        print("!!!! invalide")
-
-    return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
-
-
-@require_POST
-@login_required
-def withdraw(request):
-    form = WithdrawForm(request.POST)
-
-    if form.is_valid():
-        colle_id = form.cleaned_data["colle_id"]
-        amend(request, colle_id, False)
-    else:
-        print("!!!! invalide")
-
-    return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
+def data_dump(request):
+    template = loader.get_template("data_dump.html")
+    return HttpResponse(template.render())

colloscope/viewsets.py

@@ -1,101 +0,0 @@
-from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
-
-from rest_framework.permissions import IsAuthenticated
-
-from colloscope.models import *
-from colloscope.serializers import *
-
-
-class SchoolViewset(ReadOnlyModelViewSet):
-    serializer_class = SchoolSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return School.objects.all()
-
-
-class ClassViewset(ReadOnlyModelViewSet):
-    serializer_class = ClassSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Class.objects.all()
-
-
-class TermViewset(ReadOnlyModelViewSet):
-    serializer_class = TermSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Term.objects.all()
-
-
-class SubjectViewset(ReadOnlyModelViewSet):
-    serializer_class = SubjectSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Subject.objects.all()
-
-
-class GroupTypeViewset(ReadOnlyModelViewSet):
-    serializer_class = GroupTypeSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return GroupType.objects.all()
-
-
-class GroupViewset(ReadOnlyModelViewSet):
-    serializer_class = GroupSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Group.objects.all()
-
-
-class StudentViewset(ReadOnlyModelViewSet):
-    serializer_class = StudentSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Student.objects.all()
-
-
-class ColleurViewset(ReadOnlyModelViewSet):
-    serializer_class = ColleurSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Colleur.objects.all()
-
-
-class SlotViewset(ReadOnlyModelViewSet):
-    serializer_class = SlotSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return Slot.objects.all()
-
-
-class ColleViewset(ModelViewSet):
-    serializer_class = ColleSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return (Colle.objects
-                .select_related("slot", "slot__term")
-                .prefetch_related("swap_set")
-                .annotate(base_vol=Count("groups__members"))
-                .annotate(swap_plus=Count("swap", filter=Q(swap__enroll=1), distinct=True))
-                .annotate(swap_minus=Count("swap", filter=Q(swap__enroll=0), distinct=True))
-                .annotate(volume=F("base_vol") + F("swap_plus") - F("swap_minus"))
-                .order_by("datetime", "slot__time"))
-
-
-class CalendarLinkViewset(ReadOnlyModelViewSet):
-    serializer_class = CalendarLinkSerializer
-    permission_classes = [IsAuthenticated]
-
-    def get_queryset(self):
-        return CalendarLink.objects.all()

kholles_web/settings.sample.py

@@ -0,0 +1,147 @@
+"""
+Django settings for kholles_web project.
+
+Generated by 'django-admin startproject' using Django 5.0.4.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.0/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/5.0/ref/settings/
+"""
+
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/5.0/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'django-insecure-$)@!wj+$^y1@^tr78ay&)cna10da_k^vncrbo+4ja-qth$8bhz'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ["127.0.0.1"] # à modifier
+
+CSRF_TRUSTED_ORIGINS = [
+    "http://127.0.0.1:8000",
+    "https://colles.mp2i-vms.fr"
+] # à modifier
+
+CORS_ORIGIN_WHITELIST = [
+    "http://localhost:8000",
+    "https://colles.mp2i-vms.fr"
+]
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'colloscope',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'kholles_web.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [ BASE_DIR / "templates" ],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'kholles_web.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/5.0/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/5.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/5.0/topics/i18n/
+
+LANGUAGE_CODE = 'fr-fr'
+
+TIME_ZONE = 'Europe/Paris'
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/5.0/howto/static-files/
+
+STATIC_URL = 'static/'
+
+STATICFILES_DIRS = [
+    BASE_DIR / "static",
+]
+
+STATICFILES_FINDERS = [
+    "django.contrib.staticfiles.finders.FileSystemFinder",
+    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
+]
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/5.0/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+LOGIN_URL = "/comptes/login"
+LOGIN_REDIRECT_URL = "home"
+LOGOUT_REDIRECT_URL = "home"

kholles_web/urls.py

@@ -16,46 +16,12 @@ Including another URLconf
 """
 from django.contrib import admin, auth
 from django.urls import include, path
-from django.shortcuts import redirect
-from django.contrib.staticfiles import views as vstatic
-from rest_framework import routers
-from rest_framework_simplejwt.views import (
-    TokenObtainPairView,
-    TokenRefreshView,
-)
-from drf_spectacular.views import SpectacularAPIView, SpectacularRedocView, SpectacularSwaggerView
 
 from colloscope.views import home_redirect
-from colloscope.viewsets import *
-
-router = routers.SimpleRouter()
-router.register('school', SchoolViewset, basename='school')
-router.register('class', ClassViewset, basename='class')
-router.register('term', TermViewset, basename='term')
-router.register("subject", SubjectViewset, basename='subject')
-router.register('grouptype', GroupTypeViewset, basename='grouptype')
-router.register("group", GroupViewset, basename='group')
-router.register("student", StudentViewset, basename='student')
-router.register("colleur", ColleurViewset, basename='colleur')
-router.register("slot", SlotViewset, basename='slot')
-router.register("colle", ColleViewset, basename='colle')
-router.register("calendarlink", CalendarLinkViewset, basename='calendarlink')
-
 
 urlpatterns = [
     path('', home_redirect, name="home"),
-    path('api-auth/', include('rest_framework.urls')),
-    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
-    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
-    path('api/schema/', SpectacularAPIView.as_view(), name='schema'),
-    path('api/documentation/', SpectacularSwaggerView.as_view(url_name='schema'), name='api-doc'),
-    path("api/", lambda request: redirect("api-doc")),
-    path("api/doc/", lambda request: redirect("api-doc")),
-    path("api/", include(router.urls)),
-
-    path("oauth2/", include('oauth2_provider.urls', namespace='oauth2_provider')),
-    path("favicon.ico", lambda req: vstatic.serve(req, "favicon.ico")),
     path('colloscope/', include('colloscope.urls')),
     path('admin/', admin.site.urls),
-    path('accounts/', include("django.contrib.auth.urls")),
+    path('comptes/', include("django.contrib.auth.urls")),
 ]

requirements.txt

@@ -1,60 +0,0 @@
-aiohttp==3.9.5
-aiosignal==1.3.1
-asgiref==3.8.1
-attrs==23.2.0
-autobahn==23.6.2
-Automat==22.10.0
-certifi==2024.2.2
-cffi==1.16.0
-charset-normalizer==3.3.2
-constantly==23.10.4
-cryptography==42.0.5
-daphne==4.1.2
-defusedxml==0.7.1
-discord.py==2.3.2
-Django==5.0.4
-django-cors-headers==4.3.1
-django-oauth-toolkit==2.3.0
-django-smtp-ssl==1.0
-djangorestframework==3.15.1
-djangorestframework-simplejwt==5.3.1
-drf-spectacular==0.27.2
-fonttools==4.51.0
-fpdf2==2.7.8
-frozenlist==1.4.1
-hyperlink==21.0.0
-icalendar==5.0.12
-idna==3.7
-incremental==22.10.0
-inflection==0.5.1
-jsonschema==4.22.0
-jsonschema-specifications==2023.12.1
-jwcrypto==1.5.6
-multidict==6.0.5
-numpy==1.26.4
-oauthlib==3.2.2
-pandas==2.2.2
-pillow==10.3.0
-pyasn1==0.6.0
-pyasn1_modules==0.4.0
-pycparser==2.22
-PyJWT==2.8.0
-pyOpenSSL==24.1.0
-python-dateutil==2.9.0.post0
-pytz==2024.1
-PyYAML==6.0.1
-referencing==0.35.1
-requests==2.31.0
-rpds-py==0.18.0
-service-identity==24.1.0
-setuptools==69.5.1
-six==1.16.0
-sqlparse==0.4.4
-Twisted==24.3.0
-txaio==23.1.1
-typing_extensions==4.11.0
-tzdata==2024.1
-uritemplate==4.1.1
-urllib3==2.2.1
-yarl==1.9.4
-zope.interface==6.3

scrape_csv.py

@@ -20,11 +20,11 @@ def scrape(periode, chemin):
         else:
             c = Colleur.objects.get(nom=nom_colleur, civilite=civilite)
         
-        if not Subject.objects.filter(classe=periode.classe, libelle=matiere).exists():
-            m = Subject(classe=periode.classe, libelle=matiere, code=matiere.upper())
+        if not Matiere.objects.filter(classe=periode.classe, libelle=matiere).exists():
+            m = Matiere(classe=periode.classe, libelle=matiere, code=matiere.upper())
             m.save()
         else:
-            m = Subject.objects.get(classe=periode.classe, libelle=matiere)
+            m = Matiere.objects.get(classe=periode.classe, libelle=matiere)
 
         jours_dict = {"dimanche": 0, "lundi": 1, "mardi": 2, "mercredi": 3, "jeudi": 4, "vendredi": 5, "samedi": 6}
         j = jours_dict[jour]
@@ -40,11 +40,11 @@ def scrape(periode, chemin):
 
         print(f"--> Traitement de {c=}, {m=}, {j=}, {h=}, {d=}, {c2=}")
 
-        if not Slot.objects.filter(periode=periode, jour=j, heure=h, duree=d, matiere=m, colleur=c, est_colle=True, capacite=c2).exists():
-            creneau = Slot(periode=periode, jour=j, heure=h, duree=d, salle="nc", matiere=m, colleur=c, est_colle=True, capacite=c2)
+        if not Creneau.objects.filter(periode=periode, jour=j, heure=h, duree=d, matiere=m, colleur=c, est_colle=True, capacite=c2).exists():
+            creneau = Creneau(periode=periode, jour=j, heure=h, duree=d, salle="nc", matiere=m, colleur=c, est_colle=True, capacite=c2)
             creneau.save()
         else:
-            creneau = Slot.objects.get(periode=periode, jour=j, heure=h, duree=d, matiere=m, colleur=c, est_colle=True, capacite=c2)
+            creneau = Creneau.objects.get(periode=periode, jour=j, heure=h, duree=d, matiere=m, colleur=c, est_colle=True, capacite=c2)
 
         for i, r in enumerate(rotations):
             sem = headers[4+i].split("/")
@@ -53,16 +53,16 @@ def scrape(periode, chemin):
             
             s = date.fromisoformat("-".join(sem)) + (j-1) * timedelta(days=1)
 
-            if not Colle.objects.filter(creneau=creneau, date=s):
-                rot = Colle(creneau=creneau, date=s)
+            if not Rotation.objects.filter(creneau=creneau, date=s):
+                rot = Rotation(creneau=creneau, date=s)
                 rot.save()
             else:
-                rot = Colle.objects.get(creneau=creneau, date=s)
+                rot = Rotation.objects.get(creneau=creneau, date=s)
 
-            rot.groupes.add(Group.objects.get(libelle=r))
+            rot.groupes.add(Groupe.objects.get(libelle=r))
 
 def main():
-    periode = Term.objects.get(id=3)
+    periode = Periode.objects.get(id=3)
     scrape(periode, "colloscope.csv")
 
 if __name__ == "__main__":

static/colloscope-v3.csv

@@ -1,74 +0,0 @@
-;Semaine;;;;;;;;;;;;;
-;;;;;;;;22/04/24;29/04/24;13/05/24;20/05/24;27/05/24;03/06/24;10/06/24
-type;matière;jour;heure;durée;colleur;récurrent (semaines);salle;;;;;;;
-;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;
-colle;InfoTP;mercredi;14h;2h;M. ROUVROY;;M101;11;12;8;5;11;12;5
-colle;InfoTP;mercredi;14h;2h;M. ROUVROY;;M101;13;15;9;6;13;15;7
-colle;InfoTP;mercredi;14h;2h;M. ROUVROY;;M101;14;4;10;7;14;4;10
-colle;Info;lundi;12h;1h;M. JOSPIN;;;10;5;11;12;4;8;11
-colle;Info;lundi;13h;1h;M. JOSPIN;;;9;6;14;15;7;13;14
-;;;;;;;;;;;;;;
-colle;Maths;mercredi;15h;1h;M. CARPINTERO;;V152;7;3;11;10;9;6;2
-colle;Maths;mercredi;14h;1h;M. CARPINTERO;;V152;15;8;14;13;1;5;4
-colle;Maths;mercredi;15h;1h;M. BOULLY;;R004;6;5;13;2;3;10;14
-colle;Maths;mercredi;14h;1h;M. BOULLY;;R004;8;1;12;4;15;7;11
-colle;Maths;mardi;14h;1h;Mme. MULLAERT;;M070;9;11;4;15;5;12;7
-colle;Maths;jeudi;18h;1h;Mme. MULLAERT;;;2;14;1;8;6;13;3
-colle;Maths;jeudi;18h;1h;M. RAPIN;;C284;10;9;5;11;8;2;13
-colle;Maths;vendredi;17h;1h;M. OUBAHA;;C382;4;13;6;14;7;9;15
-colle;Maths;vendredi;18h;1h;M. OUBAHA;;C382;5;10;2;3;12;11;8
-colle;Maths;mardi;18h;1h;M. RAPIN;;V152;3;7;15;12;4;1;6
-;;;;;;;;;;;;;;
-colle;Anglais;mercredi;14h;1h;Mme. LE GOURIELLEC;;C393;1;2;5;16;7;13;8
-colle;Anglais;mercredi;15h;1h;Mme. LE GOURIELLEC;;C393;3;11;6;4;10;14;9
-colle;Anglais;mercredi;16h;1h;M. MANN;;C380;9;14;7;12;5;11;6
-colle;Anglais;mercredi;17h;1h;M. MANN;;C380;10;16;8;15;3;4;1
-colle;Anglais;mardi;14h;1h;Mme. BELAGGOUNE;;C454;5;4;10;11;9;15;10
-colle;Anglais;mardi;18h;1h;Mme. BELAGGOUNE;;;7;13;3;2;6;16;5
-colle;Anglais;mardi;17h;1h;Mme. BELAGGOUNE;;;6;12;1;14;8;12;7
-colle;Anglais;mardi;17h;1h;M. HERBAULT;;V052;8;15;9;13;1;2;3
-;;;;;;;;;;;;;;
-colle;Physique;jeudi;18h;1h;M. DE ROUX;;C054;14;8;12;5;13;3;2
-colle;Physique;vendredi;16h;1h;Mme. CHIBANI;;C284;15;9;11;10;14;6;13
-colle;Physique;lundi;12h;1h;Mme. CHEVALIER;;R105;16;10;4;8;15;7;12
-colle;Physique;mercredi;17h;1h;M. POUPY;;R012;12;6;15;9;4;5;11
-colle;Physique;mercredi;18h;1h;M. POUPY;;R012;13;7;14;3;2;1;16
-colle;Physique;mardi;17h;1h;Mme. CHEVALIER;;R103;2;1;13;7;12;9;15
-colle;Physique;mardi;17h;1h;M. COLIN;;C386;11;3;2;1;16;10;4
-colle;Physique;mardi;14h;1h;Mme. CHEVALIER;;R103;4;5;16;6;11;8;14
-;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;
-cours;TP Physique;lundi;8h30;1h30;Mme CHEVALIER;1;R417;gr 9 à 15;;;;;;
-cours;TP Physique;lundi;10h;1h30;Mme CHEVALIER;1;R417;gr 1 à 8;;;;;;
-cours;TP Info;lundi;10h;1h30;M. HALFON;2;C154;gr 9 à 15;;;;;;
-cours;TP Info;lundi;8h30;1h30;M. HALFON;2;C154;gr 4 à 8;;;;;;
-cours;TD Maths;vendredi;11h;2h;Mme MULLAERT;2;M103;B+2+3;A+1;;;;;
-cours;TD Maths;vendredi;14h;2h;Mme MULLAERT;2;M103;A+1;B+2+3;;;;;
-cours;TP Info;vendredi;14h;2h;M. HALFON;2;;B;A;;;;;
-cours;TP Info;vendredi;11h;2h;M. HALFON;2;;A;B;;;;;
-cours;TD Physique;jeudi;14h;1h;Mme CHEVALIER;1;R011;gr 9 à 15;gr 9 à 15;;;;;
-cours;TD Physique;jeudi;15h;1h;Mme CHEVALIER;1;R011;gr 1 à 8;gr 1 à 8;;;;;
-cours;Info;jeudi;10h;3h;M. HALFON;1;M103;A+B;;;;;;
-cours ;Chimie;jeudi;10h;2h;Mme CHEVALIER;1;R101;SI;;;;;;
-cours;TIPE Physique;jeudi;12h;0h30;Mme CHEVALIER;1;R101;SI;;;;;;
-cours;TP ITC ;jeudi;13h30;1h30;M. HALFON;1;;SI;;;;;;
-cours;TP SI;lundi;8h;2h;M. DERUMAUX;1;;SI;;;;;;
-cours;TIPE Physique;lundi;11h30;0h30;Mme CHEVALIER;1;;SI;;;;;;
-cours;SI;lundi;12h;1h;M. DERUMAUX;1;;SI;;;;;;
-cours;SI;mardi;14h;1h;M. DERUMAUX;1;;SI;;;;;;
-cours ;Maths;lundi;14h;4h;Mme MULLAERT;1;M103;A+B+SI;;;;;;
-cours;Maths;mardi;8h;3h;Mme MULLAERT;1;M103;A+B+SI;;;;;;
-cours;Maths;mercredi;10h;1h;Mme MULLAERT;1;M103;A+B+SI;;;;;;
-cours;Physique;mardi;15h;2h;Mme CHEVALIER;1;R013;A+B+SI;;;;;;
-cours ;Français-Philo;mercredi;11h;2h;Mme CHAPIRO;1;M103;A+B+SI;;;;;;
-cours;Physique;jeudi;8h;2h;Mme CHEVALIER;1;R101;A+B+SI;;;;;;
-cours;EPS;jeudi;16h;2h;M. TORRES-LACAZE;1;Gymnase;A+B+SI;;;;;;
-cours;Maths;vendredi;8h;3h;Mme MULLAERT;1;M103;A+B+SI;;;;;;
-;;;;;;;;;;;;;;
-cours;Anglais LV1;mardi;11h;2h;;1;;;;;;;;
-cours;Anglais LV2;mardi ;11h;1h30;;1;;;;;;;;
-cours;Espagnol LV1;mercredi;8h;2h;;1;;;;;;;;
-cours;Espagnol LV1;mercredi;8h30;1h30;;1;;;;;;;;
-cours;Allemand LV1 ;mercredi;8h;2h;;1;;;;;;;;
-cours;Allemand LV2;mercredi;8h30;1h30;;1;;;;;;;;

static/main.css

@@ -4,6 +4,7 @@
 
 body {
     font-family: sans-serif;
+    background-color: #fafafa;
     margin: 0;
 }
 
@@ -35,49 +36,6 @@ header .bandeau button:active {
     background-color: darkgoldenrod;
 }
 
-.navbar {
-    background-color: #eee;
-    display: flex;
-    flex-direction: column;
-}
-
-.navbar .block {
-    display: flex;
-    flex-direction: column;
-    text-align: center;
-}
-
-@media screen and (min-width: 400px)
-{
-    .navbar {
-        padding: 0 10px;
-        flex-direction: row;
-        justify-content: space-between;
-    }
-
-    .navbar .block {
-        flex-direction: row;
-        gap: 0 10px;
-    }
-}
-
-.navbar a:link, .navbar a:visited {
-    color: black;
-    text-decoration: none;
-}
-
-.navbar .link {
-    background: none;
-    border: none;
-    font: inherit;
-    padding: 10px;
-    cursor: pointer;
-}
-
-.navbar .link:hover {
-    background-color: #ddd;
-}
-
 main {
     margin: 20px auto;
     width: clamp(350px, 60%, 1200px);
@@ -89,34 +47,6 @@ h1 {
     text-align: center;
 }
 
-form.login table {
-    margin: auto;
-}
-
-form.login input[type=text], form.login input[type=password] {
-    padding: 5px;
-    border: none;
-    background-color: #eee;
-}
-
-form.login button {
-    border: none;
-    padding: 10px;
-    background-color: dodgerblue;
-    border-radius: 5px;
-    color: white;
-    display: block;
-    margin: 15px auto;
-}
-
-form.login button:hover {
-    background-color: #0483ff;
-}
-
-form.login button:active {
-    background-color: #0077ea;
-}
-
 nav.semaine {
     width: 100%;
     display: flex;
@@ -145,63 +75,3 @@ p.programme {
 footer {
     text-align: center;
 }
-
-
-.week {
-    background-color: dodgerblue;
-    color: white;
-    padding: 5px;
-}
-
-.week.empty {
-    background-color: gray;
-}
-
-.colle-wrapper {
-    display: grid;
-    gap: 10px;
-}
-
-@media screen and (min-width: 400px)
-{
-    .colle-wrapper {
-        grid-template-columns: repeat(3, minmax(100px, 1fr));
-    }
-}
-
-.colle {
-    border: 1px solid black;
-    padding: 10px;
-}
-
-.colle span {
-    text-align: center;
-}
-
-.colle ul {
-    padding: 0;
-}
-
-.colle li {
-    list-style-type: none;
-}
-
-.colle form {
-    display: inline;
-}
-
-.colle button {
-    padding: 5px;
-    border: none;
-    background-color: #c0392b;
-    color: white;
-    border-radius: 5px;
-}
-
-.colle button:hover {
-    background-color: #a93226;
-}
-
-.colle button:active {
-    background-color: #922b21;
-}

static/unified-navigator

@@ -1 +0,0 @@
-Subproject commit 9e2427d5ae8e7fafef9fe001394e9566e181f217

templates/404.html

@@ -7,5 +7,5 @@
 {% endblock header %}
 
 {% block main %}
-Vous vous êtes perdu. ASKMULLER
+Vous vous êtes perdu.
 {% endblock main %}

templates/base.html

@@ -5,73 +5,27 @@
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1">
         <title>{% block title %}{% endblock title %}</title>
-        <link href="{% static 'unified-navigator/navigator.css' %}" rel="stylesheet" type="text/css">
         <link href="{% static 'main.css' %}" rel="stylesheet" type="text/css">
-        <script src="https://kit.fontawesome.com/0fd87250ec.js" crossorigin="anonymous"></script>
         {% block head %}{% endblock head %}
     </head>
     <body>
         <header>
-            <script>
-                function navigator_toggleMenu() {
-                    if (document.body.clientWidth > 600)
-                        return document.location = "https://mp2i-vms.fr"
-
-                    if (document.getElementById("menu-sec").classList.contains("hidden")) {
-                        document.getElementById("menu-sec").classList.remove("hidden");
-                        document.getElementById("navigator-dropdown-indicator").className = "fa-solid fa-caret-up";
-                    } else {
-                        document.getElementById("menu-sec").classList.add("hidden");
-                        document.getElementById("navigator-dropdown-indicator").className = "fa-solid fa-caret-down";
-                    }
-                }
-            </script>
-            <div class="unified_navigator">
-                <div class="nav-container">
-                    <div class="logo-wrapper" onclick="navigator_toggleMenu();">
-                        <a class="logo">
-                            <img src="{% static 'unified-navigator/icon.png' %}" alt="logo"><strong>mp2i-vms.fr</strong>
-                        </a>
-                        <i id="navigator-dropdown-indicator" class="fa-solid fa-caret-down"></i>
-                    </div>
-                    <div class="menu-wrapper hidden" id="menu-sec">
-                        <div class="link"><a href="https://mp2i-vms.fr/pages.html"><i class="fa-solid fa-house"></i> Pages personnelles</a></div>
-                        <div class="link"><a href="https://git.mp2i-vms.fr"><i class="fa-brands fa-git-alt"></i> Git</a></div>
-                        <div class="link"><a href="https://play.mp2i-vms.fr"><i class="fa-solid fa-cubes"></i> Minecraft</a></div>
-                        <div class="link"><a href="{% url "home" %}"><i class="fa-solid fa-book"></i> Colles</a></div>
-                    </div>
-                </div>
-            </div>
-
-            <div class="navbar">
-                <div class="block">
             {% if request.user.is_authenticated %}
-                        <a href="{% url "colloscope.dashboard" %}">
-                            <div class="link"><i class="fa-solid fa-rocket"></i> Tableau de bord</div>
-                        </a>
-                        <a href="{% url "colloscope.table" %}">
-                            <div class="link"><i class="fa-solid fa-calendar"></i> Colloscope</div>
-                        </a>
-                        <a href="{% url "colloscope.marketplace" %}">
-                            <div class="link"><i class="fa-solid fa-shop"></i> Marketplace</div>
-                        </a>
+            <div class="bandeau">
+                Vous êtes connecté avec le compte <b>{{ user.username }}</b>.
+                {% if request.session.profil == "etudiant" %}
+                    Profil actuel : étudiant.
+                {% elif request.session.profil == "colleur" %}
+                    Profil actuel : colleur.
+                {% else %}
+                    Pas de profil.
                 {% endif %}
-                </div>
-                <div class="block">
-                    {% if request.user.is_authenticated %}
                 <form action="{% url 'logout' %}" method="post">
                     {% csrf_token %}
-                        <button class="link" type="submit" href="{% url "login" %}">
-                            <i class="fa-solid fa-right-from-bracket"></i> Se déconnecter
-                        </button>
+                    <button type="submit">Se déconnecter</button>
                 </form>
-                    {% else %}
-                        <a href="{% url "login" %}">
-                            <div class="link right"><i class="fa-solid fa-right-from-bracket"></i> Se connecter</div>
-                        </a>
+            </div>
             {% endif %}
-                </div>
-            </div>
 
             {% block header %}{% endblock header %}
         </header>
@@ -79,6 +33,6 @@
             {% block main %}{% endblock main %}
         </main>
         <footer>
-            {% block footer %}&copy; colles.mp2i-vms.fr 2024 - <a href="https://git.mp2i-vms.fr/mp2i-vms/kholles-web" target="_blank">Code source</a> - <a href="https://www.gnu.org/licenses/agpl-3.0.html" target="_blank">Licence GNU AGPL v3 or later</a>{% endblock footer %}
+            {% block footer %}&copy; colles.mp2i-vms.fr 2024{% endblock footer %}
         </footer>
     </body>

templates/registration/login.html

@@ -19,7 +19,7 @@
     {% endif %}
 {% endif %}
 
-<form class="login" method="post" action="{% url 'login' %}">
+<form method="post" action="{% url 'login' %}">
 {% csrf_token %}
 <table>
 <tr>
@@ -31,7 +31,8 @@
     <td>{{ form.password }}</td>
 </tr>
 </table>
-    <button type="submit">Se connecter</button>
+
+<input type="submit" value="Se connecter">
 <input type="hidden" name="next" value="{{ next }}">
 </form>