class AuctionForm(forms.ModelForm):
start = forms.DateTimeField(input_formats=['%Y-%m-%d %H:%M:%S'],
widget=DateTimePicker(options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle': True,
}))
cap_time = forms.DateTimeField(input_formats=['%Y-%m-%d %H:%M:%S'],
widget=DateTimePicker(options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle':
True,
}))
class Meta:
model = Auction
fields = [
'start',
'cap_time',
]
class RideShareForm(forms.Form):
dst_addr = forms.CharField(label="Destination", required=True)
earliest_arrival = forms.DateTimeField(label="Earlist Arrival", required=True,
widget=DateTimePicker(options={'collapse':False,'minDate': 'now','defaultDate': 'now'}))
latest_arrival = forms.DateTimeField(label="Latest Arrival", required=True,
widget=DateTimePicker(options={'collapse':False,'minDate': 'now','defaultDate': 'now'}))
passenger_num = forms.IntegerField(label="Passenger Number", required=True, min_value=1, initial=1)
class BookingForm(forms.ModelForm):
# booktime = forms.DateTimeField(widget=forms.HiddenInput())
bookfrom = forms.DateTimeField(
widget=DateTimePicker(
options={
'format': "YYYY-MM-DD HH:mm:ss", #'%Y-%m-%d %H:%M:%S'
'useCurrent': True,
'collapse': True,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}), )
bookuntil = forms.DateTimeField(
widget=DateTimePicker(
options={
'format': "YYYY-MM-DD HH:mm:ss", #'%Y-%m-%d %H:%M:%S'
'useCurrent': True,
'collapse': True,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}), )
class Meta:
model = Booking
fields = ["user", "slot"]
def __init__(self, *args, **kwargs):
super(AnnouncementForm, self).__init__(*args, **kwargs)
self.fields['date_start'].widget = DateTimePicker(options={
'timeZone':
str(timezone.get_current_timezone()),
'collapse':
False,
'minDate':
str(timezone.now().astimezone().strftime("%Y-%m-%d 00:00:00")),
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle':
True,
})
self.fields['date_stop'].widget = DateTimePicker(options={
'timeZone':
str(timezone.get_current_timezone()),
'collapse':
False,
'minDate':
str(timezone.now().astimezone().strftime("%Y-%m-%d 00:00:00")),
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle':
True,
})
now = timezone.now().astimezone().strftime("%Y-%m-%d %H:%M")
tz_name = timezone.get_current_timezone()
help_text = f"Time Zone is {tz_name} ({now})"
self.fields['date_start'].help_text = help_text
self.fields['date_stop'].help_text = help_text
class AddEventForm(forms.Form):
def __init__(self, user: User, *args, **kwargs):
super(AddEventForm, self).__init__(*args, **kwargs)
contact_objects1 = cal_app_models.Contact.objects.filter(user1=user, state="accepted")
contact_objects2 = cal_app_models.Contact.objects.filter(user2=user, state="accepted")
contact_set = {c.user2 for c in contact_objects1}.union({c.user1 for c in contact_objects2})
contact_pks = {con.pk for con in contact_set}
contacts = User.objects.filter(pk__in=contact_pks)
self.fields["shares"].queryset = contacts
self.fields["owner_importance"].help_text += "<br>1 is lowest, 10 is highest"
def clean(self):
cd = super(AddEventForm, self).clean()
if self.cleaned_data["begin_datetime"] >= self.cleaned_data["end_datetime"]:
err = forms.ValidationError("End must be after beginning!", code="invalid_date")
self.add_error("end_datetime", err)
return cd
text = forms.CharField(max_length=256)
begin_datetime = forms.DateTimeField(widget=DateTimePicker(attrs={'autocomplete': 'off'}))
end_datetime = forms.DateTimeField(widget=DateTimePicker(attrs={'autocomplete': 'off'}))
owner_importance = forms.IntegerField(max_value=10, min_value=1)
shares = forms.ModelMultipleChoiceField(widget=forms.CheckboxSelectMultiple,
queryset=User.objects.all(),
required=False,
label="Include these users:")
repetition_type = forms.ChoiceField(choices=(("none", "Do not repeat"),
("weekly", "Repeat every week on..."),
("numdays", "Repeat every n days")),
widget=forms.RadioSelect)
repetition_number = forms.IntegerField(widget=forms.HiddenInput,
initial=0)
from_date = forms.DateField(widget=DatePicker(attrs={'autocomplete': 'off'}), label='Start repeating on:')
until_date = forms.DateField(widget=DatePicker(attrs={'autocomplete': 'off'}), label='Stop repeating on:')
class AddTaskForm(forms.Form):
def __init__(self, user: User, *args, **kwargs):
super(AddTaskForm, self).__init__(*args, **kwargs)
contactObjects1 = cal_app_models.Contact.objects.filter(user1=user, state="accepted")
contactObjects2 = cal_app_models.Contact.objects.filter(user2=user, state="accepted")
contactSet = {c.user2 for c in contactObjects1}.union({c.user1 for c in contactObjects2})
contactPKs = {con.pk for con in contactSet}
contacts = User.objects.filter(pk__in=contactPKs)
self.fields["shares"].queryset = contacts
self.fields["owner_importance"].help_text += "<br>1 is lowest, 10 is highest"
text = forms.CharField(max_length=256)
due_datetime = forms.DateTimeField(widget=DateTimePicker(attrs={'autocomplete': 'off'}))
available_datetime = forms.DateTimeField(widget=DateTimePicker(attrs={'autocomplete': 'off'}))
expected_minutes = forms.IntegerField()
owner_importance = forms.IntegerField(max_value=10, min_value=1)
shares = forms.ModelMultipleChoiceField(widget=forms.CheckboxSelectMultiple,
queryset=User.objects.all(),
required=False,
label="Include these users:")
repetition_type = forms.ChoiceField(choices=(("none", "Do not repeat"),
("weekly", "Repeat every week on..."),
("numdays", "Repeat every n days")),
widget=forms.RadioSelect)
repetition_number = forms.IntegerField(widget=forms.HiddenInput,
initial=0)
from_date = forms.DateField(widget=DatePicker(attrs={'autocomplete': 'off'}), label='Start repeating on:')
until_date = forms.DateField(widget=DatePicker(attrs={'autocomplete': 'off'}), label='Stop repeating on:')
class WorkEvidenceForm(forms.ModelForm):
options = {
'icons': icons,
'format': 'YYYY-MM-DD HH:mm',
'maxDate': str(now().date() + timedelta(days=1)),
'useCurrent': False,
'stepping': 5,
'buttons': {
'showToday': True,
'showClear': True,
'showClose': True
},
'sideBySide': True
}
attrs = {
'prepend': 'fas fa-user-clock',
'append': 'fas fa-calendar-check',
'input_toggle': False,
'icon_toggle': True
}
worker = forms.ModelChoiceField(
widget=forms.HiddenInput(attrs={'readonly': True}), queryset=query)
start_work = forms.DateTimeField(label='Start of work (date and time)',
widget=DateTimePicker(options=options,
attrs=attrs))
end_work = forms.DateTimeField(label='End of work (date and time)',
widget=DateTimePicker(options=options,
attrs=attrs))
class Meta:
model = WorkEvidence
fields = ['worker', 'start_work', 'end_work']
class datetimeform(forms.Form):
Date_From = forms.DateTimeField(
widget=DateTimePicker(
options={
'minDate':
(datetime.date.today() +
datetime.timedelta(days=1)).strftime('%Y-%m-%d'), # Tomorrow
'useCurrent':
True,
'collapse':
False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}), )
Date_To = forms.DateTimeField(
widget=DateTimePicker(
options={
'minDate':
(datetime.date.today() +
datetime.timedelta(days=1)).strftime('%Y-%m-%d'), # Tomorrow
'useCurrent':
True,
'collapse':
False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}), )
class Meta:
model = Trajet
fields = [
'vehicule',
'depart',
'heure_depart',
'arrivee',
'heure_arrivee',
'tarif',
'available',
'commentaire',
]
widgets = {
'heure_depart':
DateTimePicker(options={
'useCurrent': True,
'collapse': True,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}),
'heure_arrivee':
DateTimePicker(options={
'useCurrent': True,
'collapse': True,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}),
}
class TutorSessionForm(forms.ModelForm):
start_time = forms.DateTimeField(widget=DateTimePicker(), )
expected_fin_time = forms.DateTimeField(widget=DateTimePicker(), )
class Meta:
model = TutorSession
fields = ('title', 'session_type', 'location', 'start_time',
'expected_fin_time')
def __init__(self, *args, **kwargs):
super(TutorSessionForm, self).__init__(*args, **kwargs)
now = datetime.datetime.now()
if int(now.minute) > 10:
now += timedelta(hours=1)
later_time = now + timedelta(hours=1)
start_time_str = format(now, '%Y-%m-%d %H:00:00')
end_time_str = format(later_time, '%Y-%m-%d %H:00:00')
self.fields['start_time'].widget = DateTimePicker(options={
'defaultDate': start_time_str,
'vertical': 'top',
})
self.fields['expected_fin_time'].widget = DateTimePicker(
options={
'defaultDate': end_time_str,
'vertical': 'top',
})
class Meta:
model = Noticia
fields = '__all__'
exclude = ['slug', 'autor']
labels = {
'titulo': 'Título da Notícia',
'texto': 'Texto',
'criacao': 'Data de Criação',
'edicao': 'Data de Edição',
'status': 'Marque para publicar',
'destaque': 'Destacar notícia',
'categoria': 'Categoria',
}
widgets = {
'criacao':
DateTimePicker(options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}),
'edicao':
DateTimePicker(options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}),
'texto':
SummernoteWidget(),
}
class ScheduleForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
super(ScheduleForm, self).__init__(*args, **kwargs)
for visible in self.visible_fields():
visible.field.widget.attrs['class'] = 'form-input' # give class 'form-input' to all input fields in form
start_date_time = forms.DateTimeField(
initial=datetime.now, # set initial value to now
widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': False,
'sideBySide': True,
'format': 'MMM D, YYYY h:mm A'
},
attrs={
'append': 'fa fa-calendar',
'input_toggle': True,
'icon_toggle': True,
}),
input_formats=[
'%Y-%m-%d %H:%M:%S', # '2006-10-25 14:30:59'
'%Y-%m-%d %H:%M', # '2006-10-25 14:30'
'%m/%d/%Y %H:%M:%S', # '10/25/2006 14:30:59'
'%m/%d/%Y %H:%M', # '10/25/2006 14:30'
'%m/%d/%y %H:%M:%S', # '10/25/06 14:30:59'
'%m/%d/%y %H:%M', # '10/25/06 14:30'
'%b %d, %Y %I:%M %p'] # 'October 25, 2006 2:30 AM' Custom format
)
end_date_time = forms.DateTimeField(
initial=datetime.now() + timedelta(hours=1), # set initial value to now + 1 hour
widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': False,
'sideBySide': True,
'format': 'MMM D, YYYY h:mm A'
},
attrs={
'append': 'fa fa-calendar',
'input_toggle': True,
'icon_toggle': True,
}),
input_formats=[
'%Y-%m-%d %H:%M:%S', # '2006-10-25 14:30:59'
'%Y-%m-%d %H:%M', # '2006-10-25 14:30'
'%m/%d/%Y %H:%M:%S', # '10/25/2006 14:30:59'
'%m/%d/%Y %H:%M', # '10/25/2006 14:30'
'%m/%d/%y %H:%M:%S', # '10/25/06 14:30:59'
'%m/%d/%y %H:%M', # '10/25/06 14:30'
'%b %d, %Y %I:%M %p'] # 'October 25, 2006 2:30 AM' Custom format
)
class Meta:
model = Schedule
# fields = '__all__' # use all fields
fields = ['title', 'details', 'start_date_time', 'end_date_time']
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Make start/end dates Tempus Dominus datetime picker widgets.
self.fields['start_date'].widget = DateTimePicker(
attrs={'autocomplete': 'off'})
self.fields['end_date'].widget = DateTimePicker(
attrs={'autocomplete': 'off'})
def __init__(self, user, instance, *args, **kwargs):
user = user
instance = instance
super().__init__(*args, **kwargs)
self.fields['task_name'] = forms.CharField(max_length=100,
required=True,
initial=instance.task_name)
self.fields['task_description'] = forms.CharField(
max_length=100, required=True, initial=instance.tast_description)
self.fields['task_created_date'] = forms.DateTimeField(
label='Previous created date: ' +
instance.task_created_date.strftime("%D"),
required=True,
initial=instance.task_created_date,
widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': True,
'format': "YYYY-MM-DD HH:mm",
# Calendar and time widget formatting
'date': 'fas fa-calendar',
'clear': 'fas fa-delete',
},
attrs={
'append': 'fas fa-calendar',
'icon_toggle': True,
}),
)
self.fields['task_due_date'] = forms.DateTimeField(
label='Previous due date: ' +
instance.task_due_date.strftime("%D"),
required=True,
initial=instance.task_due_date,
widget=DateTimePicker(options={
'useCurrent': True,
'collapse': True,
'format': "YYYY-MM-DD HH:mm",
'date': 'fas fa-calendar',
'clear': 'fas fa-delete',
},
attrs={
'append': 'fas fa-calendar',
'icon_toggle': True,
}),
)
self.fields['task_priority'] = forms.ChoiceField(
choices=CHOICES, initial=instance.task_priority)
self.fields['task_completion'] = forms.BooleanField(
required=False, initial=instance.task_completion)
self.fields['task_list'] = forms.ModelChoiceField(
queryset=TaskList.objects.filter(task_user=user),
error_messages={"required": "Please choose a List"},
initial=instance.task_list)
class TaskForm(forms.Form):
def __init__(self, user_id=None, *args, **kwargs):
super(TaskForm, self).__init__(*args, **kwargs)
categories = tmlib.commands.user_categories(
create_categories_controller(user_id,
settings.TASK_MANAGER_DATABASE_PATH))
categories_tuple = [(category.id, category.name)
for category in categories]
tasks = tmlib.commands.filter_tasks(
create_tasks_controller(user_id,
settings.TASK_MANAGER_DATABASE_PATH),
(Task.status != Status.TEMPLATE.value) & (Task.user_id == user_id))
tasks_tuple = [(task.id, task.title) for task in tasks]
tasks_tuple.insert(0, ('', '---------')) # required for default value
self.fields['category'] = forms.ChoiceField(choices=categories_tuple,
required=False)
self.fields['parent_task'] = forms.ChoiceField(choices=tasks_tuple,
required=False)
title = forms.CharField(
max_length=200,
widget=forms.TextInput(
attrs={'placeholder': 'Your amazing task title'}))
note = forms.CharField(
required=False,
widget=forms.TextInput(attrs={'placeholder': 'Your amazing note'}))
category = forms.ChoiceField(required=False)
status = forms.ChoiceField(choices=[(e.value, Status(e).name)
for e in Status])
priority = forms.ChoiceField(choices=[(e.value, Priority(e).name)
for e in Priority])
event = forms.BooleanField(initial=False, required=False)
start_time = forms.DateTimeField(widget=DateTimePicker(
options={
'minDate': (datetime.date.today()).strftime('%Y-%m-%d'),
'useCurrent': True,
}),
required=False)
end_time = forms.DateTimeField(widget=DateTimePicker(
options={
'minDate': (datetime.date.today() +
datetime.timedelta(days=1)).strftime('%Y-%m-%d'),
'useCurrent':
False,
}),
required=False)
parent_task = forms.ChoiceField()
assigned_user = forms.ModelChoiceField(queryset=User.objects.all(),
required=False)
can_read = forms.ModelMultipleChoiceField(queryset=User.objects.all(),
required=False)
can_write = forms.ModelMultipleChoiceField(queryset=User.objects.all(),
required=False)
def get_form(self):
form = super().get_form()
form.fields['heure_depart'].widget = DateTimePicker(
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}
)
form.fields['heure_arrivee'].widget = DateTimePicker(
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}
)
return form
class dateForm(forms.Form):
date_field = forms.DateField(widget=DatePicker())
date_field_required_with_min_max_date = forms.DateField(
required=True,
widget=DatePicker(options={
'minDate': '2009-01-20',
'maxDate': '2017-01-20',
}, ),
initial='2013-01-01',
)
"""
In this example, the date portion of defaultDate is irrelevant;
only the time portion is used. The reason for this is that it has
to be passed in a valid MomentJS format. This will default the time
to be 14:56:00 (or 2:56pm).
"""
time_field = forms.TimeField(widget=TimePicker(
options={
'enabledHours': [9, 10, 11, 12, 13, 14, 15, 16],
'defaultDate': '1970-01-01T14:56:00'
},
attrs={
'input_toggle': True,
'input_group': False,
},
), )
datetime_field = forms.DateTimeField(widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}), )
class TicketForm(forms.ModelForm):
def __init__(self, wallet, *args, **kwargs):
super(TicketForm, self).__init__(*args, **kwargs)
self.fields['category'].queryset = Category.objects.filter(
wallet=wallet)
title = forms.CharField(widget=forms.TextInput(attrs={'placeholder': ''}))
date = forms.DateTimeField(widget=DateTimePicker(options={
'useCurrent': True,
'collapse': True,
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle': True,
}), )
desc = forms.CharField(widget=forms.Textarea(attrs={
'cols': 4,
'rows': 4
}),
required=False)
class Meta:
model = Ticket
exclude = [
'wallet',
]
class OrderFormUpdate(BSModalForm):
date = DateTimeField(widget=DateTimePicker(options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}))
commission = DecimalField(required=False, max_digits=6, min_value=0)
price = DecimalField(required=False, min_value=0)
def __init__(self, *args, **kwargs):
super(OrderFormUpdate, self).__init__(*args, **kwargs)
self.fields['price'].required = True
self.fields['commission'].required = True
self.fields['size'].required = True
self.fields['date'].required = True
class Meta:
model = Orders
fields = ['stock', 'date', 'size', 'price', 'commission']
def save(self):
my_order = super(CreateUpdateAjaxMixin, self).save()
return my_order
class AdjustmentForm(forms.ModelForm):
created = forms.DateTimeField(widget=DateTimePicker(options={
'defaultDate': (datetime.now()).strftime("%m/%d/%Y, %H:%M:%S"),
'minDate':
'2010-01-01',
'useCurrent':
True,
'collapse':
True,
},
attrs={
'append':
'fa fa-calendar',
'input_toggle':
False,
'icon_toggle':
True,
}), )
loan = forms.ModelChoiceField(
queryset=Loan.unreleased.all(),
widget=ModelSelect2Widget(
model=Loan,
queryset=Loan.unreleased.all(),
search_fields=['loanid_icontains'],
# dependent_fields={'customer':'customer'}
))
class Meta:
model = Adjustment
fields = ['loan', 'amount_received', 'as_interest']
class OrdersForm(ModelForm):
date = DateTimeField(
widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}
),
)
def __init__(self, *args, **kwargs):
super(OrdersForm, self).__init__(*args, **kwargs)
self.fields['price'].required = True
self.fields['commission'].required = True
class Meta:
model = Orders
fields = ['stock', 'portfolio', 'size', 'price', 'commission', 'date']
def save(self, commit=True):
my_order = super(OrdersForm, self).save(commit=False)
data = self.cleaned_data
my_order.status = 'completed'
my_order.order_type = 'market'
my_order.order_uuid = uuid.uuid4()
my_order.price_complete = float(data['price']) * float(data['size'])
my_order.is_sell = False
if commit:
my_order.save()
return my_order
class ServiceBookingForm(forms.ModelForm):
disable_dates = []
mindate = "{}".format(timezone.now().date())
selected_date = forms.DateTimeField(widget=DateTimePicker(
options={
'minDate': mindate,
'maxDate': '2029-01-20',
'format': 'L',
'disabledDates': disable_dates,
'daysOfWeekDisabled': [0]
}), )
service_type = forms.CharField(widget=forms.Select(choices=SERVICE_TYPES))
vehicle_type = forms.CharField(widget=forms.Select(choices=VEHICLE_TYPE))
vehicle_make = forms.CharField(widget=forms.Select(choices=VEHICLE_MAKE))
class Meta:
model = BookService
widgets = {
'selected_date':
forms.DateInput(
attrs={
'min': timezone.now().date(),
'type': 'date',
'id': 'datepicker01',
'class': 'form-control md-form datepicker'
}),
}
fields = [
'service_type', 'customer_name', 'contact_details', 'vehicle_type',
'vehicle_make', 'vehicle_licence', 'vehicle_engine_type',
'customer_comments', 'selected_date'
]
class eventCreateForm(forms.Form):
name = forms.CharField(label="名称")
time = forms.DateTimeField(
label="时间",
widget=DateTimePicker(options={"format": "YYYY-MM-DD HH:mm"}))
type = forms.CharField(label="类型")
description = forms.CharField(label="", widget=CKEditorUploadingWidget())
def __init__(self, *args, **kwargs):
super(SquestModelForm, self).__init__(*args, **kwargs)
for field_name, current_field in self.fields.items():
if isinstance(current_field.widget, Select):
current_field.widget.attrs[
'class'] = 'form-control selectpicker'
current_field.widget.attrs['data-live-search'] = "true"
elif isinstance(current_field.widget, CheckboxInput):
current_field.widget.attrs['class'] = ''
elif isinstance(current_field.widget, CheckboxSelectMultiple):
current_field.widget.attrs[
'class'] = 'form-control form-control-checkbox disable_list_style'
elif isinstance(current_field.widget, RadioSelect):
current_field.widget.attrs['class'] = "disable_list_style"
elif isinstance(current_field.widget, FileInput):
current_field.widget.attrs['class'] = ""
elif isinstance(current_field.widget, DateTimeInput):
current_field.widget = DateTimePicker(options={
'timeZone':
str(timezone.get_current_timezone()),
'collapse':
False,
},
attrs={
'append':
'fa fa-calendar',
'icon_toggle': True,
})
else:
current_field.widget.attrs['class'] = 'form-control'
def get_form_class(self):
self.get_fields()
form_class = super().get_form_class()
for field_name, field in form_class.base_fields.items():
if isinstance(field.widget, DateTimeInput):
options = dict(format='DD/MM/YYYY', locale='fr')
min_date = timezone.now().strftime('%Y-%m-%d')
options['minDate'] = min_date
field.help_text = "La date de minimum de publication est le %s." % timezone.now(
).strftime('%d/%m/%Y')
if field_name == 'event_start':
min_date = self.object.minimum_event_start_date.strftime(
'%Y-%m-%d')
options['minDate'] = min_date
min_delay_before_event = self.object.get_min_delay_before_event_start(
)
field.help_text = self.object.VALIDATION_MESSAGES[
'pub_gte_start'] % min_delay_before_event
field.widget = DateTimePicker(options=options,
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
})
else:
field.widget.attrs['class'] = 'form-control'
return form_class
def __init__(self, *args, **kwargs):
current_status = kwargs.pop('current_status', 0)
super(PuzzleInfoForm, self).__init__(*args, **kwargs)
self.fields[
'publish_date'].input_formats = settings.DATETIME_INPUT_FORMATS
self.fields['publish_date'].widget = DateTimePicker(
options={
'format': 'DD-MM-YYYY HH:mm',
'pickSeconds': False,
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
})
if current_status != 2:
to_hide = [
'publish_date', 'reference', 'reference_url', 'pdb_id',
'pdb_url', 'img'
]
for item in to_hide:
self.fields[item].widget = forms.HiddenInput()
if current_status != 0:
readonly = ['description', 'sequence']
for item in readonly:
self.fields[item].widget.attrs['readonly'] = True
self.fields['pdb_file'].disabled = True
class PostForm(forms.ModelForm):
title = forms.CharField(max_length=255)
content = forms.CharField(required=False, widget=CKEditorUploadingWidget())
description = forms.CharField(max_length=300, required=False)
published = forms.BooleanField(required=False)
attachment = forms.ImageField(required=True)
delay = forms.BooleanField(required=False)
delay_time = forms.DateTimeField(
required=False,
widget=DateTimePicker(attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
},
options={
'locale': 'uk',
'icons': {
'time': 'fa fa-clock',
'date': 'fa fa-calendar',
'up': 'fa fa-arrow-up',
'down': 'fa fa-arrow-down',
'previous': 'fa fa-chevron-left',
'next': 'fa fa-chevron-right',
'today': 'fa fa-calendar-check-o',
'clear': 'fa fa-trash',
'close': 'fa fa-times'
}
}),
input_formats=['%d.%m.%Y %H:%M:%S'],
validators=[check_date])
class Meta:
model = Post
fields = ('title', 'content', 'published', 'attachment', 'delay',
'delay_time', 'description')
class ReservationForm(ModelForm):
reserve_date = forms.DateTimeField(widget=DateTimePicker(
options={
'useCurrent': True,
'collapse': True,
'minDate': '2020-07-13 00:00:00',
'maxDate': '2024-01-20 23:59:00',
# Calendar and time widget formatting
'time': 'fa fa-clock-o',
'date': 'fa fa-calendar',
'up': 'fa fa-arrow-up',
'down': 'fa fa-arrow-down',
'previous': 'fa fa-chevron-left',
'next': 'fa fa-chevron-right',
'today': 'fa fa-calendar-check-o',
'clear': 'fa fa-delete',
'close': 'fa fa-times'
},
attrs={
'append': 'fa fa-calendar',
'icon_toggle': True,
}))
def __init__(self, *args, **kwargs):
super(ReservationForm, self).__init__(*args, **kwargs)
self.fields['product'].queryset = self.fields['product'].queryset.filter(tags__name="Reservation")
class Meta:
model = Order
fields = '__all__'
widgets = {'customer' : forms.HiddenInput(),
'status' : forms.HiddenInput()}
class MammographyWeeklyQAForm(forms.Form):
modality = forms.ModelChoiceField(
queryset=Modality.objects.all().filter(in_use__exact=True),
label='Modalitet')
measurement_date = forms.DateTimeField(
label='Mätdatum',
input_formats=('%Y-%m-%d %H:%M:%S', ),
widget=DateTimePicker(
options={
'minDate': (date.today() -
relativedelta(years=1)).strftime('%Y-%m-%d'),
'useCurrent':
True,
'collapse':
False,
}))
mas = forms.FloatField(
label='mAs',
min_value=0,
widget=forms.NumberInput(attrs={'class': 'validate-field'}))
entrance_dose = forms.FloatField(
label='Ingångsdos',
min_value=0,
widget=forms.NumberInput(attrs={'class': 'validate-field'}))
comment = forms.CharField(
required=False,
max_length=4000,
label='Kommentar',
widget=forms.TextInput(attrs={'class': 'full-width-form-field'}))
signature = forms.CharField(max_length=200, label='Signatur')
class FullBodyMeasurementForm(forms.Form):
personnel = forms.ModelChoiceField(queryset=Personnel.objects.filter(person_id__isnull=False).all(), label='Personal', required=True)
measurement_date = forms.DateTimeField(
label='Mätdatum', input_formats=('%Y-%m-%d %H:%M:%S',),
widget=DateTimePicker(
options={'useCurrent': True, 'collapse': False},
), initial=timezone.now(), required=True)
result = forms.ChoiceField(choices=FULL_BODY_ASSESSMENT, label='Resultat', required=True)
comment = forms.CharField(max_length=4000, label='Kommentar', required=False)