mp2i-vms.fr
266 lines
8.9 KiB
Python
266 lines
8.9 KiB
Python
from math import ceil
|
|
from datetime import date, datetime, timedelta
|
|
|
|
from django.db import models
|
|
from django.db.models import F, Q
|
|
|
|
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) ),
|
|
]
|
|
}
|
|
|
|
class Lycee(models.Model):
|
|
uai = models.CharField(max_length=10)
|
|
libelle = models.CharField(max_length=100)
|
|
vacances = models.CharField(max_length=1)
|
|
|
|
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.classe.lycee.vacances
|
|
vacances = calendrier[zone]
|
|
jour0 = self.classe.jour_zero
|
|
|
|
n = 1 + ((jour - jour0).days)//7
|
|
for debut, fin in vacances:
|
|
if jour > debut:
|
|
n -= 2
|
|
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.classe.lycee.vacances
|
|
vacances = calendrier[zone]
|
|
jour0 = self.classe.jour_zero
|
|
|
|
jour = jour0 + (n-1) * timedelta(weeks=1)
|
|
|
|
for debut, _ in vacances:
|
|
if jour >= debut:
|
|
jour += 2*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)
|
|
|
|
|
|
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)
|
|
|
|
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 Critere(models.Model):
|
|
periode = models.ForeignKey(Periode, on_delete=models.CASCADE)
|
|
libelle = 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)
|
|
|
|
def membres(self):
|
|
return Etudiant.objects.filter(id__in=Appartenance.objects.filter(groupe=self))
|
|
|
|
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)
|
|
#lv1 = models.ForeignKey(Matiere, on_delete=models.CASCADE)
|
|
#lv2 = models.ForeignKey(Matiere, on_delete=models.CASCADE)
|
|
|
|
def appartient(self, groupe):
|
|
"""
|
|
Renvoie si self appartient au groupe.
|
|
"""
|
|
return Appartenance.objects.filter(etudiant=self, groupe=groupe).exists()
|
|
|
|
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")
|
|
|
|
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)
|
|
|
|
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()
|
|
|
|
class Rotation(models.Model):
|
|
creneau = models.ForeignKey(Creneau, on_delete=models.CASCADE)
|
|
groupes = models.ManyToManyField(Groupe)
|
|
semaine = models.IntegerField()
|
|
|
|
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()) 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()
|
|
|
|
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 Utilisateur(models.Model):
|
|
username = models.CharField(max_length=100)
|
|
password = models.CharField(max_length=300)
|
|
timestamp = models.DateTimeField(auto_now_add=True)
|
|
etudiant = models.ForeignKey(Etudiant, on_delete=models.SET_NULL, null=True)
|
|
colleur = models.ForeignKey(Colleur, on_delete=models.SET_NULL, null=True)
|