我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用django.forms.DateTimeField()。
def get_prep_value(self, value): value = super(DateTimeField, self).get_prep_value(value) value = self.to_python(value) if value is not None and settings.USE_TZ and timezone.is_naive(value): # For backwards compatibility, interpret naive datetimes in local # time. This won't work during DST change, but we can't do much # about it, so we let the exceptions percolate up the call stack. try: name = '%s.%s' % (self.model.__name__, self.name) except AttributeError: name = '(unbound)' warnings.warn("DateTimeField %s received a naive datetime (%s)" " while time zone support is active." % (name, value), RuntimeWarning) default_timezone = timezone.get_default_timezone() value = timezone.make_aware(value, default_timezone) return value
def ChildForm(instance): """ Form for editing a Child model. This is roughly based on the equivalent ModelForm, but uses Form as a base class so that selection boxes for the AS and Prefixes can be edited in a single form. """ class _wrapped(forms.Form): valid_until = forms.DateTimeField(initial=instance.valid_until) as_ranges = forms.ModelMultipleChoiceField(queryset=models.ChildASN.objects.filter(child=instance), required=False, label='AS Ranges', help_text='deselect to remove delegation') address_ranges = forms.ModelMultipleChoiceField(queryset=models.ChildNet.objects.filter(child=instance), required=False, help_text='deselect to remove delegation') return _wrapped
def get_internal_type(self): return "DateTimeField"
def pre_save(self, model_instance, add): if self.auto_now or (self.auto_now_add and add): value = timezone.now() setattr(model_instance, self.attname, value) return value else: return super(DateTimeField, self).pre_save(model_instance, add) # contribute_to_class is inherited from DateField, it registers # get_next_by_FOO and get_prev_by_FOO # get_prep_lookup is inherited from DateField
def formfield(self, **kwargs): defaults = {'form_class': forms.DateTimeField} defaults.update(kwargs) return super(DateTimeField, self).formfield(**defaults)
def angular_model(model, angular_model_name, extra_params={}): """ Returns javascript that preprocesses obj before attaching it to window where angular controller can grab it """ ret = "<script>\n" if model is None: ret += "window.%s = {};\n" % (angular_model_name) else: # cast foreign key and m2m fields to be strings json_ret = model.to_json() model_dict = json.loads(json_ret) fk_fields = model.get_foreign_key_fields() m2m_fields = model.get_many_to_many_fields() for field, val in model_dict["fields"].iteritems(): if field in fk_fields: model_dict["fields"][field] = str(val) if field in m2m_fields: model_dict["fields"][field] = map(str, val) ret += "window.%s = %s;\n" % (angular_model_name, json.dumps(model_dict, sort_keys=True)) # adds converter for datetime fields for field in model.READABLE_ATTRS(type_filter=models.DateField): # DateTimeFields are instances of DateFields ret += ("window.%s.fields.%s = new Date(window.%s.fields.%s);\n" % (angular_model_name, field, angular_model_name, field)) # date_fields = model.WRITEABLE_ATTRS(type_filter=models.DateField, type_exclude=models.DateTimeField) # date_fields = json.dumps(date_fields) # ret += "window.%s.date_fields = %s" % (angular_model_name, date_fields) ret += "</script>\n" return mark_safe(ret)
def angular_input_field(form_field, angular_model_name, extra_params={}): try: form_field_value = form_field.value form_field.value = lambda: None attrs = {"ng-model": "%s.fields.%s" % (angular_model_name, form_field.name), "class": "form-control"} if form_field.field.required: attrs["required"] = "true" if isinstance(form_field.field, DateTimeField): separator = extra_params.pop("silica_datetime_separator", "") widget1 = _get_datepicker(form_field, attrs, extra_params) attrs["type"] = "time" attrs.update(extra_params) widget2 = form_field.as_widget(attrs=attrs) return format_html(widget1 + separator + widget2) if isinstance(form_field.field, DateField): return format_html(_get_datepicker(form_field, attrs, extra_params)) if isinstance(form_field.field, ModelChoiceField): pass #return format_html(_get_datepicker(form_field, attrs, extra_params)) if isinstance(form_field.field, ModelMultipleChoiceField): pass #return format_html(_get_datepicker(form_field, attrs, extra_params)) attrs.update(extra_params) return format_html(form_field.as_widget(attrs=attrs)) finally: form_field.value = form_field_value
def test_fields(self): """ This tests that all fields were added to the form with the correct types """ form_class = self.fb.get_form_class() field_names = form_class.base_fields.keys() # All fields are present in form self.assertIn('your-name', field_names) self.assertIn('your-biography', field_names) self.assertIn('your-birthday', field_names) self.assertIn('your-birthtime', field_names) self.assertIn('your-email', field_names) self.assertIn('your-homepage', field_names) self.assertIn('your-favourite-number', field_names) self.assertIn('your-favourite-python-ides', field_names) self.assertIn('your-favourite-python-ide', field_names) self.assertIn('your-choices', field_names) self.assertIn('i-agree-to-the-terms-of-use', field_names) # All fields have proper type self.assertIsInstance(form_class.base_fields['your-name'], forms.CharField) self.assertIsInstance(form_class.base_fields['your-biography'], forms.CharField) self.assertIsInstance(form_class.base_fields['your-birthday'], forms.DateField) self.assertIsInstance(form_class.base_fields['your-birthtime'], forms.DateTimeField) self.assertIsInstance(form_class.base_fields['your-email'], forms.EmailField) self.assertIsInstance(form_class.base_fields['your-homepage'], forms.URLField) self.assertIsInstance(form_class.base_fields['your-favourite-number'], forms.DecimalField) self.assertIsInstance(form_class.base_fields['your-favourite-python-ides'], forms.ChoiceField) self.assertIsInstance(form_class.base_fields['your-favourite-python-ide'], forms.ChoiceField) self.assertIsInstance(form_class.base_fields['your-choices'], forms.MultipleChoiceField) self.assertIsInstance(form_class.base_fields['i-agree-to-the-terms-of-use'], forms.BooleanField) # Some fields have non-default widgets self.assertIsInstance(form_class.base_fields['your-biography'].widget, forms.Textarea) self.assertIsInstance(form_class.base_fields['your-favourite-python-ide'].widget, forms.RadioSelect) self.assertIsInstance(form_class.base_fields['your-choices'].widget, forms.CheckboxSelectMultiple)
def __init__(self, input_formats=None, format=None, *args, **kwargs): self.input_formats = self.input_formats if input_formats is None else input_formats self.format = self.format if format is None else format super(DateTimeField, self).__init__(*args, **kwargs)
def from_native(self, value): if value in validators.EMPTY_VALUES: return None if isinstance(value, datetime.datetime): return value if isinstance(value, datetime.date): value = datetime.datetime(value.year, value.month, value.day) if settings.USE_TZ: # For backwards compatibility, interpret naive datetimes in # local time. This won't work during DST change, but we can't # do much about it, so we let the exceptions percolate up the # call stack. warnings.warn("DateTimeField received a naive datetime (%s)" " while time zone support is active." % value, RuntimeWarning) default_timezone = timezone.get_default_timezone() value = timezone.make_aware(value, default_timezone) return value for fmt in self.input_formats: if fmt.lower() == ISO_8601: try: parsed = parse_datetime(value) except (ValueError, TypeError): pass else: if parsed is not None: return parsed else: try: parsed = datetime.datetime.strptime(value, fmt) except (ValueError, TypeError): pass else: return parsed msg = self.error_messages['invalid'] % readable_datetime_formats(self.input_formats) raise ValidationError(msg)
def test_should_date_time_convert_string(): assert_conversion(forms.DateTimeField, graphene.String)
def prepare_form(self): class MyForm(forms.Form): dt = forms.DateTimeField(label='????') zone = forms.CharField(label='????')
def setUp(self): class TestForm(forms.Form): char = forms.CharField(max_length=255) hidden = forms.CharField(max_length=255, widget=forms.HiddenInput()) date = forms.DateField(widget=AdminDateWidget()) datetime = forms.DateTimeField(widget=AdminSplitDateTime()) self.form = TestForm({ 'char': 'hi there', 'hidden': 'hidden text', 'date': '20140111', })
def pre_save(self, model_instance, add): if self.auto_now or (self.auto_now_add and add): value = timezone.now() setattr(model_instance, self.attname, value) return value else: return super(DateTimeField, self).pre_save(model_instance, add) # contribute_to_class is inherited from DateField, it registers # get_next_by_FOO and get_prev_by_FOO
def get_form_field(self, **kwargs): """Return a Django form field appropriate for a date-time property. This defaults to a DateTimeField instance, except if auto_now or auto_now_add is set, in which case None is returned, as such 'auto' fields should not be rendered as part of the form. """ if self.auto_now or self.auto_now_add: return None defaults = {'form_class': forms.DateTimeField} defaults.update(kwargs) return super(DateTimeProperty, self).get_form_field(**defaults)
def to_python(self, value): if value is None: return value if isinstance(value, datetime.datetime): return value if isinstance(value, datetime.date): value = datetime.datetime(value.year, value.month, value.day) if settings.USE_TZ: # For backwards compatibility, interpret naive datetimes in # local time. This won't work during DST change, but we can't # do much about it, so we let the exceptions percolate up the # call stack. warnings.warn("DateTimeField %s.%s received a naive datetime " "(%s) while time zone support is active." % (self.model.__name__, self.name, value), RuntimeWarning) default_timezone = timezone.get_default_timezone() value = timezone.make_aware(value, default_timezone) return value try: parsed = parse_datetime(value) if parsed is not None: return parsed except ValueError: raise exceptions.ValidationError( self.error_messages['invalid_datetime'], code='invalid_datetime', params={'value': value}, ) try: parsed = parse_date(value) if parsed is not None: return datetime.datetime(parsed.year, parsed.month, parsed.day) except ValueError: raise exceptions.ValidationError( self.error_messages['invalid_date'], code='invalid_date', params={'value': value}, ) raise exceptions.ValidationError( self.error_messages['invalid'], code='invalid', params={'value': value}, )
def make_game_form(user, game_status): class CreateGameForm(forms.Form): date_format= '%m/%d/%Y %I:%M %p' title = forms.CharField(label='Title', max_length=100, help_text='This game\'s title') required_character_status = forms.ChoiceField(choices=HIGH_ROLLER_STATUS, help_text='Players will only be able to RSVP with characters of the selected status.') hook = forms.CharField(label='Hook', max_length=500, help_text='Entice players to accept your invite, or provide information.') if game_status == str(GAME_STATUS[0][0]): scenario = ScenarioModelChoiceField(queryset=user.scenario_set.all(), empty_label="Create New Scenario", required=False, help_text='Select the Scenario that the game will follow.') scheduled_start_time = forms.DateTimeField(widget=DateTimePicker(options=False), input_formats=[date_format], help_text='For planning only. Places no restrictions on when you actually decide to start the Game.') open_invitations = forms.BooleanField(label="Open Invitations", required=False, initial=True, help_text="If checked, players will be able to invite themselves to the game. " "You will still be able to declare which characters may actually attend as you start the game.",) else: scenario = ScenarioModelChoiceField(queryset=user.scenario_set.all(), empty_label=None, disabled=True, help_text='You can no longer change the chosen Scenario.', required=False) scheduled_start_time = forms.DateTimeField(initial=datetime.today(), disabled=True, help_text='You can no longer change the scheduled start time', required=False) open_invitations = forms.BooleanField(label="Open Invitations", required=False, initial=True, help_text="If checked, players will be able to invite themselves to the game. " "You will still be able to declare which characters may actually attend as you start the game.", ) def default_date(self): if self.initial: #if you pass this in with the same name as the field, you get initial value issues return self.initial['start_time'].strftime(self.date_format) return None return CreateGameForm
def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False): """ Returns field's value prepared for database lookup. """ if not prepared: value = self.get_prep_lookup(lookup_type, value) prepared = True if hasattr(value, 'get_compiler'): value = value.get_compiler(connection=connection) if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'): # If the value has a relabeled_clone method it means the # value will be handled later on. if hasattr(value, 'relabeled_clone'): return value if hasattr(value, 'as_sql'): sql, params = value.as_sql() else: sql, params = value._as_sql(connection=connection) return QueryWrapper(('(%s)' % sql), params) if lookup_type in ('month', 'day', 'week_day', 'hour', 'minute', 'second', 'search', 'regex', 'iregex', 'contains', 'icontains', 'iexact', 'startswith', 'endswith', 'istartswith', 'iendswith'): return [value] elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'): return [self.get_db_prep_value(value, connection=connection, prepared=prepared)] elif lookup_type in ('range', 'in'): return [self.get_db_prep_value(v, connection=connection, prepared=prepared) for v in value] elif lookup_type == 'isnull': return [] elif lookup_type == 'year': if isinstance(self, DateTimeField): return connection.ops.year_lookup_bounds_for_datetime_field(value) elif isinstance(self, DateField): return connection.ops.year_lookup_bounds_for_date_field(value) else: return [value] # this isn't supposed to happen else: return [value]
