class CreateContest(forms.Form):
name = forms.CharField(widget=forms.TextInput(attrs={'max_length': 30, 'class': 'form-control'}), label=_("Name"))
contest_code = forms.CharField(widget=forms.TextInput(attrs={'max_length': 30, 'class': 'form-control'}),
label="Contest Code")
start_date = forms.SplitDateTimeField(widget=widgets.AdminSplitDateTime())#attrs={'class': "form-control"}))
end_date = forms.SplitDateTimeField(widget=widgets.AdminSplitDateTime())#attrs={'class': "form-control"}))
def clean_contest_code(self):
try:
contest = Contest.objects.get(contest_code=self.cleaned_data['contest_code'])
raise forms.ValidationError("A Contest with same contest code already exists.")
except:
return self.cleaned_data['contest_code']
def clean_start_date(self):
now = aware(datetime.datetime.now())
if now >= self.cleaned_data['start_date']:
raise forms.ValidationError("Past dates are not allowed.")
return self.cleaned_data['start_date']
def clean_end_date(self):
now = aware(datetime.datetime.now())
condition = self.cleaned_data['end_date'] <= self.cleaned_data['start_date']
if now >= self.cleaned_data['end_date'] or condition:
raise forms.ValidationError("Invalid time")
return self.cleaned_data['end_date']
class DriverSearchOrderForm(forms.Form):
#can not eariler than current time£¡£¡
earliest_aptime = forms.SplitDateTimeField(
label='Earliest Accetable DateTime',
widget=widgets.AdminSplitDateTime())
latest_aptime = forms.SplitDateTimeField(
label='Latest Accetable DateTime', widget=widgets.AdminSplitDateTime())
departure = forms.CharField(label='Departure',
required=False,
max_length=200)
destination = forms.CharField(label='Destination',
required=False,
max_length=200)
def clean_earliest_aptime(self):
earliest_aptime = self.cleaned_data.get('earliest_aptime')
datetime_now = timezone.now()
if earliest_aptime < datetime_now:
raise forms.ValidationError(
"Datetime should not earlier than current datetime.")
return earliest_aptime
def clean_latest_aptime(self):
latest_aptime = self.cleaned_data.get('latest_aptime')
datetime_now = timezone.now()
if latest_aptime < datetime_now:
raise forms.ValidationError(
"Datetime should not earlier than current datetime.")
return latest_aptime
class BlogForm(forms.Form):
posting_time = forms.DateTimeField(
widget=admin_widgets.AdminSplitDateTime())
display_time = forms.DateTimeField(
widget=admin_widgets.AdminSplitDateTime())
keywords = forms.CharField(max_length=500, required=False)
title = forms.CharField(max_length=100)
byline = forms.CharField(max_length=100, required=False)
byline_link = forms.CharField(max_length=100, required=False)
reviewed_by = forms.CharField(max_length=100, required=False)
reviewed_by_link = forms.CharField(max_length=100, required=False)
body = forms.CharField(widget=forms.Textarea)
sections = forms.MultipleChoiceField(widget=forms.SelectMultiple())
urlname = forms.CharField(required=False, widget=forms.HiddenInput)
def __init__(self, *args, **kwargs):
if 'sections' in kwargs:
sections = kwargs['sections']
kwargs.pop('sections')
else:
sections = None
if 'initial_sections' in kwargs:
initial_sections = kwargs['initial_sections']
kwargs.pop('initial_sections')
else:
initial_sections = None
super(BlogForm, self).__init__(*args, **kwargs)
if sections:
self.fields['sections'].choices = sections
if initial_sections:
self.fields['sections'].initial = initial_sections
self.fields['posting_time'].initial = datetime.now()
self.fields['display_time'].initial = datetime.now()
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
exclude = ['host']
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 Meta:
model = EventTime
exclude = ('event', )
widgets = {
'event_start_time': widgets.AdminSplitDateTime(),
'event_end_time': widgets.AdminSplitDateTime()
}
class Meta:
fields = ('nodeaddr','wateraddr','rvalue','fvalue','metertype','meterstate','commstate','rtime','lastrvalue','lastrtime','dosage','islargecalibermeter')
model = models.Watermeter
widgets = {
'rtime':widgets.AdminSplitDateTime(),
'lastrtime':widgets.AdminSplitDateTime()
}
class Meta:
model = models.Banner
exclude = ['libraries', 'library_creator', 'in_descendants', 'global_banner']
widgets = {
'start_date': widgets.AdminSplitDateTime(),
'end_date': widgets.AdminSplitDateTime()
}
class FilterForm(forms.Form):
env_choices = []
env_list = NrsEnvironment.objects.all().order_by('-title')
if env_list:
for env in env_list:
env_choices.append((env.id, env.title))
environment = forms.ChoiceField(label="Scegliere il sito",
choices=env_choices)
datetime_from = forms.DateTimeField(label="Limite inferiore",
widget=widgets.AdminSplitDateTime())
datetime_to = forms.DateTimeField(label="Limite superiore",
widget=widgets.AdminSplitDateTime())
view_option = forms.ChoiceField(label="Vista",
choices=(('map', 'Mappa'), ('serie',
'Serie')))
aggregate_option = forms.ChoiceField(
label="Elaborazione",
choices=(('avg', 'Valore Medio'), ('last', 'Ultimo Campione'),
('first', 'Primo Campione'), ('min', 'Valore Minimo'),
('max', 'Valore Massimo')))
interpolation_method = forms.ChoiceField(label=" ",
choices=(('linear', 'Lineare'),
('cubic', 'Cubica'),
('nearest', 'Nearest')))
class Media:
css = {'all': ('layout.css', )}
class createEvent(ModelForm):
start_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
end_time = SplitDateTimeField(widget=widgets.AdminSplitDateTime())
class Meta:
model = Event
exclude = ['created_by']
class Meta:
model = Deal
fields = '__all__'
start_date_time = forms.SplitDateTimeField(
widget=widgets.AdminSplitDateTime())
end_date_time = forms.SplitDateTimeField(
widget=widgets.AdminSplitDateTime())
class Meta:
model = Poll
exclude = ('library', )
widgets = {
'start_date': widgets.AdminSplitDateTime(),
'end_date': widgets.AdminSplitDateTime()
}
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 SuscriptionsFormAdmin(forms.Form):
user = forms.ModelChoiceField(queryset=User.objects.all())
type_subs = forms.ModelChoiceField(queryset=SuscriptionType.objects.all())
init_date = forms.SplitDateTimeField(label="Fecha Inicial",
widget=widgets.AdminSplitDateTime())
end_date = forms.SplitDateTimeField(label="Fecha final",
widget=widgets.AdminSplitDateTime())
suscriptions = forms.IntegerField(label="suscripciones", )
class Meta:
model = Event
exclude = ('library', )
widgets = {
'start_date': widgets.AdminSplitDateTime(),
'end_date': widgets.AdminSplitDateTime(),
'age_category': forms.CheckboxSelectMultiple(),
'event_type': forms.CheckboxSelectMultiple()
}
def __init__(self, *args, **kwargs):
if hasattr(self, 'user'):
kwargs.update({'user': self.user})
super(JobAdminForm, self).__init__(*args, **kwargs)
if hasattr(self, 'user'):
self.fields['activation_dt'] = forms.DateTimeField(widget=widgets.AdminSplitDateTime(), initial=datetime.now())
self.fields['expiration_dt'] = forms.DateTimeField(widget=widgets.AdminSplitDateTime(), initial=datetime.now())
self.fields['post_dt'] = forms.DateTimeField(widget=widgets.AdminSplitDateTime(), initial=datetime.now())
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"
]
def __init__(self, request, *args, **kwargs):
super(MetaDataForm, self).__init__(*args, **kwargs)
self.fields["publication_date"].widget = widgets.AdminSplitDateTime()
self.fields["start_date"].widget = widgets.AdminSplitDateTime()
self.fields["end_date"].widget = widgets.AdminSplitDateTime(
attrs={"required": False})
instance = kwargs.get("instance").get_content_object()
if not instance.has_permission(request.user, "manage_content"):
self.fields["creator"].widget = ReadOnlyInput()
language = instance.language
ctr = get_info(instance)
if not getattr(settings, "LFC_MULTILANGUAGE"):
del self.fields["canonical"]
del self.fields["language"]
# Templates - display only registered templates for this instance
if len(ctr.templates.all()) < 2:
del self.fields["template"]
else:
self.fields["template"].choices = [
(template.id, _(template.name))
for template in ctr.templates.all()
]
# Canonical - display only pages with default language
if settings.LFC_MULTILANGUAGE:
if instance.is_canonical():
del self.fields["canonical"]
else:
canonicals = [(p.id, p.title)
for p in BaseContent.objects.filter(
language=settings.LANGUAGE_CODE)]
canonicals.insert(0, ("", "----------"))
self.fields["canonical"].choices = canonicals
# Standard - display only children of the current instance
if not language == "0":
children = instance.children.filter(language__in=(language, "0"))
else:
children = instance.children.all()
standards = [(p.id, p.title) for p in children]
standards = sorted(standards, lambda a, b: cmp(a[1], b[1]))
standards.insert(0, ("", "----------"))
self.fields["standard"].choices = standards
# Position
if not ctr.display_position:
del self.fields["position"]
class EventEditForm(forms.ModelForm):
user = None
event_date_start = forms.SplitDateTimeField(
widget=widgets.AdminSplitDateTime(), initial=now())
event_date_end = forms.SplitDateTimeField(
widget=widgets.AdminSplitDateTime(), initial=now())
sign_up_args = {
"widget": widgets.AdminSplitDateTime(),
"initial": now(),
"required": False
}
sign_up_others = forms.SplitDateTimeField(**sign_up_args)
sign_up_members = forms.SplitDateTimeField(**sign_up_args)
sign_up_deadline = forms.SplitDateTimeField(**sign_up_args)
sign_up_cancelling_deadline = forms.SplitDateTimeField(**sign_up_args)
class Meta:
model = Event
fields = ('title', 'event_date_start', 'event_date_end', 'content',
'sign_up', 'sign_up_max_participants', 'sign_up_others',
'sign_up_members', 'sign_up_deadline', 'sign_up_cancelling',
'sign_up_cancelling_deadline', 'published', 'sign_up_avec',
'slug', 'members_only')
class Media:
js = (
'//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js', # jquery,
'js/eventform.js',
)
def save(self, commit=True):
post = super(EventEditForm, self).save(commit=False)
if self.user is None:
return None
post.modified_time = now()
if not post.sign_up:
post.sign_up_max_participants = 0
post.sign_up_others = None
post.sign_up_members = None
post.sign_up_deadline = None
post.sign_up_cancelling = False
post.sign_up_cancelling_deadline = None
if commit:
post.update_or_create(pk=post.pk)
return post
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']
def __init__(self, *args, **kwargs):
super(VideoForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields['description'].widget.mce_attrs['app_instance_id'] = self.instance.pk
else:
self.fields['description'].widget.mce_attrs['app_instance_id'] = 0
self.fields['release_dt'].widget = widgets.AdminSplitDateTime()
class EventForm (forms.ModelForm):
repeat = forms.ChoiceField(choices=REPEAT_CHOICES, required=False)
repeat_until = forms.DateTimeField(required=False, widget=widgets.AdminSplitDateTime())
update = forms.ChoiceField(choices=UPDATE_CHOICES, initial="me", required=False)
def clean (self):
cleaned_data = super(EventForm, self).clean()
if cleaned_data.get('repeat') and cleaned_data.get('repeat') != 'none':
if cleaned_data.get('repeat_until'):
if cleaned_data.get('start_dt') and cleaned_data.get('repeat_until') <= cleaned_data.get('start_dt'):
self._errors["repeat_until"] = self.error_class(['Repeat Until must be after Start.'])
else:
self._errors["repeat_until"] = self.error_class(['Repeat Until required when repeating.'])
if cleaned_data.get('start_dt') and cleaned_data.get('end_dt'):
if cleaned_data.get('end_dt') <= cleaned_data.get('start_dt'):
self._errors["end_dt"] = self.error_class(['End must be after Start.'])
return cleaned_data
class Meta:
model = Event
fields = ('title', 'start_dt', 'end_dt', 'all_day', 'body', 'image', 'imageset', 'categories', 'series')
widgets = {
'body': RichText
}
def __init__(self, *args, **kwargs):
super(ReportValueModelForm, self).__init__(*args, **kwargs)
if self.instance.pk:
item = self.instance.item
if item.type == 'check':
realvalue = forms.NullBooleanField(
initial=self.instance.boolean_value)
elif item.type == 'dict':
realvalue = forms.ModelChoiceField(
Value.objects.filter(
dictionary=self.instance.item.dictionary),
initial=self.instance.key_value)
elif item.type == 'int':
realvalue = forms.IntegerField(initial=self.instance.int_value)
elif item.type == 'date':
realvalue = forms.DateField(initial=self.instance.date_value,
widget=widgets.AdminDateWidget())
elif item.type == 'datetime':
realvalue = forms.DateTimeField(
initial=self.instance.date_value,
widget=widgets.AdminSplitDateTime())
else:
realvalue = forms.CharField(initial=self.instance.string_value)
realvalue.required = False
self.fields['realvalue'] = realvalue
def __init__(self, *args, **kwargs):
# If exclude is there, remove some fields from the Form
# if kwargs.get('exclude'):
# exclude_list = kwargs.pop('exclude')
super(AttendanceForm, self).__init__(*args, **kwargs)
self.fields['pub_date'].widget = widgets.AdminSplitDateTime()
self.fields[
'pub_date'].help_text = "<small>(Time in format hh:mm:ss)</small>"
def __init__(self, *args, **kwargs):
super(CambioMecanicoForm, self).__init__(*args, **kwargs)
for form in self.visible_fields():
form.field.widget.attrs['class'] = 'form-control'
form.field.widget.attrs['autocomplete'] = 'off'
self.fields['create'].widget.attrs['readonly'] = True
self.fields['fecha_fin'].widget = widgets.AdminSplitDateTime()
self.fields['parada'].widget.attrs['autofocus'] = True
class Meta:
model = Lesson
fields = ['student', 'date', 'lesson_long', 'skype', 'status']
labels = {'student': _('Select Student'), }
help_texts = {'student': _('With who you lesson'), }
widgets = {
'date': widgets.AdminSplitDateTime(),
}
def __init__(self, *args, **kwargs):
super(EventForm, self).__init__(*args, **kwargs)
self.fields['when'].widget = widgets.AdminSplitDateTime()
self.fields['when'].initial = datetime.now()
self.fields['when'].label = 'Cănd?'
self.fields['text'].widget = forms.Textarea()
self.fields['picture'].label = 'Poză'
self.fields['title'].label = 'Titlu'
class TransitionForm(forms.ModelForm):
class Meta:
model = Transition
fields = ['sim', 'employee', 'comment']
exclude = ['date']
date_field = forms.SplitDateTimeField(widget=widgets.AdminSplitDateTime())
date_field.label = 'Дата передачи'
def test_localization(self):
w = widgets.AdminSplitDateTime()
with self.settings(USE_L10N=True), translation.override('de-at'):
w.is_localized = True
self.assertHTMLEqual(
w.render('test', datetime(2007, 12, 1, 9, 30)),
'<p class="datetime">Datum: <input value="01.12.2007" type="text" class="vDateField" name="test_0" size="10" /><br />Zeit: <input value="09:30:00" type="text" class="vTimeField" name="test_1" size="8" /></p>',
)
