rc/aircox
13
1
Fork 1
Code Issues 15 Pull Requests Projects Releases Wiki Activity

work on timezone bug -- still need run checks

Browse Source
This commit is contained in:
bkfox 2017-05-11 16:29:05 +02:00
parent 7a769c168b
commit c39ad228d7
7 changed files with 208 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
aircox/management/commands/streamer.py
View File

@ -84,8 +84,7 @@ class Monitor:
if not current_sound or not current_source: if not current_sound or not current_source:
return return
log = Log.objects.get_for(model = Sound) \ log = Log.objects.get_for(self.station, model = Sound) \
.filter(station = self.station) \
.order_by('date').last() .order_by('date').last()
# only streamed # only streamed
@ -113,7 +112,7 @@ class Monitor:
Log tracks for the given sound (for streamed programs); Called by Log tracks for the given sound (for streamed programs); Called by
self.trace self.trace
""" """
logs = Log.objects.get_for(model = Track) \ logs = Log.objects.get_for(self.station, model = Track) \
.filter(pk__gt = log.pk) .filter(pk__gt = log.pk)
logs = [ log.related_id for log in logs ] logs = [ log.related_id for log in logs ]
@ -160,11 +159,11 @@ class Monitor:
if not self.cancel_timeout: if not self.cancel_timeout:
return return
diffs = Diffusions.objects.get_at().filter( diffs = Diffusions.objects.at(self.station).filter(
type = Diffusion.Type.normal, type = Diffusion.Type.normal,
sound__type = Sound.Type.archive, sound__type = Sound.Type.archive,
) )
logs = station.get_played(models = Diffusion) logs = station.played(models = Diffusion)
date = tz.now() - datetime.timedelta(seconds = self.cancel_timeout) date = tz.now() - datetime.timedelta(seconds = self.cancel_timeout)
for diff in diffs: for diff in diffs:
@ -188,14 +187,14 @@ class Monitor:
station = self.station station = self.station
now = tz.now() now = tz.now()
diff_log = station.get_played(models = Diffusion) \ diff_log = station.played(models = Diffusion) \
.order_by('date').last() .order_by('date').last()
if not diff_log or \ if not diff_log or \
not diff_log.related.is_date_in_range(now): not diff_log.related.is_date_in_range(now):
return None, [] return None, []
# sound has switched? assume it has been (forced to) stopped # sound has switched? assume it has been (forced to) stopped
sounds = station.get_played(models = Sound) \ sounds = station.played(models = Sound) \
.filter(date__gte = diff_log.date) \ .filter(date__gte = diff_log.date) \
.order_by('date') .order_by('date')
@ -228,7 +227,7 @@ class Monitor:
now = tz.now() now = tz.now()
args = {'start__gt': diff.date } if diff else {} args = {'start__gt': diff.date } if diff else {}
diff = Diffusion.objects.get_at(now).filter( diff = Diffusion.objects.at(station, now).filter(
type = Diffusion.Type.normal, type = Diffusion.Type.normal,
sound__type = Sound.Type.archive, sound__type = Sound.Type.archive,
**args **args

201
aircox/models.py
View File

@ -27,7 +27,7 @@ logger = logging.getLogger('aircox.core')
# Abstracts # Abstracts
# #
class RelatedManager(models.Manager): class RelatedManager(models.Manager):
def get_for(self, object = None, model = None): def get_for(self, object = None, model = None, qs = None):
""" """
Return a queryset that filter on the given object or model(s) Return a queryset that filter on the given object or model(s)
@ -37,13 +37,15 @@ class RelatedManager(models.Manager):
if not model and object: if not model and object:
model = type(object) model = type(object)
qs = qs or self
if hasattr(model, '__iter__'): if hasattr(model, '__iter__'):
model = [ ContentType.objects.get_for_model(m).id model = [ ContentType.objects.get_for_model(m).id
for m in model ] for m in model ]
qs = self.filter(related_type__pk__in = model) qs = qs.filter(related_type__pk__in = model)
else: else:
model = ContentType.objects.get_for_model(model) model = ContentType.objects.get_for_model(model)
qs = self.filter(related_type__pk = model.id) qs = qs.filter(related_type__pk = model.id)
if object: if object:
qs = qs.filter(related_id = object.pk) qs = qs.filter(related_id = object.pk)
return qs return qs
@ -224,23 +226,11 @@ class Station(Nameable):
self.__prepare() self.__prepare()
return self.__streamer return self.__streamer
def get_played(self, models, archives = True): def played(self, models, archives = True):
""" """
Return a queryset with log of played elements on this station, Call Log.objects.played for this station
of the given models, ordered by date ascending.
* models: a model or a list of models
* archives: if false, exclude log of diffusion's archives from
the queryset;
""" """
qs = Log.objects.get_for(model = models) \ return Log.objects.played(self, models, archives)
.filter(station = self, type = Log.Type.play)
if not archives and self.dealer:
qs = qs.exclude(
source = self.dealer.id,
related_type = ContentType.objects.get_for_model(Sound)
)
return qs.order_by('date')
@staticmethod @staticmethod
def __mix_logs_and_diff(diffs, logs, count = 0): def __mix_logs_and_diff(diffs, logs, count = 0):
@ -319,16 +309,17 @@ class Station(Nameable):
if not date and not count: if not date and not count:
raise ValueError('at least one argument must be set') raise ValueError('at least one argument must be set')
# FIXME can be a potential source of bug
if date and date > datetime.date.today(): if date and date > datetime.date.today():
return [] return []
logs = Log.objects.get_for(model = Track) \
.filter(station = self)
if date: if date:
logs = logs.filter(date__contains = date) logs = Log.objects.at_for(self, date, model = Track)
diffs = Diffusion.objects.get_at(date) diffs = Diffusion.objects.at(self, date)
else: else:
logs = Log.objects.get_for(self, model = Track)
diffs = Diffusion.objects diffs = Diffusion.objects
logs = logs.filter(station = self)
diffs = diffs.filter(program__station = self) \ diffs = diffs.filter(program__station = self) \
.filter(type = Diffusion.Type.normal) \ .filter(type = Diffusion.Type.normal) \
@ -345,6 +336,11 @@ class Station(Nameable):
super().save(*args, **kwargs) super().save(*args, **kwargs)
class ProgramManager(models.Manager):
def station(self, station, qs = None):
qs = qs or self
return qs.filter(station = station)
class Program(Nameable): class Program(Nameable):
""" """
A Program can either be a Streamed or a Scheduled program. A Program can either be a Streamed or a Scheduled program.
@ -373,6 +369,8 @@ class Program(Nameable):
help_text = _('update later diffusions according to schedule changes') help_text = _('update later diffusions according to schedule changes')
) )
objects = ProgramManager()
@property @property
def path(self): def path(self):
""" """
@ -586,7 +584,7 @@ class Schedule(models.Model):
if self.frequency == Schedule.Frequency.one_on_two: if self.frequency == Schedule.Frequency.one_on_two:
# cf notes in date_of_month # cf notes in date_of_month
diff = utils.as_date(date, False) - utils.as_date(self.date, False) diff = utils.cast_date(date, False) - utils.cast_date(self.date, False)
return not (diff.days % 14) return not (diff.days % 14)
first_of_month = date.replace(day = 1) first_of_month = date.replace(day = 1)
@ -601,14 +599,16 @@ class Schedule(models.Model):
def normalize(self, date): def normalize(self, date):
""" """
Set the time of a datetime to the schedule's one Set the time of a datetime to the schedule's one
Ensure timezone awareness.
""" """
date = date.replace(hour = self.date.hour, minute = self.date.minute, date = tz.datetime(date.year, date.month, date.day,
second = 0) self.date.hour, self.date.minute, 0, 0)
return date if tz.is_aware(date) else tz.make_aware(date) return date if tz.is_aware(date) else tz.make_aware(date)
def dates_of_month(self, date = None): def dates_of_month(self, date = None):
""" """
Return a list with all matching dates of date.month (=today) Return a list with all matching dates of date.month (=today)
Ensure timezone awareness.
""" """
if self.frequency == Schedule.Frequency.ponctual: if self.frequency == Schedule.Frequency.ponctual:
return [] return []
@ -622,10 +622,10 @@ class Schedule(models.Model):
# end of month before the wanted weekday: move one week back # end of month before the wanted weekday: move one week back
if date.weekday() < self.date.weekday(): if date.weekday() < self.date.weekday():
date -= datetime.timedelta(days = 7) date -= tz.timedelta(days = 7)
delta = self.date.weekday() - date.weekday() delta = self.date.weekday() - date.weekday()
date += datetime.timedelta(days = delta) date += tz.timedelta(days = delta)
return [self.normalize(date)] return [self.normalize(date)]
# move to the first day of the month that matches the schedule's weekday # move to the first day of the month that matches the schedule's weekday
@ -639,7 +639,7 @@ class Schedule(models.Model):
dates = [] dates = []
if freq == Schedule.Frequency.one_on_two: if freq == Schedule.Frequency.one_on_two:
# check date base on a diff of dates base on a 14 days delta # check date base on a diff of dates base on a 14 days delta
diff = utils.as_date(date, False) - utils.as_date(self.date, False) diff = utils.cast_date(date, False) - utils.cast_date(self.date, False)
if diff.days % 14: if diff.days % 14:
date += tz.timedelta(days = 7) date += tz.timedelta(days = 7)
@ -716,51 +716,81 @@ class Schedule(models.Model):
class DiffusionManager(models.Manager): class DiffusionManager(models.Manager):
def get_at(self, date = None, next = False): def station(self, station, qs = None):
""" qs = qs or self
Return a queryset of diffusions that have the given date return qs.filter(program__station = station)
in their range.
If date is a datetime.date object, check only against the @staticmethod
date. def __in_range(field, range, field_ = None, reversed = False):
""" """
date = utils.date_or_default(date) Return a kwargs to catch diffusions based on the given field name
if not issubclass(type(date), datetime.datetime): and datetime range.
return self.filter( """
models.Q(start__contains = date) | \ if reversed:
models.Q(end__contains = date) return { field + "__lte": range[1],
(field_ or field) + "__gte": range[0] }
return { field + "__gte" : range[0],
(field_ or field) + "__lte" : range[1] }
def at(self, station, date = None, next = False, qs = None):
"""
Return diffusions occuring at the given date, ordered by +start
If date is a datetime instance, get diffusions that occurs at
the given moment. If date is not a datetime object, it uses
it as a date, and get diffusions that occurs this day.
When date is None, uses tz.now().
When next is true, include diffusions that also occur after
the given moment.
"""
# note: we work with localtime
date = utils.date_or_default(date, keep_type = True)
qs = qs or self
filters = None
if isinstance(date, datetime.datetime):
# use datetime: we want diffusion that occurs around this
# range
range = date, date
filters = self.__in_range('start', range, 'end', True)
if next:
qs = qs.filter(
models.Q(date__gte = date) | models.Q(**filters)
) )
else:
qs = qs.filter(**filters)
else:
# use date: we want diffusions that occurs this day
range = utils.date_range(date)
filters = models.Q(**self.__in_range('start', range)) | \
models.Q(**self.__in_range('end', range))
if next:
# include also diffusions of the next day
filters |= models.Q(start__gte = range[0])
qs = qs.filter(filters)
return self.station(station, qs).order_by('start').distinct()
def after(self, station, date = None, qs = None):
if not date.is_aware():
date = make_aware(date)
if not next:
return self.filter(start__lte = date, end__gte = date) \
.order_by('start')
return self.filter(
models.Q(start__lte = date, end__gte = date) |
models.Q(start__gte = date),
).order_by('start')
def get_after(self, date = None):
""" """
Return a queryset of diffusions that happen after the given Return a queryset of diffusions that happen after the given
date. date.
""" """
date = utils.date_or_default(date) date = utils.date_or_default(date)
return self.filter( return self.station(station, qs).filter(
start__gte = date, start__gte = date,
).order_by('start') ).order_by('start')
def get_before(self, date): def before(self, station, date = None, qs = None):
""" """
Return a queryset of diffusions that finish before the given Return a queryset of diffusions that finish before the given
date. date.
""" """
date = utils.date_or_default(date) date = utils.date_or_default(date)
return self.filter( qs = qs or self
return self.station(station, qs).filter(
end__lte = date, end__lte = date,
).order_by('start') ).order_by('start')
@ -1171,6 +1201,58 @@ class Port (models.Model):
) )
class LogManager(RelatedManager):
def station(self, station, qs = None):
qs = qs or self
return qs.filter(station = station)
def get_for(self, station, *args, **kwargs):
qs = super().get_for(*args, **kwargs)
return self.station(station, qs) if station else qs
def _at(self, date = None, qs = None):
start, end = utils.date_range(date)
qs = qs or self
return qs.filter(date__gte = start,
date__lte = end)
def at(self, station = None, date = None, qs = None):
"""
Return a queryset of logs that have the given date
in their range.
"""
qs = self._at(date, qs)
return self.station(station, qs) if station else qs
def at_for(self, station, date, object = None, model = None, qs = None):
"""
Return a queryset of logs that occured at the given date
for the given model or object.
"""
qs = self.get_for(station, object, model, qs)
return self._at(date, qs)
def played(self, station, models, archives = True):
"""
Return a queryset of the played elements' log for the given
station and model. This queryset is ordered by date ascending
* station: related station
* models: a model or a list of models
* archives: if false, exclude log of diffusion's archives from
the queryset;
"""
qs = self.get_for(station, model = models) \
.filter(type = Log.Type.play)
if not archives and station.dealer:
qs = qs.exclude(
source = station.dealer.id,
related_type = ContentType.objects.get_for_model(Sound)
)
return qs.order_by('date')
class Log(Related): class Log(Related):
""" """
Log sounds and diffusions that are played on the station. Log sounds and diffusions that are played on the station.
@ -1206,14 +1288,14 @@ class Log(Related):
station = models.ForeignKey( station = models.ForeignKey(
Station, Station,
verbose_name = _('station'), verbose_name = _('station'),
help_text = _('station on which the event occured'), help_text = _('related station'),
) )
source = models.CharField( source = models.CharField(
# we use a CharField to avoid loosing logs information if the # we use a CharField to avoid loosing logs information if the
# source is removed # source is removed
_('source'), _('source'),
max_length=64, max_length=64,
help_text = _('source id that make it happen on the station'), help_text = _('identifier of the source related to this log'),
blank = True, null = True, blank = True, null = True,
) )
date = models.DateTimeField( date = models.DateTimeField(
@ -1226,6 +1308,8 @@ class Log(Related):
blank = True, null = True, blank = True, null = True,
) )
objects = LogManager()
@property @property
def end(self): def end(self):
""" """
@ -1260,4 +1344,3 @@ class Log(Related):
) )

