1 files changed, 60 insertions, 18 deletions

diff --git a/management/commands/timetables.py b/management/commands/timetables.py
index 76f0a7c..ff00c8f 100644
--- a/management/commands/timetables.py
+++ b/management/commands/timetables.py
@@ -14,42 +14,80 @@
 #    along with celcatsanitizer.  If not, see <http://www.gnu.org/licenses/>.
 
 import datetime
+import traceback
 
 from django.core.management.base import BaseCommand
 from django.db import transaction
 from django.db.models import Min
-from django.utils import timezone
 
 from edt.models import Course, Timetable
-from edt.utils import get_week
+from edt.utils import get_week, tz_now
 from ._private import delete_courses_in_week, get_events, get_update_date, get_weeks, get_xml
 
 @transaction.atomic
 def process_timetable_week(timetable, soup, weeks_in_soup, force, year=None, week=None):
-    criteria = {}
     if year is not None and week is not None:
         begin, end = get_week(year, week)
-        criteria["begin__gte"] = begin
-        criteria["begin__lt"] = end
 
-    last_update_date = Course.objects.filter(timetable=timetable, **criteria) \
-                                     .aggregate(Min("last_update")) \
-                                     ["last_update__min"]
+    # Si on force la mise à jour, on définit de moment
+    # de la mise à jour au début de la semaine
+    if force and year is not None and week is not None:
+        today = begin
+    elif force:
+        # Si la mise à jour est faite sur tout l’emploi du temps,
+        # alors la date de début est indéfinie.
+        today = None
+    else:
+        today = tz_now()
+
+    # On récupère la mise à jour la plus ancienne dans les cours de l’emploi du temps
+    last_update_date = Course.objects.filter(timetable=timetable)
+
+    if today is not None:
+        # Cette date concerne les éléments commençant à partir d’aujourd’hui si la valeur
+        # n’est pas nulle.
+        last_update_date = last_update_date.filter(begin__gte=today)
+
+    if year is not None and week is not None:
+        # Si jamais on traite une semaine spécifique, on limite les cours sélectionnés
+        # à ceux qui commencent entre le début du traitement et la fin de la semaine
+        last_update_date = last_update_date.filter(begin__lt=end)
+
+    last_update_date = last_update_date.aggregate(Min("last_update")) \
+                       ["last_update__min"]
+
+    # Date de mise à jour de Celcat, utilisée à des fins de statistiques
     new_update_date = get_update_date(soup)
 
+    # On ne fait pas la mise à jour si jamais la dernière date de MàJ est plus récente
+    # que celle indiquée par Celcat.
+    # Attention, le champ last_update de la classe Course représente l’heure à laquelle
+    # le cours a été inséré dans la base de données, et non pas la date indiquée par
+    # Celcat.
     if not force and last_update_date is not None and new_update_date is not None and \
        last_update_date >= new_update_date:
         return
 
     if year is not None and week is not None:
-        delete_courses_in_week(timetable, year, week)
+        # On efface la semaine à partir de maintenant si jamais
+        # on demande le traitement d’une seule semaine
+        delete_courses_in_week(timetable, year, week, today)
     else:
-        Course.objects.filter(timetable=timetable,
-                              begin__gte=min(weeks_in_soup.values())).delete()
-
-    for course in get_events(timetable, soup, weeks_in_soup, year, week):
+        # Sinon, on efface tous les cours à partir de maintenant.
+        # Précisément, on prend la plus grande valeur entre la première semaine
+        # présente dans Celcat et maintenant.
+        delete_from = min(weeks_in_soup.values())
+        if not force:
+            # Si jamais on force la MàJ, on efface tout à partir de la première semaine
+            delete_from = max(delete_from, today)
+        Course.objects.filter(timetable=timetable, begin__gte=delete_from).delete()
+
+    # Tous les cours commençant sur la période traitée
+    # sont parsés, puis enregistrés dans la base de données.
+    for course in get_events(timetable, soup, weeks_in_soup, today, year, week):
         course.save()
 
+    # On renseigne la date de mise à jour de Celcat, à des fins de statistiques
     timetable.last_update_date = new_update_date
     timetable.save()
 
@@ -80,16 +118,16 @@ class Command(BaseCommand):
         if options["all"]:
             weeks = None
         elif options["week"] is None:
-            _, week, day = timezone.now().isocalendar()
+            _, week, day = tz_now().isocalendar()
             if day >= 6:
-                year, week, _ = (timezone.now() + datetime.timedelta(weeks=1)).isocalendar()
+                year, week, _ = (tz_now() + datetime.timedelta(weeks=1)).isocalendar()
             weeks = [week]
         else:
             weeks = options["week"]
 
         if not options["all"]:
             if options["year"] is None and year is None:
-                year = timezone.now().year
+                year = tz_now().year
             elif year is None:
                 year = options["year"][0]
 
@@ -98,9 +136,13 @@ class Command(BaseCommand):
 
             try:
                 process_timetable(timetable, options["force"], year, weeks)
-            except Exception as exc:
+            except KeyboardInterrupt:
+                break
+            except Exception:
                 self.stderr.write(
-                    self.style.ERROR("Failed to process {0}: {1}".format(timetable, exc)))
+                    self.style.ERROR("Failed to process {0}:".format(timetable))
+                )
+                self.stderr.write(self.style.ERROR(traceback.format_exc()))
                 errcount += 1
 
         if errcount == 0: