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 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"))