class EventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
exclude = ['host']
class SurveyForm(ModelForm):
opens = SplitDateTimeField(
widget=CustomSplitDateTime(),
label=Survey._meta.get_field("opens").verbose_name)
closes = SplitDateTimeField(
widget=CustomSplitDateTime(),
label=Survey._meta.get_field("closes").verbose_name)
class Meta:
model = Survey
exclude = ("created_by", "editable_by", "slug", "recipient_type",
"recipient_id")
def clean(self):
title_slug = slugify(self.cleaned_data.get("title"))
if not hasattr(self, "instance"):
if not len(Survey.objects.filter(slug=title_slug)) == 0:
raise ValidationError, _(
'The title of the survey must be unique.')
elif self.instance.title != self.cleaned_data.get("title"):
if not len(Survey.objects.filter(slug=title_slug)) == 0:
raise ValidationError, _(
'The title of the survey must be unique.')
return self.cleaned_data
class SejourForm(SejourFormBase, ModelForm):
date_arrivee = SplitDateTimeField(
required=True, widget=SplitDateTimeWidget(time_format=('%H:%M')))
date_depart = SplitDateTimeField(
required=True, widget=SplitDateTimeWidget(time_format=('%H:%M')))
class Meta:
model = Sejour
fields = (
"cohabitation",
"date_arrivee",
"date_depart",
"proprietaire",
"animaux",
"nb_cages_fournies",
"nb_cages_a_fournir",
"vaccination",
"soin",
"injection",
"commentaire",
"montant",
"arrhes",
"montant_restant",
)
widgets = {
'proprietaire':
autocomplete.ModelSelect2(url='proprietaire_autocomplete')
}
class createEvent(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
exclude = ['created_by']
class NewEventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
fields = ['title', 'location', 'venue', 'start_time', 'end_time']
exclude =['host']
def clean_event_date(self):
data = self.cleaned_data['start_time']
# Check if a date is not in the past.
if data < datetime.date.today():
raise ValidationError(_('Invalid date - event is in past'))
# Check if a date is in the allowed range (+4 weeks from today).
if data > datetime.date.today() + datetime.timedelta(weeks=52):
raise ValidationError(_('Invalid date - renewal more than 1 year ahead'))
# Remember to always return the cleaned data.
return data
def save_new_event(request):
form= NewEventForm(request.POST or None)
if form.is_valid():
event = NewEventForm.save(comit=False)
event.host = request.user
NewEventform.save()
context= {'form': form }
return render(request, 'index.html', context)
class EventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
exclude = ['host']
def clean(self):
cleaned_data = super().clean()
start_time = cleaned_data.get('start_time')
end_time = cleaned_data.get('end_time')
if start_time > end_time:
raise ValidationError(
'Start time and date must be before end time and date.')
def clean_content(self):
content = self.cleaned_data['content']
content_type = content.content_type.split('/')[0]
if content_type in settings.CONTENT_TYPES:
if content._size > settings.MAX_UPLOAD_SIZE:
raise ValidationError(
_('Please keep filesize under %s. Current filesize %s') %
(filesizeformat(settings.MAX_UPLOAD_SIZE),
filesizeformat(content._size)))
else:
raise ValidationError(_('File type is not supported'))
return content
class EventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
fields = '__all__' #includes all fields from the models
class EventOccurrenceInlineForm(ModelForm):
WIDGET_FORMATS = ['%I:%M%p', '%I:%M %p', '%I:%M', '%H:%M:%S', '%H:%M']
startTime = SplitDateTimeField(required=True,
label=_('Start Date/Time'),
input_time_formats=WIDGET_FORMATS)
endTime = SplitDateTimeField(required=True,
label=_('End Date/Time'),
input_time_formats=WIDGET_FORMATS)
class EventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
fields = [
"title", "location", "venue", "start_time", "end_time",
"categories"
]
class BookingForm(ModelForm):
start_time = SplitDateTimeField(
widget=AdminSplitDateTime(),
input_date_formats=settings.DATE_INPUT_FORMATS,
input_time_formats=settings.TIME_INPUT_FORMATS)
end_time = SplitDateTimeField(
widget=AdminSplitDateTime(),
input_date_formats=settings.DATE_INPUT_FORMATS,
input_time_formats=settings.TIME_INPUT_FORMATS)
class Meta:
model = Booking
fields = "__all__"
def clean(self):
cleaned_data = super(BookingForm, self).clean()
start_time = cleaned_data.get("start_time")
end_time = cleaned_data.get("end_time")
car = cleaned_data.get("car")
driver = cleaned_data.get("driver")
if not start_time or not end_time:
return
#CHECK FOR OVERLAPPING BOOKINGS on Car or Driver
overlapping_bookings = Booking.objects.filter(
Q(car__pk=car.pk) | Q(driver__pk=driver.pk)).filter(
Q(start_time__gte=start_time, start_time__lt=end_time)
| Q(end_time__gt=start_time, end_time__lte=end_time))
if overlapping_bookings.count() > 0:
raise ValidationError(
"This car is unavailable for this date/time or you already have another car booked for this slot."
)
#CHECK FOR PADDING TIME
start_time_minus_2hrs = start_time - timedelta(hours=2)
invalid_bookings = Booking.objects.filter(car__pk=car.pk).filter(
Q(end_time__gt=start_time_minus_2hrs)
& Q(start_time__lt=start_time_minus_2hrs))
if invalid_bookings.count() > 0:
raise ValidationError(
"This car is unavailable for this start time.")
end_time_plus_2hrs = end_time + timedelta(hours=2)
invalid_bookings = Booking.objects.filter(car__pk=car.pk).filter(
Q(start_time__lt=end_time_plus_2hrs)
& Q(end_time__gt=end_time_plus_2hrs))
if invalid_bookings.count() > 0:
raise ValidationError(
"This booking must be ended at an earlier time.")
def _get_form_fields(self):
return OrderedDict(
(
(self.lookup_kwarg_gte, SplitDateTimeField(
label='',
widget=AdminSplitDateTime(attrs={'style': 'width: 50%', 'placeholder': 'From'}),
required=False
)),
(self.lookup_kwarg_lte, SplitDateTimeField(
label='',
widget=AdminSplitDateTime(attrs={'style': 'width: 50%', 'placeholder': 'To'}),
required=False
)),
)
)
class EventForm(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
fields = [
'host', 'title', 'location', 'venue', 'start_time', 'end_time',
'category'
]
widgets = {
'start_time': widgets.AdminSplitDateTime,
'end_time': widgets.AdminSplitDateTime,
}
exclude = ['host']
class StoryForm(ModelForm):
image_link = forms.URLField(required=False)
# ,help_text='Enter URL to a direct image. Otherwise, a random image will be chosen for you')
pub_date = SplitDateTimeField(
# use split date time field to allow the user to input both date and time
widget=SplitDateTimeWidget(
# 'class'="form-item",
# we use the split date time widget to specify how the html gets built
date_attrs={
'type': 'date',
'class': "form-item",
'id': 'form-date'
},
# type date tells django to use the HTML5 date input
time_attrs={
'type': 'time',
'class': "form-item",
'id': 'form-time'
},
# type time tells django to use the HTML5 time input
# default=timezone.now
))
class Meta:
model = NewsStory
fields = ['title', 'pub_date', 'content', 'image_link', 'category']
widgets = {
'title':
forms.TextInput(
attrs={
'size': 10,
'id': 'form-title',
'class': "form-item",
'placeholder': 'Enter a catchy title',
}),
# 'author': forms.TextInput(attrs={'size': 10, 'id': 'form-author','class': "form-item",'placeholder': 'Your name',}
# ),
'content':
forms.Textarea(
attrs={
'size': 10,
'id': 'form-content',
'class': "form-item",
'placeholder': 'Enter a rivoting story',
}),
'image_link':
forms.TextInput(attrs={
'size':
10,
'id':
'form-link',
'class':
"form-item",
'placeholder':
'Enter URL to a direct image. Otherwise, a random image will be chosen for you',
}, ),
# forces you to upload with url
# want to verify it exists. Django automatically does this
}
def __init__(self, required=True, widget=None, label=None, initial=None):
fields = (
CharField(),
MultipleChoiceField(choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))),
SplitDateTimeField()
)
super(ComplexField, self).__init__(fields, required, widget, label, initial)
class StoryForm(ModelForm):
pub_date = SplitDateTimeField(
widget=SplitDateTimeWidget(
date_attrs={'type': 'date'},
time_attrs={'type': 'time'},
),
label="Published on"
)
class Meta:
model = NewsStory
fields = ['title', 'pub_date', 'image', 'story_category', 'content']
labels = {'image': "Image URL"}
widgets = {
'pub_date': forms.DateInput(
format = ('%m/%d/%Y'),
attrs={
'class': 'form-control',
'placeholder': 'Select a date',
'type': 'date'
}
),
'category': forms.ModelMultipleChoiceField(
widget = forms.SelectMultiple,
queryset = Category.objects.all()
),
}
def __init__(self, required=True, widget=None, label=None, initial=None):
fields = (
CharField(),
MultipleChoiceField(choices=WidgetTest.beatles),
SplitDateTimeField(),
)
super().__init__(fields, required, widget, label, initial)
class StoryForm(ModelForm):
pub_date = SplitDateTimeField(widget=SplitDateTimeWidget(
date_attrs={'type': 'date'},
time_attrs={'type': 'time'},
),
label='Publication Date')
class Meta:
model = NewsStory
fields = ['title', 'pub_date', 'image', 'content']
labels = {'image': 'Image URL'}
widgets = {
'title':
forms.TextInput(attrs={
'class': 'form',
'placeholder': 'Article Title',
}),
'content':
forms.Textarea(
attrs={
'class': 'form',
'id': 'box-size',
'placeholder': 'Article Content'
}),
'image':
forms.URLInput(attrs={
'class': 'form',
'placeholder': 'Enter image URL here'
}),
}
class ProductTradeForm(ModelForm):
dateTime = SplitDateTimeField()
def clean(self):
cd = super(ProductTradeForm, self).clean()
try:
self.instance.product = Product.objects.get(
name=self.data['product'])
except ObjectDoesNotExist:
self.add_error('sold_product_quantity', 'Product topilmadi')
return cd
if self.instance.product.remaining_quantity < Decimal(
self.data['sold_product_quantity']):
self.add_error(
'sold_product_quantity',
'Sotilayotgan product qolgan product sonidan ortiq')
return cd
def is_valid(self):
return super(ProductTradeForm, self).is_valid()
class Meta:
model = ProductTrade
fields = ['sold_product_quantity', 'dateTime']
def __init__(self, **kwargs):
fields = (
CharField(),
MultipleChoiceField(choices=beatles),
SplitDateTimeField(),
)
super().__init__(fields, **kwargs)
def test_splitdatetimefield_changed(self):
f = SplitDateTimeField(input_date_formats=['%d/%m/%Y'])
self.assertFalse(
f.has_changed(['11/01/2012', '09:18:15'],
['11/01/2012', '09:18:15']))
self.assertTrue(
f.has_changed(
datetime.datetime(2008, 5, 6, 12, 40, 00),
['2008-05-06', '12:40:00']))
self.assertFalse(
f.has_changed(
datetime.datetime(2008, 5, 6, 12, 40, 00),
['06/05/2008', '12:40']))
self.assertTrue(
f.has_changed(
datetime.datetime(2008, 5, 6, 12, 40, 00),
['06/05/2008', '12:41']))
class CreateAppointmentForm(ModelForm):
time = SplitDateTimeField(widget=SplitDateTimeWidget(
attrs={'class': 'form-control'}))
description = forms.CharField(widget=forms.Textarea(
attrs={'class': 'form-control'}))
class Meta:
model = Appointment
fields = ['time', 'description']
def test_splitdatetimefield(self):
e = {
'required': 'REQUIRED',
'invalid_date': 'INVALID DATE',
'invalid_time': 'INVALID TIME',
}
f = SplitDateTimeField(error_messages=e)
self.assertFormErrors(['REQUIRED'], f.clean, '')
self.assertFormErrors(['INVALID DATE', 'INVALID TIME'], f.clean, ['a', 'b'])
class EventCreateForm(ModelForm):
date = SplitDateTimeField(input_time_formats=[
'%I:%M %p',
'%I:%M%p',
'%H:%M:%S',
'%H:%M',
])
class Meta:
model = Event
widgets = {'date': SplitDateTimeWidget}
def test_splitdatetimefield(self):
e = {
"required": "REQUIRED",
"invalid_date": "INVALID DATE",
"invalid_time": "INVALID TIME",
}
f = SplitDateTimeField(error_messages=e)
self.assertFormErrors(["REQUIRED"], f.clean, "")
self.assertFormErrors(["INVALID DATE", "INVALID TIME"], f.clean,
["a", "b"])
class EventForm(djangoforms.ModelForm):
country = ChoiceField(widget=Select({'class': "select_country"}))
city = ChoiceField(widget=Select({'class': "select_city"}))
sexs = ['ස්ත්රී', 'පුරුෂ']
sex = ChoiceField(choices=zip(sexs, sexs),
widget=RadioSelect(),
initial=0,
required=False)
sex.widget.renderer.render = lambda self: mark_safe('\n'.join(
[u'%s' % w for w in self]))
sex.widget.renderer.safe = False
name = CharField(label='නම',
error_messages={'required': 'නම ඇතුළත් කරන්න'})
time = SplitDateTimeField(
widget=MyDateTimeWidget(),
error_messages={
'required':
'වේලාව ඇතුළත් කරන්න',
'invalid':
'වලංගු දිනයක් හා වේලාවක් ඇතුළත් කරන්න (උදා : 1980-2-29 23:59:59)',
})
def __init__(self, data=None, instance=None, *args, **kwargs):
super(EventForm, self).__init__(data=data,
instance=instance,
*args,
**kwargs)
self.fields['country'].choices = map(
lambda country: (country, country),
set(map(lambda loc: loc.country,
Location.all().fetch(1000))))
self.fields['country'].initial = instance and instance.location.country
country = \
(data and 'country' in data) and data['country'] \
or (instance and instance.location.country) \
or (self.fields['country'].choices[0][0] if self.fields['country'].choices else None)
if country:
self.fields['city'].choices = [
(loc.key(), loc.city) for loc in Location.all().filter(
'country =', country).fetch(1000)
]
self.fields['city'].initial = instance and instance.location.key()
def save(self):
if not self.is_valid():
return
self.cleaned_data['location'] = Location.get(self.cleaned_data['city'])
entity = djangoforms.ModelForm.save(self, commit=False)
entity.added_by = users.get_current_user()
entity.put()
class Meta:
model = Event
exclude = ['added_by']
class EventForm(ModelForm):
date = SplitDateTimeField(input_time_formats=[
'%I:%M %p',
'%I:%M%p',
'%H:%M:%S',
'%H:%M',
])
class Meta:
model = Event
widgets = {'date': SplitDateTimeWidget}
exclude=('is_template')
class StoryForm(ModelForm):
Cuisine_CHOICES = [
('French', 'French'),
('Italian', 'Italian'),
('Modern Australian', 'Modern Australian'),
('Indonesian', 'Indonesian'),
('Chinese', 'Chinese'),
('Japanese', 'Japanese'),
('Thai', 'Thai'),
('American', 'American'),
('Middle Eastern', 'Middle Eastern'),
('Indian', 'Indian'),
('Moroccan', 'Moroccan'),
('Other', 'Other'),
]
image_upload = forms.URLField(required=False, help_text='If image path is left blank, a randomly generated image will appear in your article',
widget=forms.TextInput(attrs={'class': "form_entry"}))
CHOICES = [('1','Awful'),('2','Average'),('3','Okay'),('4','Good'),('5','Fantastic')]
Food_rating=forms.CharField(label='Overall Experience Rating', widget=forms.RadioSelect(choices=CHOICES))
pub_date = SplitDateTimeField(
# use split date time field to allow the user to input both date and time
widget=SplitDateTimeWidget(
# we use the split date time widget to specify how the html gets built
date_attrs={'type': 'date', 'class':'form_entry'},
# type date tells django to use the HTML5 date input
time_attrs={'type': 'time','class':'form_entry'},
# type time tells django to use the HTML5 time input
)
)
class Meta:
model = NewsStory
fields = ['title','Restaurant', 'pub_date','image_upload','content','cuisine_type']
widgets = {
"content": forms.Textarea(
attrs={'placeholder': 'We cannot wait to hear where you have eaten and what it was like!','class':'form_entry' },
)
,
"title": forms.TextInput(
attrs={
'class':'form_entry'}
)
,
"Restaurant": forms.TextInput(
attrs={
'class':'form_entry'}
)
}
class StoryForm(ModelForm):
class Meta:
model=NewsStory
fields= ['title', 'pub_date', 'content', 'img_url']
pub_date = SplitDateTimeField(
# use split date time field to allow the user to input both date and time
widget=SplitDateTimeWidget(
# we use the split date time widget to specify how the html gets built
date_attrs={'type': 'date'},
# type date tells django to use the HTML5 date input
time_attrs={'type': 'time'},
# type time tells django to use the HTML5 time input
)
)
class InlineAssignmentForm(ModelForm):
start_date = SplitDateTimeField(widget=AdminSplitDateTime)
end_date = SplitDateTimeField(widget=AdminSplitDateTime, required=False)
def __init__(self, *args, **kwargs):
super(InlineAssignmentForm, self).__init__(*args, **kwargs)
# necessary because SplitDateTimeWidget doesn't follow the spec and
# call callables, instead it tries to unpack the value
if self.initial is not None and not 'start_date' in self.initial:
self.initial['start_date'] = datetime.now()
class Meta:
exclude = ('access_object', 'id')
def clean(self):
data = super(InlineAssignmentForm, self).clean()
if data['end_date'] is None:
data['end_date'] = datetime.max
return data
# we want to always create new Assignments because we create a new access
# object
def has_changed(self):
return True
class OilTradeForm(ModelForm):
dateTime = SplitDateTimeField()
def clean(self):
cd = super(OilTradeForm, self).clean()
if 'oil' not in cd:
self.errors.pop(
'oil'
) # Removing English error message and then adding Uzbek error message
if self.data['oil'] == '':
self.add_error('oil', 'Yog\' Nomi bo\'sh bo\'lmasligi kerak')
else:
self.add_error(
'oil',
'Siz kiritgan "' + self.data['oil'] + '" yog\' topilmadi')
return cd
if 'litreSold' not in cd:
self.errors.pop(
'litreSold'
) # Removing English error message and then adding Uzbek error message
if self.data['litreSold'] == '':
self.add_error('litreSold',
'Sotilgan Litr bo\'sh bo\'lmasligi kerak')
else:
self.add_error(
'litreSold',
'Sotilgan litr sonini to\'g\'ri formatda kiriting')
return cd
else:
litre_sold = Decimal(cd['litreSold'])
if litre_sold <= 0:
self.add_error('litreSold',
'Sotilgan litr 0 dan katta bo\'lishi kerak')
return cd
oil = Oil.objects.get(name=cd['oil'])
if oil.RemainingLitres < litre_sold:
self.add_error(
'litreSold',
'Kiritilgan litr qolgan yog\' miqdoridan oshib ketdi')
return cd
class Meta:
model = OilTrade
fields = ['oil', 'litreSold', 'dateTime']
class StoryForm(ModelForm):
pub_date = SplitDateTimeField(
widget = SplitDateTimeWidget(
date_attrs={'type': 'date'},
time_attrs={'type': 'time'},
)
)
class Meta:
model = NewsStory
fields = ['title', 'pub_date', 'content', 'image']
labels = {
'image' : _('Image (URL)'),
}
widgets = {
'title' : forms.TextInput(attrs={'placeholder': 'Title'}),
'content' : forms.Textarea(attrs={'placeholder': 'Story Content'}),
'image' : forms.URLInput(attrs={'placeholder': 'Image URL'})
}
def test_splitdatetimefield_1(self):
f = SplitDateTimeField()
self.assertIsInstance(f.widget, SplitDateTimeWidget)
self.assertEqual(
datetime.datetime(2006, 1, 10, 7, 30), f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean("")
with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
f.clean("hello")
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.', 'Enter a valid time.'"):
f.clean(["hello", "there"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(["2006-01-10", "there"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(["hello", "07:30"])
def test_splitdatetimefield_2(self):
f = SplitDateTimeField(required=False)
self.assertEqual(
datetime.datetime(2006, 1, 10, 7, 30),
f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
)
self.assertEqual(datetime.datetime(2006, 1, 10, 7, 30), f.clean(['2006-01-10', '07:30']))
self.assertIsNone(f.clean(None))
self.assertIsNone(f.clean(''))
self.assertIsNone(f.clean(['']))
self.assertIsNone(f.clean(['', '']))
with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
f.clean('hello')
with self.assertRaisesRegex(ValidationError, r"'Enter a valid date\.', u?'Enter a valid time\.'"):
f.clean(['hello', 'there'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(['2006-01-10', 'there'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(['hello', '07:30'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(['2006-01-10', ''])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(['2006-01-10'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(['', '07:30'])
def test_splitdatetimefield_2(self):
f = SplitDateTimeField(required=False)
self.assertEqual(
datetime.datetime(2006, 1, 10, 7, 30), f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
)
self.assertEqual(datetime.datetime(2006, 1, 10, 7, 30), f.clean(["2006-01-10", "07:30"]))
self.assertIsNone(f.clean(None))
self.assertIsNone(f.clean(""))
self.assertIsNone(f.clean([""]))
self.assertIsNone(f.clean(["", ""]))
with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
f.clean("hello")
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.', 'Enter a valid time.'"):
f.clean(["hello", "there"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(["2006-01-10", "there"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(["hello", "07:30"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(["2006-01-10", ""])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(["2006-01-10"])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(["", "07:30"])
def test_splitdatetimefield_1(self):
f = SplitDateTimeField()
self.assertIsInstance(f.widget, SplitDateTimeWidget)
self.assertEqual(
datetime.datetime(2006, 1, 10, 7, 30),
f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean('')
with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
f.clean('hello')
with self.assertRaisesRegex(ValidationError, r"'Enter a valid date\.', u?'Enter a valid time\.'"):
f.clean(['hello', 'there'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
f.clean(['2006-01-10', 'there'])
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(['hello', '07:30'])
def test_splitdatetimefield_changed(self):
f = SplitDateTimeField(input_date_formats=["%d/%m/%Y"])
self.assertFalse(f.has_changed(["11/01/2012", "09:18:15"], ["11/01/2012", "09:18:15"]))
self.assertTrue(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ["2008-05-06", "12:40:00"]))
self.assertFalse(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ["06/05/2008", "12:40"]))
self.assertTrue(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ["06/05/2008", "12:41"]))
