class DateTimeField(BaseTemporalField):
widget = DateTimeInput
input_formats = formats.get_format_lazy('DATETIME_INPUT_FORMATS')
default_error_messages = {
'invalid': _('Enter a valid date/time.'),
}
def prepare_value(self, value):
if isinstance(value, datetime.datetime):
value = to_current_timezone(value)
return value
def to_python(self, value):
"""
Validate that the input can be converted to a datetime. Return a
Python datetime.datetime object.
"""
if value in self.empty_values:
return None
if isinstance(value, datetime.datetime):
return from_current_timezone(value)
if isinstance(value, datetime.date):
result = datetime.datetime(value.year, value.month, value.day)
return from_current_timezone(result)
try:
result = parse_datetime(value.strip())
except ValueError:
raise ValidationError(self.error_messages['invalid'],
code='invalid')
if not result:
result = super().to_python(value)
return from_current_timezone(result)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format)
class DocboxListViewBase(ListView):
paginate_by = 50
date_format = formats.get_format_lazy("DATE_INPUT_FORMATS")[0]
def post(self, request, *args, **kwargs):
start_date = request.POST.get("start_date")
end_date = request.POST.get("end_date")
start_date = datetime.strptime(start_date, self.date_format)
end_date = datetime.strptime(end_date, self.date_format)
request.session["start_date"] = start_date.strftime(self.date_format)
request.session["end_date"] = end_date.strftime(self.date_format)
def get(self, request, *args, **kwargs):
today = date.today()
quarter = timedelta(weeks=13)
def_start_date = (today - quarter).replace(day=1)
def_start_date = def_start_date.strftime(self.date_format)
def_end_date = date(today.year + 1, 1, 1).strftime(self.date_format)
start_date = request.session.get("start_date", def_start_date)
end_date = request.session.get("end_date", def_end_date)
self.start_date = datetime.strptime(start_date, self.date_format)
self.end_date = datetime.strptime(end_date, self.date_format)
return super().get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["start_date"] = self.start_date.strftime(self.date_format)
context["end_date"] = self.end_date.strftime(self.date_format)
return context
class SplitDateTimeFieldTests(DateTimeFieldTestCase):
default_time_input_formats = formats.get_format_lazy('TIME_INPUT_FORMATS')
def test_init_no_input_formats(self):
field = SplitDateTimeField()
date_field, time_field = field.fields
self.assertInputFormats(date_field, self.default_date_input_formats)
self.assertInputFormats(time_field, self.default_time_input_formats)
def test_init_empty_input_formats(self):
field = SplitDateTimeField(input_date_formats=(),
input_time_formats=())
date_field, time_field = field.fields
self.assertInputFormats(date_field, self.default_date_input_formats)
self.assertInputFormats(time_field, ())
def test_init_custom_input_formats(self):
date_input_formats = ('%m/%d/%Y', '%m/%d/%y')
time_input_formats = ('%H:%M', '%H:%M:%S')
field = SplitDateTimeField(input_date_formats=date_input_formats,
input_time_formats=time_input_formats)
date_field, time_field = field.fields
self.assertInputFormats(date_field, date_input_formats)
self.assertInputFormats(time_field, time_input_formats)
class DateTimeField(BaseTemporalField):
widget = DateTimeInput
input_formats = formats.get_format_lazy('DATETIME_INPUT_FORMATS')
default_error_messages = {
'invalid': _(u'Enter a valid date/time.'),
}
def to_python(self, value):
"""
Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.
"""
if value in validators.EMPTY_VALUES:
return None
if isinstance(value, datetime.datetime):
return value
if isinstance(value, datetime.date):
return datetime.datetime(value.year, value.month, value.day)
if isinstance(value, list):
# Input comes from a SplitDateTimeWidget, for example. So, it's two
# components: date and time.
if len(value) != 2:
raise ValidationError(self.error_messages['invalid'])
if value[0] in validators.EMPTY_VALUES and value[1] in validators.EMPTY_VALUES:
return None
value = '%s %s' % tuple(value)
return super(DateTimeField, self).to_python(value)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format)
class KrynnDateTimeFormField(BaseTemporalField):
widget = DateTimeInput
input_formats = formats.get_format_lazy('DATETIME_INPUT_FORMATS')
default_error_messages = {
'invalid': _('Enter a valid date/time.'),
}
def prepare_value(self, value):
return value
def to_python(self, value):
"""
Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.
"""
if value in self.empty_values:
return None
if isinstance(value, datetime.datetime):
return from_current_timezone(value)
if isinstance(value, datetime.date):
return datetime.datetime(value.year, value.month, value.day)
if isinstance(value, list):
# Input comes from a SplitDateTimeWidget, for example. So, it's two
# components: date and time.
if len(value) != 2:
raise ValidationError(self.error_messages['invalid'],
code='invalid')
if value[0] in self.empty_values and value[1] in self.empty_values:
return None
value = '%s %s' % tuple(value)
result = super(KrynnDateTimeFormField, self).to_python(value)
return result
def strptime(self, value, format):
return datetime.datetime.strptime(force_str(value), format)
class DateTimeField(BaseTemporalField):
input_formats = formats.get_format_lazy('DATETIME_INPUT_FORMATS')
default_error_messages = {
'invalid': _(u'Enter a valid date/time.'),
}
def prepare_value(self, value):
if isinstance(value, datetime.datetime):
value = to_current_timezone(value)
return value
def to_python(self, value):
"""
Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.
"""
if value in validators.EMPTY_VALUES:
return self.default
if isinstance(value, datetime.datetime):
return from_current_timezone(value)
if isinstance(value, datetime.date):
result = datetime.datetime(value.year, value.month, value.day)
return from_current_timezone(result)
if isinstance(value, list):
# Input comes from a SplitDateTimeWidget, for example. So, it's two
# components: date and time.
if value in validators.EMPTY_VALUES and value[
1] in validators.EMPTY_VALUES:
return self.default
result = super(DateTimeField, self).to_python(value)
return from_current_timezone(result)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format)
class DateRangeField(BaseTemporalField):
widget = forms.DateInput
input_formats = get_format_lazy('DATE_INPUT_FORMATS')
default_error_messages = {
'invalid': _('Enter a valid date range.'),
}
def to_python(self, value):
"""Takes the raw form input and translates it to two python datetime objects"""
# If any of (None, '', [], (), {})
if value in self.empty_values:
return None
try:
date1, date2 = value.split(' to ')
date1 = super(DateRangeField, self).to_python(date1)
date2 = super(DateRangeField, self).to_python(date2)
except ValueError:
raise ValidationError(
'Date range format invalid. Two dates are needed.')
except ValidationError:
raise ValidationError(
'Date range format invalid. Try \'Y-m-d to Y-m-d\'',
code='invalid')
return date1, date2
def strptime(self, value, format):
"""Overwrites the builtin to parse a datetime out of str"""
return datetime.datetime.strptime(force_str(value), format).date()
class DateTimeField(BaseTemporalField):
widget = DateTimeInput
input_formats = formats.get_format_lazy('DATETIME_INPUT_FORMATS')
default_error_messages = {
'invalid': _('Enter a valid date/time.'),
}
def prepare_value(self, value):
if isinstance(value, datetime.datetime):
value = to_current_timezone(value)
return value
def to_python(self, value):
"""
Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.
"""
if value in self.empty_values:
return None
if isinstance(value, datetime.datetime):
return from_current_timezone(value)
if isinstance(value, datetime.date):
result = datetime.datetime(value.year, value.month, value.day)
return from_current_timezone(result)
result = super(DateTimeField, self).to_python(value)
return from_current_timezone(result)
def strptime(self, value, format):
return datetime.datetime.strptime(force_str(value), format)
class MonthPickerForm(forms.Form):
MONTH_INPUT = get_format_lazy("YEAR_MONTH_INPUT_FORMATS")
period = DateField(
input_formats=MONTH_INPUT,
widget=DateWidget(
input_formats=MONTH_INPUT,
options={"minViewMode": "months", "maxViewMode": "years"},
),
)
def get_datetime_input_format(date_only=False):
"""
Get current locale date input format.
:param date_only:
:return:
"""
return formats.get_format_lazy(
'DATE_INPUT_FORMATS' if date_only else 'DATETIME_INPUT_FORMATS')[0]
class Meta:
# django.utils.dates.WEEKDAYS and MONTHS int are not iterables
model = DaysOff
fields = '__all__'
localized_fields = ( 'day', 'end_day', 'from_day', 'to_day',)
widgets = {
'name': forms.TextInput(attrs={'placeholder': _('Days off name')}),
'description': forms.TextInput(attrs={'placeholder': _('Days off description')}),
#'type': forms.Select(choices=DaysOff.TYPE_OF_DAY_CHOICES),
#'day': forms.SelectDateWidget(),
'day': forms.DateInput(attrs={'placeholder': formats.get_format_lazy("SHORT_DATE_FORMAT")}),
'end_day': forms.DateInput(attrs={'placeholder': formats.get_format_lazy("SHORT_DATE_FORMAT")}),
'week_day': forms.Select(choices=DaysOff.WEEKDAY_CHOICES), # Monday='MO' ...
'month': forms.Select(choices=DaysOff.MONTH_CHOICES), # January='JAN' ...
'from_day': forms.DateInput(attrs={'placeholder': formats.get_format_lazy("SHORT_DATE_FORMAT")}),
#'to_day': forms.DateInput(attrs={'placeholder': formats.dateformat}),
'to_day': forms.DateInput(attrs={'placeholder': formats.get_format_lazy("SHORT_DATE_FORMAT")}),
#'to_day': forms.DateInput(attrs={'placeholder': locale.D_FMT}),
}
def parse_date_time(x):
try:
tzinfo = datetime.strptime(x[-5:], '%z').tzinfo
x = x[:-5].rstrip()
except ValueError:
tzinfo = timezone.get_default_timezone()
for i in get_format_lazy('DATETIME_INPUT_FORMATS'):
try:
return datetime.strptime(x, i).replace(tzinfo=tzinfo)
except ValueError:
pass
class TimeField(BaseTemporalField):
input_formats = formats.get_format_lazy('TIME_INPUT_FORMATS')
default_error_messages = {'invalid': _(u'Enter a valid time.')}
def to_python(self, value):
"""
Validates that the input can be converted to a time. Returns a Python
datetime.time object.
"""
if value in validators.EMPTY_VALUES:
return self.default
if isinstance(value, datetime.time):
return value
return super(TimeField, self).to_python(value)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format).time()
class TimeField(BaseTemporalField):
widget = TimeInput
input_formats = formats.get_format_lazy('TIME_INPUT_FORMATS')
default_error_messages = {'invalid': _('Enter a valid time.')}
def to_python(self, value):
"""
Validate that the input can be converted to a time. Return a Python
datetime.time object.
"""
if value in self.empty_values:
return None
if isinstance(value, datetime.time):
return value
return super().to_python(value)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format).time()
class DateField(BaseTemporalField):
widget = DateInput
input_formats = formats.get_format_lazy("DATE_INPUT_FORMATS")
default_error_messages = {"invalid": _("Enter a valid date.")}
def to_python(self, value):
"""
Validate that the input can be converted to a date. Return a Python
datetime.date object.
"""
if value in self.empty_values:
return None
if isinstance(value, datetime.datetime):
return value.date()
if isinstance(value, datetime.date):
return value
return super().to_python(value)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format).date()
def get_date_errbad(row, name, errors, error_message=None, default=''):
"""Retrieve a date, error if a bad value is given"""
if error_message is None:
error_message = _(
'Invalid value in column {}. Requires a date').format(name)
input_formats = formats.get_format_lazy('DATE_INPUT_FORMATS')
val = row.get(name, default).strip()
if default != '' and val == '':
val = default
success = False
for input_format in input_formats:
if not success:
try:
val = datetime.strptime(val, input_format)
except (ValueError, TypeError):
continue
else:
success = True
if not success:
errors.append(error_message)
return val
class DateField(BaseTemporalField):
widget = DateInput
input_formats = formats.get_format_lazy('DATE_INPUT_FORMATS')
default_error_messages = {
'invalid': _(u'Enter a valid date.'),
}
def to_python(self, value):
"""
Validates that the input can be converted to a date. Returns a Python
datetime.date object.
"""
if value in validators.EMPTY_VALUES:
return None
if isinstance(value, datetime.datetime):
return value.date()
if isinstance(value, datetime.date):
return value
return super(DateField, self).to_python(value)
def strptime(self, value, format):
return datetime.datetime.strptime(value, format).date()
def get_sample_datetime():
return (now()-timedelta(days=365*30)).strftime(formats.get_format_lazy('DATE_INPUT_FORMATS')[0])
def get_date_format():
return formats.get_format_lazy('DATE_INPUT_FORMATS')[0]\
.replace("%Y", "0000")\
.replace("%y", "0000")\
.replace("%d", "00")\
.replace("%m", "00")
class EventForm(forms.ModelForm):
datetime_input_formats = formats.get_format_lazy("DATETIME_INPUT_FORMATS") + list(settings.DATETIME_INPUT_FORMATS)
meet_at = forms.DateTimeField(input_formats=datetime_input_formats, required=False)
access_at = forms.DateTimeField(input_formats=datetime_input_formats, required=False)
items_json = forms.CharField()
items = {}
related_models = {
'person': models.Person,
'organisation': models.Organisation,
'venue': models.Venue,
'mic': models.Profile,
'checked_in_by': models.Profile,
}
@property
def _get_items_json(self):
items = {}
for item in self.instance.items.all():
data = serializers.serialize('json', [item])
struct = simplejson.loads(data)
items[item.pk] = simplejson.dumps(struct[0])
return simplejson.dumps(items)
def __init__(self, *args, **kwargs):
super(EventForm, self).__init__(*args, **kwargs)
self.fields['items_json'].initial = self._get_items_json
self.fields['start_date'].widget.format = '%Y-%m-%d'
self.fields['end_date'].widget.format = '%Y-%m-%d'
self.fields['access_at'].widget.format = '%Y-%m-%dT%H:%M:%S'
self.fields['meet_at'].widget.format = '%Y-%m-%dT%H:%M:%S'
def init_items(self):
self.items = self.process_items_json()
return self.items
def process_items_json(self, event=None):
data = simplejson.loads(self.cleaned_data['items_json'])
items = {}
for key in data:
pk = int(key)
items[pk] = self._get_or_initialise_item(pk, data[key]['fields'], event)
return items
def _get_or_initialise_item(self, pk, data, event):
try:
item = models.EventItem.objects.get(pk=pk, event=event)
except models.EventItem.DoesNotExist:
# This occurs for one of two reasons
# 1) The event has been duplicated, so the item PKs belong to another event
# 2) The items are brand new, with negative PK values
# In either case, we want to create the items
item = models.EventItem()
# Take the data from the form and update the item object
item.name = data['name']
item.description = data['description']
item.quantity = data['quantity']
item.cost = data['cost']
item.order = data['order']
if (event):
item.event = event
item.full_clean()
else:
item.full_clean('event')
return item
def save(self, commit=True):
m = super(EventForm, self).save(commit=False)
if (commit):
m.save()
cur_items = m.items.all()
items = self.process_items_json(m)
# Delete any unneeded items
for item in cur_items:
if item.pk not in items:
item.delete()
for key in items:
items[key].save()
return m
class Meta:
model = models.Event
fields = ['is_rig', 'name', 'venue', 'start_time', 'end_date', 'start_date',
'end_time', 'meet_at', 'access_at', 'description', 'notes', 'mic',
'person', 'organisation', 'dry_hire', 'checked_in_by', 'status',
'purchase_order', 'collector']
from datetime import date, datetime
from typing import Any, List, Optional, Union
import dateutil.parser
from django.forms.utils import from_current_timezone
from django.utils import formats
from django.utils.translation import gettext_lazy as _
from ...scalars import ScalarType
date_input_formats = formats.get_format_lazy("DATE_INPUT_FORMATS")
datetime_input_formats = formats.get_format_lazy("DATETIME_INPUT_FORMATS")
date_scalar = ScalarType("Date")
datetime_scalar = ScalarType("DateTime")
@date_scalar.serializer
def serialize_date(value: Union[date, datetime]) -> str:
if isinstance(value, datetime):
value = value.date()
return value.isoformat()
@date_scalar.value_parser
def parse_date_value(value: Any) -> date:
parsed_value = parse_value(value, date_input_formats)
if not parsed_value:
raise ValueError(_("Enter a valid date."))
return parsed_value.date()
def __init__(self, *args, **kwargs):
super(ApplyTemplateForm, self).__init__(*args, **kwargs)
self.js_date_format = translate_date_format(
formats.get_format_lazy('DATE_INPUT_FORMATS')[0])
def get_sample_datetime():
return (now() - timedelta(days=365 * 30)).strftime(
formats.get_format_lazy('DATE_INPUT_FORMATS')[0])
from datetime import time
from typing import Any
from django.utils import formats
from django.utils.translation import gettext_lazy as _
from ariadne import ScalarType
from ariadne_django.scalars.utils.parsers import parse_value
time_input_formats = formats.get_format_lazy("TIME_INPUT_FORMATS")
time_scalar = ScalarType("Time")
@time_scalar.serializer
def serialize_time(value: time) -> str:
return value.isoformat()
@time_scalar.value_parser
def parse_time_value(value: Any) -> time:
parsed_value = parse_value(value, time_input_formats)
if not parsed_value:
raise ValueError(_("Enter a valid time."))
return parsed_value.time()
def get_date_format():
return formats.get_format_lazy('DATE_INPUT_FORMATS')[0]\
.replace("%Y", "0000")\
.replace("%y", "0000")\
.replace("%d", "00")\
.replace("%m", "00")
def store_relatives(self, request):
input_formats = formats.get_format_lazy("DATE_INPUT_FORMATS")
def strptime(value):
for fmt in input_formats:
try:
return datetime.datetime.strptime(force_str(value),
fmt).date()
except (ValueError, TypeError):
continue
persons_created = 0
connections_created = 0
persons_updated = 0
connections_updated = 0
for rec_id in request.POST.getlist("iswear"):
last_name = request.POST.get("person_%s_last_name" % rec_id)
first_name = request.POST.get("person_%s_first_name" % rec_id)
patronymic = request.POST.get("person_%s_patronymic" % rec_id)
base_person_id = request.POST.get("person_%s_id" % rec_id)
declaration_id = request.POST.get("person_%s_declaration_id" %
rec_id)
relation_from = request.POST.get("person_%s_relation_from" %
rec_id)
relation_to = request.POST.get("person_%s_relation_to" % rec_id)
dob = strptime(request.POST.get("person_%s_dob" % rec_id))
dob_details = int(
request.POST.get("person_%s_dob_details" % rec_id))
base_person = Person.objects.get(pk=base_person_id)
declaration = Declaration.objects.get(pk=declaration_id)
rcpt_id = request.POST.get("person_%s_rcpt_id" % rec_id)
rel_id = request.POST.get("person_%s_rel_id" % rec_id)
if rcpt_id:
relative = Person.objects.get(pk=int(rcpt_id))
relative.first_name_uk = first_name
relative.patronymic_uk = patronymic
persons_updated += 1
relative.save()
else:
relative = Person.objects.create(
first_name_uk=first_name,
patronymic_uk=patronymic,
last_name_uk=last_name,
type_of_official=5,
is_pep=False,
)
persons_created += 1
if dob is not None:
relative.dob = dob
relative.dob_details = dob_details
relative.save()
if rel_id:
relation = Person2Person.objects.get(pk=int(rel_id))
relation.declarations = list(
set((relation.declarations or []) + [declaration_id]))
if relation.from_person_id == base_person.pk:
relation.from_relationship_type = relation_from
relation.to_relationship_type = relation_to
else:
relation.from_relationship_type = relation_to
relation.to_relationship_type = relation_from
relation.save()
connections_updated += 1
else:
relation = Person2Person.objects.create(
declarations=[declaration.pk],
from_person=base_person,
to_person=relative,
from_relationship_type=relation_from,
to_relationship_type=relation_to,
)
connections_created += 1
url = declaration.url + "?source"
try:
relation.proofs.get(proof=url)
except RelationshipProof.DoesNotExist:
relation.proofs.create(
proof=url,
proof_title_uk="Декларація за %s рік" % declaration.year,
proof_title_en="Income and assets declaration, %s" %
declaration.year,
)
except RelationshipProof.MultipleObjectsReturned:
pass
declaration.relatives_populated = True
declaration.save()
self.message_user(
request,
"%s осіб та %s зв'язків було створено." %
(persons_created, connections_created),
)
self.message_user(
request,
"%s осіб та %s зв'язків було оновлено." %
(persons_updated, connections_updated),
)
if request.POST.get("redirect_back"):
return redirect(request.POST.get("redirect_back"))
else:
return redirect(reverse("admin:core_declaration_changelist"))
def __init__(self, *args, **kwargs):
super(ApplyTemplateForm, self).__init__(*args, **kwargs)
self.js_date_format = translate_date_format(
formats.get_format_lazy('DATE_INPUT_FORMATS')[0])
