[frontend] Timezone and date format for date display and datetime pickers

inginious/common/custom_yaml.py

@@ -5,6 +5,8 @@
 
 """ A custom YAML based on PyYAML, that provides Ordered Dicts """
 # Most ideas for this implementation comes from http://stackoverflow.com/questions/5121931/in-python-how-can-you-load-yaml-mappings-as-ordereddicts
+from datetime import datetime
+
 from collections import OrderedDict
 
 import yaml as original_yaml
@@ -74,10 +76,16 @@ def _long_str_representer(dumper, data):
     def _default_representer(dumper, data):
         return _long_str_representer(dumper, str(data))
 
+    def _timestamp_representer(dumper, data):
+        date = data.strftime("%4Y-%m-%dT%H:%M:%SZ")
+        return dumper.represent_scalar('tag:yaml.org,2002:timestamp', date)
+
+
     OrderedDumper.add_representer(str, _long_str_representer)
     OrderedDumper.add_representer(str, _long_str_representer)
     OrderedDumper.add_representer(OrderedDict, _dict_representer)
     OrderedDumper.add_representer(None, _default_representer)
+    OrderedDumper.add_representer(datetime, _timestamp_representer)
 
     s = original_yaml.dump(data, stream, OrderedDumper, encoding='utf-8', allow_unicode=True, default_flow_style=False, indent=4, **kwds)
 

inginious/frontend/accessible_time.py

@@ -5,21 +5,31 @@
 
 """ Contains AccessibleTime, class that represents the period of time when a course/task is accessible """
 
-from datetime import datetime
+from datetime import datetime, timezone
 
 
 def parse_date(date, default=None):
-    """ Parse a valid date """
+    """
+        Parse a valid date
+        :param date: string, date to parse
+        :param default: datetime object, optionnal, default value to return if date is empty
+        :return: datetime object of the parsed date
+    """
     if date == "":
         if default is not None:
             return default
         else:
-            raise Exception("Unknown format for " + date)
+            raise Exception("Empty date given to AccessibleTime")
 
-    for format_type in ["%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%d %H", "%Y-%m-%d", "%d/%m/%Y %H:%M:%S", "%d/%m/%Y %H:%M", "%d/%m/%Y %H",
-                        "%d/%m/%Y"]:
+    if date == "0001-01-01 00:00:00":
+        return datetime.min.replace(tzinfo=timezone.utc)
+    if date == "9999-12-31 23:59:59":
+        return datetime.max.replace(microsecond=0, tzinfo=timezone.utc)
+
+    for format_type in ["%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%d %H", "%Y-%m-%d", "%d/%m/%Y %H:%M:%S",
+                        "%d/%m/%Y %H:%M", "%d/%m/%Y %H", "%d/%m/%Y"]:
         try:
-            return datetime.strptime(date, format_type)
+            return datetime.strptime(date, format_type).replace(tzinfo=timezone.utc)
         except ValueError:
             pass
     raise Exception("Unknown format for " + date)
@@ -28,55 +38,78 @@ def parse_date(date, default=None):
 class AccessibleTime(object):
     """ represents the period of time when a course/task is accessible """
 
-    def __init__(self, val=None):
+    def __init__(self, period):
         """
-            Parse a string/a boolean to get the correct time period.
-            Correct values for val:
-            True (task always open)
-            False (task always closed)
-            2014-07-16 11:24:00 (task is open from 2014-07-16 at 11:24:00)
-            2014-07-16 (task is open from 2014-07-16)
-            / 2014-07-16 11:24:00 (task is only open before the 2014-07-16 at 11:24:00)
-            / 2014-07-16 (task is only open before the 2014-07-16)
-            2014-07-16 11:24:00 / 2014-07-20 11:24:00 (task is open from 2014-07-16 11:24:00 and will be closed the 2014-07-20 at 11:24:00)
-            2014-07-16 / 2014-07-20 11:24:00 (...)
-            2014-07-16 11:24:00 / 2014-07-20 (...)
-            2014-07-16 / 2014-07-20 (...)
-            2014-07-16 11:24:00 / 2014-07-20 11:24:00 / 2014-07-20 12:24:00 (task is open from 2014-07-16 11:24:00, has a soft deadline set at 2014-07-20 11:24:00 and will be closed the 2014-07-20 at 11:24:00)
-            2014-07-16 / 2014-07-20 11:24:00 / 2014-07-21 (...)
-            2014-07-16 / 2014-07-20 / 2014-07-21 (...)
+            Used to represent the period of time when a course/task is accessible.
+            :param period : dict, contains start, end and optionally soft_end as datetime objects or strings
+                            (for frontend use through templates).
+                            Can be a boolean, None or string if using the legacy format "start/soft_end/end"
         """
-        if val is None or val == "" or val is True:
-            self._val = [datetime.min, datetime.max]
-            self._soft_end = datetime.max
-        elif val == False:
-            self._val = [datetime.max, datetime.max]
-            self._soft_end = datetime.max
-        else:  # str
-            values = val.split("/")
-            if len(values) == 1:
-                self._val = [parse_date(values[0].strip(), datetime.min), datetime.max]
-                self._soft_end = datetime.max
-            elif len(values) == 2:
-                # Has start time and hard deadline
-                self._val = [parse_date(values[0].strip(), datetime.min), parse_date(values[1].strip(), datetime.max)]
-                self._soft_end = self._val[1]
-            else:
-                # Has start time, soft deadline and hard deadline
-                self._val = [parse_date(values[0].strip(), datetime.min), parse_date(values[2].strip(), datetime.max)]
-                self._soft_end = parse_date(values[1].strip(), datetime.max)
 
-        # Having a soft deadline after the hard one does not make sense, make soft-deadline same as hard-deadline
-        if self._soft_end > self._val[1]:
-            self._soft_end = self._val[1]
+        self.max = datetime.max.replace(microsecond=0, tzinfo=timezone.utc)
+        self.min = datetime.min.replace(tzinfo=timezone.utc)
 
+        if not isinstance(period, (dict, str, bool, type(None))):  # add None check
+            raise Exception("Wrong period given to AccessibleTime")
+
+        # if legacy format (start/soft_end/end string, empty string, bool)
+        if isinstance(period, str):
+            period = self.legacy_string_structure_to_dict(period)
+        if isinstance(period, (bool, type(None))):
+            if period is (True or None):
+                period = {"start": self.min, "soft_end": self.max, "end": self.max}
+            else:
+                period = {"start": self.max, "soft_end": self.max, "end": self.max}
+
+        # transforming strings into datetimes in case AccessibleTime is used in html files, where datetime objects are not supported
+        for key, date in period.items():
+            if not isinstance(date, (datetime, str)):
+                raise Exception("Wrong period given to AccessibleTime")
+            if isinstance(date, str):
+                period[key] = parse_date(date)
+
+        self._start = period["start"].replace(tzinfo=timezone.utc) if period["start"] not in [self.min, self.max] else period["start"]
+        self._end = period["end"].replace(tzinfo=timezone.utc) if period["end"] != self.max else period["end"]
+        if "soft_end" in period:
+            if period["soft_end"].replace(tzinfo=timezone.utc) == self.max:
+                self._soft_end = self.max
+            else:
+                soft_end = min(period["soft_end"], period["end"])
+                self._soft_end = soft_end.replace(tzinfo=timezone.utc)
+
+    def legacy_string_structure_to_dict(self, legacy_date):
+        """
+            Convert the legacy string structure to a dictionary. The legacy structure follows "start/soft_end/end" for
+            tasks or "start/end" for courses with some of the values being optional. Sometimes only a start date is
+            given as a string (ex: "start//end", "start//", "//end", "start/end", "start", "/end", ...).
+            :param legacy_date: string, legacy date structure
+            :return period: dict, containing the start, soft_end and end as strings
+        """
+        period = {}
+
+        values = legacy_date.split("/")
+        if len(values) == 1:
+            period["start"] = parse_date(values[0].strip(), self.min)
+            period["soft_end"] = self.max
+            period["end"] = self.max
+        elif len(values) == 2:
+            # Has start time and hard deadline
+            period["start"] = parse_date(values[0].strip(), self.min)
+            period["end"] = parse_date(values[1].strip(), self.max)
+            period["soft_end"] = period["end"]
+        else:
+            # Has start time, soft deadline and hard deadline
+            period["start"] = parse_date(values[0].strip(), self.min)
+            period["soft_end"] = parse_date(values[1].strip(), self.max)
+            period["end"] = parse_date(values[2].strip(), self.max)
+        return period
 
     def before_start(self, when=None):
         """ Returns True if the task/course is not yet accessible """
         if when is None:
-            when = datetime.now()
+            when = datetime.now(timezone.utc)
 
-        return self._val[0] > when
+        return self._start > when
 
     def after_start(self, when=None):
         """ Returns True if the task/course is or have been accessible in the past """
@@ -85,56 +118,71 @@ def after_start(self, when=None):
     def is_open(self, when=None):
         """ Returns True if the course/task is still open """
         if when is None:
-            when = datetime.now()
+            when = datetime.now(timezone.utc)
 
-        return self._val[0] <= when and when <= self._val[1]
+        return self._start <= when <= self._end
 
     def is_open_with_soft_deadline(self, when=None):
         """ Returns True if the course/task is still open with the soft deadline """
         if when is None:
-            when = datetime.now()
+            when = datetime.now(timezone.utc)
 
-        return self._val[0] <= when and when <= self._soft_end
+        return self._start <= when <= self._soft_end
 
     def is_always_accessible(self):
         """ Returns true if the course/task is always accessible """
-        return self._val[0] == datetime.min and self._val[1] == datetime.max
+        return self._start == self.min and self._end == self.max
 
     def is_never_accessible(self):
         """ Returns true if the course/task is never accessible """
-        return self._val[0] == datetime.max and self._val[1] == datetime.max
+        return self._start == self.max and self._end == self.max
 
     def get_std_start_date(self):
-        """ If the date is custom, return the start datetime with the format %Y-%m-%d %H:%M:%S. Else, returns "". """
-        first, _ = self._val
-        if first != datetime.min and first != datetime.max:
-            return first.strftime("%Y-%m-%d %H:%M:%S")
-        else:
-            return ""
+        """ If the date is custom, return the start datetime with the format %4Y-%m-%d %H:%M:%S. Else, returns "". """
+        if self._start not in [self.min, self.max]:
+            return self._start.strftime("%4Y-%m-%d %H:%M:%S")
+        return ""
 
     def get_std_end_date(self):
-        """ If the date is custom, return the end datetime with the format %Y-%m-%d %H:%M:%S. Else, returns "". """
-        _, second = self._val
-        if second != datetime.max:
-            return second.strftime("%Y-%m-%d %H:%M:%S")
-        else:
-            return ""
+        """ If the date is custom, return the end datetime with the format %4Y-%m-%d %H:%M:%S. Else, returns "". """
+        if self._end != self.max:
+            return self._end.strftime("%4Y-%m-%d %H:%M:%S")
+        return ""
 
     def get_std_soft_end_date(self):
-        """ If the date is custom, return the soft datetime with the format %Y-%m-%d %H:%M:%S. Else, returns "". """
-        if self._soft_end != datetime.max:
-            return self._soft_end.strftime("%Y-%m-%d %H:%M:%S")
-        else:
-            return ""
+        """ If the date is custom, return the soft datetime with the format %4Y-%m-%d %H:%M:%S. Else, returns "". """
+        if self._soft_end != self.max:
+            return self._soft_end.strftime("%4Y-%m-%d %H:%M:%S")
+        return ""
 
     def get_start_date(self):
         """ Return a datetime object, representing the date when the task/course become accessible """
-        return self._val[0]
+        return self._start
 
     def get_end_date(self):
         """ Return a datetime object, representing the deadline for accessibility """
-        return self._val[1]
+        return self._end
 
     def get_soft_end_date(self):
         """ Return a datetime object, representing the soft deadline for accessibility """
         return self._soft_end
+
+    def string_date(self, date):
+        """ Returns the date as a string """
+        return date.strftime("%4Y-%m-%d %H:%M:%S")
+
+    def get_string_dict(self):
+        """ Returns a dictionary with the start, end and soft_end as strings """
+        return {
+            "start": self.string_date(self._start),
+            "soft_end": self.string_date(self._soft_end),
+            "end": self.string_date(self._end)
+        }
+
+    def string_max(self):
+        """ Returns the max date as a string """
+        return self.string_date(self.max)
+
+    def string_min(self):
+        """ Returns the min date as a string """
+        return self.string_date(self.min)