3715 lines
143 KiB
Python
3715 lines
143 KiB
Python
# chrono - agendas system
|
|
# Copyright (C) 2016 Entr'ouvert
|
|
#
|
|
# This program 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.
|
|
#
|
|
# This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import collections
|
|
import copy
|
|
import dataclasses
|
|
import datetime
|
|
import functools
|
|
import itertools
|
|
import math
|
|
import sys
|
|
import uuid
|
|
from contextlib import contextmanager
|
|
|
|
import requests
|
|
import vobject
|
|
from dateutil.relativedelta import SU, relativedelta
|
|
from dateutil.rrule import DAILY, WEEKLY, rrule, rruleset
|
|
from django.conf import settings
|
|
from django.contrib.auth.models import Group
|
|
from django.contrib.humanize.templatetags.humanize import ordinal
|
|
from django.contrib.postgres.fields import ArrayField
|
|
from django.core.exceptions import ValidationError
|
|
from django.core.validators import MaxValueValidator, MinValueValidator
|
|
from django.db import connection, models, transaction
|
|
from django.db.models import (
|
|
Count,
|
|
Exists,
|
|
ExpressionWrapper,
|
|
F,
|
|
Func,
|
|
IntegerField,
|
|
Max,
|
|
OuterRef,
|
|
Prefetch,
|
|
Q,
|
|
Subquery,
|
|
Value,
|
|
)
|
|
from django.db.models.functions import Cast, Coalesce, Concat, ExtractWeek, ExtractWeekDay, JSONObject
|
|
from django.template import (
|
|
Context,
|
|
RequestContext,
|
|
Template,
|
|
TemplateSyntaxError,
|
|
VariableDoesNotExist,
|
|
engines,
|
|
)
|
|
from django.urls import reverse
|
|
from django.utils import functional
|
|
from django.utils.dates import WEEKDAYS
|
|
from django.utils.encoding import force_str
|
|
from django.utils.formats import date_format
|
|
from django.utils.functional import cached_property
|
|
from django.utils.html import escape
|
|
from django.utils.module_loading import import_string
|
|
from django.utils.safestring import mark_safe
|
|
from django.utils.text import slugify
|
|
from django.utils.translation import gettext
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.utils.translation import ngettext, pgettext_lazy
|
|
|
|
from chrono.interval import Interval, IntervalSet
|
|
from chrono.utils.date import get_weekday_index
|
|
from chrono.utils.db import ArraySubquery, SumCardinality
|
|
from chrono.utils.misc import AgendaImportError, ICSError, clean_import_data, generate_slug
|
|
from chrono.utils.publik_urls import translate_from_publik_url
|
|
from chrono.utils.requests_wrapper import requests as requests_wrapper
|
|
from chrono.utils.timezone import is_aware, localtime, make_aware, make_naive, now, utc
|
|
|
|
AGENDA_KINDS = (
|
|
('events', _('Events')),
|
|
('meetings', _('Meetings')),
|
|
('virtual', _('Virtual')),
|
|
)
|
|
|
|
AGENDA_VIEWS = (
|
|
('day', _('Day view')),
|
|
('week', _('Week view')),
|
|
('month', _('Month view')),
|
|
('open_events', _('Open events')),
|
|
)
|
|
|
|
WEEKDAYS_PLURAL = {
|
|
0: _('Mondays'),
|
|
1: _('Tuesdays'),
|
|
2: _('Wednesdays'),
|
|
3: _('Thursdays'),
|
|
4: _('Fridays'),
|
|
5: _('Saturdays'),
|
|
6: _('Sundays'),
|
|
}
|
|
|
|
WEEKDAY_CHOICES = [
|
|
(0, _('Mo')),
|
|
(1, _('Tu')),
|
|
(2, _('We')),
|
|
(3, _('Th')),
|
|
(4, _('Fr')),
|
|
(5, _('Sa')),
|
|
(6, _('Su')),
|
|
]
|
|
|
|
|
|
def is_midnight(dtime):
|
|
dtime = localtime(dtime)
|
|
return dtime.hour == 0 and dtime.minute == 0
|
|
|
|
|
|
def validate_not_digit(value):
|
|
if value.isdigit():
|
|
raise ValidationError(_('This value cannot be a number.'))
|
|
|
|
|
|
def django_template_validator(value):
|
|
try:
|
|
engines['django'].from_string(value)
|
|
except TemplateSyntaxError as e:
|
|
raise ValidationError(_('syntax error: %s') % e)
|
|
|
|
|
|
def event_template_validator(value):
|
|
example_event = Event(
|
|
start_datetime=now(),
|
|
publication_datetime=now(),
|
|
recurrence_end_date=now().date(),
|
|
places=1,
|
|
duration=1,
|
|
)
|
|
try:
|
|
Template(value).render(Context({'event': example_event}))
|
|
except (VariableDoesNotExist, TemplateSyntaxError) as e:
|
|
raise ValidationError(_('syntax error: %s') % e)
|
|
|
|
|
|
def booking_template_validator(value):
|
|
example_event = Event(
|
|
start_datetime=now(),
|
|
publication_datetime=now(),
|
|
recurrence_end_date=now().date(),
|
|
places=1,
|
|
duration=1,
|
|
)
|
|
example_booking = Booking(event=example_event)
|
|
try:
|
|
Template(value).render(Context({'booking': example_booking}))
|
|
except TemplateSyntaxError as e:
|
|
raise ValidationError(_('syntax error: %s') % e)
|
|
except VariableDoesNotExist:
|
|
pass
|
|
|
|
|
|
class Agenda(models.Model):
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
slug = models.SlugField(_('Identifier'), max_length=160, unique=True)
|
|
kind = models.CharField(_('Kind'), max_length=20, choices=AGENDA_KINDS, default='events')
|
|
minimal_booking_delay = models.PositiveIntegerField(
|
|
_('Minimal booking delay (in days)'),
|
|
default=None,
|
|
null=True,
|
|
blank=True,
|
|
validators=[MaxValueValidator(10000)],
|
|
)
|
|
minimal_booking_delay_in_working_days = models.BooleanField(
|
|
_('Minimal booking delay in working days'),
|
|
default=False,
|
|
)
|
|
maximal_booking_delay = models.PositiveIntegerField(
|
|
_('Maximal booking delay (in days)'),
|
|
default=None,
|
|
null=True,
|
|
blank=True,
|
|
validators=[MaxValueValidator(10000)],
|
|
) # eight weeks
|
|
anonymize_delay = models.PositiveIntegerField(
|
|
_('Anonymize delay (in days)'),
|
|
default=None,
|
|
null=True,
|
|
blank=True,
|
|
validators=[MinValueValidator(30), MaxValueValidator(1000)],
|
|
help_text=_('User data will be kept for the specified number of days passed the booking date.'),
|
|
)
|
|
real_agendas = models.ManyToManyField(
|
|
'self',
|
|
related_name='virtual_agendas',
|
|
symmetrical=False,
|
|
through='VirtualMember',
|
|
through_fields=('virtual_agenda', 'real_agenda'),
|
|
)
|
|
edit_role = models.ForeignKey(
|
|
Group,
|
|
blank=True,
|
|
null=True,
|
|
default=None,
|
|
related_name='+',
|
|
verbose_name=_('Edit Role'),
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
view_role = models.ForeignKey(
|
|
Group,
|
|
blank=True,
|
|
null=True,
|
|
default=None,
|
|
related_name='+',
|
|
verbose_name=_('View Role'),
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
resources = models.ManyToManyField('Resource')
|
|
category = models.ForeignKey(
|
|
'Category', verbose_name=_('Category'), blank=True, null=True, on_delete=models.SET_NULL
|
|
)
|
|
default_view = models.CharField(_('Default view'), max_length=20, choices=AGENDA_VIEWS)
|
|
booking_form_url = models.CharField(
|
|
_('Booking form URL'), max_length=200, blank=True, validators=[django_template_validator]
|
|
)
|
|
desk_simple_management = models.BooleanField(default=False)
|
|
mark_event_checked_auto = models.BooleanField(
|
|
_('Automatically mark event as checked when all bookings have been checked'), default=False
|
|
)
|
|
disable_check_update = models.BooleanField(
|
|
_('Prevent the check of bookings when event was marked as checked'), default=False
|
|
)
|
|
enable_check_for_future_events = models.BooleanField(
|
|
_('Enable the check of bookings when event has not passed'), default=False
|
|
)
|
|
booking_check_filters = models.CharField(
|
|
_('Filters'),
|
|
max_length=250,
|
|
blank=True,
|
|
help_text=_('Comma separated list of keys defined in extra_data.'),
|
|
)
|
|
booking_user_block_template = models.TextField(
|
|
_('User block template'),
|
|
blank=True,
|
|
validators=[django_template_validator],
|
|
)
|
|
booking_extra_user_block_template = models.TextField(
|
|
_('Extra user block template'),
|
|
blank=True,
|
|
validators=[django_template_validator],
|
|
help_text=_('Displayed on check page'),
|
|
)
|
|
event_display_template = models.CharField(
|
|
_('Event display template'),
|
|
max_length=256,
|
|
blank=True,
|
|
validators=[event_template_validator],
|
|
help_text=_(
|
|
'By default event labels will be displayed to users. '
|
|
'This allows for a custom template to include additional informations. '
|
|
'For example, "{{ event.label }} - {{ event.start_datetime }}" will show event datetime after label. '
|
|
'Available variables: event.label (label), event.start_datetime (start date/time), event.places (places), '
|
|
'event.remaining_places (remaining places), event.duration (duration), event.pricing (pricing).'
|
|
),
|
|
)
|
|
events_type = models.ForeignKey(
|
|
'agendas.EventsType',
|
|
verbose_name=_('Events type'),
|
|
on_delete=models.CASCADE,
|
|
related_name='agendas',
|
|
null=True,
|
|
blank=True,
|
|
)
|
|
minimal_booking_time = models.TimeField(
|
|
verbose_name=_('Minimal booking time'),
|
|
default=datetime.time(0, 0, 0), # booking is possible starting and finishin at 00:00
|
|
help_text=_(
|
|
'Ex.: 08:00:00. If left empty, available events will be those that are later than the current time.'
|
|
),
|
|
null=True,
|
|
blank=True,
|
|
)
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.slug:
|
|
self.slug = generate_slug(self)
|
|
if self.kind != 'virtual':
|
|
if self.minimal_booking_delay is None:
|
|
self.minimal_booking_delay = 1
|
|
if self.maximal_booking_delay is None:
|
|
self.maximal_booking_delay = 8 * 7
|
|
if not self.default_view:
|
|
if self.kind == 'events':
|
|
self.default_view = 'month'
|
|
else:
|
|
self.default_view = 'day'
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
def get_absolute_url(self):
|
|
return reverse('chrono-manager-agenda-view', kwargs={'pk': self.id})
|
|
|
|
def get_settings_url(self):
|
|
return reverse('chrono-manager-agenda-settings', kwargs={'pk': self.id})
|
|
|
|
def get_lingo_url(self):
|
|
if not settings.KNOWN_SERVICES.get('lingo'):
|
|
return
|
|
lingo = list(settings.KNOWN_SERVICES['lingo'].values())[0]
|
|
lingo_url = lingo.get('url') or ''
|
|
return '%smanage/pricing/agenda/%s/' % (lingo_url, self.slug)
|
|
|
|
def can_be_managed(self, user):
|
|
if user.is_staff:
|
|
return True
|
|
group_ids = [x.id for x in user.groups.all()]
|
|
return bool(self.edit_role_id in group_ids)
|
|
|
|
def can_be_viewed(self, user):
|
|
if self.can_be_managed(user):
|
|
return True
|
|
group_ids = [x.id for x in user.groups.all()]
|
|
return bool(self.view_role_id in group_ids)
|
|
|
|
def accept_meetings(self):
|
|
if self.kind == 'virtual':
|
|
return not self.real_agendas.filter(~Q(kind='meetings')).exists()
|
|
return self.kind == 'meetings'
|
|
|
|
def get_real_agendas(self):
|
|
if self.kind == 'virtual':
|
|
return self.real_agendas.all()
|
|
return [self]
|
|
|
|
@cached_property
|
|
def cached_meetingtypes(self):
|
|
return list(self.iter_meetingtypes())
|
|
|
|
def iter_meetingtypes(self, excluded_agenda=None):
|
|
"""Expose agenda's meetingtypes.
|
|
straighforward on a real agenda
|
|
On a virtual agenda we expose transient meeting types based on on the
|
|
the real ones shared by every real agendas.
|
|
"""
|
|
if self.kind == 'virtual':
|
|
base_qs = MeetingType.objects.filter(agenda__virtual_agendas__in=[self], deleted=False)
|
|
real_agendas = self.real_agendas
|
|
if excluded_agenda:
|
|
base_qs = base_qs.exclude(agenda=excluded_agenda)
|
|
real_agendas = real_agendas.exclude(pk=excluded_agenda.pk)
|
|
queryset = (
|
|
base_qs.values('slug', 'duration', 'label')
|
|
.annotate(total=Count('*'))
|
|
.filter(total=real_agendas.count())
|
|
)
|
|
return [
|
|
MeetingType(duration=mt['duration'], label=mt['label'], slug=mt['slug'])
|
|
for mt in queryset.order_by('slug')
|
|
]
|
|
|
|
return self.meetingtype_set.filter(deleted=False).all().order_by('slug')
|
|
|
|
def get_meetingtype(self, id_=None, slug=None):
|
|
match = id_ or slug
|
|
assert match, 'an identifier or a slug should be specified'
|
|
|
|
if self.kind == 'virtual':
|
|
match = id_ or slug
|
|
meeting_type = None
|
|
for mt in self.cached_meetingtypes:
|
|
if mt.slug == match:
|
|
meeting_type = mt
|
|
break
|
|
if meeting_type is None:
|
|
raise MeetingType.DoesNotExist()
|
|
return meeting_type
|
|
|
|
if id_:
|
|
return MeetingType.objects.get(id=id_, agenda=self, deleted=False)
|
|
return MeetingType.objects.get(slug=slug, agenda=self, deleted=False)
|
|
|
|
def get_virtual_members(self):
|
|
return VirtualMember.objects.filter(virtual_agenda=self)
|
|
|
|
def get_max_meeting_duration(self):
|
|
return max(x.duration for x in self.cached_meetingtypes)
|
|
|
|
def get_base_meeting_duration(self):
|
|
durations = [x.duration for x in self.cached_meetingtypes]
|
|
if not durations:
|
|
raise ValueError()
|
|
gcd = durations[0]
|
|
for duration in durations[1:]:
|
|
gcd = math.gcd(duration, gcd)
|
|
if gcd == 0:
|
|
raise ValueError()
|
|
return gcd
|
|
|
|
def export_json(self):
|
|
agenda = {
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
'kind': self.kind,
|
|
'category': self.category.slug if self.category else None,
|
|
'minimal_booking_delay': self.minimal_booking_delay,
|
|
'maximal_booking_delay': self.maximal_booking_delay,
|
|
'permissions': {
|
|
'view': self.view_role.name if self.view_role else None,
|
|
'edit': self.edit_role.name if self.edit_role else None,
|
|
},
|
|
'resources': [x.slug for x in self.resources.all()],
|
|
'default_view': self.default_view,
|
|
}
|
|
if hasattr(self, 'reminder_settings'):
|
|
agenda['reminder_settings'] = self.reminder_settings.export_json()
|
|
if self.kind == 'events':
|
|
agenda['booking_form_url'] = self.booking_form_url
|
|
agenda['events'] = [x.export_json() for x in self.event_set.filter(primary_event__isnull=True)]
|
|
if hasattr(self, 'notifications_settings'):
|
|
agenda['notifications_settings'] = self.notifications_settings.export_json()
|
|
agenda['exceptions_desk'] = self.desk_set.get().export_json()
|
|
agenda['minimal_booking_delay_in_working_days'] = self.minimal_booking_delay_in_working_days
|
|
agenda['booking_user_block_template'] = self.booking_user_block_template
|
|
agenda['booking_check_filters'] = self.booking_check_filters
|
|
agenda['event_display_template'] = self.event_display_template
|
|
agenda['mark_event_checked_auto'] = self.mark_event_checked_auto
|
|
agenda['events_type'] = self.events_type.slug if self.events_type else None
|
|
elif self.kind == 'meetings':
|
|
agenda['meetingtypes'] = [x.export_json() for x in self.meetingtype_set.filter(deleted=False)]
|
|
agenda['desks'] = [desk.export_json() for desk in self.desk_set.all()]
|
|
agenda['desk_simple_management'] = self.desk_simple_management
|
|
elif self.kind == 'virtual':
|
|
agenda['excluded_timeperiods'] = [x.export_json() for x in self.excluded_timeperiods.all()]
|
|
agenda['real_agendas'] = [{'slug': x.slug, 'kind': x.kind} for x in self.real_agendas.all()]
|
|
return agenda
|
|
|
|
@classmethod
|
|
def import_json(cls, data, overwrite=False):
|
|
data = copy.deepcopy(data)
|
|
permissions = data.pop('permissions') or {}
|
|
reminder_settings = data.pop('reminder_settings', None)
|
|
if data['kind'] == 'events':
|
|
events = data.pop('events')
|
|
notifications_settings = data.pop('notifications_settings', None)
|
|
exceptions_desk = data.pop('exceptions_desk', None)
|
|
elif data['kind'] == 'meetings':
|
|
meetingtypes = data.pop('meetingtypes')
|
|
desks = data.pop('desks')
|
|
elif data['kind'] == 'virtual':
|
|
excluded_timeperiods = data.pop('excluded_timeperiods')
|
|
real_agendas = data.pop('real_agendas')
|
|
for permission in ('view', 'edit'):
|
|
if permissions.get(permission):
|
|
data[permission + '_role'] = Group.objects.get(name=permissions[permission])
|
|
resources_slug = data.pop('resources', [])
|
|
resources_by_slug = {r.slug: r for r in Resource.objects.filter(slug__in=resources_slug)}
|
|
for resource_slug in resources_slug:
|
|
if resource_slug not in resources_by_slug:
|
|
raise AgendaImportError(_('Missing "%s" resource') % resource_slug)
|
|
data = clean_import_data(cls, data)
|
|
desk_simple_management = data.pop('desk_simple_management', None)
|
|
if data.get('category'):
|
|
try:
|
|
data['category'] = Category.objects.get(slug=data['category'])
|
|
except Category.DoesNotExist:
|
|
del data['category']
|
|
if data.get('events_type'):
|
|
try:
|
|
data['events_type'] = EventsType.objects.get(slug=data['events_type'])
|
|
except EventsType.DoesNotExist:
|
|
raise AgendaImportError(_('Missing "%s" events type') % data['events_type'])
|
|
agenda, created = cls.objects.update_or_create(slug=data['slug'], defaults=data)
|
|
if overwrite:
|
|
AgendaReminderSettings.objects.filter(agenda=agenda).delete()
|
|
if reminder_settings:
|
|
reminder_settings['agenda'] = agenda
|
|
AgendaReminderSettings.import_json(reminder_settings)
|
|
if data['kind'] == 'events':
|
|
if overwrite:
|
|
Event.objects.filter(agenda=agenda).delete()
|
|
AgendaNotificationsSettings.objects.filter(agenda=agenda).delete()
|
|
for event_data in events:
|
|
event_data['agenda'] = agenda
|
|
Event.import_json(event_data)
|
|
if notifications_settings:
|
|
notifications_settings['agenda'] = agenda
|
|
AgendaNotificationsSettings.import_json(notifications_settings)
|
|
if exceptions_desk:
|
|
exceptions_desk['agenda'] = agenda
|
|
Desk.import_json(exceptions_desk)
|
|
elif data['kind'] == 'meetings':
|
|
if overwrite:
|
|
MeetingType.objects.filter(agenda=agenda).delete()
|
|
Desk.objects.filter(agenda=agenda).delete()
|
|
for type_data in meetingtypes:
|
|
type_data['agenda'] = agenda
|
|
MeetingType.import_json(type_data)
|
|
for desk in desks:
|
|
desk['agenda'] = agenda
|
|
Desk.import_json(desk)
|
|
agenda.resources.set(resources_by_slug.values())
|
|
elif data['kind'] == 'virtual':
|
|
if overwrite:
|
|
TimePeriod.objects.filter(agenda=agenda).delete()
|
|
VirtualMember.objects.filter(virtual_agenda=agenda).delete()
|
|
for excluded_timeperiod in excluded_timeperiods:
|
|
excluded_timeperiod['agenda'] = agenda
|
|
TimePeriod.import_json(excluded_timeperiod)
|
|
for real_agenda in real_agendas:
|
|
try:
|
|
real_agenda = Agenda.objects.get(slug=real_agenda['slug'], kind=real_agenda['kind'])
|
|
except Agenda.DoesNotExist:
|
|
raise AgendaImportError(_('The real agenda "%s" does not exist.') % real_agenda['slug'])
|
|
try:
|
|
vm, created = VirtualMember.objects.get_or_create(
|
|
virtual_agenda=agenda, real_agenda=real_agenda
|
|
)
|
|
vm.clean()
|
|
except ValidationError as exc:
|
|
raise AgendaImportError(' '.join(exc.messages))
|
|
|
|
if data['kind'] == 'meetings' and desk_simple_management is not None:
|
|
if desk_simple_management is True and not agenda.desk_simple_management:
|
|
if agenda.is_available_for_simple_management():
|
|
agenda.desk_simple_management = True
|
|
agenda.save()
|
|
elif desk_simple_management is False and agenda.desk_simple_management:
|
|
agenda.desk_simple_management = False
|
|
agenda.save()
|
|
|
|
return created, agenda
|
|
|
|
def duplicate(self, label=None):
|
|
# clone current agenda
|
|
new_agenda = copy.deepcopy(self)
|
|
new_agenda.pk = None
|
|
new_agenda.label = label or _('Copy of %s') % self.label
|
|
# reset slug
|
|
new_agenda.slug = None
|
|
new_agenda.save()
|
|
|
|
# clone related objects
|
|
if self.kind == 'meetings':
|
|
for meeting_type in self.meetingtype_set.all():
|
|
meeting_type.duplicate(agenda_target=new_agenda)
|
|
for desk in self.desk_set.all():
|
|
desk.duplicate(agenda_target=new_agenda)
|
|
new_agenda.resources.set(self.resources.all())
|
|
|
|
elif self.kind == 'events':
|
|
for event in self.event_set.filter(recurrence_days__isnull=True, primary_event__isnull=True):
|
|
event.duplicate(agenda_target=new_agenda)
|
|
for primary_event in self.event_set.filter(recurrence_days__isnull=False):
|
|
dup_primary_event = primary_event.duplicate(agenda_target=new_agenda)
|
|
for child_event in self.event_set.filter(primary_event=primary_event):
|
|
child_event.duplicate(agenda_target=new_agenda, primary_event=dup_primary_event)
|
|
self.desk_set.get().duplicate(agenda_target=new_agenda, reset_slug=False)
|
|
if hasattr(self, 'notifications_settings'):
|
|
self.notifications_settings.duplicate(agenda_target=new_agenda)
|
|
|
|
elif self.kind == 'virtual':
|
|
for timeperiod in self.excluded_timeperiods.all():
|
|
timeperiod.duplicate(agenda_target=new_agenda)
|
|
for real_agenda in self.real_agendas.all():
|
|
VirtualMember.objects.create(virtual_agenda=new_agenda, real_agenda=real_agenda)
|
|
if hasattr(self, 'reminder_settings'):
|
|
self.reminder_settings.duplicate(agenda_target=new_agenda)
|
|
return new_agenda
|
|
|
|
def get_effective_time_periods(self, min_datetime=None, max_datetime=None):
|
|
"""Regroup timeperiods by desks.
|
|
|
|
List all timeperiods, timeperiods having the same begin_time and
|
|
end_time are regrouped in a SharedTimePeriod object, which has a
|
|
list of desks instead of only one desk.
|
|
"""
|
|
min_date = min_datetime.date() if min_datetime else None
|
|
max_date = max_datetime.date() if max_datetime else None
|
|
if self.kind == 'virtual':
|
|
return self.get_effective_time_periods_virtual(min_date, max_date)
|
|
elif self.kind == 'meetings':
|
|
return self.get_effective_time_periods_meetings(min_date, max_date)
|
|
else:
|
|
raise ValueError('does not work with kind %r' % self.kind)
|
|
|
|
def get_effective_time_periods_meetings(self, min_date, max_date):
|
|
"""List timeperiod instances for all desks of the agenda, convert them
|
|
into an Interval of WeekTime which can be compared and regrouped using
|
|
itertools.groupby.
|
|
"""
|
|
time_periods = TimePeriod.objects.filter(desk__agenda=self)
|
|
if min_date:
|
|
time_periods.filter(Q(date__isnull=True) | Q(date__gte=min_date))
|
|
if max_date:
|
|
time_periods.filter(Q(date__isnull=True) | Q(date__lte=max_date))
|
|
|
|
yield from (
|
|
SharedTimePeriod.from_weektime_interval(
|
|
weektime_interval,
|
|
desks=[time_period.desk for time_period in time_periods],
|
|
)
|
|
for weektime_interval, time_periods in itertools.groupby(
|
|
time_periods.prefetch_related('desk').order_by('weekday', 'start_time', 'end_time'),
|
|
key=TimePeriod.as_weektime_interval,
|
|
)
|
|
)
|
|
|
|
def get_effective_time_periods_virtual(self, min_date, max_date):
|
|
"""List timeperiod instances for all desks of all real agendas of this
|
|
virtual agenda, convert them into an Interval of WeekTime which can be
|
|
compared and regrouped using itertools.groupby.
|
|
"""
|
|
time_periods = TimePeriod.objects.filter(desk__agenda__virtual_agendas=self)
|
|
if min_date:
|
|
time_periods.filter(Q(date__isnull=True) | Q(date__gte=min_date))
|
|
if max_date:
|
|
time_periods.filter(Q(date__isnull=True) | Q(date__lte=max_date))
|
|
|
|
closed_hours_by_days = IntervalSet.from_ordered(
|
|
[
|
|
time_period.as_weektime_interval()
|
|
for time_period in self.excluded_timeperiods.order_by('weekday', 'start_time', 'end_time')
|
|
]
|
|
)
|
|
for time_period_interval, time_periods in itertools.groupby(
|
|
time_periods.order_by('weekday', 'start_time', 'end_time').prefetch_related('desk'),
|
|
key=lambda tp: tp.as_weektime_interval(),
|
|
):
|
|
time_periods = list(time_periods)
|
|
desks = [time_period.desk for time_period in time_periods]
|
|
if not closed_hours_by_days:
|
|
yield SharedTimePeriod.from_weektime_interval(time_period_interval, desks=desks)
|
|
else:
|
|
date = time_period_interval.begin.date
|
|
weekday_indexes = time_period_interval.begin.weekday_indexes
|
|
for weektime_interval in IntervalSet.simple(*time_period_interval) - closed_hours_by_days:
|
|
yield SharedTimePeriod.from_weektime_interval(
|
|
weektime_interval, desks=desks, date=date, weekday_indexes=weekday_indexes
|
|
)
|
|
|
|
@functional.cached_property
|
|
def max_booking_datetime(self):
|
|
if self.maximal_booking_delay is None:
|
|
return None
|
|
|
|
# reference is now, in local timezone
|
|
t = localtime(now())
|
|
|
|
# add delay
|
|
t += datetime.timedelta(days=self.maximal_booking_delay)
|
|
|
|
# replace time if needed
|
|
if self.minimal_booking_time:
|
|
t = datetime.datetime.combine(t.date(), self.minimal_booking_time, tzinfo=t.tzinfo)
|
|
# t could not exist, recompute it as an existing datetime by converting to UTC then to localtime
|
|
return localtime(t.astimezone(utc))
|
|
|
|
@functional.cached_property
|
|
def min_booking_datetime(self):
|
|
if self.minimal_booking_delay is None:
|
|
return None
|
|
|
|
# reference is now, in local timezone
|
|
t = localtime(now())
|
|
|
|
# add delay
|
|
if settings.WORKING_DAY_CALENDAR is not None and self.minimal_booking_delay_in_working_days:
|
|
source_class = import_string(settings.WORKING_DAY_CALENDAR)
|
|
calendar = source_class()
|
|
t = calendar.add_working_days(t, self.minimal_booking_delay, keep_datetime=True)
|
|
else:
|
|
t += datetime.timedelta(days=self.minimal_booking_delay)
|
|
|
|
# replace time if needed
|
|
if self.minimal_booking_time:
|
|
t = datetime.datetime.combine(t.date(), self.minimal_booking_time, tzinfo=t.tzinfo)
|
|
# t could not exist, recompute it as an existing datetime by converting to UTC then to localtime
|
|
return localtime(t.astimezone(utc))
|
|
|
|
def get_open_events(
|
|
self,
|
|
prefetched_queryset=False,
|
|
min_start=None,
|
|
max_start=None,
|
|
bypass_delays=False,
|
|
show_out_of_minimal_delay=False,
|
|
):
|
|
assert self.kind == 'events'
|
|
|
|
if prefetched_queryset:
|
|
entries = self.prefetched_events
|
|
# we may have past events
|
|
entries = [e for e in entries if e.start_datetime >= localtime(now())]
|
|
else:
|
|
# recurring events are never opened
|
|
entries = self.event_set.filter(recurrence_days__isnull=True)
|
|
# exclude canceled events
|
|
entries = entries.filter(cancelled=False)
|
|
# we never want to allow booking for past events.
|
|
entries = entries.filter(start_datetime__gte=localtime(now()))
|
|
# exclude non published events
|
|
entries = entries.filter(
|
|
Q(publication_datetime__isnull=True) | Q(publication_datetime__lte=now())
|
|
)
|
|
|
|
if not bypass_delays and not show_out_of_minimal_delay and self.minimal_booking_delay:
|
|
min_start = max(self.min_booking_datetime, min_start) if min_start else self.min_booking_datetime
|
|
|
|
if min_start:
|
|
if prefetched_queryset:
|
|
entries = [e for e in entries if e.start_datetime >= min_start]
|
|
else:
|
|
entries = entries.filter(start_datetime__gte=min_start)
|
|
|
|
if not bypass_delays and self.maximal_booking_delay:
|
|
max_start = min(self.max_booking_datetime, max_start) if max_start else self.max_booking_datetime
|
|
|
|
if max_start:
|
|
if prefetched_queryset:
|
|
entries = [e for e in entries if e.start_datetime < max_start]
|
|
else:
|
|
entries = entries.filter(start_datetime__lt=max_start)
|
|
|
|
return entries
|
|
|
|
def get_past_events(
|
|
self,
|
|
prefetched_queryset=False,
|
|
min_start=None,
|
|
max_start=None,
|
|
):
|
|
assert self.kind == 'events'
|
|
|
|
if prefetched_queryset:
|
|
entries = self.prefetched_events
|
|
# we may have future events
|
|
entries = [e for e in entries if e.start_datetime < localtime(now())]
|
|
else:
|
|
# no recurring events
|
|
entries = self.event_set.filter(recurrence_days__isnull=True)
|
|
# exclude canceled events
|
|
entries = entries.filter(cancelled=False)
|
|
# we want only past events
|
|
entries = entries.filter(start_datetime__lt=localtime(now()))
|
|
|
|
if min_start and not prefetched_queryset:
|
|
entries = entries.filter(start_datetime__gte=min_start)
|
|
|
|
if max_start and not prefetched_queryset:
|
|
entries = entries.filter(start_datetime__lt=max_start)
|
|
|
|
return entries
|
|
|
|
def get_open_recurring_events(self):
|
|
return [
|
|
e
|
|
for e in self.prefetched_recurring_events
|
|
if not e.recurrence_end_date or e.recurrence_end_date > localtime(now()).date()
|
|
]
|
|
|
|
@transaction.atomic
|
|
def update_event_recurrences(self):
|
|
recurring_events = self.event_set.filter(recurrence_days__isnull=False)
|
|
recurrences = self.event_set.filter(primary_event__isnull=False)
|
|
|
|
if recurrences.exists():
|
|
self.remove_recurrences_inside_exceptions(recurring_events, recurrences)
|
|
|
|
Event.create_events_recurrences(recurring_events)
|
|
|
|
def remove_recurrences_inside_exceptions(self, recurring_events, recurrences):
|
|
datetimes = []
|
|
min_start = localtime(now())
|
|
max_start = recurrences.aggregate(dt=Max('start_datetime'))['dt']
|
|
|
|
exceptions = self.get_recurrence_exceptions(min_start, max_start)
|
|
for event in recurring_events:
|
|
events = event.get_recurrences(min_start, max_start, exceptions=exceptions)
|
|
datetimes.extend([event.start_datetime for event in events])
|
|
|
|
events = recurrences.filter(start_datetime__gt=min_start).exclude(start_datetime__in=datetimes)
|
|
# do not delete events where start_datetime was modified
|
|
events_to_delete = [
|
|
event.pk for event in events if event.datetime_slug == make_naive(event.start_datetime)
|
|
]
|
|
|
|
recurrences.filter(
|
|
Q(booking__isnull=True) | Q(booking__cancellation_datetime__isnull=False), pk__in=events_to_delete
|
|
).delete()
|
|
|
|
# report events that weren't deleted because they have bookings
|
|
report, dummy = RecurrenceExceptionsReport.objects.get_or_create(agenda=self)
|
|
report.events.set(recurrences.filter(pk__in=events_to_delete))
|
|
|
|
def get_booking_form_url(self):
|
|
if not self.booking_form_url:
|
|
return
|
|
template_vars = Context(settings.TEMPLATE_VARS)
|
|
try:
|
|
return Template(self.booking_form_url).render(template_vars)
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
def get_booking_check_filters(self):
|
|
if not self.booking_check_filters:
|
|
return []
|
|
return [x.strip() for x in self.booking_check_filters.split(',')]
|
|
|
|
def get_booking_user_block_template(self):
|
|
if self.kind == 'events':
|
|
default = '{{ booking.user_name|default:booking.label|default:"%s" }}' % _('Anonymous')
|
|
else:
|
|
default = """{%% if booking.label and booking.user_name %%}
|
|
{{ booking.label }} - {{ booking.user_name }}
|
|
{%% else %%}
|
|
{{ booking.user_name|default:booking.label|default:"%s" }}
|
|
{%% endif %%}""" % _(
|
|
'booked'
|
|
)
|
|
return self.booking_user_block_template or default
|
|
|
|
def get_recurrence_exceptions(self, min_start, max_start):
|
|
return TimePeriodException.objects.filter(
|
|
Q(desk__slug='_exceptions_holder', desk__agenda=self)
|
|
| Q(
|
|
unavailability_calendar__desks__slug='_exceptions_holder',
|
|
unavailability_calendar__desks__agenda=self,
|
|
),
|
|
start_datetime__lt=max_start,
|
|
end_datetime__gt=min_start,
|
|
)
|
|
|
|
def prefetch_desks_and_exceptions(self, min_date, max_date=None, with_sources=False):
|
|
if self.kind == 'meetings':
|
|
desks = self.desk_set.all()
|
|
elif self.kind == 'virtual':
|
|
desks = (
|
|
Desk.objects.filter(agenda__virtual_agendas=self)
|
|
.select_related('agenda')
|
|
.order_by('agenda', 'label')
|
|
)
|
|
else:
|
|
raise ValueError('does not work with kind %r' % self.kind)
|
|
|
|
past_date_time_periods = TimePeriod.objects.filter(desk=OuterRef('pk'), date__lt=min_date)
|
|
desks = desks.annotate(has_past_date_time_periods=Exists(past_date_time_periods))
|
|
|
|
time_period_queryset = TimePeriod.objects.filter(Q(date__isnull=True) | Q(date__gte=min_date))
|
|
if max_date:
|
|
time_period_queryset = time_period_queryset.filter(Q(date__isnull=True) | Q(date__lte=max_date))
|
|
|
|
self.prefetched_desks = desks.prefetch_related(
|
|
'unavailability_calendars', Prefetch('timeperiod_set', queryset=time_period_queryset)
|
|
)
|
|
if with_sources:
|
|
self.prefetched_desks = self.prefetched_desks.prefetch_related('timeperiodexceptionsource_set')
|
|
unavailability_calendar_ids = UnavailabilityCalendar.objects.filter(
|
|
desks__in=self.prefetched_desks
|
|
).values('pk')
|
|
all_desks_exceptions = TimePeriodException.objects.filter(
|
|
Q(desk__in=self.prefetched_desks) | Q(unavailability_calendar__in=unavailability_calendar_ids)
|
|
)
|
|
for desk in self.prefetched_desks:
|
|
uc_ids = [uc.pk for uc in desk.unavailability_calendars.all()]
|
|
desk.prefetched_exceptions = [
|
|
e
|
|
for e in all_desks_exceptions
|
|
if e.desk_id == desk.pk or e.unavailability_calendar_id in uc_ids
|
|
]
|
|
|
|
@staticmethod
|
|
def filter_for_guardian(qs, guardian_external_id, child_external_id, min_start=None, max_start=None):
|
|
agendas = SharedCustodyAgenda.objects.filter(child__user_external_id=child_external_id).order_by(
|
|
'date_start'
|
|
)
|
|
if max_start:
|
|
agendas = agendas.filter(date_start__lte=max_start)
|
|
if min_start:
|
|
agendas = agendas.filter(Q(date_end__isnull=True) | Q(date_end__gte=min_start))
|
|
|
|
if not agendas:
|
|
return qs
|
|
|
|
qs = (
|
|
qs.annotate(week=ExtractWeek('start_datetime'))
|
|
.annotate(week_number=Cast('week', models.IntegerField()))
|
|
.annotate(odd_week=F('week_number') % 2)
|
|
)
|
|
|
|
previous_date_end = None
|
|
filtered_qs = Event.objects.none()
|
|
for agenda in agendas:
|
|
filtered_qs |= Agenda.filter_for_custody_agenda(qs, agenda, guardian_external_id)
|
|
|
|
if not previous_date_end:
|
|
# first shared custody agenda, include all events before it begins
|
|
filtered_qs |= qs.filter(start_datetime__lt=agenda.date_start)
|
|
else:
|
|
# include all events between agendas
|
|
filtered_qs |= qs.filter(
|
|
start_datetime__lt=agenda.date_start, start_datetime__date__gt=previous_date_end
|
|
)
|
|
previous_date_end = agenda.date_end
|
|
|
|
if previous_date_end:
|
|
# last agenda has end date, include all events after it
|
|
filtered_qs |= qs.filter(start_datetime__gt=previous_date_end)
|
|
|
|
return filtered_qs
|
|
|
|
@staticmethod
|
|
def filter_for_custody_agenda(qs, agenda, guardian_external_id):
|
|
rules = (
|
|
SharedCustodyRule.objects.filter(
|
|
guardian__user_external_id=guardian_external_id,
|
|
agenda=agenda,
|
|
)
|
|
.annotate(day=Func(F('days'), function='unnest', output_field=models.IntegerField()))
|
|
.annotate(week_day=(F('day') + 1) % 7 + 1) # convert ISO day number to db lookup day number
|
|
.values('week_day')
|
|
)
|
|
|
|
rules_lookup = (
|
|
Q(start_datetime__week_day__in=rules.filter(weeks=''))
|
|
| Q(start_datetime__week_day__in=rules.filter(weeks='even'), odd_week=False)
|
|
| Q(start_datetime__week_day__in=rules.filter(weeks='odd'), odd_week=True)
|
|
)
|
|
|
|
all_periods = SharedCustodyPeriod.objects.filter(
|
|
agenda=agenda,
|
|
date_start__lte=OuterRef('start_datetime'),
|
|
date_end__gt=OuterRef('start_datetime'),
|
|
)
|
|
holiday_periods = all_periods.filter(holiday_rule__isnull=False)
|
|
exceptional_periods = all_periods.filter(holiday_rule__isnull=True)
|
|
qs = qs.annotate(
|
|
in_holiday_period=Exists(holiday_periods.filter(guardian__user_external_id=guardian_external_id)),
|
|
in_excluded_holiday_period=Exists(
|
|
holiday_periods.exclude(guardian__user_external_id=guardian_external_id)
|
|
),
|
|
in_exceptional_period=Exists(
|
|
exceptional_periods.filter(guardian__user_external_id=guardian_external_id)
|
|
),
|
|
in_excluded_exceptional_period=Exists(
|
|
exceptional_periods.exclude(guardian__user_external_id=guardian_external_id)
|
|
),
|
|
)
|
|
|
|
rules_lookup = (rules_lookup | Q(in_holiday_period=True)) & Q(in_excluded_holiday_period=False)
|
|
qs = qs.filter(
|
|
(rules_lookup | Q(in_exceptional_period=True)) & Q(in_excluded_exceptional_period=False),
|
|
start_datetime__gte=agenda.date_start,
|
|
)
|
|
if agenda.date_end:
|
|
qs = qs.filter(start_datetime__date__lte=agenda.date_end)
|
|
|
|
return qs
|
|
|
|
@staticmethod
|
|
def prefetch_recurring_events(
|
|
qs, with_overlaps=None, user_external_id=None, start_datetime=None, end_datetime=None
|
|
):
|
|
recurring_event_queryset = Event.objects.filter(
|
|
Q(publication_datetime__isnull=True) | Q(publication_datetime__lte=now()),
|
|
recurrence_days__isnull=False,
|
|
)
|
|
|
|
if with_overlaps:
|
|
recurring_event_queryset = Event.annotate_recurring_events_with_overlaps(
|
|
recurring_event_queryset, agendas=qs
|
|
)
|
|
recurring_event_queryset = Event.annotate_recurring_events_with_booking_overlaps(
|
|
recurring_event_queryset, with_overlaps, user_external_id, start_datetime, end_datetime
|
|
)
|
|
|
|
qs = qs.prefetch_related(
|
|
Prefetch(
|
|
'event_set',
|
|
queryset=recurring_event_queryset,
|
|
to_attr='prefetched_recurring_events',
|
|
)
|
|
)
|
|
return qs
|
|
|
|
@staticmethod
|
|
def prefetch_events(qs, user_external_id=None, guardian_external_id=None, annotate_for_user=True):
|
|
event_queryset = Event.objects.filter(
|
|
Q(publication_datetime__isnull=True) | Q(publication_datetime__lte=now()),
|
|
recurrence_days__isnull=True,
|
|
cancelled=False,
|
|
start_datetime__gte=localtime(now()),
|
|
).order_by()
|
|
if user_external_id and annotate_for_user:
|
|
event_queryset = Event.annotate_queryset_for_user(event_queryset, user_external_id)
|
|
if guardian_external_id and user_external_id:
|
|
event_queryset = Agenda.filter_for_guardian(
|
|
event_queryset, guardian_external_id, user_external_id
|
|
)
|
|
|
|
return qs.filter(kind='events').prefetch_related(
|
|
Prefetch(
|
|
'event_set',
|
|
queryset=event_queryset,
|
|
to_attr='prefetched_events',
|
|
),
|
|
)
|
|
|
|
def is_available_for_simple_management(self):
|
|
if self.kind != 'meetings':
|
|
return False
|
|
|
|
was_prefetched = False
|
|
if hasattr(self, 'prefetched_desks'):
|
|
desks = self.prefetched_desks
|
|
was_prefetched = True
|
|
else:
|
|
desks = self.desk_set.all()
|
|
if len(desks) < 2:
|
|
# no desk or just one, it's ok
|
|
return True
|
|
|
|
desk = desks[0]
|
|
|
|
def values_list(obj, qs_name, qs, fields, for_exception=False):
|
|
if not was_prefetched:
|
|
prefetched_qs = getattr(obj, qs).values_list(*fields)
|
|
if for_exception:
|
|
prefetched_qs = prefetched_qs.filter(source__isnull=True)
|
|
return prefetched_qs
|
|
values = []
|
|
if for_exception:
|
|
prefetched_qs = obj.prefetched_exceptions
|
|
else:
|
|
prefetched_qs = obj._prefetched_objects_cache.get(qs_name) # XXX django 1.11 compat
|
|
if prefetched_qs is None:
|
|
prefetched_qs = obj._prefetched_objects_cache.get(qs)
|
|
for inst in prefetched_qs:
|
|
# queryset is prefetched, fake values_list
|
|
if for_exception and inst.source_id is not None:
|
|
continue
|
|
values.append(tuple(getattr(inst, f) for f in fields))
|
|
return values
|
|
|
|
period_fields = ['weekday', 'start_time', 'end_time']
|
|
exception_fields = ['label', 'start_datetime', 'end_datetime']
|
|
source_fields = ['ics_filename', 'ics_url', 'settings_slug', 'enabled']
|
|
desk_time_periods = set(values_list(desk, 'timeperiod', 'timeperiod_set', period_fields))
|
|
desk_exceptions = set(
|
|
values_list(
|
|
desk, 'timeperiodexception', 'timeperiodexception_set', exception_fields, for_exception=True
|
|
)
|
|
)
|
|
desk_sources = set(
|
|
values_list(desk, 'timeperiodexceptionsource', 'timeperiodexceptionsource_set', source_fields)
|
|
)
|
|
desk_unavaibility_calendars = set(
|
|
values_list(desk, 'unavailability_calendars', 'unavailability_calendars', ['pk'])
|
|
)
|
|
for other_desk in desks[1:]:
|
|
# compare time periods
|
|
other_desk_time_periods = set(
|
|
values_list(other_desk, 'timeperiod', 'timeperiod_set', period_fields)
|
|
)
|
|
if desk_time_periods != other_desk_time_periods:
|
|
return False
|
|
|
|
# compare exceptions
|
|
other_desk_exceptions = set(
|
|
values_list(
|
|
other_desk,
|
|
'timeperiodexception',
|
|
'timeperiodexception_set',
|
|
exception_fields,
|
|
for_exception=True,
|
|
)
|
|
)
|
|
if desk_exceptions != other_desk_exceptions:
|
|
return False
|
|
|
|
# compare sources
|
|
other_desk_sources = set(
|
|
values_list(
|
|
other_desk, 'timeperiodexceptionsource', 'timeperiodexceptionsource_set', source_fields
|
|
)
|
|
)
|
|
if desk_sources != other_desk_sources:
|
|
return False
|
|
|
|
# compare unavailability calendars
|
|
other_desk_unavaibility_calendars = set(
|
|
values_list(other_desk, 'unavailability_calendars', 'unavailability_calendars', ['pk'])
|
|
)
|
|
if desk_unavaibility_calendars != other_desk_unavaibility_calendars:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
class VirtualMember(models.Model):
|
|
"""Trough model to link virtual agendas to their real agendas.
|
|
|
|
Real agendas linked to a virtual agenda MUST all have the same list of
|
|
MeetingType based on their label, slug and duration. It's enforced by
|
|
VirtualMember.clean() and the realted management views.
|
|
"""
|
|
|
|
virtual_agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE, related_name='real_members')
|
|
real_agenda = models.ForeignKey(
|
|
Agenda, on_delete=models.CASCADE, related_name='virtual_members', verbose_name='Agenda'
|
|
)
|
|
|
|
class Meta:
|
|
unique_together = (('virtual_agenda', 'real_agenda'),)
|
|
|
|
def clean(self):
|
|
error_msg = [_('This agenda does not have the same meeting types provided by the virtual agenda.')]
|
|
virtual_meetingtypes = self.virtual_agenda.iter_meetingtypes(excluded_agenda=self.real_agenda)
|
|
if not virtual_meetingtypes:
|
|
return
|
|
virtual_meetingtypes = {(mt.label, mt.slug, mt.duration) for mt in virtual_meetingtypes}
|
|
real_meetingtypes = self.real_agenda.iter_meetingtypes()
|
|
real_meetingtypes = {(mt.label, mt.slug, mt.duration) for mt in real_meetingtypes}
|
|
if virtual_meetingtypes - real_meetingtypes:
|
|
# missing meeting type in real agenda
|
|
for mt in virtual_meetingtypes - real_meetingtypes:
|
|
error_msg += [
|
|
_(
|
|
'Meeting type "%(label)s" (%(duration)s minutes) '
|
|
'(identifier: %(slug)s) does no exist.'
|
|
)
|
|
% {'label': mt[0], 'slug': mt[1], 'duration': mt[2]}
|
|
]
|
|
raise ValidationError(error_msg)
|
|
if real_meetingtypes - virtual_meetingtypes:
|
|
# extra meeting type in real agenda
|
|
for mt in real_meetingtypes - virtual_meetingtypes:
|
|
error_msg += ['Extra meeting type, "%s".' % mt[0]]
|
|
raise ValidationError(error_msg)
|
|
|
|
|
|
WEEKDAYS_LIST = sorted(WEEKDAYS.items(), key=lambda x: x[0])
|
|
|
|
|
|
class WeekTime(collections.namedtuple('WeekTime', ['weekday', 'weekday_indexes', 'date', 'time'])):
|
|
"""Representation of a time point in a weekday, ex.: Monday at 5 o'clock."""
|
|
|
|
def __new__(cls, weekday, weekday_indexes, date, time):
|
|
if date:
|
|
weekday = date.weekday()
|
|
return super().__new__(cls, weekday, weekday_indexes, date, time)
|
|
|
|
def __repr__(self):
|
|
return '%s / %s' % (
|
|
self.date or force_str(WEEKDAYS[self.weekday]),
|
|
date_format(self.time, 'TIME_FORMAT'),
|
|
)
|
|
|
|
def keep_only_weekday_and_time(self):
|
|
return WeekTime(weekday=self.weekday, time=self.time, date=None, weekday_indexes=None)
|
|
|
|
|
|
WEEK_CHOICES = [
|
|
(1, _('First of the month')),
|
|
(2, _('Second of the month')),
|
|
(3, _('Third of the month')),
|
|
(4, _('Fourth of the month')),
|
|
(5, _('Fifth of the month')),
|
|
]
|
|
|
|
|
|
class TimePeriod(models.Model):
|
|
weekday = models.IntegerField(_('Week day'), choices=WEEKDAYS_LIST, null=True)
|
|
weekday_indexes = ArrayField(
|
|
models.IntegerField(choices=WEEK_CHOICES),
|
|
verbose_name=_('Repeat'),
|
|
blank=True,
|
|
null=True,
|
|
)
|
|
date = models.DateField(_('Date'), null=True)
|
|
start_time = models.TimeField(_('Start'))
|
|
end_time = models.TimeField(_('End'))
|
|
desk = models.ForeignKey('Desk', on_delete=models.CASCADE, null=True)
|
|
agenda = models.ForeignKey(
|
|
Agenda, on_delete=models.CASCADE, null=True, related_name='excluded_timeperiods'
|
|
)
|
|
|
|
class Meta:
|
|
ordering = ['weekday', 'date', 'start_time']
|
|
constraints = [
|
|
models.CheckConstraint(
|
|
check=Q(date__isnull=True, weekday__isnull=False)
|
|
| Q(date__isnull=False, weekday__isnull=True),
|
|
name='date_xor_weekday',
|
|
)
|
|
]
|
|
|
|
def __str__(self):
|
|
if self.date:
|
|
label = date_format(self.date, 'l d F Y')
|
|
else:
|
|
label = force_str(WEEKDAYS[self.weekday])
|
|
if self.weekday_indexes:
|
|
label = _('%(weekday)s (%(ordinals)s of the month)') % {
|
|
'weekday': label,
|
|
'ordinals': ', '.join(ordinal(i) for i in self.weekday_indexes),
|
|
}
|
|
|
|
label = '%s / %s → %s' % (
|
|
label,
|
|
date_format(self.start_time, 'TIME_FORMAT'),
|
|
date_format(self.end_time, 'TIME_FORMAT'),
|
|
)
|
|
return mark_safe(label)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.agenda:
|
|
assert self.agenda.kind == 'virtual', "a time period can only reference a virtual agenda"
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def weekday_str(self):
|
|
return WEEKDAYS[self.weekday]
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
data = clean_import_data(cls, data)
|
|
cls.objects.update_or_create(defaults=data, **data)
|
|
|
|
def export_json(self):
|
|
return {
|
|
'weekday': self.weekday,
|
|
'weekday_indexes': self.weekday_indexes,
|
|
'date': self.date.strftime('%Y-%m-%d') if self.date else None,
|
|
'start_time': self.start_time.strftime('%H:%M'),
|
|
'end_time': self.end_time.strftime('%H:%M'),
|
|
}
|
|
|
|
def duplicate(self, desk_target=None, agenda_target=None):
|
|
# clone current period
|
|
new_period = copy.deepcopy(self)
|
|
new_period.pk = None
|
|
# set desk
|
|
new_period.desk = desk_target or self.desk
|
|
# set agenda
|
|
new_period.agenda = agenda_target or self.agenda
|
|
# store new period
|
|
new_period.save()
|
|
|
|
return new_period
|
|
|
|
def as_weektime_interval(self):
|
|
return Interval(
|
|
WeekTime(self.weekday, self.weekday_indexes, self.date, self.start_time),
|
|
WeekTime(self.weekday, self.weekday_indexes, self.date, self.end_time),
|
|
)
|
|
|
|
def as_shared_timeperiods(self):
|
|
return SharedTimePeriod(
|
|
weekday=self.weekday,
|
|
weekday_indexes=self.weekday_indexes,
|
|
start_time=self.start_time,
|
|
end_time=self.end_time,
|
|
date=self.date,
|
|
desks=[self.desk],
|
|
)
|
|
|
|
|
|
@functools.total_ordering
|
|
class SharedTimePeriod:
|
|
"""
|
|
Hold common timeperiod for multiple desks.
|
|
|
|
To improve performance when generating meetings slots for virtual
|
|
agendas or agendas with many desks, we deduplicate time-periods between
|
|
all desks of all agendas.
|
|
|
|
Deduplication is based on a common key, and implemented through __eq__
|
|
and __lt__ which will be used by itertools.groupby().
|
|
|
|
(weekday, start_datetime, end_datetime)
|
|
|
|
it's done in the deduplicate() classmethod.
|
|
|
|
At the level of gel_all_slots() timeperiod are re-duplicated if the
|
|
min_datetime,max_datetime of the desk's agendas differs (see the code
|
|
of get_all_slots() for details).
|
|
"""
|
|
|
|
__slots__ = ['weekday', 'weekday_indexes', 'start_time', 'end_time', 'date', 'desks']
|
|
|
|
def __init__(self, weekday, weekday_indexes, start_time, end_time, date, desks):
|
|
self.weekday = weekday
|
|
self.weekday_indexes = weekday_indexes
|
|
self.start_time = start_time
|
|
self.end_time = end_time
|
|
self.date = date
|
|
self.desks = set(desks)
|
|
|
|
def __str__(self):
|
|
return '%s / %s → %s' % (
|
|
force_str(WEEKDAYS[self.weekday]),
|
|
date_format(self.start_time, 'TIME_FORMAT'),
|
|
date_format(self.end_time, 'TIME_FORMAT'),
|
|
)
|
|
|
|
def __eq__(self, other):
|
|
return (self.weekday, self.start_time, self.end_time, self.date) == (
|
|
other.weekday,
|
|
other.start_time,
|
|
other.end_time,
|
|
other.date,
|
|
)
|
|
|
|
def __lt__(self, other):
|
|
return (self.weekday, self.start_time, self.end_time, self.date) < (
|
|
other.weekday,
|
|
other.start_time,
|
|
other.end_time,
|
|
other.date,
|
|
)
|
|
|
|
def get_time_slots(self, min_datetime, max_datetime, meeting_duration, base_duration):
|
|
"""Generate all possible time slots between min_datetime and max_datime
|
|
of duration meeting_duration minutes and spaced by base_duration
|
|
minutes, i.e.
|
|
|
|
compute a list [a,b] -> [c,d] -> ...
|
|
where b-a = meeting_duration and c-a = base_duration.
|
|
|
|
We start with the first time following min_datetime and being on
|
|
the same weekday of the current period.
|
|
|
|
Then we iterate, advancing by base_duration minutes each time.
|
|
|
|
If we cross the end_time of the period or end of the current_day
|
|
(means end_time is midnight), it advance time to self.start_time on
|
|
the next week (same weekday, same start, one week in the future).
|
|
|
|
When it crosses end_datetime it stops.
|
|
|
|
Generated start_datetime MUST be in the local timezone, and the local
|
|
timezone must not change, as the API needs it to generate stable ids.
|
|
"""
|
|
if self.date and not (min_datetime.date() <= self.date <= max_datetime.date()):
|
|
return
|
|
|
|
meeting_duration = datetime.timedelta(minutes=meeting_duration)
|
|
duration = datetime.timedelta(minutes=base_duration)
|
|
|
|
if not self.date:
|
|
real_min_datetime = min_datetime + datetime.timedelta(days=self.weekday - min_datetime.weekday())
|
|
if real_min_datetime < min_datetime:
|
|
real_min_datetime += datetime.timedelta(days=7)
|
|
else:
|
|
real_min_datetime = make_aware(
|
|
datetime.datetime(day=self.date.day, month=self.date.month, year=self.date.year)
|
|
)
|
|
|
|
# make sure datetime in local timezone, it's ABSOLUTELY necessary
|
|
# to have stable event ids in the API.
|
|
real_min_datetime = real_min_datetime.replace(
|
|
hour=12
|
|
) # so aware datetime will be int the dst of the day
|
|
event_datetime = make_aware(make_naive(real_min_datetime)).replace(
|
|
hour=self.start_time.hour, minute=self.start_time.minute, second=0, microsecond=0
|
|
)
|
|
|
|
# don't start before min_datetime
|
|
event_datetime = max(event_datetime, min_datetime)
|
|
|
|
# get slots
|
|
while event_datetime < max_datetime:
|
|
end_time = event_datetime + meeting_duration
|
|
next_time = event_datetime + duration
|
|
if (
|
|
end_time.time() > self.end_time
|
|
or event_datetime.date() != next_time.date()
|
|
or (self.weekday_indexes and get_weekday_index(event_datetime) not in self.weekday_indexes)
|
|
):
|
|
# if time slot is not repeating, end now
|
|
if self.date:
|
|
break
|
|
|
|
# switch to naive time for day/week changes
|
|
event_datetime = make_naive(event_datetime)
|
|
# back to morning
|
|
event_datetime = event_datetime.replace(
|
|
hour=self.start_time.hour, minute=self.start_time.minute
|
|
)
|
|
# but next week
|
|
event_datetime += datetime.timedelta(days=7)
|
|
|
|
# and re-align to timezone afterwards
|
|
event_datetime = make_aware(event_datetime)
|
|
continue
|
|
|
|
# don't end after max_datetime
|
|
if event_datetime > max_datetime:
|
|
break
|
|
|
|
yield event_datetime
|
|
event_datetime = next_time
|
|
|
|
@classmethod
|
|
def from_weektime_interval(cls, weektime_interval, desks=(), date=None, weekday_indexes=None):
|
|
begin, end = weektime_interval
|
|
assert begin.weekday == end.weekday
|
|
|
|
return cls(
|
|
weekday=begin.weekday,
|
|
weekday_indexes=begin.weekday_indexes or end.weekday_indexes or weekday_indexes,
|
|
start_time=begin.time,
|
|
end_time=end.time,
|
|
date=begin.date or end.date or date,
|
|
desks=desks,
|
|
)
|
|
|
|
|
|
class MeetingType(models.Model):
|
|
agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
slug = models.SlugField(_('Identifier'), max_length=160)
|
|
duration = models.IntegerField(_('Duration (in minutes)'), default=30, validators=[MinValueValidator(1)])
|
|
deleted = models.BooleanField(_('Deleted'), default=False)
|
|
|
|
class Meta:
|
|
ordering = ['duration', 'label']
|
|
unique_together = ['agenda', 'slug']
|
|
|
|
def save(self, *args, **kwargs):
|
|
assert self.agenda.kind != 'virtual', "a meetingtype can't reference a virtual agenda"
|
|
if not self.slug:
|
|
self.slug = generate_slug(self, agenda=self.agenda)
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
data = clean_import_data(cls, data)
|
|
cls.objects.update_or_create(slug=data['slug'], agenda=data['agenda'], defaults=data)
|
|
|
|
def export_json(self):
|
|
return {
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
'duration': self.duration,
|
|
}
|
|
|
|
def duplicate(self, agenda_target=None):
|
|
new_meeting_type = copy.deepcopy(self)
|
|
new_meeting_type.pk = None
|
|
if agenda_target:
|
|
new_meeting_type.agenda = agenda_target
|
|
else:
|
|
new_meeting_type.slug = None
|
|
new_meeting_type.save()
|
|
|
|
return new_meeting_type
|
|
|
|
|
|
class Event(models.Model):
|
|
id = models.BigAutoField(primary_key=True)
|
|
INTERVAL_CHOICES = [
|
|
(1, _('Every week')),
|
|
(2, _('Every two weeks')),
|
|
(3, _('Every three weeks')),
|
|
]
|
|
|
|
agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE)
|
|
start_datetime = models.DateTimeField(_('Date/time'))
|
|
recurrence_days = ArrayField(
|
|
models.IntegerField(choices=WEEKDAY_CHOICES),
|
|
verbose_name=_('Recurrence days'),
|
|
blank=True,
|
|
null=True,
|
|
)
|
|
recurrence_week_interval = models.IntegerField(_('Repeat'), choices=INTERVAL_CHOICES, default=1)
|
|
recurrence_end_date = models.DateField(
|
|
_('Recurrence end date'),
|
|
null=True,
|
|
blank=True,
|
|
help_text=_('If left blank, a one-year maximal booking delay will be applied for this event.'),
|
|
)
|
|
primary_event = models.ForeignKey('self', null=True, on_delete=models.CASCADE, related_name='recurrences')
|
|
duration = models.PositiveIntegerField(_('Duration (in minutes)'), default=None, null=True, blank=True)
|
|
publication_datetime = models.DateTimeField(_('Publication date/time'), blank=True, null=True)
|
|
places = models.PositiveIntegerField(_('Places'))
|
|
waiting_list_places = models.PositiveIntegerField(_('Places in waiting list'), default=0)
|
|
label = models.CharField(
|
|
_('Label'),
|
|
max_length=150,
|
|
null=True,
|
|
blank=True,
|
|
help_text=_('Optional label to identify this date.'),
|
|
)
|
|
slug = models.SlugField(_('Identifier'), max_length=160, blank=True, validators=[validate_not_digit])
|
|
description = models.TextField(
|
|
_('Description'), null=True, blank=True, help_text=_('Optional event description.')
|
|
)
|
|
pricing = models.CharField(_('Pricing'), max_length=150, null=True, blank=True)
|
|
url = models.CharField(_('URL'), max_length=200, null=True, blank=True)
|
|
booked_places = models.PositiveSmallIntegerField(default=0)
|
|
booked_waiting_list_places = models.PositiveSmallIntegerField(default=0)
|
|
almost_full = models.BooleanField(default=False)
|
|
full = models.BooleanField(default=False)
|
|
cancelled = models.BooleanField(default=False)
|
|
cancellation_scheduled = models.BooleanField(default=False)
|
|
checked = models.BooleanField(default=False)
|
|
meeting_type = models.ForeignKey(MeetingType, null=True, on_delete=models.CASCADE)
|
|
desk = models.ForeignKey('Desk', null=True, on_delete=models.CASCADE)
|
|
resources = models.ManyToManyField('Resource')
|
|
custom_fields = models.JSONField(blank=True, default=dict)
|
|
|
|
almost_full_notification_timestamp = models.DateTimeField(null=True, blank=True)
|
|
full_notification_timestamp = models.DateTimeField(null=True, blank=True)
|
|
cancelled_notification_timestamp = models.DateTimeField(null=True, blank=True)
|
|
|
|
class Meta:
|
|
ordering = ['agenda', 'start_datetime', 'duration', 'label']
|
|
unique_together = ('agenda', 'slug')
|
|
|
|
def __str__(self):
|
|
if self.label:
|
|
return self.label
|
|
return date_format(localtime(self.start_datetime), format='DATETIME_FORMAT')
|
|
|
|
@functional.cached_property
|
|
def cancellation_status(self):
|
|
if self.cancelled:
|
|
return _('Cancelled')
|
|
if self.cancellation_scheduled:
|
|
return _('Cancellation in progress')
|
|
|
|
def save(self, seen_slugs=None, *args, **kwargs):
|
|
assert self.agenda.kind != 'virtual', "an event can't reference a virtual agenda"
|
|
assert not (self.slug and self.slug.isdigit()), 'slug cannot be a number'
|
|
self.start_datetime = self.start_datetime.replace(second=0, microsecond=0)
|
|
if not self.slug:
|
|
self.slug = generate_slug(self, seen_slugs=seen_slugs, agenda=self.agenda)
|
|
return super().save(*args, **kwargs)
|
|
|
|
@contextmanager
|
|
def update_recurrences(self, changed_data, cleaned_data, protected_fields, exclude_fields):
|
|
with transaction.atomic():
|
|
if any(field for field in changed_data if field in protected_fields):
|
|
self.recurrences.all().delete()
|
|
elif self.recurrence_days:
|
|
update_fields = {
|
|
field: value for field, value in cleaned_data.items() if field not in exclude_fields
|
|
}
|
|
self.recurrences.update(**update_fields)
|
|
yield
|
|
|
|
if self.recurrence_days:
|
|
if self.recurrence_end_date:
|
|
self.recurrences.filter(start_datetime__gt=self.recurrence_end_date).delete()
|
|
self.create_all_recurrences()
|
|
|
|
@property
|
|
def base_slug(self):
|
|
# label can be empty
|
|
return slugify(self.label or ('%s-event' % self.agenda.label))
|
|
|
|
def main_list_full(self):
|
|
return bool(self.booked_places >= self.places)
|
|
|
|
def set_is_checked(self):
|
|
if not self.agenda.mark_event_checked_auto:
|
|
return
|
|
if self.checked:
|
|
return
|
|
booking_qs = self.booking_set.filter(
|
|
cancellation_datetime__isnull=True,
|
|
in_waiting_list=False,
|
|
user_was_present__isnull=True,
|
|
)
|
|
if booking_qs.exists():
|
|
return
|
|
self.checked = True
|
|
self.save(update_fields=['checked'])
|
|
|
|
def in_bookable_period(self, bypass_delays=False):
|
|
if self.publication_datetime and now() < self.publication_datetime:
|
|
return False
|
|
if (
|
|
not bypass_delays
|
|
and self.agenda.maximal_booking_delay
|
|
and self.start_datetime > self.agenda.max_booking_datetime
|
|
):
|
|
return False
|
|
if self.recurrence_days is not None:
|
|
# bookable recurrences probably exist
|
|
return True
|
|
if (
|
|
not bypass_delays
|
|
and self.agenda.minimal_booking_delay
|
|
and self.start_datetime < self.agenda.min_booking_datetime
|
|
):
|
|
return False
|
|
if self.start_datetime < now():
|
|
return False
|
|
return True
|
|
|
|
def is_day_past(self):
|
|
return self.start_datetime.date() <= now().date()
|
|
|
|
@staticmethod
|
|
def annotate_queryset_for_user(qs, user_external_id, with_status=False):
|
|
qs = qs.annotate(
|
|
user_places_count=Count(
|
|
'booking',
|
|
filter=Q(
|
|
booking__cancellation_datetime__isnull=True,
|
|
booking__in_waiting_list=False,
|
|
booking__user_external_id=user_external_id,
|
|
),
|
|
),
|
|
user_waiting_places_count=Count(
|
|
'booking',
|
|
filter=Q(
|
|
booking__cancellation_datetime__isnull=True,
|
|
booking__in_waiting_list=True,
|
|
booking__user_external_id=user_external_id,
|
|
),
|
|
),
|
|
)
|
|
if with_status:
|
|
qs = qs.annotate(
|
|
user_absence_count=Count(
|
|
'booking',
|
|
filter=Q(
|
|
booking__cancellation_datetime__isnull=True,
|
|
booking__user_was_present=False,
|
|
booking__user_external_id=user_external_id,
|
|
),
|
|
),
|
|
user_cancelled_count=Count(
|
|
'booking',
|
|
filter=Q(
|
|
booking__cancellation_datetime__isnull=False,
|
|
booking__user_external_id=user_external_id,
|
|
),
|
|
),
|
|
)
|
|
return qs
|
|
|
|
@staticmethod
|
|
def annotate_queryset_with_overlaps(qs, other_events=None):
|
|
if not other_events:
|
|
other_events = qs
|
|
|
|
common_annotations = {
|
|
'computed_end_datetime': ExpressionWrapper(
|
|
F('start_datetime') + datetime.timedelta(minutes=1) * F('duration'),
|
|
output_field=models.DateTimeField(),
|
|
),
|
|
'computed_slug': Concat('agenda__slug', Value('@'), 'slug', output_field=models.CharField()),
|
|
}
|
|
|
|
qs = qs.annotate(**common_annotations)
|
|
other_events = other_events.annotate(**common_annotations)
|
|
|
|
overlapping_events = other_events.filter(
|
|
start_datetime__lt=OuterRef('computed_end_datetime'),
|
|
computed_end_datetime__gt=OuterRef('start_datetime'),
|
|
).exclude(pk=OuterRef('pk'))
|
|
|
|
return qs.annotate(
|
|
overlaps=ArraySubquery(
|
|
overlapping_events.values('computed_slug'),
|
|
output_field=ArrayField(models.CharField()),
|
|
),
|
|
has_overlap=Exists(overlapping_events),
|
|
)
|
|
|
|
@staticmethod
|
|
def annotate_recurring_events_with_overlaps(qs, agendas=None):
|
|
qs = qs.annotate(
|
|
start_hour=Cast('start_datetime', models.TimeField()),
|
|
computed_end_datetime=ExpressionWrapper(
|
|
F('start_datetime') + datetime.timedelta(minutes=1) * F('duration'),
|
|
output_field=models.DateTimeField(),
|
|
),
|
|
end_hour=Cast('computed_end_datetime', models.TimeField()),
|
|
computed_slug=Concat('agenda__slug', Value('@'), 'slug', output_field=models.CharField()),
|
|
)
|
|
|
|
overlapping_events = qs.filter(
|
|
start_hour__lt=OuterRef('end_hour'),
|
|
end_hour__gt=OuterRef('start_hour'),
|
|
recurrence_days__overlap=F('recurrence_days'),
|
|
).exclude(pk=OuterRef('pk'))
|
|
|
|
if agendas:
|
|
overlapping_events = overlapping_events.filter(agenda__in=agendas)
|
|
|
|
json_object = JSONObject(
|
|
slug=F('computed_slug'),
|
|
days=F('recurrence_days'),
|
|
)
|
|
|
|
return qs.annotate(
|
|
overlaps=ArraySubquery(
|
|
overlapping_events.values(json=json_object),
|
|
output_field=ArrayField(models.JSONField()),
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def annotate_recurring_events_with_booking_overlaps(
|
|
qs, agenda_slugs, user_external_id, start_datetime, end_datetime
|
|
):
|
|
recurrences = Event.objects.filter(primary_event=OuterRef('pk'))
|
|
recurrences = recurrences.annotate(
|
|
dj_weekday=ExtractWeekDay('start_datetime'),
|
|
dj_weekday_int=Cast('dj_weekday', models.IntegerField()),
|
|
weekday=(F('dj_weekday_int') - 2) % 7,
|
|
)
|
|
recurrences_with_overlaps = Event.annotate_queryset_with_booked_event_overlaps(
|
|
recurrences, agenda_slugs, user_external_id, start_datetime, end_datetime
|
|
).filter(has_overlap=True)
|
|
|
|
return qs.annotate(
|
|
days_with_booking_overlaps=ArraySubquery(
|
|
recurrences_with_overlaps.values('weekday'), output_field=ArrayField(models.IntegerField())
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def annotate_queryset_with_booked_event_overlaps(
|
|
qs, agenda_slugs, user_external_id, start_datetime, end_datetime, exclude_events=None
|
|
):
|
|
booked_events = Event.objects.filter(
|
|
agenda__slug__in=agenda_slugs,
|
|
start_datetime__gte=start_datetime,
|
|
booking__user_external_id=user_external_id,
|
|
booking__cancellation_datetime__isnull=True,
|
|
)
|
|
|
|
if end_datetime:
|
|
booked_events = booked_events.filter(start_datetime__lte=end_datetime)
|
|
if exclude_events:
|
|
booked_events = booked_events.exclude(pk__in=exclude_events)
|
|
|
|
return Event.annotate_queryset_with_overlaps(qs, booked_events)
|
|
|
|
@staticmethod
|
|
def annotate_booking_checks(qs):
|
|
bookings = (
|
|
Booking.objects.filter(
|
|
event=OuterRef('pk'), cancellation_datetime__isnull=True, in_waiting_list=False
|
|
)
|
|
.order_by()
|
|
.values('event')
|
|
)
|
|
present_count = bookings.filter(user_was_present=True).annotate(count=Count('event')).values('count')
|
|
absent_count = bookings.filter(user_was_present=False).annotate(count=Count('event')).values('count')
|
|
notchecked_count = (
|
|
bookings.filter(user_was_present__isnull=True).annotate(count=Count('event')).values('count')
|
|
)
|
|
return qs.annotate(
|
|
present_count=Coalesce(Subquery(present_count, output_field=IntegerField()), Value(0)),
|
|
absent_count=Coalesce(Subquery(absent_count, output_field=IntegerField()), Value(0)),
|
|
notchecked_count=Coalesce(Subquery(notchecked_count, output_field=IntegerField()), Value(0)),
|
|
)
|
|
|
|
@property
|
|
def remaining_places(self):
|
|
return max(0, self.places - self.booked_places)
|
|
|
|
@property
|
|
def remaining_waiting_list_places(self):
|
|
return max(0, self.waiting_list_places - self.booked_waiting_list_places)
|
|
|
|
@property
|
|
def end_datetime(self):
|
|
if self.meeting_type:
|
|
minutes = self.meeting_type.duration
|
|
else:
|
|
minutes = self.duration
|
|
if minutes is None:
|
|
return None
|
|
return self.start_datetime + datetime.timedelta(minutes=minutes)
|
|
|
|
def get_absolute_url(self):
|
|
return reverse('chrono-manager-event-edit', kwargs={'pk': self.agenda.id, 'event_pk': self.id})
|
|
|
|
def get_absolute_view_url(self):
|
|
return reverse('chrono-manager-event-view', kwargs={'pk': self.agenda.id, 'event_pk': self.id})
|
|
|
|
def get_booking_form_url(self):
|
|
if not self.agenda.booking_form_url:
|
|
return
|
|
template_vars = Context(settings.TEMPLATE_VARS)
|
|
try:
|
|
url = Template(self.agenda.booking_form_url).render(template_vars)
|
|
url += '&' if '?' in url else '?'
|
|
url += 'agenda=%s&event=%s' % (self.agenda.slug, self.slug)
|
|
return mark_safe(url)
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
try:
|
|
data['start_datetime'] = make_aware(
|
|
datetime.datetime.strptime(data['start_datetime'], '%Y-%m-%d %H:%M:%S')
|
|
)
|
|
except ValueError:
|
|
raise AgendaImportError(_('Bad datetime format "%s"') % data['start_datetime'])
|
|
data = clean_import_data(cls, data)
|
|
if data.get('slug'):
|
|
event, dummy = cls.objects.update_or_create(
|
|
agenda=data['agenda'], slug=data['slug'], defaults=data
|
|
)
|
|
else:
|
|
event = cls(**data)
|
|
event.save()
|
|
if event.recurrence_days:
|
|
event.refresh_from_db()
|
|
if event.recurrence_end_date:
|
|
event.recurrences.filter(start_datetime__gt=event.recurrence_end_date).delete()
|
|
update_fields = {
|
|
field: getattr(event, field)
|
|
for field in [
|
|
'label',
|
|
'duration',
|
|
'publication_datetime',
|
|
'places',
|
|
'waiting_list_places',
|
|
'description',
|
|
'pricing',
|
|
'url',
|
|
]
|
|
}
|
|
event.recurrences.update(**update_fields)
|
|
event.create_all_recurrences()
|
|
|
|
def export_json(self):
|
|
recurrence_end_date = (
|
|
self.recurrence_end_date.strftime('%Y-%m-%d') if self.recurrence_end_date else None
|
|
)
|
|
return {
|
|
'start_datetime': make_naive(self.start_datetime).strftime('%Y-%m-%d %H:%M:%S'),
|
|
'publication_datetime': make_naive(self.publication_datetime).strftime('%Y-%m-%d %H:%M:%S')
|
|
if self.publication_datetime
|
|
else None,
|
|
'recurrence_days': self.recurrence_days,
|
|
'recurrence_week_interval': self.recurrence_week_interval,
|
|
'recurrence_end_date': recurrence_end_date,
|
|
'places': self.places,
|
|
'waiting_list_places': self.waiting_list_places,
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
'description': self.description,
|
|
'url': self.url,
|
|
'pricing': self.pricing,
|
|
'duration': self.duration,
|
|
}
|
|
|
|
def duplicate(self, agenda_target=None, primary_event=None, label=None, start_datetime=None):
|
|
new_event = copy.deepcopy(self)
|
|
new_event.pk = None
|
|
if label:
|
|
new_event.label = label
|
|
if start_datetime:
|
|
new_event.start_datetime = start_datetime
|
|
if agenda_target:
|
|
new_event.agenda = agenda_target
|
|
else:
|
|
new_event.slug = None
|
|
if primary_event:
|
|
new_event.primary_event = primary_event
|
|
new_event.save()
|
|
|
|
return new_event
|
|
|
|
def cancel(self, cancel_bookings=True):
|
|
bookings_to_cancel = self.booking_set.filter(cancellation_datetime__isnull=True).all()
|
|
if cancel_bookings and bookings_to_cancel.exclude(cancel_callback_url='').exists():
|
|
# booking cancellation needs network calls, schedule it for later
|
|
self.cancellation_scheduled = True
|
|
self.save()
|
|
else:
|
|
with transaction.atomic():
|
|
for booking in bookings_to_cancel:
|
|
booking.cancel()
|
|
self.cancelled = True
|
|
self.save()
|
|
|
|
def get_recurrences(self, min_datetime, max_datetime, exceptions=None):
|
|
recurrences = []
|
|
rrule_set = rruleset()
|
|
|
|
if exceptions is None:
|
|
exceptions = self.agenda.get_recurrence_exceptions(min_datetime, max_datetime)
|
|
for exception in exceptions:
|
|
exception_start = localtime(exception.start_datetime)
|
|
event_start = localtime(self.start_datetime)
|
|
if event_start.time() < exception_start.time():
|
|
exception_start += datetime.timedelta(days=1)
|
|
exception_start = exception_start.replace(
|
|
hour=event_start.hour, minute=event_start.minute, second=0, microsecond=0
|
|
)
|
|
rrule_set.exrule(
|
|
rrule(
|
|
freq=DAILY,
|
|
dtstart=make_naive(exception_start),
|
|
until=make_naive(exception.end_datetime),
|
|
)
|
|
)
|
|
|
|
event_base = Event(
|
|
agenda=self.agenda,
|
|
primary_event=self,
|
|
slug=self.slug,
|
|
duration=self.duration,
|
|
places=self.places,
|
|
waiting_list_places=self.waiting_list_places,
|
|
publication_datetime=self.publication_datetime,
|
|
label=self.label,
|
|
description=self.description,
|
|
pricing=self.pricing,
|
|
url=self.url,
|
|
custom_fields=self.custom_fields,
|
|
)
|
|
|
|
# remove pytz info because dateutil doesn't support DST changes
|
|
min_datetime = make_naive(min_datetime)
|
|
max_datetime = make_naive(max_datetime)
|
|
rrule_set.rrule(rrule(dtstart=make_naive(self.start_datetime), **self.recurrence_rule))
|
|
|
|
for start_datetime in rrule_set.between(min_datetime, max_datetime, inc=True):
|
|
event = copy.copy(event_base)
|
|
# add timezone back
|
|
aware_start_datetime = make_aware(start_datetime)
|
|
event.slug = '%s--%s' % (
|
|
event.slug,
|
|
aware_start_datetime.strftime('%Y-%m-%d-%H%M'),
|
|
)
|
|
event.start_datetime = aware_start_datetime.astimezone(utc)
|
|
recurrences.append(event)
|
|
|
|
return recurrences
|
|
|
|
def get_recurrence_display(self):
|
|
time = date_format(localtime(self.start_datetime), 'TIME_FORMAT')
|
|
|
|
days_count = len(self.recurrence_days)
|
|
if days_count == 7:
|
|
repeat = _('Daily')
|
|
elif days_count > 1 and (self.recurrence_days[-1] - self.recurrence_days[0]) == days_count - 1:
|
|
# days are contiguous
|
|
repeat = _('From %(weekday)s to %(last_weekday)s') % {
|
|
'weekday': str(WEEKDAYS[self.recurrence_days[0]]),
|
|
'last_weekday': str(WEEKDAYS[self.recurrence_days[-1]]),
|
|
}
|
|
else:
|
|
repeat = _('On %(weekdays)s') % {
|
|
'weekdays': ', '.join([str(WEEKDAYS_PLURAL[i]) for i in self.recurrence_days])
|
|
}
|
|
|
|
recurrence_display = _('%(On_day_x)s at %(time)s') % {'On_day_x': repeat, 'time': time}
|
|
|
|
if self.recurrence_week_interval > 1:
|
|
if self.recurrence_week_interval == 2:
|
|
every_x_weeks = _('every two weeks')
|
|
elif self.recurrence_week_interval == 3:
|
|
every_x_weeks = _('every three weeks')
|
|
recurrence_display = _('%(Every_x_days)s, once %(every_x_weeks)s') % {
|
|
'Every_x_days': recurrence_display,
|
|
'every_x_weeks': every_x_weeks,
|
|
}
|
|
|
|
if self.start_datetime > now():
|
|
start_date = date_format(self.start_datetime, 'DATE_FORMAT')
|
|
recurrence_display = _('%(Every_x_days)s, from %(date)s') % {
|
|
'Every_x_days': recurrence_display,
|
|
'date': start_date,
|
|
}
|
|
|
|
if self.recurrence_end_date:
|
|
end_date = date_format(self.recurrence_end_date, 'DATE_FORMAT')
|
|
recurrence_display = _('%(Every_x_days)s, until %(date)s') % {
|
|
'Every_x_days': recurrence_display,
|
|
'date': end_date,
|
|
}
|
|
return recurrence_display
|
|
|
|
@property
|
|
def recurrence_rule(self):
|
|
recurrence_rule = {
|
|
'freq': WEEKLY,
|
|
'byweekday': self.recurrence_days,
|
|
'interval': self.recurrence_week_interval,
|
|
}
|
|
if self.recurrence_end_date:
|
|
recurrence_rule['until'] = datetime.datetime.combine(
|
|
self.recurrence_end_date, datetime.time(0, 0)
|
|
)
|
|
else:
|
|
recurrence_rule['until'] = make_naive(now() + datetime.timedelta(days=365))
|
|
return recurrence_rule
|
|
|
|
def has_recurrences_booked(self, after=None):
|
|
return Booking.objects.filter(
|
|
event__primary_event=self,
|
|
event__start_datetime__gt=after or now(),
|
|
cancellation_datetime__isnull=True,
|
|
).exists()
|
|
|
|
def create_all_recurrences(self):
|
|
Event.create_events_recurrences([self])
|
|
|
|
@classmethod
|
|
def create_events_recurrences(cls, events):
|
|
for event in events:
|
|
if event.recurrence_end_date:
|
|
max_datetime = datetime.datetime.combine(event.recurrence_end_date, datetime.time(0, 0))
|
|
else:
|
|
max_datetime = make_naive(now() + datetime.timedelta(days=365))
|
|
existing_recurrences = event.recurrences.values_list('slug', flat=True)
|
|
all_recurrences = event.get_recurrences(localtime(event.start_datetime), make_aware(max_datetime))
|
|
recurrences_to_create = [r for r in all_recurrences if r.slug not in existing_recurrences]
|
|
if recurrences_to_create:
|
|
Event.objects.bulk_create(recurrences_to_create, ignore_conflicts=True)
|
|
|
|
@property
|
|
def datetime_slug(self):
|
|
assert self.primary_event_id is not None, 'only for event recurrence'
|
|
|
|
datetime_part = self.slug.rsplit('--')[-1]
|
|
return datetime.datetime.strptime(datetime_part, '%Y-%m-%d-%H%M')
|
|
|
|
def get_custom_fields(self):
|
|
if not self.agenda.events_type:
|
|
return {}
|
|
custom_fields = {}
|
|
for custom_field in self.agenda.events_type.get_custom_fields():
|
|
custom_fields[custom_field['varname']] = self.custom_fields.get(custom_field['varname'])
|
|
return custom_fields
|
|
|
|
|
|
class EventsType(models.Model):
|
|
slug = models.SlugField(_('Identifier'), max_length=160, unique=True)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
custom_fields = models.JSONField(blank=True, default=list)
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.slug:
|
|
self.slug = generate_slug(self)
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
def get_custom_fields(self):
|
|
custom_fields = []
|
|
if not isinstance(self.custom_fields, list):
|
|
return custom_fields
|
|
for values in self.custom_fields:
|
|
if not isinstance(values, dict):
|
|
continue
|
|
complete = True
|
|
for k in ['varname', 'label', 'field_type']:
|
|
if not values.get(k):
|
|
complete = False
|
|
break
|
|
if complete:
|
|
custom_fields.append(values)
|
|
return custom_fields
|
|
|
|
@classmethod
|
|
def import_json(cls, data, overwrite=False):
|
|
data = clean_import_data(cls, data)
|
|
slug = data.pop('slug')
|
|
events_type, created = cls.objects.update_or_create(slug=slug, defaults=data)
|
|
return created, events_type
|
|
|
|
def export_json(self):
|
|
return {
|
|
'slug': self.slug,
|
|
'label': self.label,
|
|
'custom_fields': self.custom_fields,
|
|
}
|
|
|
|
|
|
class BookingColor(models.Model):
|
|
COLOR_COUNT = 8
|
|
|
|
label = models.CharField(_('Label'), max_length=250)
|
|
index = models.PositiveSmallIntegerField()
|
|
|
|
class Meta:
|
|
unique_together = ('label',)
|
|
ordering = ('pk',)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.index is None:
|
|
last_color = BookingColor.objects.last() or BookingColor(index=-1)
|
|
self.index = (last_color.index + 1) % self.COLOR_COUNT
|
|
super().save(*args, **kwargs)
|
|
|
|
def __str__(self):
|
|
return '%s' % self.label
|
|
|
|
|
|
class Booking(models.Model):
|
|
event = models.ForeignKey(Event, on_delete=models.CASCADE)
|
|
extra_data = models.JSONField(null=True)
|
|
anonymization_datetime = models.DateTimeField(null=True)
|
|
cancellation_datetime = models.DateTimeField(null=True)
|
|
email_reminder_datetime = models.DateTimeField(null=True)
|
|
sms_reminder_datetime = models.DateTimeField(null=True)
|
|
in_waiting_list = models.BooleanField(default=False)
|
|
creation_datetime = models.DateTimeField(auto_now_add=True)
|
|
# primary booking is used to group multiple bookings together
|
|
primary_booking = models.ForeignKey(
|
|
'self', null=True, on_delete=models.CASCADE, related_name='secondary_booking_set'
|
|
)
|
|
|
|
label = models.CharField(max_length=250, blank=True)
|
|
user_display_label = models.CharField(
|
|
verbose_name=_('Label displayed to user'), max_length=250, blank=True
|
|
)
|
|
user_external_id = models.CharField(max_length=250, blank=True)
|
|
user_last_name = models.CharField(max_length=250, blank=True)
|
|
user_first_name = models.CharField(max_length=250, blank=True)
|
|
user_email = models.EmailField(blank=True)
|
|
user_phone_number = models.CharField(max_length=30, blank=True)
|
|
user_was_present = models.BooleanField(null=True)
|
|
user_check_type_slug = models.CharField(max_length=160, blank=True, null=True)
|
|
user_check_type_label = models.CharField(max_length=150, blank=True, null=True)
|
|
out_of_min_delay = models.BooleanField(default=False)
|
|
|
|
extra_emails = ArrayField(models.EmailField(), default=list)
|
|
extra_phone_numbers = ArrayField(models.CharField(max_length=16), default=list)
|
|
|
|
form_url = models.URLField(blank=True)
|
|
backoffice_url = models.URLField(blank=True)
|
|
cancel_callback_url = models.URLField(blank=True)
|
|
color = models.ForeignKey(BookingColor, null=True, on_delete=models.SET_NULL, related_name='bookings')
|
|
|
|
@property
|
|
def user_name(self):
|
|
return ('%s %s' % (self.user_first_name, self.user_last_name)).strip()
|
|
|
|
@cached_property
|
|
def emails(self):
|
|
emails = set(self.extra_emails)
|
|
if self.user_email:
|
|
emails.add(self.user_email)
|
|
return list(emails)
|
|
|
|
@cached_property
|
|
def phone_numbers(self):
|
|
phone_numbers = set(self.extra_phone_numbers)
|
|
if self.user_phone_number:
|
|
phone_numbers.add(self.user_phone_number)
|
|
return list(phone_numbers)
|
|
|
|
def cancel(self, trigger_callback=False):
|
|
timestamp = now()
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(cancellation_datetime=timestamp)
|
|
self.cancellation_datetime = timestamp
|
|
self.save()
|
|
if self.cancel_callback_url and trigger_callback:
|
|
r = requests_wrapper.post(self.cancel_callback_url, remote_service='auto', timeout=15)
|
|
r.raise_for_status()
|
|
|
|
def accept(self):
|
|
self.in_waiting_list = False
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(in_waiting_list=False)
|
|
self.save()
|
|
|
|
def suspend(self):
|
|
self.in_waiting_list = True
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(in_waiting_list=True)
|
|
self.save()
|
|
|
|
def reset_user_was_present(self):
|
|
self.user_check_type_slug = None
|
|
self.user_check_type_label = None
|
|
self.user_was_present = None
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(user_check_type_slug=None)
|
|
self.secondary_booking_set.update(user_check_type_label=None)
|
|
self.secondary_booking_set.update(user_was_present=None)
|
|
self.save()
|
|
self.event.checked = False
|
|
self.event.save(update_fields=['checked'])
|
|
|
|
def mark_user_absence(self, check_type_slug=None, check_type_label=None):
|
|
self.user_check_type_slug = check_type_slug
|
|
self.user_check_type_label = check_type_label
|
|
self.user_was_present = False
|
|
self.cancellation_datetime = None
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(user_check_type_slug=check_type_slug)
|
|
self.secondary_booking_set.update(user_check_type_label=check_type_label)
|
|
self.secondary_booking_set.update(user_was_present=False)
|
|
self.secondary_booking_set.update(cancellation_datetime=None)
|
|
self.save()
|
|
self.event.set_is_checked()
|
|
|
|
def mark_user_presence(self, check_type_slug=None, check_type_label=None):
|
|
self.user_check_type_slug = check_type_slug
|
|
self.user_check_type_label = check_type_label
|
|
self.user_was_present = True
|
|
self.cancellation_datetime = None
|
|
with transaction.atomic():
|
|
self.secondary_booking_set.update(user_check_type_slug=check_type_slug)
|
|
self.secondary_booking_set.update(user_check_type_label=check_type_label)
|
|
self.secondary_booking_set.update(user_was_present=True)
|
|
self.secondary_booking_set.update(cancellation_datetime=None)
|
|
self.save()
|
|
self.event.set_is_checked()
|
|
|
|
def get_user_block(self):
|
|
template_vars = Context(settings.TEMPLATE_VARS, autoescape=False)
|
|
template_vars.update(
|
|
{
|
|
'booking': self,
|
|
}
|
|
)
|
|
try:
|
|
return escape(Template(self.event.agenda.get_booking_user_block_template()).render(template_vars))
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
def get_extra_user_block(self, request):
|
|
context = RequestContext(request)
|
|
context.update(
|
|
{
|
|
'booking': self,
|
|
}
|
|
)
|
|
try:
|
|
return Template(self.event.agenda.booking_extra_user_block_template).render(context)
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
@classmethod
|
|
def anonymize_bookings(cls, bookings_queryset):
|
|
bookings_queryset.update(
|
|
label='',
|
|
user_display_label='',
|
|
user_external_id='',
|
|
user_last_name='',
|
|
user_first_name='',
|
|
extra_data={},
|
|
anonymization_datetime=now(),
|
|
)
|
|
|
|
def get_ics(self, request=None):
|
|
ics = vobject.iCalendar()
|
|
ics.add('prodid').value = '-//Entr\'ouvert//NON SGML Publik'
|
|
vevent = vobject.newFromBehavior('vevent')
|
|
vevent.add('uid').value = '%s-%s-%s' % (
|
|
self.event.start_datetime.isoformat(),
|
|
self.event.agenda.pk,
|
|
self.pk,
|
|
)
|
|
|
|
vevent.add('summary').value = self.user_display_label or self.label
|
|
vevent.add('dtstart').value = self.event.start_datetime
|
|
if self.user_name:
|
|
vevent.add('attendee').value = self.user_name
|
|
if request is None or request.GET.get('organizer') != 'no':
|
|
organizer_name = getattr(settings, 'TEMPLATE_VARS', {}).get('global_title', 'chrono')
|
|
organizer_email = getattr(settings, 'TEMPLATE_VARS', {}).get(
|
|
'default_from_email', 'chrono@example.net'
|
|
)
|
|
organizer = vevent.add('organizer')
|
|
organizer.value = f'mailto:{organizer_email}'
|
|
organizer.cn_param = organizer_name
|
|
|
|
if self.event.end_datetime:
|
|
vevent.add('dtend').value = self.event.end_datetime
|
|
|
|
for field in ('description', 'location', 'comment', 'url'):
|
|
field_value = request and request.GET.get(field) or (self.extra_data or {}).get(field)
|
|
if field_value:
|
|
vevent.add(field).value = field_value
|
|
ics.add(vevent)
|
|
return ics.serialize()
|
|
|
|
def clone(self, primary_booking=None, save=True):
|
|
new_booking = copy.deepcopy(self)
|
|
new_booking.id = None
|
|
new_booking.primary_booking = primary_booking
|
|
if save:
|
|
new_booking.save()
|
|
return new_booking
|
|
|
|
def events_display(self):
|
|
name = self.user_name or self.label or _('Anonymous')
|
|
return '%s, %s' % (name, date_format(localtime(self.creation_datetime), 'DATETIME_FORMAT'))
|
|
|
|
def get_form_url(self):
|
|
return translate_from_publik_url(self.form_url)
|
|
|
|
def get_backoffice_url(self):
|
|
return translate_from_publik_url(self.backoffice_url)
|
|
|
|
|
|
OpeningHour = collections.namedtuple('OpeningHour', ['begin', 'end'])
|
|
|
|
|
|
class Desk(models.Model):
|
|
agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
slug = models.SlugField(_('Identifier'), max_length=160)
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
class Meta:
|
|
ordering = ['label', 'slug']
|
|
unique_together = ['agenda', 'slug']
|
|
|
|
def save(self, *args, **kwargs):
|
|
assert self.agenda.kind != 'virtual', "a desk can't reference a virtual agenda"
|
|
if not self.slug:
|
|
self.slug = generate_slug(self, agenda=self.agenda)
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
timeperiods = data.pop('timeperiods', [])
|
|
exceptions = data.pop('exceptions', [])
|
|
sources = data.pop('exception_sources', [])
|
|
unavailability_calendars = data.pop('unavailability_calendars', [])
|
|
data = clean_import_data(cls, data)
|
|
desk, dummy = cls.objects.update_or_create(slug=data['slug'], agenda=data['agenda'], defaults=data)
|
|
for timeperiod in timeperiods:
|
|
timeperiod['desk'] = desk
|
|
TimePeriod.import_json(timeperiod)
|
|
for exception in exceptions:
|
|
exception['desk'] = desk
|
|
TimePeriodException.import_json(exception)
|
|
for source in sources:
|
|
source['desk'] = desk
|
|
TimePeriodExceptionSource.import_json(source)
|
|
for unavailability_calendar in unavailability_calendars:
|
|
slug = unavailability_calendar['slug']
|
|
try:
|
|
target_calendar = UnavailabilityCalendar.objects.get(slug=slug)
|
|
except UnavailabilityCalendar.DoesNotExist:
|
|
raise AgendaImportError(_('The unavailability calendar "%s" does not exist.') % slug)
|
|
desk.unavailability_calendars.add(target_calendar)
|
|
|
|
def export_json(self):
|
|
time_period_exceptions = self.timeperiodexception_set.filter(source__settings_slug__isnull=True)
|
|
time_period_exception_sources = self.timeperiodexceptionsource_set.filter(settings_slug__isnull=False)
|
|
return {
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
'timeperiods': [time_period.export_json() for time_period in self.timeperiod_set.filter()],
|
|
'exceptions': [exception.export_json() for exception in time_period_exceptions],
|
|
'exception_sources': [source.export_json() for source in time_period_exception_sources],
|
|
'unavailability_calendars': [{'slug': x.slug} for x in self.unavailability_calendars.all()],
|
|
}
|
|
|
|
def duplicate(self, label=None, agenda_target=None, reset_slug=True):
|
|
# clone current desk
|
|
new_desk = copy.deepcopy(self)
|
|
new_desk.pk = None
|
|
# set label
|
|
new_desk.label = label or new_desk.label
|
|
# reset slug
|
|
if reset_slug:
|
|
new_desk.slug = None
|
|
# set agenda
|
|
if agenda_target:
|
|
new_desk.agenda = agenda_target
|
|
# store new desk
|
|
new_desk.save()
|
|
|
|
# clone related objects
|
|
for time_period in self.timeperiod_set.all():
|
|
time_period.duplicate(desk_target=new_desk)
|
|
for time_period_exception in self.timeperiodexception_set.filter(source__isnull=True):
|
|
time_period_exception.duplicate(desk_target=new_desk)
|
|
for time_period_exception_source in self.timeperiodexceptionsource_set.all():
|
|
time_period_exception_source.duplicate(desk_target=new_desk)
|
|
new_desk.unavailability_calendars.set(self.unavailability_calendars.all())
|
|
|
|
return new_desk
|
|
|
|
def get_exceptions_within_two_weeks(self):
|
|
# prefetched_exceptions contains desks exceptions + unavailability_calendars exceptions
|
|
# default ordering: start_datetime
|
|
in_two_weeks = make_aware(datetime.datetime.today() + datetime.timedelta(days=14))
|
|
exceptions = []
|
|
for exception in self.prefetched_exceptions:
|
|
if exception.end_datetime < now():
|
|
# exception ends in the past, skip it
|
|
continue
|
|
if exception.end_datetime <= in_two_weeks:
|
|
# ends in less than 2 weeks
|
|
exceptions.append(exception)
|
|
elif exception.start_datetime < now():
|
|
# has already started
|
|
exceptions.append(exception)
|
|
if exceptions:
|
|
return exceptions
|
|
# if none found within the 2 coming weeks, return the next one
|
|
for exception in self.prefetched_exceptions:
|
|
if exception.start_datetime < now():
|
|
# exception starts in the past, skip it
|
|
continue
|
|
# returns the first exception found
|
|
return [exception]
|
|
return []
|
|
|
|
def are_all_exceptions_displayed(self):
|
|
in_two_weeks = self.get_exceptions_within_two_weeks()
|
|
return len(self.prefetched_exceptions) == len(in_two_weeks)
|
|
|
|
def get_opening_hours(self, date):
|
|
openslots = IntervalSet()
|
|
weekday_index = get_weekday_index(date)
|
|
real_date = date.date() if isinstance(date, datetime.datetime) else date
|
|
for timeperiod in self.timeperiod_set.all():
|
|
if timeperiod.weekday_indexes and weekday_index not in timeperiod.weekday_indexes:
|
|
continue
|
|
# timeperiod_set.all() are prefetched, do not filter in queryset
|
|
if timeperiod.date != real_date and timeperiod.weekday != date.weekday():
|
|
continue
|
|
start_datetime = make_aware(datetime.datetime.combine(date, timeperiod.start_time))
|
|
end_datetime = make_aware(datetime.datetime.combine(date, timeperiod.end_time))
|
|
openslots.add(start_datetime, end_datetime)
|
|
|
|
aware_date = make_aware(datetime.datetime(date.year, date.month, date.day))
|
|
exceptions = IntervalSet()
|
|
aware_next_date = aware_date + datetime.timedelta(days=1)
|
|
for exception in self.prefetched_exceptions:
|
|
if exception.end_datetime < aware_date:
|
|
continue
|
|
if exception.start_datetime > aware_next_date:
|
|
continue
|
|
exceptions.add(exception.start_datetime, exception.end_datetime)
|
|
|
|
return [OpeningHour(*time_range) for time_range in (openslots - exceptions)]
|
|
|
|
def import_timeperiod_exceptions_from_settings(self, enable=False, spool=True):
|
|
start_update = now()
|
|
for slug, source_info in settings.EXCEPTIONS_SOURCES.items():
|
|
label = source_info['label']
|
|
try:
|
|
source = TimePeriodExceptionSource.objects.get(desk=self, settings_slug=slug)
|
|
except TimePeriodExceptionSource.DoesNotExist:
|
|
source = TimePeriodExceptionSource.objects.create(
|
|
desk=self, settings_slug=slug, enabled=False
|
|
)
|
|
source.settings_label = _(label)
|
|
source.save()
|
|
if enable or source.enabled: # if already enabled, update anyway
|
|
source.enable(spool=spool)
|
|
TimePeriodExceptionSource.objects.filter(
|
|
desk=self, settings_slug__isnull=False, last_update__lt=start_update
|
|
).delete() # source was not in settings anymore
|
|
|
|
|
|
class Resource(models.Model):
|
|
slug = models.SlugField(_('Identifier'), max_length=160, unique=True)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
description = models.TextField(_('Description'), blank=True, help_text=_('Optional description.'))
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.slug:
|
|
self.slug = generate_slug(self)
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
def can_be_viewed(self, user):
|
|
if user.is_staff:
|
|
return True
|
|
group_ids = [x.id for x in user.groups.all()]
|
|
return self.agenda_set.filter(edit_role_id__in=group_ids).exists()
|
|
|
|
@classmethod
|
|
def import_json(cls, data, overwrite=False):
|
|
data = clean_import_data(cls, data)
|
|
slug = data.pop('slug')
|
|
resource, created = cls.objects.update_or_create(slug=slug, defaults=data)
|
|
return created, resource
|
|
|
|
def export_json(self):
|
|
return {
|
|
'slug': self.slug,
|
|
'label': self.label,
|
|
'description': self.description,
|
|
}
|
|
|
|
|
|
class Category(models.Model):
|
|
slug = models.SlugField(_('Identifier'), max_length=160, unique=True)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.slug:
|
|
self.slug = generate_slug(self)
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
@classmethod
|
|
def import_json(cls, data, overwrite=False):
|
|
data = clean_import_data(cls, data)
|
|
slug = data.pop('slug')
|
|
category, created = cls.objects.update_or_create(slug=slug, defaults=data)
|
|
return created, category
|
|
|
|
def export_json(self):
|
|
return {
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
}
|
|
|
|
|
|
def ics_directory_path(instance, filename):
|
|
return f'ics/{str(uuid.uuid4())}/{filename}'
|
|
|
|
|
|
class TimePeriodExceptionSource(models.Model):
|
|
desk = models.ForeignKey(Desk, on_delete=models.CASCADE, null=True)
|
|
unavailability_calendar = models.ForeignKey('UnavailabilityCalendar', on_delete=models.CASCADE, null=True)
|
|
ics_filename = models.CharField(null=True, max_length=256)
|
|
ics_file = models.FileField(upload_to=ics_directory_path, blank=True, null=True)
|
|
ics_url = models.URLField(null=True, max_length=500)
|
|
settings_slug = models.CharField(null=True, max_length=150)
|
|
settings_label = models.CharField(null=True, max_length=150)
|
|
last_update = models.DateTimeField(auto_now=True, null=True)
|
|
enabled = models.BooleanField(default=True)
|
|
|
|
class Meta:
|
|
unique_together = ['desk', 'settings_slug']
|
|
|
|
def __str__(self):
|
|
if self.ics_filename is not None:
|
|
return self.ics_filename
|
|
if self.settings_label is not None:
|
|
return gettext(self.settings_label)
|
|
return self.ics_url
|
|
|
|
def duplicate(self, desk_target=None):
|
|
# clone current source
|
|
new_source = copy.deepcopy(self)
|
|
new_source.pk = None
|
|
# set desk
|
|
new_source.desk = desk_target or self.desk
|
|
# set ics_file
|
|
if self.ics_file:
|
|
with open(self.ics_file.path) as ics_file:
|
|
new_source.ics_file.save(self.ics_filename, ics_file, save=False)
|
|
# store new source
|
|
new_source.save()
|
|
# clone related objects
|
|
for time_period_exception in self.timeperiodexception_set.all():
|
|
time_period_exception.duplicate(desk_target=desk_target, source_target=new_source)
|
|
|
|
return new_source
|
|
|
|
def enable(self, spool=True):
|
|
self.enabled = True
|
|
self.save()
|
|
|
|
if spool and 'uwsgi' in sys.modules:
|
|
from chrono.utils.spooler import refresh_exceptions_from_settings
|
|
|
|
tenant = getattr(connection, 'tenant', None)
|
|
transaction.on_commit(
|
|
lambda: refresh_exceptions_from_settings.spool(
|
|
source_id=str(self.pk), domain=getattr(tenant, 'domain_url', None)
|
|
)
|
|
)
|
|
return
|
|
|
|
self.refresh_from_settings()
|
|
|
|
def refresh_from_settings(self):
|
|
if not self.enabled:
|
|
return
|
|
source_info = settings.EXCEPTIONS_SOURCES.get(self.settings_slug)
|
|
if not source_info:
|
|
return
|
|
source_class = import_string(source_info['class'])
|
|
calendar = source_class()
|
|
this_year = now().year
|
|
days = [day for year in range(this_year, this_year + 3) for day in calendar.holidays(year)]
|
|
with transaction.atomic():
|
|
self.timeperiodexception_set.all().delete()
|
|
for day, label in days:
|
|
start_datetime = make_aware(datetime.datetime.combine(day, datetime.datetime.min.time()))
|
|
end_datetime = start_datetime + datetime.timedelta(days=1)
|
|
TimePeriodException.objects.create(
|
|
desk=self.desk,
|
|
source=self,
|
|
label=_(label),
|
|
start_datetime=start_datetime,
|
|
end_datetime=end_datetime,
|
|
)
|
|
|
|
def disable(self):
|
|
self.timeperiodexception_set.all().delete()
|
|
self.enabled = False
|
|
self.save()
|
|
|
|
def render_ics_url(self):
|
|
return Template(self.ics_url).render(Context(settings.TEMPLATE_VARS))
|
|
|
|
def _check_ics_content(self):
|
|
if self.ics_url:
|
|
ics_url = self.render_ics_url()
|
|
try:
|
|
response = requests.get(ics_url, proxies=settings.REQUESTS_PROXIES, timeout=15)
|
|
response.raise_for_status()
|
|
except requests.HTTPError as e:
|
|
raise ICSError(
|
|
_('Failed to retrieve remote calendar (%(url)s, HTTP error %(status_code)s).')
|
|
% {'url': ics_url, 'status_code': e.response.status_code}
|
|
)
|
|
except requests.RequestException as e:
|
|
raise ICSError(
|
|
_('Failed to retrieve remote calendar (%(url)s, %(exception)s).')
|
|
% {'url': ics_url, 'exception': e}
|
|
)
|
|
try:
|
|
# override response encoding received in HTTP headers as it may
|
|
# often be missing and defaults to iso-8859-15.
|
|
response.content.decode('utf-8')
|
|
response.encoding = 'utf-8'
|
|
except UnicodeDecodeError:
|
|
pass
|
|
data = response.text
|
|
else:
|
|
data = force_str(self.ics_file.read())
|
|
|
|
try:
|
|
parsed = vobject.readOne(data)
|
|
except vobject.base.ParseError:
|
|
raise ICSError(_('File format is invalid.'))
|
|
|
|
if not parsed.contents.get('vevent'):
|
|
raise ICSError(_('The file doesn\'t contain any events.'))
|
|
|
|
for vevent in parsed.contents.get('vevent', []):
|
|
summary = self._get_summary_from_vevent(vevent)
|
|
try:
|
|
vevent.dtstart.value
|
|
except AttributeError:
|
|
raise ICSError(_('Event "%s" has no start date.') % summary)
|
|
|
|
return parsed
|
|
|
|
def _get_summary_from_vevent(self, vevent):
|
|
if 'summary' in vevent.contents:
|
|
return force_str(vevent.contents['summary'][0].value)
|
|
return _('Exception')
|
|
|
|
def refresh_timeperiod_exceptions(self, data=None):
|
|
if 'uwsgi' in sys.modules:
|
|
from chrono.utils.spooler import refresh_exception_source
|
|
|
|
tenant = getattr(connection, 'tenant', None)
|
|
transaction.on_commit(
|
|
lambda: refresh_exception_source.spool(
|
|
source_id=str(self.pk), domain=getattr(tenant, 'domain_url', None)
|
|
)
|
|
)
|
|
return
|
|
|
|
self.refresh_timeperiod_exceptions_from_ics(data=data)
|
|
|
|
def refresh_timeperiod_exceptions_from_ics(self, data=None, recurring_days=600):
|
|
if data is None:
|
|
parsed = self._check_ics_content()
|
|
else:
|
|
parsed = data
|
|
|
|
categories = collections.defaultdict(list)
|
|
with transaction.atomic():
|
|
# delete old exceptions related to this source
|
|
self.timeperiodexception_set.all().delete()
|
|
# create new exceptions
|
|
update_datetime = now()
|
|
for vevent in parsed.contents.get('vevent', []):
|
|
summary = self._get_summary_from_vevent(vevent)
|
|
try:
|
|
start_dt = vevent.dtstart.value
|
|
if not isinstance(start_dt, datetime.datetime):
|
|
start_dt = datetime.datetime.combine(start_dt, datetime.datetime.min.time())
|
|
if not is_aware(start_dt):
|
|
start_dt = make_aware(start_dt)
|
|
except AttributeError:
|
|
raise ICSError(_('Event "%s" has no start date.') % summary)
|
|
try:
|
|
end_dt = vevent.dtend.value
|
|
if not isinstance(end_dt, datetime.datetime):
|
|
end_dt = datetime.datetime.combine(end_dt, datetime.datetime.min.time())
|
|
if not is_aware(end_dt):
|
|
end_dt = make_aware(end_dt)
|
|
duration = end_dt - start_dt
|
|
except AttributeError:
|
|
try:
|
|
duration = vevent.duration.value
|
|
end_dt = start_dt + duration
|
|
except AttributeError:
|
|
# events without end date are considered as ending the same day
|
|
end_dt = make_aware(datetime.datetime.combine(start_dt, datetime.datetime.max.time()))
|
|
duration = end_dt - start_dt
|
|
|
|
event = {
|
|
'start_datetime': start_dt,
|
|
'end_datetime': end_dt,
|
|
'label': summary,
|
|
'desk_id': self.desk_id,
|
|
'unavailability_calendar_id': self.unavailability_calendar_id,
|
|
'source': self,
|
|
'recurrence_id': 0,
|
|
}
|
|
|
|
if 'categories' in vevent.contents and len(vevent.categories.value) > 0:
|
|
category = vevent.categories.value[0]
|
|
else:
|
|
category = None
|
|
|
|
if not vevent.rruleset:
|
|
# classical event
|
|
exception = TimePeriodException.objects.create(**event)
|
|
if category:
|
|
categories[category].append(exception)
|
|
elif vevent.rruleset.count():
|
|
# recurring event until recurring_days in the future
|
|
from_dt = start_dt
|
|
until_dt = update_datetime + datetime.timedelta(days=recurring_days)
|
|
if not is_aware(vevent.rruleset[0]):
|
|
from_dt = make_naive(from_dt)
|
|
until_dt = make_naive(until_dt)
|
|
i = -1
|
|
for i, start_dt in enumerate(vevent.rruleset.between(from_dt, until_dt, inc=True)):
|
|
# recompute start_dt and end_dt from occurrences and duration
|
|
if not is_aware(start_dt):
|
|
start_dt = make_aware(start_dt)
|
|
end_dt = start_dt + duration
|
|
event['recurrence_id'] = i
|
|
event['start_datetime'] = start_dt
|
|
event['end_datetime'] = end_dt
|
|
if end_dt >= update_datetime:
|
|
exception = TimePeriodException.objects.create(**event)
|
|
if category:
|
|
categories[category].append(exception)
|
|
|
|
if self.unavailability_calendar_id:
|
|
for category, exceptions in categories.items():
|
|
exception_group, dummy = TimePeriodExceptionGroup.objects.get_or_create(
|
|
unavailability_calendar_id=self.unavailability_calendar_id,
|
|
slug=category,
|
|
defaults={'label': exceptions[0].label},
|
|
)
|
|
exception_group.exceptions.add(*exceptions)
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
data = clean_import_data(cls, data)
|
|
desk = data.pop('desk')
|
|
settings_slug = data.pop('settings_slug')
|
|
source, _ = cls.objects.update_or_create(desk=desk, settings_slug=settings_slug, defaults=data)
|
|
if source.enabled:
|
|
source.enable()
|
|
|
|
def export_json(self):
|
|
'''Export only sources from settings.'''
|
|
return {
|
|
'settings_slug': self.settings_slug,
|
|
'settings_label': self.settings_label,
|
|
'enabled': self.enabled,
|
|
}
|
|
|
|
|
|
class UnavailabilityCalendar(models.Model):
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
slug = models.SlugField(_('Identifier'), max_length=160, unique=True)
|
|
desks = models.ManyToManyField(Desk, related_name='unavailability_calendars')
|
|
edit_role = models.ForeignKey(
|
|
Group,
|
|
blank=True,
|
|
null=True,
|
|
default=None,
|
|
related_name='+',
|
|
verbose_name=_('Edit Role'),
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
view_role = models.ForeignKey(
|
|
Group,
|
|
blank=True,
|
|
null=True,
|
|
default=None,
|
|
related_name='+',
|
|
verbose_name=_('View Role'),
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
@property
|
|
def base_slug(self):
|
|
return slugify(self.label)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.slug:
|
|
self.slug = generate_slug(self)
|
|
super().save(*args, **kwargs)
|
|
|
|
def can_be_managed(self, user):
|
|
if user.is_staff:
|
|
return True
|
|
group_ids = [x.id for x in user.groups.all()]
|
|
return bool(self.edit_role_id in group_ids)
|
|
|
|
def can_be_viewed(self, user):
|
|
if self.can_be_managed(user):
|
|
return True
|
|
group_ids = [x.id for x in user.groups.all()]
|
|
return bool(self.view_role_id in group_ids)
|
|
|
|
def get_absolute_url(self):
|
|
return reverse('chrono-manager-unavailability-calendar-view', kwargs={'pk': self.id})
|
|
|
|
def export_json(self):
|
|
unavailability_calendar = {
|
|
'label': self.label,
|
|
'slug': self.slug,
|
|
'permissions': {
|
|
'view': self.view_role.name if self.view_role else None,
|
|
'edit': self.edit_role.name if self.edit_role else None,
|
|
},
|
|
'exceptions': [exception.export_json() for exception in self.timeperiodexception_set.all()],
|
|
}
|
|
return unavailability_calendar
|
|
|
|
@classmethod
|
|
def import_json(cls, data, overwrite=False):
|
|
data = data.copy()
|
|
permissions = data.pop('permissions', {})
|
|
exceptions = data.pop('exceptions', [])
|
|
for permission in ('view', 'edit'):
|
|
if permissions.get(permission):
|
|
data[permission + '_role'] = Group.objects.get(name=permissions[permission])
|
|
data = clean_import_data(cls, data)
|
|
unavailability_calendar, created = cls.objects.update_or_create(slug=data['slug'], defaults=data)
|
|
if overwrite:
|
|
TimePeriodException.objects.filter(unavailability_calendar=unavailability_calendar).delete()
|
|
for exception in exceptions:
|
|
exception['unavailability_calendar'] = unavailability_calendar
|
|
TimePeriodException.import_json(exception)
|
|
|
|
return created, unavailability_calendar
|
|
|
|
|
|
class TimePeriodExceptionGroup(models.Model):
|
|
unavailability_calendar = models.ForeignKey(UnavailabilityCalendar, on_delete=models.CASCADE)
|
|
slug = models.SlugField(_('Identifier'), max_length=160)
|
|
label = models.CharField(_('Label'), max_length=150)
|
|
|
|
class Meta:
|
|
ordering = ['label']
|
|
unique_together = ['unavailability_calendar', 'slug']
|
|
|
|
def __str__(self):
|
|
return self.label
|
|
|
|
|
|
class TimePeriodException(models.Model):
|
|
desk = models.ForeignKey(Desk, on_delete=models.CASCADE, null=True)
|
|
unavailability_calendar = models.ForeignKey(UnavailabilityCalendar, on_delete=models.CASCADE, null=True)
|
|
source = models.ForeignKey(TimePeriodExceptionSource, on_delete=models.CASCADE, null=True)
|
|
label = models.CharField(_('Optional Label'), max_length=150, blank=True, null=True)
|
|
start_datetime = models.DateTimeField(_('Exception start time'))
|
|
end_datetime = models.DateTimeField(_('Exception end time'))
|
|
update_datetime = models.DateTimeField(auto_now=True)
|
|
recurrence_id = models.PositiveIntegerField(_('Recurrence ID'), default=0)
|
|
group = models.ForeignKey(
|
|
TimePeriodExceptionGroup, on_delete=models.CASCADE, null=True, related_name='exceptions'
|
|
)
|
|
|
|
@property
|
|
def read_only(self):
|
|
if self.source_id:
|
|
return True
|
|
if self.unavailability_calendar_id:
|
|
return True
|
|
return False
|
|
|
|
class Meta:
|
|
ordering = ['start_datetime']
|
|
|
|
def __str__(self):
|
|
if is_midnight(self.start_datetime) and is_midnight(self.end_datetime):
|
|
# if both dates are at midnight don't include the time part
|
|
if self.end_datetime == self.start_datetime + datetime.timedelta(days=1):
|
|
# a single day
|
|
exc_repr = '%s' % date_format(localtime(self.start_datetime), 'SHORT_DATE_FORMAT')
|
|
else:
|
|
exc_repr = '%s → %s' % (
|
|
date_format(localtime(self.start_datetime), 'SHORT_DATE_FORMAT'),
|
|
date_format(localtime(self.end_datetime), 'SHORT_DATE_FORMAT'),
|
|
)
|
|
else:
|
|
if localtime(self.start_datetime).date() == localtime(self.end_datetime).date():
|
|
# same day
|
|
exc_repr = '%s → %s' % (
|
|
date_format(localtime(self.start_datetime), 'SHORT_DATETIME_FORMAT'),
|
|
date_format(localtime(self.end_datetime), 'TIME_FORMAT'),
|
|
)
|
|
else:
|
|
exc_repr = '%s → %s' % (
|
|
date_format(localtime(self.start_datetime), 'SHORT_DATETIME_FORMAT'),
|
|
date_format(localtime(self.end_datetime), 'SHORT_DATETIME_FORMAT'),
|
|
)
|
|
|
|
if self.label:
|
|
exc_repr = '%s (%s)' % (self.label, exc_repr)
|
|
|
|
return exc_repr
|
|
|
|
def has_booking_within_time_slot(self, target_desk=None):
|
|
if not (self.start_datetime and self.end_datetime):
|
|
# incomplete time period, can't tell
|
|
return False
|
|
|
|
query = Event.objects
|
|
if self.desk:
|
|
query = query.filter(desk=self.desk)
|
|
elif self.unavailability_calendar and not target_desk:
|
|
query = query.filter(desk__in=self.unavailability_calendar.desks.all())
|
|
elif target_desk:
|
|
query = query.filter(desk=target_desk)
|
|
else:
|
|
# orphan exception
|
|
return False
|
|
|
|
for event in query.filter(booking__isnull=False, booking__cancellation_datetime__isnull=True):
|
|
if self.start_datetime <= event.start_datetime < self.end_datetime:
|
|
return True
|
|
if event.meeting_type:
|
|
if (
|
|
event.start_datetime
|
|
<= self.start_datetime
|
|
< event.start_datetime + datetime.timedelta(minutes=event.meeting_type.duration)
|
|
):
|
|
return True
|
|
return False
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
def import_datetime(s):
|
|
'''Import datetime as a naive ISO8601 serialization'''
|
|
try:
|
|
return make_aware(datetime.datetime.strptime(s, '%Y-%m-%d %H:%M:%S'))
|
|
except ValueError:
|
|
raise AgendaImportError(_('Bad datetime format "%s"') % s)
|
|
|
|
for k, v in data.items():
|
|
if k.endswith('_datetime'):
|
|
data[k] = import_datetime(v)
|
|
data = clean_import_data(cls, data)
|
|
query_data = data.copy()
|
|
query_data.pop('update_datetime')
|
|
try:
|
|
cls.objects.update_or_create(defaults=data, **query_data)
|
|
except cls.MultipleObjectsReturned:
|
|
cls.objects.filter(**query_data).update(update_datetime=data['update_datetime'])
|
|
|
|
def export_json(self):
|
|
def export_datetime(dt):
|
|
'''Export datetime as a naive ISO8601 serialization'''
|
|
return make_naive(dt).strftime('%Y-%m-%d %H:%M:%S')
|
|
|
|
return {
|
|
'label': self.label,
|
|
'start_datetime': export_datetime(self.start_datetime),
|
|
'end_datetime': export_datetime(self.end_datetime),
|
|
'recurrence_id': self.recurrence_id,
|
|
'update_datetime': export_datetime(self.update_datetime),
|
|
}
|
|
|
|
def duplicate(self, desk_target=None, source_target=None):
|
|
# clone current exception
|
|
new_exception = copy.deepcopy(self)
|
|
new_exception.pk = None
|
|
# set desk
|
|
new_exception.desk = desk_target or self.desk
|
|
# set source
|
|
new_exception.source = source_target or self.source
|
|
# store new exception
|
|
new_exception.save()
|
|
|
|
return new_exception
|
|
|
|
def as_interval(self):
|
|
'''Simplify insertion into IntervalSet'''
|
|
return Interval(self.start_datetime, self.end_datetime)
|
|
|
|
|
|
class EventCancellationReport(models.Model):
|
|
event = models.ForeignKey(Event, related_name='cancellation_reports', on_delete=models.CASCADE)
|
|
timestamp = models.DateTimeField(auto_now_add=True)
|
|
seen = models.BooleanField(default=False)
|
|
bookings = models.ManyToManyField(Booking)
|
|
booking_errors = models.JSONField(default=dict)
|
|
|
|
def __str__(self):
|
|
return '%s - %s' % (self.timestamp.strftime('%Y-%m-%d %H:%M:%S'), self.event)
|
|
|
|
class Meta:
|
|
ordering = ['-timestamp']
|
|
|
|
|
|
class RecurrenceExceptionsReport(models.Model):
|
|
agenda = models.OneToOneField(
|
|
Agenda, related_name='recurrence_exceptions_report', on_delete=models.CASCADE
|
|
)
|
|
events = models.ManyToManyField(Event)
|
|
|
|
|
|
class NotificationType:
|
|
def __init__(self, name, related_field, settings):
|
|
self.name = name
|
|
self.related_field = related_field
|
|
self.settings = settings
|
|
|
|
@property
|
|
def enabled(self):
|
|
choice = getattr(self.settings, self.name)
|
|
if not choice:
|
|
return False
|
|
|
|
if choice == self.settings.EMAIL_FIELD:
|
|
return bool(getattr(self.settings, self.name + '_emails'))
|
|
|
|
return True
|
|
|
|
def get_recipients(self):
|
|
choice = getattr(self.settings, self.name)
|
|
if not choice:
|
|
return []
|
|
|
|
if choice == self.settings.EMAIL_FIELD:
|
|
return getattr(self.settings, self.name + '_emails')
|
|
|
|
role = self.settings.get_role_from_choice(choice)
|
|
if not role or not hasattr(role, 'role'):
|
|
return []
|
|
emails = role.role.emails
|
|
if role.role.emails_to_members:
|
|
emails.extend(role.user_set.values_list('email', flat=True))
|
|
return emails
|
|
|
|
@property
|
|
def display_value(self):
|
|
choice = getattr(self.settings, self.name)
|
|
if not choice:
|
|
return ''
|
|
|
|
if choice == self.settings.EMAIL_FIELD:
|
|
emails = getattr(self.settings, self.name + '_emails')
|
|
return ', '.join(emails)
|
|
|
|
role = self.settings.get_role_from_choice(choice) or _('undefined')
|
|
display_name = getattr(self.settings, 'get_%s_display' % self.name)()
|
|
return '%s (%s)' % (display_name, role)
|
|
|
|
@property
|
|
def label(self):
|
|
return self.settings._meta.get_field(self.name).verbose_name
|
|
|
|
|
|
class AgendaNotificationsSettings(models.Model):
|
|
EMAIL_FIELD = 'use-email-field'
|
|
VIEW_ROLE = 'view-role'
|
|
EDIT_ROLE = 'edit-role'
|
|
|
|
CHOICES = [
|
|
(EDIT_ROLE, _('Edit Role')),
|
|
(VIEW_ROLE, _('View Role')),
|
|
(EMAIL_FIELD, _('Specify email addresses manually')),
|
|
]
|
|
|
|
agenda = models.OneToOneField(Agenda, on_delete=models.CASCADE, related_name='notifications_settings')
|
|
|
|
almost_full_event = models.CharField(
|
|
max_length=16, blank=True, choices=CHOICES, verbose_name=_('Almost full event (90%)')
|
|
)
|
|
almost_full_event_emails = ArrayField(models.EmailField(), blank=True, null=True)
|
|
|
|
full_event = models.CharField(max_length=16, blank=True, choices=CHOICES, verbose_name=_('Full event'))
|
|
full_event_emails = ArrayField(models.EmailField(), blank=True, null=True)
|
|
|
|
cancelled_event = models.CharField(
|
|
max_length=16, blank=True, choices=CHOICES, verbose_name=_('Cancelled event')
|
|
)
|
|
cancelled_event_emails = ArrayField(models.EmailField(), blank=True, null=True)
|
|
|
|
@classmethod
|
|
def get_email_field_names(cls):
|
|
return [field.name for field in cls._meta.get_fields() if isinstance(field, ArrayField)]
|
|
|
|
@staticmethod
|
|
def get_role_field_names():
|
|
return ['almost_full_event', 'full_event', 'cancelled_event']
|
|
|
|
def get_notification_types(self):
|
|
for field in self.get_role_field_names():
|
|
notification_type = NotificationType(
|
|
name=field, related_field=field.replace('_event', ''), settings=self
|
|
)
|
|
if notification_type.enabled:
|
|
yield notification_type
|
|
|
|
def get_role_from_choice(self, choice):
|
|
if choice == self.EDIT_ROLE:
|
|
return self.agenda.edit_role
|
|
elif choice == self.VIEW_ROLE:
|
|
return self.agenda.view_role
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
data = clean_import_data(cls, data)
|
|
agenda = data.pop('agenda')
|
|
cls.objects.update_or_create(agenda=agenda, defaults=data)
|
|
|
|
def export_json(self):
|
|
return {
|
|
'almost_full_event': self.almost_full_event,
|
|
'almost_full_event_emails': self.almost_full_event_emails,
|
|
'full_event': self.full_event,
|
|
'full_event_emails': self.full_event_emails,
|
|
'cancelled_event': self.cancelled_event,
|
|
'cancelled_event_emails': self.cancelled_event_emails,
|
|
}
|
|
|
|
def duplicate(self, agenda_target):
|
|
new_settings = copy.deepcopy(self)
|
|
new_settings.pk = None
|
|
new_settings.agenda = agenda_target
|
|
new_settings.save()
|
|
return new_settings
|
|
|
|
|
|
class AgendaReminderSettings(models.Model):
|
|
ONE_DAY_BEFORE = 1
|
|
TWO_DAYS_BEFORE = 2
|
|
THREE_DAYS_BEFORE = 3
|
|
FOUR_DAYS_BEFORE = 4
|
|
FIVE_DAYS_BEFORE = 5
|
|
|
|
CHOICES = [
|
|
(None, _('Never')),
|
|
(ONE_DAY_BEFORE, _('One day before')),
|
|
(TWO_DAYS_BEFORE, _('Two days before')),
|
|
(THREE_DAYS_BEFORE, _('Three days before')),
|
|
(FOUR_DAYS_BEFORE, _('Four days before')),
|
|
(FIVE_DAYS_BEFORE, _('Five days before')),
|
|
]
|
|
|
|
agenda = models.OneToOneField(Agenda, on_delete=models.CASCADE, related_name='reminder_settings')
|
|
days_before_email = models.IntegerField(
|
|
null=True,
|
|
blank=True,
|
|
choices=CHOICES,
|
|
verbose_name=_('Send email reminder'),
|
|
help_text=_(
|
|
'In order to prevent users from getting a reminder shortly after booking, '
|
|
'a reminder is sent less only if at least 12 hours have elapsed since booking time.'
|
|
),
|
|
)
|
|
email_extra_info = models.TextField(
|
|
blank=True,
|
|
verbose_name=_('Additional text to include in emails'),
|
|
validators=[booking_template_validator],
|
|
help_text=_(
|
|
'Basic information such as event name, time and date are already included. '
|
|
'Booking object can be accessed using standard template syntax. '
|
|
'This allows to access agenda name via {{ booking.event.agenda.label }}, '
|
|
'meeting type name via {{ booking.event.meeting_type.label }}, or any extra '
|
|
'parameter passed on booking creation via {{ booking.extra_data.xxx }}.'
|
|
),
|
|
)
|
|
days_before_sms = models.IntegerField(
|
|
null=True,
|
|
blank=True,
|
|
choices=CHOICES,
|
|
verbose_name=_('Send SMS reminder'),
|
|
help_text=_(
|
|
'In order to prevent users from getting a reminder shortly after booking, '
|
|
'a reminder is sent less only if at least 12 hours have elapsed since booking time.'
|
|
),
|
|
)
|
|
sms_extra_info = models.TextField(
|
|
blank=True,
|
|
verbose_name=_('Additional text to include in SMS'),
|
|
validators=[booking_template_validator],
|
|
help_text=email_extra_info.help_text,
|
|
)
|
|
|
|
def display_info(self):
|
|
def get_message(days, by_email_or_sms):
|
|
return ngettext(
|
|
'Users will be reminded of their booking %(by_email_or_sms)s, one day in advance.',
|
|
'Users will be reminded of their booking %(by_email_or_sms)s, %(days)s days in advance.',
|
|
days,
|
|
) % {'days': days, 'by_email_or_sms': by_email_or_sms}
|
|
|
|
if self.days_before_email and self.days_before_email == self.days_before_sms:
|
|
return [get_message(self.days_before_email, _('both by email and by SMS'))]
|
|
|
|
messages = []
|
|
if self.days_before_email:
|
|
messages.append(get_message(self.days_before_email, _('by email')))
|
|
if self.days_before_sms:
|
|
messages.append(get_message(self.days_before_sms, _('by SMS')))
|
|
|
|
return messages
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
data = clean_import_data(cls, data)
|
|
agenda = data.pop('agenda')
|
|
cls.objects.update_or_create(agenda=agenda, defaults=data)
|
|
|
|
def export_json(self):
|
|
return {
|
|
'days_before_email': self.days_before_email,
|
|
'days_before_sms': self.days_before_sms,
|
|
'email_extra_info': self.email_extra_info,
|
|
'sms_extra_info': self.sms_extra_info,
|
|
}
|
|
|
|
def duplicate(self, agenda_target):
|
|
new_settings = copy.deepcopy(self)
|
|
new_settings.pk = None
|
|
new_settings.agenda = agenda_target
|
|
new_settings.save()
|
|
return new_settings
|
|
|
|
|
|
class Subscription(models.Model):
|
|
agenda = models.ForeignKey(Agenda, on_delete=models.CASCADE, related_name='subscriptions')
|
|
user_external_id = models.CharField(max_length=250)
|
|
user_last_name = models.CharField(max_length=250)
|
|
user_first_name = models.CharField(max_length=250)
|
|
user_email = models.EmailField(blank=True)
|
|
user_phone_number = models.CharField(max_length=30, blank=True)
|
|
extra_data = models.JSONField(null=True)
|
|
date_start = models.DateField()
|
|
date_end = models.DateField()
|
|
|
|
@property
|
|
def user_name(self):
|
|
return ('%s %s' % (self.user_first_name, self.user_last_name)).strip()
|
|
|
|
@property
|
|
def label(self):
|
|
return _('Subscription')
|
|
|
|
def get_user_block(self):
|
|
template_vars = Context(settings.TEMPLATE_VARS, autoescape=False)
|
|
template_vars.update(
|
|
{
|
|
'booking': self,
|
|
}
|
|
)
|
|
try:
|
|
return escape(Template(self.agenda.get_booking_user_block_template()).render(template_vars))
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
def get_extra_user_block(self, request):
|
|
context = RequestContext(request)
|
|
context.update(
|
|
{
|
|
'booking': self,
|
|
}
|
|
)
|
|
try:
|
|
return Template(self.agenda.booking_extra_user_block_template).render(context)
|
|
except (VariableDoesNotExist, TemplateSyntaxError):
|
|
return
|
|
|
|
|
|
class Person(models.Model):
|
|
user_external_id = models.CharField(max_length=250, unique=True)
|
|
first_name = models.CharField(max_length=250)
|
|
last_name = models.CharField(max_length=250)
|
|
|
|
def __str__(self):
|
|
return '%s %s' % (self.first_name, self.last_name)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class SharedCustodySlot:
|
|
guardian: Person = dataclasses.field(compare=False)
|
|
date: datetime.date
|
|
label: str = dataclasses.field(compare=False, default='')
|
|
|
|
def __str__(self):
|
|
if self.label:
|
|
return '%s (%s)' % (self.guardian, self.label)
|
|
else:
|
|
return str(self.guardian)
|
|
|
|
|
|
class SharedCustodyAgenda(models.Model):
|
|
first_guardian = models.ForeignKey(
|
|
Person, verbose_name=_('First guardian'), on_delete=models.CASCADE, related_name='+'
|
|
)
|
|
second_guardian = models.ForeignKey(
|
|
Person, verbose_name=_('Second guardian'), on_delete=models.CASCADE, related_name='+'
|
|
)
|
|
child = models.ForeignKey(Person, verbose_name=_('Child'), on_delete=models.CASCADE, related_name='+')
|
|
date_start = models.DateField(_('Start'))
|
|
date_end = models.DateField(_('End'), null=True)
|
|
|
|
class Meta:
|
|
constraints = [
|
|
models.UniqueConstraint(
|
|
fields=['child'], condition=Q(date_end__isnull=True), name='unique_child_no_date_end'
|
|
)
|
|
]
|
|
|
|
@property
|
|
def label(self):
|
|
return _('Custody agenda of %(first_guardian)s and %(second_guardian)s for %(child)s') % {
|
|
'first_guardian': self.first_guardian,
|
|
'second_guardian': self.second_guardian,
|
|
'child': self.child,
|
|
}
|
|
|
|
def get_absolute_url(self):
|
|
return reverse('chrono-manager-shared-custody-agenda-view', kwargs={'pk': self.pk})
|
|
|
|
def get_settings_url(self):
|
|
return reverse('chrono-manager-shared-custody-agenda-settings', kwargs={'pk': self.pk})
|
|
|
|
def get_custody_slots(self, min_date, max_date):
|
|
slots = set()
|
|
|
|
periods = (
|
|
self.periods.filter(date_start__lt=max_date, date_end__gt=min_date)
|
|
.order_by('-holiday_rule')
|
|
.select_related('holiday_rule__holiday', 'guardian')
|
|
)
|
|
for period in periods:
|
|
date = max(period.date_start, min_date)
|
|
label = period.holiday_rule.holiday.label if period.holiday_rule else ''
|
|
while date < period.date_end and date < max_date:
|
|
slots.add(SharedCustodySlot(guardian=period.guardian, date=date, label=label))
|
|
date += datetime.timedelta(days=1)
|
|
|
|
for rule in self.rules.all().select_related('guardian'):
|
|
slots.update(rule.get_slots(min_date, max_date))
|
|
|
|
slots = sorted(slots, key=lambda x: x.date)
|
|
return slots
|
|
|
|
def is_complete(self):
|
|
day_counts = self.rules.aggregate(
|
|
all_week=Coalesce(
|
|
SumCardinality('days', filter=Q(weeks='')), 0, output_field=models.IntegerField()
|
|
),
|
|
even_week=Coalesce(
|
|
SumCardinality('days', filter=Q(weeks='even')), 0, output_field=models.IntegerField()
|
|
),
|
|
odd_week=Coalesce(
|
|
SumCardinality('days', filter=Q(weeks='odd')), 0, output_field=models.IntegerField()
|
|
),
|
|
)
|
|
even_week_day_count = day_counts['all_week'] + day_counts['even_week']
|
|
odd_week_day_count = day_counts['all_week'] + day_counts['odd_week']
|
|
return bool(even_week_day_count == 7 and odd_week_day_count == 7)
|
|
|
|
def rule_overlaps(self, days, weeks, instance=None):
|
|
qs = self.rules
|
|
if hasattr(instance, 'pk'):
|
|
qs = qs.exclude(pk=instance.pk)
|
|
|
|
if weeks:
|
|
qs = qs.filter(Q(weeks='') | Q(weeks=weeks))
|
|
|
|
qs = qs.filter(days__overlap=days)
|
|
return qs.exists()
|
|
|
|
def holiday_rule_overlaps(self, holiday, years, periodicity, instance=None):
|
|
qs = self.holiday_rules.filter(holiday=holiday)
|
|
if hasattr(instance, 'pk'):
|
|
qs = qs.exclude(pk=instance.pk)
|
|
|
|
if years:
|
|
qs = qs.filter(Q(years='') | Q(years=years))
|
|
|
|
if periodicity == 'first-half':
|
|
qs = qs.exclude(periodicity='second-half')
|
|
elif periodicity == 'second-half':
|
|
qs = qs.exclude(periodicity='first-half')
|
|
elif periodicity == 'first-and-third-quarters':
|
|
qs = qs.exclude(periodicity='second-and-fourth-quarters')
|
|
elif periodicity == 'second-and-fourth-quarters':
|
|
qs = qs.exclude(periodicity='first-and-third-quarters')
|
|
|
|
return qs.exists()
|
|
|
|
def period_overlaps(self, date_start, date_end, instance=None):
|
|
qs = self.periods.filter(holiday_rule__isnull=True)
|
|
if hasattr(instance, 'pk'):
|
|
qs = qs.exclude(pk=instance.pk)
|
|
|
|
qs = qs.extra(
|
|
where=["(date_start, date_end) OVERLAPS (%s, %s)"],
|
|
params=[date_start, date_end],
|
|
)
|
|
return qs.exists()
|
|
|
|
|
|
class SharedCustodyRule(models.Model):
|
|
WEEK_CHOICES = [
|
|
('', pgettext_lazy('weeks', 'All')),
|
|
('even', pgettext_lazy('weeks', 'Even')),
|
|
('odd', pgettext_lazy('weeks', 'Odd')),
|
|
]
|
|
|
|
agenda = models.ForeignKey(SharedCustodyAgenda, on_delete=models.CASCADE, related_name='rules')
|
|
days = ArrayField(
|
|
models.IntegerField(choices=WEEKDAY_CHOICES),
|
|
verbose_name=_('Days'),
|
|
)
|
|
weeks = models.CharField(_('Weeks'), choices=WEEK_CHOICES, blank=True, max_length=16)
|
|
guardian = models.ForeignKey(Person, verbose_name=_('Guardian'), on_delete=models.CASCADE)
|
|
|
|
def get_slots(self, min_date, max_date):
|
|
recurrence_rule = {
|
|
'freq': WEEKLY,
|
|
'byweekday': self.days,
|
|
}
|
|
if self.weeks == 'odd':
|
|
recurrence_rule['byweekno'] = list(range(1, 55, 2))
|
|
elif self.weeks == 'even':
|
|
recurrence_rule['byweekno'] = list(range(0, 54, 2))
|
|
|
|
return [
|
|
SharedCustodySlot(self.guardian, dt.date())
|
|
for dt in rrule(dtstart=min_date, until=max_date - datetime.timedelta(days=1), **recurrence_rule)
|
|
]
|
|
|
|
@property
|
|
def label(self):
|
|
days_count = len(self.days)
|
|
if days_count == 7:
|
|
repeat = _('daily')
|
|
elif days_count > 1 and (self.days[-1] - self.days[0]) == days_count - 1:
|
|
# days are contiguous
|
|
repeat = _('from %(weekday)s to %(last_weekday)s') % {
|
|
'weekday': str(WEEKDAYS[self.days[0]]),
|
|
'last_weekday': str(WEEKDAYS[self.days[-1]]),
|
|
}
|
|
else:
|
|
repeat = _('on %(weekdays)s') % {
|
|
'weekdays': ', '.join([str(WEEKDAYS_PLURAL[i]) for i in self.days])
|
|
}
|
|
|
|
if self.weeks == 'odd':
|
|
repeat = '%s, %s' % (repeat, _('on odd weeks'))
|
|
elif self.weeks == 'even':
|
|
repeat = '%s, %s' % (repeat, _('on even weeks'))
|
|
|
|
return repeat
|
|
|
|
class Meta:
|
|
ordering = ['days__0', 'weeks']
|
|
|
|
|
|
class SharedCustodyHolidayRule(models.Model):
|
|
YEAR_CHOICES = [
|
|
('', pgettext_lazy('years', 'All')),
|
|
('even', pgettext_lazy('years', 'Even')),
|
|
('odd', pgettext_lazy('years', 'Odd')),
|
|
]
|
|
|
|
PERIODICITY_CHOICES = [
|
|
('first-half', _('First half')),
|
|
('second-half', _('Second half')),
|
|
('first-and-third-quarters', _('First and third quarters')),
|
|
('second-and-fourth-quarters', _('Second and fourth quarters')),
|
|
]
|
|
|
|
agenda = models.ForeignKey(SharedCustodyAgenda, on_delete=models.CASCADE, related_name='holiday_rules')
|
|
holiday = models.ForeignKey(TimePeriodExceptionGroup, verbose_name=_('Holiday'), on_delete=models.PROTECT)
|
|
years = models.CharField(_('Years'), choices=YEAR_CHOICES, blank=True, max_length=16)
|
|
periodicity = models.CharField(_('Periodicity'), choices=PERIODICITY_CHOICES, blank=True, max_length=32)
|
|
guardian = models.ForeignKey(Person, verbose_name=_('Guardian'), on_delete=models.CASCADE)
|
|
|
|
def update_or_create_periods(self):
|
|
shared_custody_periods = []
|
|
for exception in self.holiday.exceptions.all():
|
|
date_start = localtime(exception.start_datetime).date()
|
|
|
|
if self.years == 'even' and date_start.year % 2:
|
|
continue
|
|
if self.years == 'odd' and not date_start.year % 2:
|
|
continue
|
|
|
|
date_start_sunday = date_start + relativedelta(weekday=SU)
|
|
date_end = localtime(exception.end_datetime).date()
|
|
|
|
number_of_weeks = (date_end - date_start_sunday).days // 7
|
|
|
|
periods = []
|
|
if self.periodicity == 'first-half':
|
|
date_end = date_start_sunday + datetime.timedelta(days=7 * (number_of_weeks // 2))
|
|
periods = [(date_start, date_end)]
|
|
elif self.periodicity == 'second-half':
|
|
date_start = date_start_sunday + datetime.timedelta(days=7 * (number_of_weeks // 2))
|
|
periods = [(date_start, date_end)]
|
|
elif self.periodicity == 'first-and-third-quarters' and number_of_weeks >= 4:
|
|
weeks_in_quarters = round(number_of_weeks / 4)
|
|
first_quarters_date_end = date_start_sunday + datetime.timedelta(days=7 * weeks_in_quarters)
|
|
third_quarters_date_start = date_start_sunday + datetime.timedelta(
|
|
days=7 * weeks_in_quarters * 2
|
|
)
|
|
third_quarters_date_end = date_start_sunday + datetime.timedelta(
|
|
days=7 * weeks_in_quarters * 3
|
|
)
|
|
periods = [
|
|
(date_start, first_quarters_date_end),
|
|
(third_quarters_date_start, third_quarters_date_end),
|
|
]
|
|
elif self.periodicity == 'second-and-fourth-quarters' and number_of_weeks >= 4:
|
|
weeks_in_quarters = round(number_of_weeks / 4)
|
|
second_quarters_date_start = date_start_sunday + datetime.timedelta(
|
|
days=7 * weeks_in_quarters
|
|
)
|
|
second_quarters_date_end = date_start_sunday + datetime.timedelta(
|
|
days=7 * weeks_in_quarters * 2
|
|
)
|
|
fourth_quarters_date_start = date_start_sunday + datetime.timedelta(
|
|
days=7 * weeks_in_quarters * 3
|
|
)
|
|
periods = [
|
|
(second_quarters_date_start, second_quarters_date_end),
|
|
(fourth_quarters_date_start, date_end),
|
|
]
|
|
elif not self.periodicity:
|
|
periods = [(date_start, date_end)]
|
|
|
|
for date_start, date_end in periods:
|
|
shared_custody_periods.append(
|
|
SharedCustodyPeriod(
|
|
guardian=self.guardian,
|
|
agenda=self.agenda,
|
|
holiday_rule=self,
|
|
date_start=date_start,
|
|
date_end=date_end,
|
|
)
|
|
)
|
|
|
|
with transaction.atomic():
|
|
SharedCustodyPeriod.objects.filter(
|
|
guardian=self.guardian, agenda=self.agenda, holiday_rule=self
|
|
).delete()
|
|
SharedCustodyPeriod.objects.bulk_create(shared_custody_periods)
|
|
|
|
@property
|
|
def label(self):
|
|
label = self.holiday.label
|
|
|
|
if self.periodicity == 'first-half':
|
|
label = '%s, %s' % (label, _('the first half'))
|
|
elif self.periodicity == 'second-half':
|
|
label = '%s, %s' % (label, _('the second half'))
|
|
elif self.periodicity == 'first-and-third-quarters':
|
|
label = '%s, %s' % (label, _('the first and third quarters'))
|
|
elif self.periodicity == 'second-and-fourth-quarters':
|
|
label = '%s, %s' % (label, _('the second and fourth quarters'))
|
|
|
|
if self.years == 'odd':
|
|
label = '%s, %s' % (label, _('on odd years'))
|
|
elif self.years == 'even':
|
|
label = '%s, %s' % (label, _('on even years'))
|
|
|
|
return label
|
|
|
|
class Meta:
|
|
ordering = ['holiday__label', 'guardian', 'years', 'periodicity']
|
|
|
|
|
|
class SharedCustodyPeriod(models.Model):
|
|
agenda = models.ForeignKey(SharedCustodyAgenda, on_delete=models.CASCADE, related_name='periods')
|
|
guardian = models.ForeignKey(Person, on_delete=models.CASCADE, related_name='+')
|
|
holiday_rule = models.ForeignKey(SharedCustodyHolidayRule, null=True, on_delete=models.CASCADE)
|
|
date_start = models.DateField(_('Start'))
|
|
date_end = models.DateField(_('End'))
|
|
|
|
class Meta:
|
|
ordering = ['date_start']
|
|
|
|
def __str__(self):
|
|
if self.date_end == self.date_start + datetime.timedelta(days=1):
|
|
exc_repr = '%s' % date_format(self.date_start, 'SHORT_DATE_FORMAT')
|
|
else:
|
|
exc_repr = '%s → %s' % (
|
|
date_format(self.date_start, 'SHORT_DATE_FORMAT'),
|
|
date_format(self.date_end, 'SHORT_DATE_FORMAT'),
|
|
)
|
|
return '%s, %s' % (self.guardian, exc_repr)
|
|
|
|
|
|
class SharedCustodySettings(models.Model):
|
|
management_role = models.ForeignKey(
|
|
Group,
|
|
blank=True,
|
|
null=True,
|
|
default=None,
|
|
related_name='+',
|
|
verbose_name=_('Management role'),
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
holidays_calendar = models.ForeignKey(
|
|
UnavailabilityCalendar,
|
|
verbose_name=_('Holidays calendar'),
|
|
null=True,
|
|
blank=True,
|
|
related_name='+',
|
|
on_delete=models.SET_NULL,
|
|
)
|
|
|
|
def export_json(self):
|
|
return {
|
|
'management_role': self.management_role.name if self.management_role else None,
|
|
'holidays_calendar': self.holidays_calendar.slug if self.holidays_calendar else None,
|
|
}
|
|
|
|
@classmethod
|
|
def import_json(cls, data):
|
|
if data.get('management_role'):
|
|
data['management_role'] = Group.objects.get(name=data['management_role'])
|
|
|
|
if data.get('holidays_calendar'):
|
|
try:
|
|
data['holidays_calendar'] = UnavailabilityCalendar.objects.get(slug=data['holidays_calendar'])
|
|
except UnavailabilityCalendar.DoesNotExist:
|
|
raise AgendaImportError(
|
|
_('The unavailability calendar "%s" does not exist.') % data['holidays_calendar']
|
|
)
|
|
|
|
cls.objects.update_or_create(defaults=data)
|
|
|
|
@classmethod
|
|
def get_singleton(cls):
|
|
try:
|
|
return cls.objects.get()
|
|
except cls.DoesNotExist:
|
|
return cls()
|