730 lines
28 KiB
Python
730 lines
28 KiB
Python
import collections
|
|
import datetime
|
|
|
|
from django.contrib.auth.models import Group
|
|
from django.db import models, transaction
|
|
from django.db.models import ExpressionWrapper, F
|
|
from django.utils.translation import gettext_lazy as _
|
|
from rest_framework import serializers
|
|
from rest_framework.exceptions import ValidationError
|
|
|
|
from chrono.agendas.models import (
|
|
Agenda,
|
|
Booking,
|
|
BookingColor,
|
|
Category,
|
|
Event,
|
|
EventsType,
|
|
Person,
|
|
SharedCustodyAgenda,
|
|
SharedCustodyHolidayRule,
|
|
SharedCustodyRule,
|
|
Subscription,
|
|
TimePeriodExceptionGroup,
|
|
)
|
|
from chrono.utils.lingo import get_agenda_check_types
|
|
|
|
|
|
def get_objects_from_slugs(slugs, qs):
|
|
slugs = set(slugs)
|
|
objects = qs.filter(slug__in=slugs)
|
|
if len(objects) != len(slugs):
|
|
unknown_slugs = sorted(slugs - {obj.slug for obj in objects})
|
|
unknown_slugs = ', '.join(unknown_slugs)
|
|
raise ValidationError(('invalid slugs: %s') % unknown_slugs)
|
|
return objects
|
|
|
|
|
|
class StringOrListField(serializers.ListField):
|
|
def to_internal_value(self, data):
|
|
if isinstance(data, str):
|
|
data = [s.strip() for s in data.split(',') if s.strip()]
|
|
return super().to_internal_value(data)
|
|
|
|
|
|
class CommaSeparatedStringField(serializers.ListField):
|
|
def get_value(self, dictionary):
|
|
return super(serializers.ListField, self).get_value(dictionary)
|
|
|
|
def to_internal_value(self, data):
|
|
data = [s.strip() for s in data.split(',') if s.strip()]
|
|
return super().to_internal_value(data)
|
|
|
|
|
|
class DateRangeMixin(metaclass=serializers.SerializerMetaclass):
|
|
datetime_formats = ['%Y-%m-%d', '%Y-%m-%d %H:%M', 'iso-8601']
|
|
|
|
date_start = serializers.DateTimeField(required=False, input_formats=datetime_formats)
|
|
date_end = serializers.DateTimeField(required=False, input_formats=datetime_formats)
|
|
|
|
|
|
class AgendaSlugsMixin(metaclass=serializers.SerializerMetaclass):
|
|
agendas = CommaSeparatedStringField(
|
|
required=False, child=serializers.SlugField(max_length=160, allow_blank=False)
|
|
)
|
|
|
|
def get_agenda_qs(self):
|
|
return Agenda.objects.filter(kind='events').select_related('events_type')
|
|
|
|
|
|
class FillSlotSerializer(serializers.Serializer):
|
|
label = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_external_id = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_name = serializers.CharField(max_length=250, allow_blank=True) # compatibility
|
|
user_first_name = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_last_name = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_display_label = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_email = serializers.CharField(max_length=250, allow_blank=True)
|
|
user_phone_number = serializers.CharField(max_length=16, allow_blank=True)
|
|
exclude_user = serializers.BooleanField(default=False)
|
|
events = serializers.CharField(max_length=16, allow_blank=True)
|
|
bypass_delays = serializers.BooleanField(default=False)
|
|
form_url = serializers.CharField(max_length=250, allow_blank=True)
|
|
backoffice_url = serializers.URLField(allow_blank=True)
|
|
cancel_callback_url = serializers.URLField(allow_blank=True)
|
|
count = serializers.IntegerField(min_value=1)
|
|
cancel_booking_id = serializers.CharField(max_length=250, allow_blank=True, allow_null=True)
|
|
force_waiting_list = serializers.BooleanField(default=False)
|
|
use_color_for = serializers.CharField(max_length=250, allow_blank=True)
|
|
extra_emails = StringOrListField(
|
|
required=False, child=serializers.EmailField(max_length=250, allow_blank=False)
|
|
)
|
|
extra_phone_numbers = StringOrListField(
|
|
required=False, child=serializers.CharField(max_length=16, allow_blank=False)
|
|
)
|
|
check_overlaps = serializers.BooleanField(default=False)
|
|
|
|
|
|
class SlotsSerializer(serializers.Serializer):
|
|
slots = StringOrListField(required=True, child=serializers.CharField(max_length=160, allow_blank=False))
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if not attrs.get('slots'):
|
|
raise serializers.ValidationError({'slots': _('This field is required.')})
|
|
return attrs
|
|
|
|
|
|
class FillSlotsSerializer(FillSlotSerializer, SlotsSerializer):
|
|
pass
|
|
|
|
|
|
class EventsFillSlotsSerializer(FillSlotSerializer):
|
|
slots = StringOrListField(required=True, child=serializers.CharField(max_length=160))
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if 'slots' not in attrs:
|
|
raise serializers.ValidationError({'slots': _('This field is required.')})
|
|
if not attrs.get('user_external_id'):
|
|
raise serializers.ValidationError({'user_external_id': _('This field is required.')})
|
|
if 'exclude_user' in attrs:
|
|
raise serializers.ValidationError({'exclude_user': _('This parameter is not supported.')})
|
|
return attrs
|
|
|
|
|
|
class MultipleAgendasEventsFillSlotsSerializer(EventsFillSlotsSerializer):
|
|
def validate_slots(self, value):
|
|
allowed_agenda_slugs = self.context['allowed_agenda_slugs']
|
|
slots_agenda_slugs = set()
|
|
for slot in value:
|
|
try:
|
|
agenda_slug, event_slug = slot.split('@')
|
|
except ValueError:
|
|
raise ValidationError(_('Invalid format for slot %s') % slot)
|
|
if not agenda_slug:
|
|
raise ValidationError(_('Missing agenda slug in slot %s') % slot)
|
|
if not event_slug:
|
|
raise ValidationError(_('Missing event slug in slot %s') % slot)
|
|
slots_agenda_slugs.add(agenda_slug)
|
|
|
|
extra_agendas = slots_agenda_slugs - set(allowed_agenda_slugs)
|
|
if extra_agendas:
|
|
extra_agendas = ', '.join(sorted(extra_agendas))
|
|
raise ValidationError(_('Events from the following agendas cannot be booked: %s') % extra_agendas)
|
|
return value
|
|
|
|
|
|
class MultipleAgendasEventsCheckStatusSerializer(AgendaSlugsMixin, DateRangeMixin, serializers.Serializer):
|
|
user_external_id = serializers.CharField(required=False, max_length=250, allow_blank=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
for field in ['agendas', 'user_external_id', 'date_start', 'date_end']:
|
|
self.fields[field].required = True
|
|
|
|
def validate_agendas(self, value):
|
|
return get_objects_from_slugs(value, qs=self.get_agenda_qs())
|
|
|
|
|
|
class RecurringFillslotsSerializer(MultipleAgendasEventsFillSlotsSerializer):
|
|
include_booked_events_detail = serializers.BooleanField(default=False)
|
|
|
|
def validate_slots(self, value):
|
|
super().validate_slots(value)
|
|
self.initial_slots = value
|
|
open_event_slugs = collections.defaultdict(set)
|
|
for agenda in self.context['agendas']:
|
|
for event in agenda.get_open_recurring_events():
|
|
open_event_slugs[agenda.slug].add(event.slug)
|
|
|
|
slots = collections.defaultdict(lambda: collections.defaultdict(list))
|
|
for slot in value:
|
|
try:
|
|
slugs, day = slot.split(':')
|
|
day = int(day)
|
|
except ValueError:
|
|
raise ValidationError(_('invalid slot: %s') % slot)
|
|
|
|
agenda_slug, event_slug = slugs.split('@')
|
|
if event_slug not in open_event_slugs[agenda_slug]:
|
|
raise ValidationError(
|
|
_('event %(event_slug)s of agenda %(agenda_slug)s is not bookable')
|
|
% {'event_slug': event_slug, 'agenda_slug': agenda_slug}
|
|
)
|
|
|
|
# convert ISO day number to db lookup day number
|
|
day = (day + 1) % 7 + 1
|
|
slots[agenda_slug][event_slug].append(day)
|
|
|
|
return slots
|
|
|
|
|
|
class BookingSerializer(serializers.ModelSerializer):
|
|
user_absence_reason = serializers.CharField(required=False, allow_blank=True, allow_null=True)
|
|
user_presence_reason = serializers.CharField(required=False, allow_blank=True, allow_null=True)
|
|
use_color_for = serializers.CharField(required=False, allow_blank=True, allow_null=True, source='color')
|
|
|
|
class Meta:
|
|
model = Booking
|
|
fields = [
|
|
'id',
|
|
'in_waiting_list',
|
|
'user_first_name',
|
|
'user_last_name',
|
|
'user_email',
|
|
'user_phone_number',
|
|
'user_was_present',
|
|
'user_absence_reason',
|
|
'user_presence_reason',
|
|
'use_color_for',
|
|
'extra_data',
|
|
'creation_datetime',
|
|
'cancellation_datetime',
|
|
'label',
|
|
]
|
|
read_only_fields = [
|
|
'id',
|
|
'in_waiting_list',
|
|
'extra_data',
|
|
'creation_datetime',
|
|
'cancellation_datetime',
|
|
]
|
|
|
|
def to_internal_value(self, data):
|
|
if 'color' in data:
|
|
# legacy
|
|
data['use_color_for'] = data['color']
|
|
del data['color']
|
|
return super().to_internal_value(data)
|
|
|
|
def to_representation(self, instance):
|
|
ret = super().to_representation(instance)
|
|
if self.instance.event.agenda.kind != 'events':
|
|
ret['desk'] = {
|
|
'slug': self.instance.event.desk.slug,
|
|
'label': self.instance.event.desk.label,
|
|
}
|
|
ret.pop('user_was_present', None)
|
|
ret.pop('user_absence_reason', None)
|
|
ret.pop('user_presence_reason', None)
|
|
else:
|
|
ret['user_absence_reason'] = (
|
|
self.instance.user_check_type_slug if self.instance.user_was_present is False else None
|
|
)
|
|
ret['user_presence_reason'] = (
|
|
self.instance.user_check_type_slug if self.instance.user_was_present is True else None
|
|
)
|
|
return ret
|
|
|
|
def _validate_check_type(self, kind, value):
|
|
if not value:
|
|
return None
|
|
|
|
error_messages = {
|
|
'absence': _('unknown absence reason'),
|
|
'presence': _('unknown presence reason'),
|
|
}
|
|
|
|
check_types = get_agenda_check_types(self.instance.event.agenda)
|
|
for check_type in check_types:
|
|
if check_type.kind != kind:
|
|
continue
|
|
if value in [check_type.slug, check_type.label]:
|
|
return check_type
|
|
raise serializers.ValidationError(error_messages[kind])
|
|
|
|
def validate_user_absence_reason(self, value):
|
|
return self._validate_check_type('absence', value)
|
|
|
|
def validate_user_presence_reason(self, value):
|
|
return self._validate_check_type('presence', value)
|
|
|
|
def validate_use_color_for(self, value):
|
|
if value:
|
|
return BookingColor.objects.get_or_create(label=value)[0]
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if 'user_absence_reason' in attrs and 'user_presence_reason' in attrs:
|
|
raise ValidationError(
|
|
{'user_absence_reason': _('can not set user_absence_reason and user_presence_reason')}
|
|
)
|
|
if 'user_absence_reason' in attrs:
|
|
check_type = attrs['user_absence_reason']
|
|
attrs['user_check_type_slug'] = check_type.slug if check_type else None
|
|
attrs['user_check_type_label'] = check_type.label if check_type else None
|
|
del attrs['user_absence_reason']
|
|
elif 'user_presence_reason' in attrs:
|
|
check_type = attrs['user_presence_reason']
|
|
attrs['user_check_type_slug'] = check_type.slug if check_type else None
|
|
attrs['user_check_type_label'] = check_type.label if check_type else None
|
|
del attrs['user_presence_reason']
|
|
return attrs
|
|
|
|
|
|
class ResizeSerializer(serializers.Serializer):
|
|
count = serializers.IntegerField(min_value=1)
|
|
|
|
|
|
class StatisticsFiltersSerializer(serializers.Serializer):
|
|
time_interval = serializers.ChoiceField(choices=('day', _('Day')), default='day')
|
|
start = serializers.DateTimeField(required=False, input_formats=['iso-8601', '%Y-%m-%d'])
|
|
end = serializers.DateTimeField(required=False, input_formats=['iso-8601', '%Y-%m-%d'])
|
|
category = serializers.SlugField(required=False, allow_blank=False, max_length=256)
|
|
agenda = serializers.CharField(required=False, allow_blank=False, max_length=256)
|
|
group_by = serializers.ListField(
|
|
required=False, child=serializers.SlugField(allow_blank=False, max_length=256)
|
|
)
|
|
|
|
|
|
class DateRangeSerializer(DateRangeMixin, serializers.Serializer):
|
|
pass
|
|
|
|
|
|
class DatetimesSerializer(DateRangeSerializer):
|
|
min_places = serializers.IntegerField(min_value=1, default=1)
|
|
user_external_id = serializers.CharField(required=False, max_length=250, allow_blank=True)
|
|
exclude_user_external_id = serializers.CharField(required=False, max_length=250, allow_blank=True)
|
|
events = serializers.CharField(required=False, max_length=32, allow_blank=True)
|
|
hide_disabled = serializers.BooleanField(default=False)
|
|
bypass_delays = serializers.BooleanField(default=False)
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if (
|
|
'user_external_id' in attrs
|
|
and 'exclude_user_external_id' in attrs
|
|
and attrs['user_external_id'] != attrs['exclude_user_external_id']
|
|
):
|
|
raise ValidationError(
|
|
{'user_external_id': _('user_external_id and exclude_user_external_id have different values')}
|
|
)
|
|
return attrs
|
|
|
|
|
|
class AgendaOrSubscribedSlugsMixin(AgendaSlugsMixin):
|
|
subscribed = CommaSeparatedStringField(
|
|
required=False, child=serializers.SlugField(max_length=160, allow_blank=False)
|
|
)
|
|
user_external_id = serializers.CharField(required=False, max_length=250, allow_blank=False)
|
|
guardian_external_id = serializers.CharField(required=False, max_length=250, allow_blank=True)
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if 'agendas' not in attrs and 'subscribed' not in attrs:
|
|
raise ValidationError(_('Either "agendas" or "subscribed" parameter is required.'))
|
|
if 'agendas' in attrs and 'subscribed' in attrs:
|
|
raise ValidationError(_('"agendas" and "subscribed" parameters are mutually exclusive.'))
|
|
user_external_id = attrs.get('user_external_id', self.context.get('user_external_id'))
|
|
if 'subscribed' in attrs and not user_external_id:
|
|
raise ValidationError(
|
|
{'user_external_id': _('This field is required when using "subscribed" parameter.')}
|
|
)
|
|
if attrs.get('guardian_external_id') and not user_external_id:
|
|
raise serializers.ValidationError(
|
|
{'user_external_id': _('This field is required when using "guardian_external_id" parameter.')}
|
|
)
|
|
|
|
if 'subscribed' in attrs:
|
|
lookups = {'subscriptions__user_external_id': user_external_id}
|
|
if 'date_start' in attrs:
|
|
# subscription must end after requested date_start
|
|
lookups['subscriptions__date_end__gt'] = attrs['date_start']
|
|
if 'date_end' in attrs:
|
|
# subscription must start before requested date end
|
|
lookups['subscriptions__date_start__lte'] = attrs['date_end']
|
|
agendas = self.get_agenda_qs().filter(**lookups).distinct().select_related('category')
|
|
|
|
if attrs['subscribed'] != ['all']:
|
|
agendas = agendas.filter(category__slug__in=attrs['subscribed'])
|
|
|
|
attrs['agendas'] = agendas
|
|
attrs['agenda_slugs'] = [agenda.slug for agenda in agendas]
|
|
else:
|
|
attrs['agenda_slugs'] = self.agenda_slugs
|
|
return attrs
|
|
|
|
def validate_agendas(self, value):
|
|
self.agenda_slugs = value
|
|
return get_objects_from_slugs(value, qs=self.get_agenda_qs())
|
|
|
|
|
|
class MultipleAgendasDatetimesSerializer(AgendaOrSubscribedSlugsMixin, DatetimesSerializer):
|
|
show_past_events = serializers.BooleanField(default=False)
|
|
with_status = serializers.BooleanField(default=False)
|
|
check_overlaps = serializers.BooleanField(default=False)
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
user_external_id = attrs.get('user_external_id')
|
|
if attrs.get('with_status') and not user_external_id:
|
|
raise ValidationError(
|
|
{'user_external_id': _('This field is required when using "with_status" parameter.')}
|
|
)
|
|
return attrs
|
|
|
|
|
|
class AgendaOrSubscribedSlugsSerializer(AgendaOrSubscribedSlugsMixin, DateRangeMixin, serializers.Serializer):
|
|
pass
|
|
|
|
|
|
class RecurringFillslotsQueryStringSerializer(AgendaOrSubscribedSlugsSerializer):
|
|
action = serializers.ChoiceField(required=True, choices=['update', 'book', 'unbook'])
|
|
|
|
|
|
class RecurringEventsListSerializer(AgendaOrSubscribedSlugsSerializer):
|
|
sort = serializers.ChoiceField(required=False, choices=['day'])
|
|
check_overlaps = serializers.BooleanField(default=False)
|
|
|
|
|
|
class EventSerializer(serializers.ModelSerializer):
|
|
recurrence_days = StringOrListField(
|
|
required=False, child=serializers.IntegerField(min_value=0, max_value=6)
|
|
)
|
|
primary_event = serializers.SlugRelatedField(read_only=True, slug_field='slug')
|
|
agenda = serializers.SlugRelatedField(read_only=True, slug_field='slug')
|
|
|
|
class Meta:
|
|
model = Event
|
|
fields = [
|
|
'start_datetime',
|
|
'recurrence_days',
|
|
'recurrence_week_interval',
|
|
'recurrence_end_date',
|
|
'duration',
|
|
'publication_datetime',
|
|
'places',
|
|
'waiting_list_places',
|
|
'label',
|
|
'slug',
|
|
'description',
|
|
'pricing',
|
|
'url',
|
|
'primary_event',
|
|
'agenda',
|
|
]
|
|
read_only_fields = ['slug']
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
if not self.instance.agenda.events_type:
|
|
return
|
|
field_classes = {
|
|
'text': serializers.CharField,
|
|
'textarea': serializers.CharField,
|
|
'bool': serializers.NullBooleanField,
|
|
}
|
|
field_options = {
|
|
'text': {'allow_blank': True},
|
|
'textarea': {'allow_blank': True},
|
|
}
|
|
for custom_field in self.instance.agenda.events_type.get_custom_fields():
|
|
field_class = field_classes[custom_field['field_type']]
|
|
field_name = 'custom_field_%s' % custom_field['varname']
|
|
self.fields[field_name] = field_class(
|
|
required=False,
|
|
read_only=self.instance.primary_event is not None,
|
|
**(field_options.get(custom_field['field_type']) or {}),
|
|
)
|
|
|
|
def validate(self, attrs):
|
|
if not self.instance.agenda.events_type:
|
|
return attrs
|
|
if self.instance.primary_event:
|
|
return attrs
|
|
defaults = {
|
|
'text': '',
|
|
'textarea': '',
|
|
'bool': None,
|
|
}
|
|
custom_fields = self.instance.custom_fields
|
|
for custom_field in self.instance.agenda.events_type.get_custom_fields():
|
|
varname = custom_field['varname']
|
|
field_name = 'custom_field_%s' % varname
|
|
if varname not in custom_fields:
|
|
# set default
|
|
custom_fields[varname] = defaults[custom_field['field_type']]
|
|
if field_name in attrs:
|
|
custom_fields[varname] = attrs[field_name]
|
|
del attrs[field_name]
|
|
attrs['custom_fields'] = custom_fields
|
|
return attrs
|
|
|
|
def to_representation(self, instance):
|
|
ret = super().to_representation(instance)
|
|
if not self.instance.agenda.events_type:
|
|
return ret
|
|
defaults = {
|
|
'text': '',
|
|
'textarea': '',
|
|
'bool': None,
|
|
}
|
|
custom_fields = self.instance.custom_fields
|
|
for custom_field in self.instance.agenda.events_type.get_custom_fields():
|
|
varname = custom_field['varname']
|
|
field_name = 'custom_field_%s' % varname
|
|
value = defaults[custom_field['field_type']]
|
|
if varname in custom_fields:
|
|
value = custom_fields[varname]
|
|
ret[field_name] = value
|
|
return ret
|
|
|
|
|
|
class AgendaSerializer(serializers.ModelSerializer):
|
|
edit_role = serializers.CharField(required=False, max_length=150)
|
|
view_role = serializers.CharField(required=False, max_length=150)
|
|
category = serializers.SlugField(required=False, max_length=160)
|
|
events_type = serializers.SlugField(required=False, max_length=160)
|
|
|
|
class Meta:
|
|
model = Agenda
|
|
fields = [
|
|
'slug',
|
|
'label',
|
|
'kind',
|
|
'minimal_booking_delay',
|
|
'minimal_booking_delay_in_working_days',
|
|
'maximal_booking_delay',
|
|
'anonymize_delay',
|
|
'edit_role',
|
|
'view_role',
|
|
'category',
|
|
'events_type',
|
|
]
|
|
|
|
def get_role(self, value):
|
|
try:
|
|
return Group.objects.get(name=value)
|
|
except Group.DoesNotExist:
|
|
raise serializers.ValidationError(_('unknown role: %s' % value))
|
|
|
|
def validate_edit_role(self, value):
|
|
return self.get_role(value)
|
|
|
|
def validate_view_role(self, value):
|
|
return self.get_role(value)
|
|
|
|
def validate_category(self, value):
|
|
try:
|
|
return Category.objects.get(slug=value)
|
|
except Category.DoesNotExist:
|
|
raise serializers.ValidationError(_('unknown category: %s' % value))
|
|
|
|
def validate_events_type(self, value):
|
|
try:
|
|
return EventsType.objects.get(slug=value)
|
|
except EventsType.DoesNotExist:
|
|
raise serializers.ValidationError(_('unknown events type: %s' % value))
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if attrs.get('minimal_booking_delay_in_working_days') and attrs.get('kind', 'events') != 'events':
|
|
raise ValidationError(
|
|
{
|
|
'minimal_booking_delay_in_working_days': _('Option not available on %s agenda')
|
|
% attrs['kind']
|
|
}
|
|
)
|
|
if attrs.get('events_type') and attrs.get('kind', 'events') != 'events':
|
|
raise ValidationError({'events_type': _('Option not available on %s agenda') % attrs['kind']})
|
|
return attrs
|
|
|
|
|
|
class SubscriptionSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Subscription
|
|
fields = [
|
|
'id',
|
|
'user_external_id',
|
|
'user_first_name',
|
|
'user_last_name',
|
|
'user_email',
|
|
'user_phone_number',
|
|
'date_start',
|
|
'date_end',
|
|
'extra_data',
|
|
]
|
|
read_only_fields = ['id', 'extra_data']
|
|
|
|
def validate(self, attrs):
|
|
super().validate(attrs)
|
|
if attrs.get('date_start') and attrs.get('date_end') and attrs['date_start'] > attrs['date_end']:
|
|
raise ValidationError(_('start_datetime must be before end_datetime'))
|
|
return attrs
|
|
|
|
|
|
class SharedCustodyAgendaCreateSerializer(serializers.Serializer):
|
|
period_mirrors = {
|
|
'even': 'odd',
|
|
'odd': 'even',
|
|
'first-half': 'second-half',
|
|
'second-half': 'first-half',
|
|
'first-and-third-quarters': 'second-and-fourth-quarters',
|
|
'second-and-fourth-quarters': 'first-and-third-quarters',
|
|
}
|
|
|
|
guardian_first_name = serializers.CharField(max_length=250)
|
|
guardian_last_name = serializers.CharField(max_length=250)
|
|
guardian_id = serializers.CharField(max_length=250)
|
|
other_guardian_first_name = serializers.CharField(max_length=250)
|
|
other_guardian_last_name = serializers.CharField(max_length=250)
|
|
other_guardian_id = serializers.CharField(max_length=250)
|
|
child_first_name = serializers.CharField(max_length=250)
|
|
child_last_name = serializers.CharField(max_length=250)
|
|
child_id = serializers.CharField(max_length=250)
|
|
weeks = serializers.ChoiceField(required=False, choices=['', 'even', 'odd'])
|
|
date_start = serializers.DateField(required=True)
|
|
|
|
settings_url = serializers.SerializerMethodField()
|
|
|
|
def validate(self, attrs):
|
|
attrs['holidays'] = collections.defaultdict(dict)
|
|
for key, value in self.initial_data.items():
|
|
if key in attrs or ':' not in key:
|
|
continue
|
|
|
|
holiday_slug, field = key.split(':')
|
|
if field not in ('periodicity', 'years'):
|
|
raise ValidationError(
|
|
_('Unknown parameter for holiday %(holiday)s: %(param)s')
|
|
% {'holiday': holiday_slug, 'param': field}
|
|
)
|
|
attrs['holidays'][holiday_slug][field] = value
|
|
|
|
for holiday_slug in attrs['holidays'].copy():
|
|
try:
|
|
holiday = TimePeriodExceptionGroup.objects.get(slug=holiday_slug)
|
|
except TimePeriodExceptionGroup.DoesNotExist:
|
|
raise ValidationError(_('Unknown holiday: %s') % holiday_slug)
|
|
|
|
field_values = attrs['holidays'].pop(holiday_slug)
|
|
if 'periodicity' not in field_values:
|
|
raise ValidationError(_('Missing periodicity for holiday: %s') % holiday_slug)
|
|
|
|
holidays = holiday.exceptions.annotate(
|
|
delta=ExpressionWrapper(
|
|
F('end_datetime') - F('start_datetime'), output_field=models.DurationField()
|
|
)
|
|
)
|
|
is_short_holiday = holidays.filter(delta__lt=datetime.timedelta(days=28)).exists()
|
|
if 'quarter' in field_values['periodicity'] and is_short_holiday:
|
|
raise ValidationError(_('Short holidays cannot be cut into quarters.'))
|
|
|
|
attrs['holidays'][holiday] = field_values
|
|
|
|
return attrs
|
|
|
|
@transaction.atomic
|
|
def create(self, validated_data):
|
|
guardian, dummy = Person.objects.get_or_create(
|
|
user_external_id=validated_data['guardian_id'],
|
|
defaults={
|
|
'first_name': validated_data['guardian_first_name'],
|
|
'last_name': validated_data['guardian_last_name'],
|
|
},
|
|
)
|
|
other_guardian, dummy = Person.objects.get_or_create(
|
|
user_external_id=validated_data['other_guardian_id'],
|
|
defaults={
|
|
'first_name': validated_data['other_guardian_first_name'],
|
|
'last_name': validated_data['other_guardian_last_name'],
|
|
},
|
|
)
|
|
child, dummy = Person.objects.get_or_create(
|
|
user_external_id=validated_data['child_id'],
|
|
defaults={
|
|
'first_name': validated_data['child_first_name'],
|
|
'last_name': validated_data['child_last_name'],
|
|
},
|
|
)
|
|
|
|
self.agenda = SharedCustodyAgenda.objects.create(
|
|
first_guardian=guardian,
|
|
second_guardian=other_guardian,
|
|
child=child,
|
|
date_start=validated_data['date_start'],
|
|
)
|
|
|
|
if validated_data.get('weeks'):
|
|
self.create_custody_rules(guardian, validated_data['weeks'], create_mirror_for=other_guardian)
|
|
|
|
for holiday, params in validated_data.get('holidays', {}).items():
|
|
self.create_holiday_rules(
|
|
holiday,
|
|
guardian,
|
|
create_mirror_for=other_guardian,
|
|
periodicity=params['periodicity'],
|
|
years=params.get('years', ''),
|
|
)
|
|
|
|
return self.agenda
|
|
|
|
def create_custody_rules(self, guardian, weeks, create_mirror_for=None):
|
|
SharedCustodyRule.objects.create(
|
|
agenda=self.agenda, days=list(range(7)), weeks=weeks, guardian=guardian
|
|
)
|
|
|
|
if create_mirror_for:
|
|
self.create_custody_rules(create_mirror_for, self.period_mirrors[weeks])
|
|
|
|
def create_holiday_rules(self, holiday, guardian, years, periodicity, create_mirror_for=None):
|
|
rule = SharedCustodyHolidayRule.objects.create(
|
|
agenda=self.agenda, holiday=holiday, guardian=guardian, years=years, periodicity=periodicity
|
|
)
|
|
rule.update_or_create_periods()
|
|
|
|
if years:
|
|
rule = SharedCustodyHolidayRule.objects.create(
|
|
agenda=self.agenda,
|
|
holiday=holiday,
|
|
guardian=guardian,
|
|
years=self.period_mirrors[years],
|
|
periodicity=self.period_mirrors[periodicity],
|
|
)
|
|
rule.update_or_create_periods()
|
|
|
|
if create_mirror_for:
|
|
self.create_holiday_rules(holiday, create_mirror_for, years, self.period_mirrors[periodicity])
|
|
|
|
def get_settings_url(self, obj):
|
|
request = self.context.get('request')
|
|
return request.build_absolute_uri(obj.get_settings_url())
|
|
|
|
|
|
class SharedCustodyAgendaSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = SharedCustodyAgenda
|
|
fields = ['date_start']
|