def default_starts():
when = utils_time.round_datetime(
when=timezone.now(),
precision=appsettings.DEFAULT_STARTS_PRECISION,
rounding=utils.time.ROUND_UP,
)
return when
def generate(self, until=None):
"""
Return a list of datetime objects for event occurrence start and end
times, up to the given ``until`` parameter or up to the configured
``REPEAT_LIMIT`` for unlimited events.
"""
# Get starting datetime just before this event's start date or time
# (must be just before since start & end times are *excluded* by the
# `between` method below)
start_dt = self.start - timedelta(seconds=1)
# Limit `until` to provided or configured maximum, unless event has its
# own `repeat_end` which is always respected.
if until is None:
if self.repeat_end:
until = self.repeat_end
else:
until = timezone.now() + appsettings.REPEAT_LIMIT
# Determine duration to add to each start time
occurrence_duration = self.duration or timedelta(days=1)
# `start_dt` and `until` datetimes are exclusive for our rruleset
# lookup and will not be included
rruleset = self.get_rruleset(until=until)
return (
(start, start + occurrence_duration)
for start in rruleset.between(start_dt, until)
)
def pre_etl(self):
"""
Prepare for ETL, for example, by prefetching other necessary data.
By default, sets self.start_time.
:return:
"""
self.start_time = timezone.now()
return
def pre_etl(self):
"""
Prepare for ETL, for example, by prefetching other necessary data.
By default, sets self.start_time.
:return:
"""
self.start_time = timezone.now()
return
def preview(self, request):
"""
Return a occurrences in JSON format up until the configured limit.
"""
recurrence_rule = request.POST.get('recurrence_rule')
limit = int(request.POST.get('limit', 10))
try:
rruleset = rrule.rrulestr(
recurrence_rule, dtstart=timezone.now(), forceset=True)
except ValueError as e:
data = {
'error': six.text_type(e),
}
else:
data = {
'occurrences': rruleset[:limit]
}
return JsonResponse(data)
def _build_complete_rrule(self, start_dt=None, until=None):
"""
Convert recurrence rule, start datetime and (optional) end datetime
into a full iCAL RRULE spec.
"""
if start_dt is None:
start_dt = self.start
if until is None:
until = self.repeat_end \
or timezone.now() + appsettings.REPEAT_LIMIT
# We assume `recurrence_rule` is always a RRULE repeat spec of the form
# "FREQ=DAILY", "FREQ=WEEKLY", etc?
rrule_spec = "DTSTART:%s" % format_ical_dt(start_dt)
if not self.recurrence_rule:
rrule_spec += "\nRDATE:%s" % format_ical_dt(start_dt)
else:
rrule_spec += "\nRRULE:%s" % self.recurrence_rule
# Apply this event's end repeat
rrule_spec += ";UNTIL=%s" % format_ical_dt(
until - timedelta(seconds=1))
return rrule_spec
def round_datetime(when=None, precision=60, rounding=ROUND_NEAREST):
"""
Round a datetime object to a time that matches the given precision.
when (datetime), default now
The datetime object to be rounded.
precision (int, timedelta, str), default 60
The number of seconds, weekday (MON, TUE, WED, etc.) or timedelta
object to which the datetime object should be rounded.
rounding (str), default ROUND_NEAREST
The rounding method to use (ROUND_DOWN, ROUND_NEAREST, ROUND_UP).
"""
when = when or timezone.now()
weekday = WEEKDAYS.get(precision, WEEKDAYS['MON'])
if precision in WEEKDAYS:
precision = int(timedelta(days=7).total_seconds())
elif isinstance(precision, timedelta):
precision = int(precision.total_seconds())
# Get delta between the beginning of time and the given datetime object.
# If precision is a weekday, the beginning of time must be that same day.
when_min = when.min + timedelta(days=weekday)
if timezone.is_aware(when):
# It doesn't seem to be possible to localise `datetime.min` without
# raising `OverflowError`, so create a timezone aware object manually.
when_min = datetime(tzinfo=when.tzinfo, *when_min.timetuple()[:3])
delta = when - when_min
remainder = int(delta.total_seconds()) % precision
# First round down and strip microseconds.
when -= timedelta(seconds=remainder, microseconds=when.microsecond)
# Then add precision to round up.
if rounding == ROUND_UP or (rounding == ROUND_NEAREST
and remainder >= precision / 2):
when += timedelta(seconds=precision)
return when
def round_datetime(when=None, precision=60, rounding=ROUND_NEAREST):
"""
Round a datetime object to a time that matches the given precision.
when (datetime), default now
The datetime object to be rounded.
precision (int, timedelta, str), default 60
The number of seconds, weekday (MON, TUE, WED, etc.) or timedelta
object to which the datetime object should be rounded.
rounding (str), default ROUND_NEAREST
The rounding method to use (ROUND_DOWN, ROUND_NEAREST, ROUND_UP).
"""
when = when or timezone.now()
weekday = WEEKDAYS.get(precision, WEEKDAYS['MON'])
if precision in WEEKDAYS:
precision = int(timedelta(days=7).total_seconds())
elif isinstance(precision, timedelta):
precision = int(precision.total_seconds())
# Get delta between the beginning of time and the given datetime object.
# If precision is a weekday, the beginning of time must be that same day.
when_min = when.min + timedelta(days=weekday)
if timezone.is_aware(when):
# It doesn't seem to be possible to localise `datetime.min` without
# raising `OverflowError`, so create a timezone aware object manually.
when_min = datetime(tzinfo=when.tzinfo, *when_min.timetuple()[:3])
delta = when - when_min
remainder = int(delta.total_seconds()) % precision
# First round down and strip microseconds.
when -= timedelta(seconds=remainder, microseconds=when.microsecond)
# Then add precision to round up.
if rounding == ROUND_UP or (
rounding == ROUND_NEAREST and remainder >= precision / 2):
when += timedelta(seconds=precision)
return when
def test_now(self):
self.assertTrue(timezone.now())
def forwards(apps, schema_editor):
"""
Create sample events.
"""
starts = time.round_datetime(
when=timezone.now(),
precision=timedelta(days=1),
rounding=time.ROUND_DOWN)
ends = starts + appsettings.DEFAULT_ENDS_DELTA
recurrence_rules = dict(
RecurrenceRule.objects.values_list('description', 'recurrence_rule'))
daily = recurrence_rules['Daily']
weekdays = recurrence_rules['Daily, Weekdays']
weekends = recurrence_rules['Daily, Weekends']
weekly = recurrence_rules['Weekly']
monthly = recurrence_rules['Monthly']
yearly = recurrence_rules['Yearly']
daily_event = G(
Event,
title='Daily Event',
starts=starts + timedelta(hours=9),
ends=ends + timedelta(hours=9),
recurrence_rule=daily,
)
weekday_event = G(
Event,
title='Weekday Event',
starts=starts + timedelta(hours=11),
ends=ends + timedelta(hours=11),
recurrence_rule=weekdays,
)
weekend_event = G(
Event,
title='Weekend Event',
starts=starts + timedelta(hours=13),
ends=ends + timedelta(hours=13),
recurrence_rule=weekends,
)
weekly_event = G(
Event,
title='Weekly Event',
starts=starts + timedelta(hours=15),
ends=ends + timedelta(hours=15),
recurrence_rule=weekly,
)
monthly_event = G(
Event,
title='Monthly Event',
starts=starts + timedelta(hours=17),
ends=ends + timedelta(hours=17),
recurrence_rule=monthly,
)
yearly_event = G(
Event,
title='Yearly Event',
starts=starts + timedelta(hours=19),
ends=ends + timedelta(hours=19),
recurrence_rule=yearly,
)
def save(self, *args, **kwargs):
"""
Update ``self.modified``.
"""
self.modified = timezone.now()
super(AbstractBaseModel, self).save(*args, **kwargs)
def forwards(apps, schema_editor):
"""
Create sample events.
"""
starts = time.round_datetime(when=timezone.now(),
precision=timedelta(days=1),
rounding=time.ROUND_DOWN)
ends = starts + appsettings.DEFAULT_ENDS_DELTA
recurrence_rules = dict(
RecurrenceRule.objects.values_list('description', 'recurrence_rule'))
daily = recurrence_rules['Daily']
weekdays = recurrence_rules['Daily, Weekdays']
weekends = recurrence_rules['Daily, Weekends']
weekly = recurrence_rules['Weekly']
monthly = recurrence_rules['Monthly']
yearly = recurrence_rules['Yearly']
daily_event = G(
Event,
title='Daily Event',
starts=starts + timedelta(hours=9),
ends=ends + timedelta(hours=9),
recurrence_rule=daily,
)
weekday_event = G(
Event,
title='Weekday Event',
starts=starts + timedelta(hours=11),
ends=ends + timedelta(hours=11),
recurrence_rule=weekdays,
)
weekend_event = G(
Event,
title='Weekend Event',
starts=starts + timedelta(hours=13),
ends=ends + timedelta(hours=13),
recurrence_rule=weekends,
)
weekly_event = G(
Event,
title='Weekly Event',
starts=starts + timedelta(hours=15),
ends=ends + timedelta(hours=15),
recurrence_rule=weekly,
)
monthly_event = G(
Event,
title='Monthly Event',
starts=starts + timedelta(hours=17),
ends=ends + timedelta(hours=17),
recurrence_rule=monthly,
)
yearly_event = G(
Event,
title='Yearly Event',
starts=starts + timedelta(hours=19),
ends=ends + timedelta(hours=19),
recurrence_rule=yearly,
)
