mirror of
https://github.com/pretix/pretix.git
synced 2026-05-14 16:44:06 +00:00
638 lines
24 KiB
Python
638 lines
24 KiB
Python
#
|
|
# This file is part of pretix (Community Edition).
|
|
#
|
|
# Copyright (C) 2014-2020 Raphael Michel and contributors
|
|
# Copyright (C) 2020-today pretix GmbH and contributors
|
|
#
|
|
# 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 in version 3 of the License.
|
|
#
|
|
# ADDITIONAL TERMS APPLY: Pursuant to Section 7 of the GNU Affero General Public License, additional terms are
|
|
# applicable granting you additional permissions and placing additional restrictions on your usage of this software.
|
|
# Please refer to the pretix LICENSE file to obtain the full terms applicable to this work. If you did not receive
|
|
# this file, see <https://pretix.eu/about/en/license>.
|
|
#
|
|
# 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
|
|
# <https://www.gnu.org/licenses/>.
|
|
#
|
|
import datetime
|
|
from collections import namedtuple
|
|
from typing import Tuple, Union
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from dateutil import parser
|
|
from django import forms
|
|
from django.core.exceptions import ValidationError
|
|
from django.db import models
|
|
from django.utils.formats import get_format
|
|
from django.utils.functional import lazy
|
|
from django.utils.timezone import now
|
|
from django.utils.translation import gettext_lazy as _
|
|
from rest_framework import serializers
|
|
|
|
EVENT_CHOICES = (
|
|
('date_from', _('Event start')),
|
|
('date_to', _('Event end')),
|
|
('date_admission', _('Event admission')),
|
|
('presale_start', _('Presale start')),
|
|
('presale_end', _('Presale end')),
|
|
)
|
|
|
|
# extend NO_BEFORE_VALUES in reldate.js if changed
|
|
ORDER_CHOICES = (
|
|
('datetime', _('Order creation')),
|
|
)
|
|
ORDER_CHOICES_KEYS = [choice[0] for choice in ORDER_CHOICES]
|
|
|
|
RelativeDate = namedtuple('RelativeDate', ['days', 'minutes', 'time', 'is_after', 'base_date_name'], defaults=(0, None, None, False, 'date_from'))
|
|
|
|
|
|
class RelativeDateWrapper:
|
|
"""
|
|
This contains information on a date that might be relative to an event. This means
|
|
that the underlying data is either a fixed date or a number of days and a wall clock
|
|
time to calculate the date based on a base point.
|
|
|
|
The base point can be the ``date_from``, ``date_to``, ``date_admission``, ``presale_start``
|
|
or ``presale_end`` attribute of an event or subevent, as well as a ``datetime`` of an order.
|
|
If the respective attribute is not set, ``date_from`` will be used.
|
|
"""
|
|
|
|
def __init__(self, data: Union[datetime.datetime, RelativeDate]):
|
|
self.data = data
|
|
|
|
def _resolve_base_date(self, reference) -> Tuple[datetime.datetime, ZoneInfo]:
|
|
"""
|
|
|
|
:param reference:
|
|
:return:
|
|
"""
|
|
from .models import Event, Order, SubEvent
|
|
|
|
if self.data.base_date_name in ORDER_CHOICES_KEYS:
|
|
if not isinstance(reference, Order):
|
|
raise ValueError('A order-based relative datetime choice must be used with an order object')
|
|
event = reference.event
|
|
base_date = getattr(reference, self.data.base_date_name)
|
|
elif isinstance(reference, SubEvent):
|
|
event = reference.event
|
|
base_date = (getattr(reference, self.data.base_date_name) or
|
|
getattr(reference.event, self.data.base_date_name) or
|
|
reference.date_from)
|
|
elif isinstance(reference, Event):
|
|
event = reference
|
|
base_date = getattr(reference, self.data.base_date_name) or event.date_from
|
|
else:
|
|
raise ValueError("Only event, subevent or order objects are supported")
|
|
|
|
tz = ZoneInfo(event.settings.timezone)
|
|
|
|
return base_date, tz
|
|
|
|
def date(self, reference) -> datetime.date:
|
|
if isinstance(self.data, datetime.datetime):
|
|
return self.data.date()
|
|
elif isinstance(self.data, datetime.date):
|
|
return self.data
|
|
else:
|
|
if self.data.minutes is not None:
|
|
raise ValueError('A minute-based relative datetime can not be used as a date')
|
|
|
|
base_date, tz = self._resolve_base_date(reference)
|
|
|
|
if self.data.is_after:
|
|
new_date = base_date.astimezone(tz) + datetime.timedelta(days=self.data.days)
|
|
else:
|
|
new_date = base_date.astimezone(tz) - datetime.timedelta(days=self.data.days)
|
|
return new_date.date()
|
|
|
|
def datetime(self, reference) -> datetime.datetime:
|
|
if isinstance(self.data, (datetime.datetime, datetime.date)):
|
|
return self.data
|
|
else:
|
|
base_date, tz = self._resolve_base_date(reference)
|
|
|
|
if self.data.minutes is not None:
|
|
if self.data.is_after:
|
|
return base_date.astimezone(tz) + datetime.timedelta(minutes=self.data.minutes)
|
|
else:
|
|
return base_date.astimezone(tz) - datetime.timedelta(minutes=self.data.minutes)
|
|
else:
|
|
if self.data.is_after:
|
|
new_date = (base_date.astimezone(tz) + datetime.timedelta(days=self.data.days)).astimezone(tz)
|
|
else:
|
|
new_date = (base_date.astimezone(tz) - datetime.timedelta(days=self.data.days)).astimezone(tz)
|
|
if self.data.time:
|
|
new_date = new_date.replace(
|
|
hour=self.data.time.hour,
|
|
minute=self.data.time.minute,
|
|
second=self.data.time.second
|
|
)
|
|
new_date = new_date.astimezone(tz)
|
|
return new_date
|
|
|
|
def to_string(self) -> str:
|
|
if isinstance(self.data, (datetime.datetime, datetime.date)):
|
|
return self.data.isoformat()
|
|
else:
|
|
if self.data.minutes is not None:
|
|
return 'RELDATE/minutes/{}/{}/{}'.format( #
|
|
self.data.minutes,
|
|
self.data.base_date_name,
|
|
'after' if self.data.is_after else '',
|
|
)
|
|
return 'RELDATE/{}/{}/{}/{}'.format( #
|
|
self.data.days,
|
|
self.data.time.strftime('%H:%M:%S') if self.data.time else '-',
|
|
self.data.base_date_name,
|
|
'after' if self.data.is_after else '',
|
|
)
|
|
|
|
@classmethod
|
|
def from_string(cls, input: str):
|
|
if input.startswith('RELDATE/'):
|
|
parts = input.split('/')
|
|
if parts[1] == 'minutes':
|
|
data = RelativeDate(
|
|
days=0,
|
|
minutes=int(parts[2]),
|
|
base_date_name=parts[3],
|
|
time=None,
|
|
is_after=len(parts) > 4 and parts[4] == "after",
|
|
)
|
|
else:
|
|
if parts[2] == '-':
|
|
time = None
|
|
else:
|
|
timeparts = parts[2].split(':')
|
|
time = datetime.time(hour=int(timeparts[0]), minute=int(timeparts[1]), second=int(timeparts[2]))
|
|
try:
|
|
data = RelativeDate(
|
|
days=int(parts[1] or 0),
|
|
base_date_name=parts[3],
|
|
time=time,
|
|
minutes=None,
|
|
is_after=len(parts) > 4 and parts[4] == "after",
|
|
)
|
|
except ValueError:
|
|
data = RelativeDate(
|
|
days=0,
|
|
base_date_name=parts[3],
|
|
time=time,
|
|
minutes=None,
|
|
is_after=len(parts) > 4 and parts[4] == "after",
|
|
)
|
|
if data.base_date_name in [k[0] for k in ORDER_CHOICES] and parts[4] != "after":
|
|
raise ValueError('ORDER_CHOICE: {} cannot be combined with "before"'.format(data.base_date_name))
|
|
if data.base_date_name not in [k[0] for k in EVENT_CHOICES + ORDER_CHOICES]:
|
|
raise ValueError('{} is not a valid base date'.format(data.base_date_name))
|
|
else:
|
|
data = parser.parse(input)
|
|
return RelativeDateWrapper(data)
|
|
|
|
def __len__(self):
|
|
return len(self.to_string())
|
|
|
|
|
|
BEFORE_AFTER_CHOICE = (
|
|
('before', _('before')),
|
|
('after', _('after')),
|
|
)
|
|
|
|
|
|
reldatetimeparts = namedtuple('reldatetimeparts', (
|
|
"status", # 0
|
|
"absolute", # 1
|
|
"rel_days_number", # 2
|
|
"rel_mins_relationto", # 3
|
|
"rel_days_timeofday", # 4
|
|
"rel_mins_number", # 5
|
|
"rel_days_relationto", # 6
|
|
"rel_mins_relation", # 7
|
|
"rel_days_relation" # 8
|
|
))
|
|
reldatetimeparts.indizes = reldatetimeparts(*range(9))
|
|
|
|
|
|
class RelativeDateTimeWidget(forms.MultiWidget):
|
|
template_name = 'pretixbase/forms/widgets/reldatetime.html'
|
|
parts = reldatetimeparts
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.status_choices = kwargs.pop('status_choices')
|
|
base_choices = kwargs.pop('base_choices')
|
|
|
|
def placeholder_datetime_format():
|
|
df = get_format('DATETIME_INPUT_FORMATS')[0]
|
|
return now().replace(
|
|
year=2000, month=12, day=31, hour=18, minute=0, second=0, microsecond=0
|
|
).strftime(df)
|
|
|
|
def placeholder_time_format():
|
|
tf = get_format('TIME_INPUT_FORMATS')[0]
|
|
return datetime.time(8, 30, 0).strftime(tf)
|
|
|
|
widgets = reldatetimeparts(
|
|
status=forms.RadioSelect(choices=self.status_choices),
|
|
absolute=forms.DateTimeInput(
|
|
attrs={'placeholder': lazy(placeholder_datetime_format, str), 'class': 'datetimepicker'}
|
|
),
|
|
rel_days_number=forms.NumberInput(),
|
|
rel_mins_relationto=forms.Select(choices=base_choices),
|
|
rel_days_timeofday=forms.TimeInput(
|
|
attrs={'placeholder': lazy(placeholder_time_format, str), 'class': 'timepickerfield'}
|
|
),
|
|
rel_mins_number=forms.NumberInput(),
|
|
rel_days_relationto=forms.Select(choices=base_choices),
|
|
rel_mins_relation=forms.Select(choices=BEFORE_AFTER_CHOICE),
|
|
rel_days_relation=forms.Select(choices=BEFORE_AFTER_CHOICE),
|
|
)
|
|
super().__init__(widgets=widgets, *args, **kwargs)
|
|
|
|
def decompress(self, value):
|
|
if isinstance(value, str):
|
|
value = RelativeDateWrapper.from_string(value)
|
|
if isinstance(value, reldatetimeparts):
|
|
return value
|
|
if not value:
|
|
return reldatetimeparts(
|
|
status="unset",
|
|
absolute=None,
|
|
rel_days_number=1,
|
|
rel_mins_relationto="date_from",
|
|
rel_days_timeofday=None,
|
|
rel_mins_number=0,
|
|
rel_days_relationto="date_from",
|
|
rel_mins_relation="before",
|
|
rel_days_relation="before"
|
|
)
|
|
elif isinstance(value.data, (datetime.datetime, datetime.date)):
|
|
return reldatetimeparts(
|
|
status="absolute",
|
|
absolute=value.data,
|
|
rel_days_number=1,
|
|
rel_mins_relationto="date_from",
|
|
rel_days_timeofday=None,
|
|
rel_mins_number=0,
|
|
rel_days_relationto="date_from",
|
|
rel_mins_relation="before",
|
|
rel_days_relation="before"
|
|
)
|
|
elif value.data.minutes is not None:
|
|
return reldatetimeparts(
|
|
status="relative_minutes",
|
|
absolute=None,
|
|
rel_days_number=None,
|
|
rel_mins_relationto=value.data.base_date_name,
|
|
rel_days_timeofday=None,
|
|
rel_mins_number=value.data.minutes,
|
|
rel_days_relationto=value.data.base_date_name,
|
|
rel_mins_relation="after" if value.data.is_after else "before",
|
|
rel_days_relation="after" if value.data.is_after else "before"
|
|
)
|
|
return reldatetimeparts(
|
|
status="relative",
|
|
absolute=None,
|
|
rel_days_number=value.data.days,
|
|
rel_mins_relationto=value.data.base_date_name,
|
|
rel_days_timeofday=value.data.time,
|
|
rel_mins_number=0,
|
|
rel_days_relationto=value.data.base_date_name,
|
|
rel_mins_relation="after" if value.data.is_after else "before",
|
|
rel_days_relation="after" if value.data.is_after else "before"
|
|
)
|
|
|
|
def get_context(self, name, value, attrs):
|
|
ctx = super().get_context(name, value, attrs)
|
|
ctx['required'] = self.status_choices[0][0] == 'unset'
|
|
|
|
ctx['rendered_subwidgets'] = self.parts(*(
|
|
self._render(w['template_name'], {**ctx, 'widget': w})
|
|
for w in ctx['widget']['subwidgets']
|
|
))._asdict()
|
|
|
|
return ctx
|
|
|
|
|
|
class RelativeDateTimeField(forms.MultiValueField):
|
|
def __init__(self, *args, **kwargs):
|
|
status_choices = [
|
|
('absolute', _('Fixed date:')),
|
|
('relative', _('Relative date:')),
|
|
('relative_minutes', _('Relative time:')),
|
|
]
|
|
if kwargs.get('limit_choices'):
|
|
limit = kwargs.pop('limit_choices')
|
|
choices = [(k, v) for k, v in EVENT_CHOICES if k in limit]
|
|
else:
|
|
choices = EVENT_CHOICES
|
|
|
|
self.relative_to_order = kwargs.pop('relative_to_order', False)
|
|
if self.relative_to_order:
|
|
choices += ORDER_CHOICES
|
|
|
|
if not kwargs.get('required', True):
|
|
status_choices.insert(0, ('unset', _('Not set')))
|
|
|
|
fields = reldatetimeparts(
|
|
status=forms.ChoiceField(
|
|
choices=status_choices,
|
|
required=True
|
|
),
|
|
absolute=forms.DateTimeField(
|
|
required=False
|
|
),
|
|
rel_days_number=forms.IntegerField(
|
|
required=False
|
|
),
|
|
rel_mins_relationto=forms.ChoiceField(
|
|
choices=choices,
|
|
required=False
|
|
),
|
|
rel_days_timeofday=forms.TimeField(
|
|
required=False,
|
|
),
|
|
rel_mins_number=forms.IntegerField(
|
|
required=False
|
|
),
|
|
rel_days_relationto=forms.ChoiceField(
|
|
choices=choices,
|
|
required=False
|
|
),
|
|
rel_mins_relation=forms.ChoiceField(
|
|
choices=BEFORE_AFTER_CHOICE,
|
|
required=False
|
|
),
|
|
rel_days_relation=forms.ChoiceField(
|
|
choices=BEFORE_AFTER_CHOICE,
|
|
required=False
|
|
),
|
|
)
|
|
if 'widget' not in kwargs:
|
|
kwargs['widget'] = RelativeDateTimeWidget(status_choices=status_choices, base_choices=choices)
|
|
kwargs.pop('max_length', 0)
|
|
kwargs.pop('empty_value', 0)
|
|
super().__init__(
|
|
fields=fields, require_all_fields=False, *args, **kwargs
|
|
)
|
|
|
|
def set_event(self, event):
|
|
choices = [
|
|
(k, v) for k, v in EVENT_CHOICES if getattr(event, k, None)
|
|
]
|
|
if self.relative_to_order:
|
|
choices += ORDER_CHOICES
|
|
self.widget.widgets[reldateparts.indizes.rel_days_relationto].choices = choices
|
|
self.widget.widgets[reldatetimeparts.indizes.rel_mins_relationto].choices = choices
|
|
|
|
def compress(self, data_list):
|
|
if not data_list:
|
|
return None
|
|
data = reldatetimeparts(*data_list)
|
|
if data.status == 'absolute':
|
|
return RelativeDateWrapper(data.absolute)
|
|
elif data.status == 'unset':
|
|
return None
|
|
elif data.status == 'relative_minutes':
|
|
return RelativeDateWrapper(RelativeDate(
|
|
days=0,
|
|
base_date_name=data.rel_mins_relationto,
|
|
time=None,
|
|
minutes=data.rel_mins_number,
|
|
is_after=data.rel_mins_relation == "after",
|
|
))
|
|
else:
|
|
return RelativeDateWrapper(RelativeDate(
|
|
days=data.rel_days_number,
|
|
base_date_name=data.rel_days_relationto,
|
|
time=data.rel_days_timeofday,
|
|
minutes=None,
|
|
is_after=data.rel_days_relation == "after",
|
|
))
|
|
|
|
def has_changed(self, initial, data):
|
|
if initial is None:
|
|
initial = self.widget.decompress(initial)
|
|
return super().has_changed(initial, data)
|
|
|
|
def clean(self, value):
|
|
data = reldatetimeparts(*value)
|
|
if data.status == 'absolute' and not data.absolute:
|
|
raise ValidationError(self.error_messages['incomplete'])
|
|
elif data.status == 'relative' and (data.rel_days_number is None or not data.rel_days_relationto):
|
|
raise ValidationError(self.error_messages['incomplete'])
|
|
elif data.status == 'relative_minutes' and (data.rel_mins_number is None or not data.rel_mins_relationto):
|
|
raise ValidationError(self.error_messages['incomplete'])
|
|
elif data.status == 'relative' and data.rel_days_relationto in ORDER_CHOICES_KEYS and data.rel_days_relation == 'before':
|
|
raise ValidationError(_('A relative date in relation to an order can only be after the order has been placed'))
|
|
elif data.status == 'relative' and data.rel_mins_relationto in ORDER_CHOICES_KEYS and data.rel_mins_relation == 'before':
|
|
raise ValidationError(_('A relative date in relation to an order can only be after the order has been placed'))
|
|
|
|
return super().clean(value)
|
|
|
|
|
|
reldateparts = namedtuple('reldateparts', (
|
|
"status", # 0
|
|
"absolute", # 1
|
|
"rel_days_number", # 2
|
|
"rel_days_relationto", # 3
|
|
"rel_days_relation", # 4
|
|
))
|
|
reldateparts.indizes = reldateparts(*range(5))
|
|
|
|
|
|
class RelativeDateWidget(RelativeDateTimeWidget):
|
|
template_name = 'pretixbase/forms/widgets/reldate.html'
|
|
parts = reldateparts
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.status_choices = kwargs.pop('status_choices')
|
|
base_choices = kwargs.pop('base_choices')
|
|
widgets = reldateparts(
|
|
status=forms.RadioSelect(choices=self.status_choices),
|
|
absolute=forms.DateInput(
|
|
attrs={'class': 'datepickerfield'}
|
|
),
|
|
rel_days_number=forms.NumberInput(),
|
|
rel_days_relationto=forms.Select(choices=base_choices),
|
|
rel_days_relation=forms.Select(choices=BEFORE_AFTER_CHOICE),
|
|
)
|
|
forms.MultiWidget.__init__(self, widgets=widgets, *args, **kwargs)
|
|
|
|
def decompress(self, value):
|
|
if isinstance(value, str):
|
|
value = RelativeDateWrapper.from_string(value)
|
|
if not value:
|
|
return reldateparts(
|
|
status="unset",
|
|
absolute=None,
|
|
rel_days_number=1,
|
|
rel_days_relationto="date_from",
|
|
rel_days_relation="before"
|
|
)
|
|
if isinstance(value, reldateparts):
|
|
return value
|
|
elif isinstance(value.data, (datetime.datetime, datetime.date)):
|
|
return reldateparts(
|
|
status="absolute",
|
|
absolute=value.data,
|
|
rel_days_number=1,
|
|
rel_days_relationto="date_from",
|
|
rel_days_relation="before"
|
|
)
|
|
return reldateparts(
|
|
status="relative",
|
|
absolute=None,
|
|
rel_days_number=value.data.days,
|
|
rel_days_relationto=value.data.base_date_name,
|
|
rel_days_relation="after" if value.data.is_after else "before"
|
|
)
|
|
|
|
|
|
class RelativeDateField(RelativeDateTimeField):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
status_choices = [
|
|
('absolute', _('Fixed date:')),
|
|
('relative', _('Relative date:')),
|
|
]
|
|
if not kwargs.get('required', True):
|
|
status_choices.insert(0, ('unset', _('Not set')))
|
|
|
|
choices = EVENT_CHOICES
|
|
self.relative_to_order = kwargs.pop('relative_to_order', False)
|
|
if self.relative_to_order:
|
|
choices += ORDER_CHOICES
|
|
|
|
fields = reldateparts(
|
|
status=forms.ChoiceField(
|
|
choices=status_choices,
|
|
required=True
|
|
),
|
|
absolute=forms.DateField(
|
|
required=False
|
|
),
|
|
rel_days_number=forms.IntegerField(
|
|
required=False
|
|
),
|
|
rel_days_relationto=forms.ChoiceField(
|
|
choices=choices,
|
|
required=False
|
|
),
|
|
rel_days_relation=forms.ChoiceField(
|
|
choices=BEFORE_AFTER_CHOICE,
|
|
required=False
|
|
),
|
|
)
|
|
if 'widget' not in kwargs:
|
|
kwargs['widget'] = RelativeDateWidget(status_choices=status_choices, base_choices=choices)
|
|
forms.MultiValueField.__init__(
|
|
self, fields=fields, require_all_fields=False, *args, **kwargs
|
|
)
|
|
|
|
def set_event(self, event):
|
|
choices = [
|
|
(k, v) for k, v in EVENT_CHOICES if getattr(event, k, None)
|
|
]
|
|
if self.relative_to_order:
|
|
choices += ORDER_CHOICES
|
|
self.widget.widgets[reldateparts.indizes.rel_days_relationto].choices = choices
|
|
|
|
def compress(self, data_list):
|
|
if not data_list:
|
|
return None
|
|
data = reldateparts(*data_list)
|
|
if data.status == 'absolute':
|
|
return RelativeDateWrapper(data.absolute)
|
|
elif data.status == 'unset':
|
|
return None
|
|
else:
|
|
return RelativeDateWrapper(RelativeDate(
|
|
days=data.rel_days_number,
|
|
base_date_name=data.rel_days_relationto,
|
|
time=None, minutes=None,
|
|
is_after=data.rel_days_relation == "after"
|
|
))
|
|
|
|
def clean(self, value):
|
|
data = reldateparts(*value)
|
|
if data.status == 'absolute' and not data.absolute:
|
|
raise ValidationError(self.error_messages['incomplete'])
|
|
elif data.status == 'relative' and (data.rel_days_number is None or not data.rel_days_relationto):
|
|
raise ValidationError(self.error_messages['incomplete'])
|
|
elif data.status == 'relative' and data.rel_days_relationto in ORDER_CHOICES_KEYS and data.rel_days_relation == 'before':
|
|
raise ValidationError(_('A relative date in relation to an order can only be after the order has been placed'))
|
|
|
|
return forms.MultiValueField.clean(self, value)
|
|
|
|
|
|
class ModelRelativeDateTimeField(models.CharField):
|
|
form_class = RelativeDateTimeField
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.event = kwargs.pop('event', None)
|
|
kwargs.setdefault('max_length', 255)
|
|
super().__init__(*args, **kwargs)
|
|
|
|
def to_python(self, value):
|
|
if isinstance(value, RelativeDateWrapper):
|
|
return value
|
|
if value is None:
|
|
return None
|
|
return RelativeDateWrapper.from_string(value)
|
|
|
|
def get_prep_value(self, value):
|
|
if isinstance(value, RelativeDateWrapper):
|
|
return value.to_string()
|
|
return value
|
|
|
|
def from_db_value(self, value, expression, connection):
|
|
if value is None:
|
|
return None
|
|
return RelativeDateWrapper.from_string(value)
|
|
|
|
def formfield(self, **kwargs):
|
|
defaults = {'form_class': self.form_class}
|
|
defaults.update(kwargs)
|
|
return super().formfield(**defaults)
|
|
|
|
|
|
class SerializerRelativeDateField(serializers.CharField):
|
|
|
|
def to_internal_value(self, data):
|
|
if data is None:
|
|
return None
|
|
try:
|
|
r = RelativeDateWrapper.from_string(data)
|
|
if isinstance(r.data, RelativeDate):
|
|
if r.data.time is not None:
|
|
raise ValidationError("Do not specify a time for a date field")
|
|
return r
|
|
except:
|
|
raise ValidationError("Invalid relative date")
|
|
|
|
def to_representation(self, value: RelativeDateWrapper):
|
|
if value is None:
|
|
return None
|
|
return value.to_string()
|
|
|
|
|
|
class SerializerRelativeDateTimeField(serializers.CharField):
|
|
|
|
def to_internal_value(self, data):
|
|
if data is None:
|
|
return None
|
|
try:
|
|
return RelativeDateWrapper.from_string(data)
|
|
except:
|
|
raise ValidationError("Invalid relative date")
|
|
|
|
def to_representation(self, value: RelativeDateWrapper):
|
|
if value is None:
|
|
return None
|
|
return value.to_string()
|