mp2i-vms.fr
365 lines
12 KiB
Python
365 lines
12 KiB
Python
from datetime import date, datetime, timedelta
|
|
from pytz import timezone
|
|
|
|
from django.db import models
|
|
from django.db.models import F, Q
|
|
from django.contrib.auth.models import User
|
|
|
|
|
|
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 Lycee(models.Model):
|
|
uai = models.CharField(max_length=10)
|
|
libelle = models.CharField(max_length=100)
|
|
vacances = models.CharField(max_length=1)
|
|
|
|
def __str__(self):
|
|
return self.libelle
|
|
|
|
|
|
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 no_semaine(self, jour):
|
|
"""
|
|
Entrées :
|
|
- self
|
|
- jour (datetime.date)
|
|
|
|
Sortie :
|
|
- 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.lycee.vacances
|
|
vacances = calendrier[zone]
|
|
jour0 = self.jour_zero
|
|
|
|
n = 1 + ((jour - jour0).days)//7
|
|
for debut, fin in vacances:
|
|
if jour > debut:
|
|
n -= round( ( fin - debut )/timedelta(weeks=1) )
|
|
return n
|
|
|
|
def no_aujourdhui(self):
|
|
"""
|
|
Entrée:
|
|
- self
|
|
|
|
Sortie:
|
|
- Le numéro de la semaine courante
|
|
"""
|
|
|
|
return self.no_semaine(date.today())
|
|
|
|
|
|
def date_debut_sem(self, n):
|
|
"""
|
|
Entrée:
|
|
- self
|
|
- n (int) <-> numéro de semaine
|
|
|
|
Sortie:
|
|
- Le date du lundi de la semaine n
|
|
"""
|
|
|
|
zone = self.lycee.vacances
|
|
vacances = calendrier[zone]
|
|
jour0 = self.jour_zero
|
|
|
|
jour = jour0 + (n-1) * timedelta(weeks=1)
|
|
|
|
for debut, fin in vacances:
|
|
if jour >= debut:
|
|
jour += round( (fin - debut)/timedelta(weeks=1) )*timedelta(weeks=1)
|
|
|
|
return jour
|
|
|
|
def periode(self, jour):
|
|
"""
|
|
Entrées :
|
|
- self
|
|
- jour (datetime.date)
|
|
|
|
Sortie :
|
|
- La période (si elle existe et est unique) contenant jour
|
|
|
|
Exceptions:
|
|
- Le jour n'est pas dans une période
|
|
- Le jour est au chevauchement de deux périodes
|
|
"""
|
|
return Periode.objects.get(classe=self, debut__lte=jour, fin__gte=jour)
|
|
|
|
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 Periode.objects \
|
|
.filter(classe=self, fin__gte=date.today()) \
|
|
.order_by("-debut") \
|
|
.first()
|
|
|
|
def __str__(self):
|
|
return f"{self.libelle} ({self.lycee.libelle})"
|
|
|
|
|
|
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 = ["debut"]
|
|
|
|
def range_semaines(self):
|
|
"""
|
|
Entrée:
|
|
- self
|
|
|
|
Sortie:
|
|
- Un range des numéros de semaine
|
|
"""
|
|
return range(self.classe.no_semaine(self.debut), self.classe.no_semaine(self.fin)+1)
|
|
|
|
def query_rotations(self):
|
|
return Rotation.objects.filter(creneau__periode=self)
|
|
|
|
|
|
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)
|
|
|
|
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.libelle
|
|
|
|
|
|
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.libelle
|
|
|
|
def get_colles(self):
|
|
return Rotation.objects.filter(groupes=self).order_by("date")
|
|
|
|
def get_colles_par_sem(self):
|
|
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_flat.filter(date__gte=lundi, date__lt=lundi+timedelta(weeks=1)))
|
|
for sem, lundi in semaines
|
|
]
|
|
|
|
|
|
class Etudiant(models.Model):
|
|
class Meta:
|
|
ordering=["classe", "nom", "prenom"]
|
|
|
|
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 appartient(self, groupe):
|
|
"""
|
|
Renvoie si self appartient au groupe.
|
|
"""
|
|
return groupe.membres.contains(self)
|
|
|
|
def groupe_du_critere(self, periode, critere):
|
|
"""
|
|
Renvoie le groupe du critère auquel self appartient.
|
|
"""
|
|
if isinstance(critere, str):
|
|
critere = Critere.objects.get(periode=periode, libelle=critere)
|
|
|
|
return Appartenance.objects.get(groupe__periode=periode, etudiant=self, groupe__critere=critere).groupe
|
|
|
|
def groupe_de_colle(self, periode):
|
|
"""
|
|
Renvoie le groupe de colle de self pendant periode.
|
|
"""
|
|
return self.groupe_du_critere(periode, "colle")
|
|
|
|
def __str__(self):
|
|
return f"{self.prenom} {self.nom}"
|
|
|
|
|
|
class Appartenance(models.Model):
|
|
etudiant = models.ForeignKey(Etudiant, on_delete=models.CASCADE)
|
|
groupe = models.ForeignKey(Groupe, on_delete=models.CASCADE)
|
|
|
|
|
|
class Colleur(models.Model):
|
|
civilite = models.CharField(max_length=1)
|
|
nom = models.CharField(max_length=100)
|
|
|
|
def __str__(self):
|
|
if self.civilite == "M":
|
|
return f"M. {self.nom}"
|
|
else:
|
|
return f"Mme {self.nom}"
|
|
|
|
def get_classes(self):
|
|
return (x.periode.classe for x in Creneau.objects.filter(colleur=self).select_related("periode__classe"))
|
|
|
|
|
|
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)
|
|
est_colle = models.BooleanField()
|
|
capacite = models.IntegerField()
|
|
|
|
def __str__(self):
|
|
jours = ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
|
|
|
|
return f"Colle {self.matiere} avec {self.colleur} {jours[self.jour]} {self.heure}"
|
|
|
|
|
|
class Rotation(models.Model):
|
|
creneau = models.ForeignKey(Creneau, on_delete=models.CASCADE)
|
|
groupes = models.ManyToManyField(Groupe)
|
|
date = models.DateField()
|
|
|
|
def groupe_initial(self):
|
|
"""
|
|
Renvoie les étudiants inscrits à la colle sans prendre en compte les amendements.
|
|
"""
|
|
return Etudiant.objects.filter(id__in=Appartenance.objects.filter(groupe__in=self.groupes.all()))
|
|
|
|
def groupe_effectif(self):
|
|
"""
|
|
Renvoie les étudiants inscrits à la colle en tenant compte des amendements.
|
|
"""
|
|
amendements=Amendement.objects.filter(rotation=self)
|
|
|
|
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 effectif(self):
|
|
"""
|
|
Renvoie le nombre d'étudiants inscrits à la colle en tenant compte des amendements.
|
|
"""
|
|
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))
|
|
|
|
return n_base + n_plus - n_moins
|
|
|
|
def est_pleine(self):
|
|
"""
|
|
Renvoie si la colle est pleine.
|
|
"""
|
|
eff = self.effectif()
|
|
return eff>=self.creneau.capacite
|
|
|
|
def est_modifiee(self):
|
|
"""
|
|
Renvoie si la colle a été amendée.
|
|
"""
|
|
return Amendement.objects.filter(rotation=self).exists()
|
|
|
|
def amender(self, etudiant, est_positif):
|
|
"""
|
|
Amende la colle en (des)inscrivant etudiant à la colle self, selon est_positif.
|
|
"""
|
|
|
|
if Amendement.objects.filter(rotation=self, etudiant=etudiant, est_positif=est_positif).exists():
|
|
raise Exception("Duplication")
|
|
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 est_positif and all(not etudiant.appartient(groupe) for groupe in self.groupes.all()):
|
|
raise Exception("Vous n'êtes pas dans le groupe")
|
|
elif est_positif and self.est_pleine():
|
|
raise Exception("Capacité dépassée")
|
|
else:
|
|
amendement = Amendement(rotation=self, etudiant=etudiant, est_positif=est_positif)
|
|
amendement.save()
|
|
|
|
def __str__(self):
|
|
return f"{self.creneau} le {self.date} avec groupes {'+'.join(str(groupe) for groupe in self.groupes.all())}"
|
|
|
|
|
|
def datetime(self):
|
|
return datetime.combine( self.date, self.creneau.heure, tzinfo=timezone("Europe/Paris") )
|
|
|
|
|
|
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.utilisateur} : {self.etudiant} ; {self.colleur}"
|
|
|
|
@staticmethod
|
|
def from_request(request, preprocess=lambda query: query):
|
|
user = request.user
|
|
session = request.session
|
|
|
|
match session.get("profil"):
|
|
case "etudiant":
|
|
profil = preprocess(Profil.objects.filter(utilisateur=user)).get()
|
|
return profil.etudiant
|
|
case "colleur":
|
|
profil = preprocess(Profil.objects.filter(utilisateur=user)).get()
|
|
return profil.colleur
|
|
case _:
|
|
raise ValueError("profil non choisi")
|