# Copyright (C) 2017-2019 Alban Gruin # # celcatsanitizer is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published # by the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # celcatsanitizer is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with celcatsanitizer. If not, see . from functools import reduce from django.db import models from django.db.models import Count, Manager, OuterRef, Q, Subquery from django.db.models.functions import ExtractWeek, ExtractYear from django.utils import timezone from django.utils.text import slugify from .utils import parse_group class SlugModel(models.Model): def save(self, *args, **kwargs): if not self.slug: self.slug = slugify(self.name) super(SlugModel, self).save(*args, **kwargs) class Meta: abstract = True class Year(SlugModel): name = models.CharField(max_length=16, verbose_name="année") slug = models.SlugField(max_length=16, unique=True, default="") def __str__(self): return self.name class Meta: verbose_name = "année" verbose_name_plural = "années" class Source(models.Model): url = models.URLField(max_length=255, verbose_name="URL") metadata = models.CharField(max_length=256, verbose_name="Métadonnée", blank=True, null=True) last_update_date = models.DateTimeField(null=True, blank=True, verbose_name="dernière mise à jour" " Celcat") def __str__(self): return "{}, {}".format(self.url, self.metadata) @property def formatted_timetables(self): return ", ".join([str(timetable) for timetable in self.timetables.all()]) class Meta: unique_together = (("url", "metadata",),) verbose_name = "source d’emploi du temps" verbose_name_plural = "sources d’emploi du temps" class TimetableManager(Manager): def get_queryset(self): return super(Manager, self).get_queryset().select_related("year") class Timetable(SlugModel): objects = TimetableManager() year = models.ForeignKey(Year, on_delete=models.CASCADE, verbose_name="année") name = models.CharField(max_length=64, verbose_name="nom") slug = models.SlugField(max_length=64, default="") source = models.ForeignKey(Source, on_delete=models.CASCADE, verbose_name="source", related_name="timetables") def __str__(self): return self.year.name + " " + self.name class Meta: unique_together = (("year", "name"), ("year", "slug"),) verbose_name = "emploi du temps" verbose_name_plural = "emplois du temps" class GroupManager(Manager): def get_parents(self, group): groups_criteria = reduce(lambda x, y: x | y, [Q(subgroup=group.subgroup[:i]) for i in range(1, len(group.subgroup) + 1)], Q(subgroup="")) return self.get_queryset().filter(groups_criteria, Q(semester=None) | Q(semester=group.semester), mention=group.mention, source=group.source) def get_relevant_groups(self, start, **criteria): courses = Course.objects.filter(groups=OuterRef("pk"), begin__gte=start) \ .only("pk")[:1] return self.get_queryset() \ .annotate(c=Subquery(courses, output_field=models.IntegerField())) \ .filter(c__isnull=False, **criteria).order_by("name") class Group(SlugModel): objects = GroupManager() name = models.CharField(max_length=255, verbose_name="nom") celcat_name = models.CharField(max_length=255, verbose_name="nom dans Celcat") source = models.ForeignKey(Source, on_delete=models.CASCADE, verbose_name="source d’emploi du temps") mention = models.CharField(max_length=128) semester = models.IntegerField(verbose_name="semestre", null=True) subgroup = models.CharField(max_length=16, verbose_name="sous-groupe", default="") slug = models.SlugField(max_length=64, default="") hidden = models.BooleanField(verbose_name="caché", default=False) def corresponds_to(self, mention, semester, subgroup): subgroup_corresponds = True if self.subgroup is not None and subgroup is not None: subgroup_corresponds = self.subgroup.startswith(subgroup) return (self.mention.startswith(mention) or mention.startswith(self.mention)) and \ (self.semester == semester or semester is None) and \ subgroup_corresponds @property def group_info(self): return self.mention, self.semester, self.subgroup def __str__(self): return self.name def save(self, *args, **kwargs): if self.name == "": self.name = self.celcat_name self.mention, self.semester, self.subgroup = parse_group(self.name) if self.subgroup is None: self.subgroup = "" super(Group, self).save(*args, **kwargs) class Meta: index_together = ("mention", "semester", "subgroup",) unique_together = (("name", "source",), ("celcat_name", "source",), ("slug", "source",),) verbose_name = "groupe" verbose_name_plural = "groupes" class RoomManager(Manager): def qsjps(self, begin, end): # On récupère la liste des cours qui commencent avant la fin # de l’intervalle sélectionné et qui terminent après le début # de l’intervalle, c’est-à-dire qu’au moins une partie du # cours se déroule pendant l’intervalle. On récupère ensuite # la liste des salles dans lesquelles se déroulent ces # cours. On exclu les cours n’ayant aucune salle assignée. courses = Course.objects.filter(begin__lt=end, end__gt=begin, rooms__isnull=False) \ .values_list("rooms", flat=True) # On sélectionne ensuite les salles qui ne sont pas dans la # liste récupérée plus haut, et on les trie par leur nom. return self.get_queryset().exclude(pk__in=courses).order_by("name") class Room(SlugModel): objects = RoomManager() name = models.CharField(max_length=255, unique=True, verbose_name="nom") slug = models.SlugField(max_length=64, default="", unique=True) def __str__(self): return self.name class Meta: verbose_name = "salle" verbose_name_plural = "salles" class Module(SlugModel): name = models.CharField(max_length=255, unique=True, verbose_name="nom") slug = models.SlugField(max_length=64, default="", unique=True) def __str__(self): return self.name class Meta: verbose_name = "module" verbose_name_plural = "modules" class CourseManager(Manager): def get_courses(self, obj, **criteria): qs = self.get_queryset() if isinstance(obj, Group): qs = qs.filter( groups__in=Group.objects.get_parents(obj), **criteria) \ .prefetch_related("rooms") elif isinstance(obj, Room): qs = qs.filter(rooms=obj, **criteria) \ .prefetch_related("rooms", "groups") else: raise(TypeError, "obj must be a Group or a Room") return qs.order_by("begin") def get_weeks(self, **criteria): return self.get_queryset() \ .filter(**criteria) \ .order_by("groups__name", "year", "week") \ .annotate(year=ExtractYear("begin"), week=ExtractWeek("begin")) \ .values("groups__mention", "groups__semester", "groups__subgroup", "year", "week") \ .annotate(c=Count("*")) class Course(models.Model): objects = CourseManager() name = models.CharField(max_length=511, verbose_name="nom", default="Sans nom") type_ = models.CharField(name="type", max_length=255, verbose_name="type de cours", null=True) source = models.ForeignKey(Source, on_delete=models.CASCADE, verbose_name="emploi du temps") notes = models.TextField(verbose_name="remarques", blank=True, null=True) groups = models.ManyToManyField(Group, verbose_name="groupes") rooms = models.ManyToManyField(Room, verbose_name="salles") begin = models.DateTimeField(verbose_name="début du cours", db_index=True) end = models.DateTimeField(verbose_name="fin du cours") last_update = models.DateTimeField(verbose_name="dernière mise à jour", default=timezone.now) celcat_id = models.CharField(max_length=64, verbose_name="ID Celcat", null=True) module = models.ForeignKey(Module, on_delete=models.SET_NULL, null=True) buggy = models.BooleanField(verbose_name="Bogué", default=False) def __str__(self): return self.name def save(self, *args, **kwargs): if self.type is not None: self.type = self.type.replace("COURS", "cours") self.type = self.type.replace("REUNION", "réunion") self.type = self.type.replace("RENCONTRE", "rencontre") if self.name is not None: self.name = self.name.split("(")[0].strip() super(Course, self).save(*args, **kwargs) class Meta: verbose_name = "cours" verbose_name_plural = "cours"