4
aircox/signals.py
View File

@ -59,7 +59,7 @@ def schedule_post_saved(sender, instance, created, *args, **kwargs):
delta = instance.date - old_sched.date delta = instance.date - old_sched.date
# update diffusions... # update diffusions...
qs = models.Diffusion.objects.get_after().filter( qs = models.Diffusion.objects.after(instance.program.station).filter(
program = instance.program program = instance.program
) )
for diff in qs: for diff in qs:
@ -84,7 +84,7 @@ def schedule_pre_delete(sender, instance, *args, **kwargs):
frequency = initial['frequency'], frequency = initial['frequency'],
) )
qs = models.Diffusion.objects.get_after().filter( qs = models.Diffusion.objects.after(instance.program.station).filter(
program = instance.program program = instance.program
) )
for diff in qs: for diff in qs:

48
aircox/utils.py
View File

@ -2,25 +2,51 @@ import datetime
import django.utils.timezone as tz import django.utils.timezone as tz
def as_date(date, as_datetime = True): def date_range(date):
""" """
If as_datetime, return the date with time info set to 0; else, return Return a range of datetime for a given day, such as:
a date with date informations of the given date/time. [date, 0:0:0:0; date, 23:59:59:999]
Ensure timezone awareness.
""" """
if as_datetime: date = date_or_default(date)
return date.replace(hour = 0, minute = 0, second = 0, microsecond = 0) range = (
date.replace(hour = 0, minute = 0, second = 0), \
date.replace(hour = 23, minute = 59, second = 59, microsecond = 999)
)
return range
def cast_date(date, to_datetime = True):
"""
Given a date reset its time information and
return it as a date or datetime object.
Ensure timezone awareness.
"""
if to_datetime:
return tz.make_aware(
tz.datetime(date.year, date.month, date.day, 0, 0, 0, 0)
)
return datetime.date(date.year, date.month, date.day) return datetime.date(date.year, date.month, date.day)
def date_or_default(date, no_time = False): def date_or_default(date, reset_time = False, keep_type = False, to_datetime = True):
""" """
Return date or default value (now) if not defined, and remove time info Return datetime or default value (now) if not defined, and remove time info
if date_only is True if reset_time is True.
\param reset_time reset time info to 0
\param keep_type keep the same type of the given date if not None
\param to_datetime force conversion to datetime if not keep_type
Ensure timezone awareness.
""" """
date = date or tz.now() date = date or tz.now()
if no_time: to_datetime = isinstance(date, tz.datetime) if keep_type else to_datetime
return as_date(date)
if isinstance(date, datetime.datetime) and not tz.is_aware(date): if reset_time or not isinstance(date, tz.datetime):
return cast_date(date, to_datetime)
if not tz.is_aware(date):
date = tz.make_aware(date) date = tz.make_aware(date)
return date return date

17
aircox_cms/models.py
View File

@ -696,9 +696,7 @@ class LogsPage(DatedListPage):
station = models.ForeignKey( station = models.ForeignKey(
aircox.models.Station, aircox.models.Station,
verbose_name = _('station'), verbose_name = _('station'),
null = True, help_text = _('(required) related station')
on_delete=models.SET_NULL,
help_text = _('(required) the station on which the logs happened')
) )
age_max = models.IntegerField( age_max = models.IntegerField(
_('maximum age'), _('maximum age'),
@ -756,6 +754,17 @@ class LogsPage(DatedListPage):
class TimetablePage(DatedListPage): class TimetablePage(DatedListPage):
template = 'aircox_cms/dated_list_page.html' template = 'aircox_cms/dated_list_page.html'
station = models.ForeignKey(
aircox.models.Station,
verbose_name = _('station'),
help_text = _('(required) related station')
)
content_panels = DatedListPage.content_panels + [
MultiFieldPanel([
FieldPanel('station'),
], heading=_('Configuration')),
]
class Meta: class Meta:
verbose_name = _('Timetable') verbose_name = _('Timetable')
@ -764,7 +773,7 @@ class TimetablePage(DatedListPage):
def get_queryset(self, request, context): def get_queryset(self, request, context):
diffs = [] diffs = []
for date in context['nav_dates']['dates']: for date in context['nav_dates']['dates']:
items = aircox.models.Diffusion.objects.get_at(date).order_by('start') items = aircox.models.Diffusion.objects.at(self.station, date)
items = [ DiffusionPage.as_item(item) for item in items ] items = [ DiffusionPage.as_item(item) for item in items ]
diffs.append((date, items)) diffs.append((date, items))
return diffs return diffs

7
aircox_cms/sections.py
View File

@ -920,6 +920,11 @@ class SectionTimetable(SectionItem,DatedListBase):
verbose_name = _('Section: Timetable') verbose_name = _('Section: Timetable')
verbose_name_plural = _('Sections: Timetable') verbose_name_plural = _('Sections: Timetable')
station = models.ForeignKey(
aircox.models.Station,
verbose_name = _('station'),
help_text = _('(required) related station')
)
target = models.ForeignKey( target = models.ForeignKey(
'aircox_cms.TimetablePage', 'aircox_cms.TimetablePage',
verbose_name = _('timetable page'), verbose_name = _('timetable page'),
@ -944,7 +949,7 @@ class SectionTimetable(SectionItem,DatedListBase):
from aircox_cms.models import DiffusionPage from aircox_cms.models import DiffusionPage
diffs = [] diffs = []
for date in context['nav_dates']['dates']: for date in context['nav_dates']['dates']:
items = aircox.models.Diffusion.objects.get_at(date).order_by('start') items = aircox.models.Diffusion.objects.at(self.station, date)
items = [ DiffusionPage.as_item(item) for item in items ] items = [ DiffusionPage.as_item(item) for item in items ]
diffs.append((date, items)) diffs.append((date, items))
return diffs return diffs

10
notes.md
View File

@ -40,12 +40,10 @@ cms:
- comments -> remove/edit by the author - comments -> remove/edit by the author
# Timezone shit: # Timezone shit:
Check: - run tests:
- manager/commands: - streamer: dealer & streams hours (to localtime)
- diffusions - diffusions: update & check
- streamer - check in templates
- admin: date printed for diffusion is utc even using localtime => tz.get_current_timezone() stays as UTC
# Instance's TODO # Instance's TODO
- menu_top .sections: - menu_top .sections: