def _hasher(self, instance):
date_field = DateField(input_formats=["%d-%m-%Y"], required=False)
return (
instance["id"],
PriceField().clean(instance["initialContractualPrice"]),
date_field.clean(instance["signingDate"]),
)
def __init__(self, **kwargs):
wid = SelectDateWidget(years = [i for i in reversed(xrange(1900,2010))])
fieldAttr = {'required' : False,
'localize': True
}
fieldAttr.update(kwargs)
DateField.__init__(self, widget= wid, **fieldAttr)
def _hasher(self, instance):
date_field = DateField(input_formats=["%d-%m-%Y"])
return (
instance["id"],
PriceField().clean(instance["basePrice"]),
date_field.clean(instance["drPublicationDate"]),
)
def test_datefield_strptime(self):
"""field.strptime() doesn't raise a UnicodeEncodeError (#16123)"""
f = DateField()
try:
f.strptime('31 мая 2011', '%d-%b-%y')
except Exception as e:
# assertIsInstance or assertRaises cannot be used because UnicodeEncodeError
# is a subclass of ValueError
self.assertEqual(e.__class__, ValueError)
def _hasher(self, instance):
date_field = DateField(input_formats=["%d-%m-%Y"])
# e.g. tender 81558 has no price set
price = None
if instance['basePrice'] is not None:
price = PriceField(required=False).clean(instance['basePrice'])
return instance['id'], price, \
date_field.clean(instance['drPublicationDate'])
def test_datefield_3(self):
f = DateField(input_formats=['%Y %m %d'])
self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
self.assertEqual(date(2006, 10, 25), f.clean('2006 10 25'))
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('2006-10-25')
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('10/25/2006')
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('10/25/06')
def customize_date_fields(f):
if isinstance(f, django.db.models.fields.DateField):
date_field=DateField(widget=forms.DateInput(format='%d.%m.%Y', attrs={"class":"dateField"}), label=f.verbose_name)
date_field.input_formats = ("%d.%m.%Y",)# + (date_field.input_formats)
return date_field
elif isinstance(f, django.db.models.fields.related.ForeignKey):
ffield = f.formfield()
ffield.choices=getHierarchicalPresentation(f.rel.to)
print ffield.choices
return ffield
else:
return f.formfield()
def plot_image(request, gage, param, extension):
df = DateField(required=False)
date_input = None
try:
date_input = request.REQUEST.get("timeseries_start", None)
beginDate = df.clean(date_input)
date_input = request.REQUEST.get("timeseries_end", None)
endDate = df.clean(date_input)
except ValidationError:
return HttpResponseBadRequest("Bad date input: " + date_input)
return _plot_simple(
gage, param, beginDate=beginDate, endDate=endDate, format=extension, show_logo=decide_logo(request)
)
def test_datefield_4(self):
# Test whitespace stripping behavior (#5714)
f = DateField()
self.assertEqual(date(2006, 10, 25), f.clean(' 10/25/2006 '))
self.assertEqual(date(2006, 10, 25), f.clean(' 10/25/06 '))
self.assertEqual(date(2006, 10, 25), f.clean(' Oct 25 2006 '))
self.assertEqual(date(2006, 10, 25), f.clean(' October 25 2006 '))
self.assertEqual(date(2006, 10, 25), f.clean(' October 25, 2006 '))
self.assertEqual(date(2006, 10, 25), f.clean(' 25 October 2006 '))
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean(' ')
class DateInputField(BaseResponseForm):
answer = DateField(widget=SelectDateWidget(attrs={'class': 'text'},
years=range(1900, 2099)))
def test_datefield_changed(self):
format = '%d/%m/%Y'
f = DateField(input_formats=[format])
d = date(2007, 9, 17)
self.assertFalse(f.has_changed(d, '17/09/2007'))
class GSCFormSubmitterInfo(Form):
"""
Delivery information section of GSC submission form.
"""
#choices
at_completion_choices = (
('R', 'Return unused sample'),
('D', 'Destroy unused sample')
)
# fields
submitter_name = CharField(
label="Name of Submitter",
max_length=100,
)
submitter_email = EmailField(
label="Submitter's email",
)
submission_date = DateField(
label="Submission Date",
help_text = 'yyyy-mm-dd',
# widget=SelectDateWidget
)
submitting_org = CharField(
label="Submitting Organization",
max_length=100,
initial="BCCRC/ UBC"
)
pi_name = CharField(
label="Name of Principal Investigator",
max_length=100,
initial="Sam Aparicio/ Carl Hansen"
)
pi_email = EmailField(
label="Principal Investigator's email",
initial="*****@*****.**"
)
project_name = CharField(
label="Project Name",
max_length=100,
initial="Single cell indexing"
)
sow = CharField(
label="Statement of Work (SOW) #",
max_length=100,
initial="GSC-0297"
)
nextera_compatible = BooleanField(
label="Nextera compatible",
required=False,
initial=True,
)
truseq_compatible = BooleanField(
label="TruSeq compatible",
required=False,
)
custom = BooleanField(
label="Custom",
required=False,
)
is_this_pbal_library = BooleanField(
label="Is this PBAL library",
required=False,
)
at_completion = ChoiceField(
label="At completion of project",
choices=at_completion_choices,
initial='R'
)
class InvoiceForm(ModelForm):
due_date = DateField(input_formats=settings.DATE_INPUT_FORMATS)
invoice_date = DateField(input_formats=settings.DATE_INPUT_FORMATS)
start_time = TimeField(input_formats=settings.TIME_INPUT_FORMATS, required=False)
end_time = TimeField(input_formats=settings.TIME_INPUT_FORMATS, required=False)
#invoice_type = ChoiceField(choices=INVOICE_TYPE, required=False)
class Meta:
model = Invoice
fields = ('invoice_number','hours','start_time','end_time','invoice_type','due_date','client','order_number','invoice_date','rate','amount','paid','remarks')
def __init__(self,*args, **kwargs):
#import pdb; pdb.set_trace()
self.user = kwargs.pop('user', None)
self.inv = kwargs.pop('invoice_type', None) #kay di mag work anf cleaned_data.get('invoice_type') sa clean_hours
#self.start = kwargs.pop('start_time', None)
#self.end = kwargs.pop('end_time', None)
return super(InvoiceForm, self).__init__(*args, **kwargs)
def clean_amount(self):
invoice_type = self.cleaned_data.get('invoice_type')
amount = self.cleaned_data.get('amount')
if invoice_type == 'fixed':
if not amount:
raise ValidationError("you pick fixed - amount should have a value")
return amount
def clean_start_time(self):
start_time = self.cleaned_data.get('start_time')
return start_time
def clean_end_time(self):
end_time = self.cleaned_data.get('end_time')
return end_time
def clean_rate(self):
hours = self.cleaned_data.get('hours')
rate = self.cleaned_data.get('rate')
if rate:
if not hours:
raise ValidationError("rate has value but doest have an hour/s")
if not rate and hours:
raise ValidationError("hours has value and rate must have value too")
return rate
def clean_order_number(self):
or_no = self.cleaned_data.get('order_number')
if or_no:
text_or_no = Invoice.objects.filter(order_number__exact=or_no)
if text_or_no:
raise ValidationError("Order Number already exists:")
return or_no
def clean_invoice_number(self):
inv_no = self.cleaned_data.get('invoice_number')
if inv_no:
test_inv_no = Invoice.objects.filter(invoice_number__exact=inv_no)
if test_inv_no:
raise ValidationError("Invoice Number already exists:")
return inv_no
def clean_invoice_date(self):
in_date = self.cleaned_data.get('invoice_date')
if in_date:
in_date = datetime.datetime.strftime( in_date, '%Y-%m-%d')
current = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d')
if current > in_date:
raise ValidationError("Datetime should be in future")
return in_date
def clean_due_date(self):
due_date = self.cleaned_data.get('due_date')
if due_date:
due_date = datetime.datetime.strftime( due_date, '%Y-%m-%d')
current = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d')
if current > due_date:
raise ValidationError("Datetime should be in future")
return due_date
def clean_hours(self):
#import pdb; pdb.set_trace()
invoice_type = self.inv
hours = self.cleaned_data.get('hours')
start_time = self.cleaned_data.get('start_time')
end_time = self.cleaned_data.get('end_time')
if invoice_type == 'fixed':
start_time = self.cleaned_data.get('start_time')
end_time = self.cleaned_data.get('end_time')
if invoice_type == 'hourly':
start_time = self.data['start_time']
end_time = self.data['end_time']
rate = self.cleaned_data.get('rate')
if invoice_type == 'hourly':
if hours:
if start_time == '' or end_time == '':
pass
else:
start_time = parse(start_time).time()
end_time = parse(end_time).time()
if start_time and end_time:
time_interval = datetime.datetime.combine(date.today(),end_time) - datetime.datetime.combine(date.today(),start_time)
time_interval = int(time_interval.seconds/3600)
if str(time_interval) != str(hours):
raise ValidationError("hours should equal to the time interval between start_time and end_time")
if not hours:
raise ValidationError("you pick hourly - hours must have a value")
return hours
def save(self, commit=True):
instance = super(InvoiceForm, self).save(commit=False)
#import pdb; pdb.set_trace()
invoice_type = self.cleaned_data.get('invoice_type')
amount = self.cleaned_data.get('amount')
hours = self.cleaned_data.get('hours')
start_time = self.cleaned_data.get('start_time')
end_time = self.cleaned_data.get('end_time')
rate = self.cleaned_data.get('rate')
if invoice_type == 'fixed':
instance.amount = amount
instance.hours = None
instance.start_time = None
instance.end_time = None
instance.rate = None
instance.total_amount = amount- instance.paid
elif invoice_type == 'hourly' :
instance.amount = None
instance.hours = hours
instance.rate = rate
instance.start_time = start_time
instance.end_time = end_time
instance.total_amount = (hours*rate)
instance.owner = self.user
if commit:
instance.save()
return instance
class ArticleForm(Form):
title = CharField()
pub_date = DateField()
class DocumentParseSearchForm(Form):
order_number_gte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'order_number',
'filter_method': '__gte',
}))
order_number_lte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'order_number',
'filter_method': '__lte',
}))
first_order_number_gte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'first_order_number',
'filter_method': '__gte',
}))
first_order_number_lte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'first_order_number',
'filter_method': '__lte',
}))
order_register_number_gte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'order_register_number',
'filter_method': '__gte',
}))
order_register_number_lte = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'order_register_number',
'filter_method': '__lte',
}))
applicant = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'applicant',
'filter_method': '__icontains',
}))
address = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'address',
'filter_method': '__icontains',
}))
copyright_holder = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'copyright_holder',
'filter_method': '__icontains',
}))
patent_atty = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'patent_atty',
'filter_method': '__icontains',
}))
date_refreshed_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_refreshed',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_refreshed_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_refreshed',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_created_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_created',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_created_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_created',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_publish_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_publish',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_publish_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_publish',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_exclusive_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_exclusive',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_exclusive_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_exclusive',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_gos_reg_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_gos_reg',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_gos_reg_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_gos_reg',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_changes_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_changes',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_changes_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_changes',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
def __init__(self, *args, **kwargs):
super(DocumentParseSearchForm, self).__init__(*args, **kwargs)
for key in self.fields:
self.fields[key].label = fields_dict[key]
class GetNotRequiredDate(Form):
mydate = DateField(widget=SelectDateWidget, required=False)
class GetRequiredDate(Form):
mydate = DateField(widget=SelectDateWidget, required=True)
class LogSearchForm(Form):
class FormNotValid(StandardError):
pass
import logging
#matrix parameters for call
type = MultipleChoiceField(choices=(
('all', 'All'),
('DELETE_LIBRARY', 'DELETE_LIBRARY'),
('UPDATE_LIBRARY_ITEM_METADATA', 'UPDATE_LIBRARY_ITEM_METADATA'),
('NONE', 'NONE'),
('IMPORT', 'IMPORT'),
('TRANSCODE', 'TRANSCODE'),
('RAW_TRANSCODE', 'RAW_TRANSCODE'),
('CONFORM', 'CONFORM'),
('TRANSCODE_RANGE', 'TRANSCODE_RANGE'),
('PLACEHOLDER_IMPORT', 'PLACEHOLDER_IMPORT'),
('RAW_IMPORT', 'RAW_IMPORT'),
('THUMBNAIL', 'THUMBNAIL'),
('AUTO_IMPORT', 'AUTO_IMPORT'),
('EXPORT', 'EXPORT'),
('COPY_FILE', 'COPY_FILE'),
('DELETE_FILE', 'DELETE_FILE'),
('MOVE_FILE', 'MOVE_FILE'),
('ESSENCE_VERSION', 'ESSENCE_VERSION'),
('FCS_RESTORE', 'FCS_RESTORE'),
('TIMELINE', 'TIMELINE'),
('SHAPE_IMPORT', 'SHAPE_IMPORT'),
('LIST_ITEMS', 'LIST_ITEMS'),
('ANALYZE', 'ANALYZE'),
('SHAPE_UPDATE', 'SHAPE_UPDATE'),
('ARCHIVE', 'ARCHIVE'),
('RESTORE', 'RESTORE'),
('SIDECAR_IMPORT', 'SIDECAR_IMPORT'),
('TEST_TRANSFER', 'TEST_TRANSFER'),
),
widget=CheckboxSelectMultiple())
state = MultipleChoiceField(
choices=(
('all', 'All'),
('NONE', 'None'),
('READY', 'Ready'),
('STARTED', 'Started'),
('STARTED_ASYNCHRONOUS', 'Started Asynchronous'),
('STARTED_PARALLEL', 'Started in background'),
('STARTED_PARALLEL_ASYNCHRONOUS',
'Started in background, asynchronous'),
('STARTED_SUBTASKS', 'Started and doing in multiple subtasks'),
('FINISHED', 'Completed'),
('FAILED_RETRY', 'Retrying'),
('FAILED_FATAL', 'Failed'),
('FAILED_TOTAL', 'Failed'),
('WAITING', 'Waiting'), #see /job/{job-id}/problem
('DISAPPEARED', 'Disappeared, lost worker')),
widget=CheckboxSelectMultiple())
sort = ChoiceField(choices=(
('startTime', 'Start Time'),
('priority', 'Priority'),
('jobId', 'Job ID'),
('type', 'Type'),
('state', 'State'),
('user', 'User'),
),
widget=Select(attrs={'style': 'width: 98%'}))
sortOrder = ChoiceField(
choices=(
('desc', 'Descending'),
('asc', 'Ascending'),
),
widget=RadioSelect(),
)
fromDate = DateField(label="Starting from",
widget=TextInput(attrs={'style': 'width: 60%'}))
fromTime = TimeField(label="Starting from",
widget=TextInput(attrs={'style': 'width: 60%'}))
toDate = DateField(label="Ending at",
widget=TextInput(attrs={'style': 'width: 60%'}))
toTime = TimeField(label="Ending at",
widget=TextInput(attrs={'style': 'width: 60%'}))
#Query parameters for call
jobmetadata = CharField(max_length=32768, widget=Textarea, required=False)
#my own params which will be put into the above
fileNameContains = CharField(
max_length=512,
widget=TextInput(attrs={'style': 'width: 98%; visibility: hidden'}),
required=False)
columns = MultipleChoiceField(choices=(
('jobId', 'jobId'),
('status', 'status'),
('type', 'type'),
('started', 'started'),
('priority', 'priority'),
('itemid', 'itemid'),
('systemJobModule', 'systemJobModule'),
('systemJobInfo', 'systemJobInfo'),
('destinationStorageId', 'destinationStorageId'),
('bestEffortFilename', 'bestEffortFilename'),
('fileId', 'fileId'),
('replicatedFileIds', 'replicatedFileIds'),
('fileDeleted', 'fileDeleted'),
('fileStateOnFailure', 'fileStateOnFailure'),
('filePathMap', 'filePathMap'),
('replicatedFileInfo', 'replicatedFileInfo'),
('checkReplicatedFiles', 'checkReplicatedFiles'),
),
widget=CheckboxSelectMultiple())
def vidispine_query_url(self, base, page):
from datetime import datetime
import time
import calendar
if not self.is_valid():
raise self.FormNotValid()
#logger=self.logging.getLogger("LogSearchForm::vidispine_query_url")
d = self.cleaned_data
if page == 1:
pagesetting = 0
else:
pagesetting = page * 100 - 100
pagesettingready = str(pagesetting)
matrixparams = ""
if not 'all' in d['state']:
matrixparams += ";state=" + ",".join(
map(lambda x: urllib.quote_plus(x, safe=""), d['state']))
if not 'all' in d['type']:
matrixparams += ";type=" + ",".join(
map(lambda x: urllib.quote_plus(x, safe=""), d['type']))
matrixparams += ";number=100;first=" + pagesettingready + ";sort={0}%20{1}".format(
urllib.quote_plus(d['sort'], safe=""), d['sortOrder'])
queryparams = "?metadata=true"
if d['fileNameContains']:
queryparams += "&jobmetadata=" + urllib.quote_plus(
"bestEffortFilename=*{0}*".format(d['fileNameContains']),
safe="")
if d['jobmetadata']:
queryparams += "&jobmetadata=" + urllib.quote_plus(
d['jobmetadata'], safe="")
fromTime = datetime.combine(d['fromDate'], d['fromTime'])
toTime = datetime.combine(d['toDate'], d['toTime'])
queryparams += "&starttime-from=" + urllib.quote_plus(
fromTime.strftime("%Y-%m-%dT%H:%M:%S.%f"), safe="")
queryparams += "&starttime-to=" + urllib.quote_plus(
toTime.strftime("%Y-%m-%dT%H:%M:%S.%f"), safe="")
print "debug: vidispine_query_url is {0}".format(base + matrixparams +
queryparams)
return base + matrixparams + queryparams
def __init__(self, *args, **kwargs):
super(InvoiceForm, self).__init__(*args, **kwargs)
self.empty_permitted = False
self.fields['date_due'] = DateField(widget=SelectDateWidget(
empty_label=None,
months=self.Meta.model.MONTHS,
attrs={'class': 'form-control invoice_date_widget'}))
self.fields['related_ticket_references'] = CharField(max_length=255)
self.fields['invoice_items'] = ModelMultipleChoiceField(
queryset=InvoiceItem.objects.all())
self.fields['issued_by'] = ModelChoiceField(
queryset=Account.objects.all())
self.fields['paid_amount'] = DecimalField(max_digits=9,
decimal_places=2)
# # SET WIDGET ATTRIBUTES
self.fields['related_ticket_references'].widget = TextInput(
attrs={'class': 'form-control'})
self.fields['related_ticket_references'].help_text = _(
'Ticket number(s) related to this invoice')
self.fields['invoice_comments'].widget = Textarea(
attrs={'class': 'form-control'})
self.fields['invoice_comments'].help_text = _(
'Any additional comments about this invoice')
self.fields['invoice_items'].widget = SelectMultiple(
attrs={'class': 'form-control'})
self.fields['invoice_items'].help_text = _(
'Select items, then quantities below')
self.fields['paid_amount'].widget = self.MyNumberInput(
attrs={
'class': 'form-control',
'min': '0.00',
'step': '0.01',
'disabled': True
})
self.fields['paid_amount'].help_text = _(
'Enter partial payment amount')
self.fields['issued_by'].widget = Select(
attrs={'class': 'form-control'})
self.fields['issued_by'].help_text = _(
'Select a business to issue from')
self.fields['discount_rate'].widget = Select(
attrs={'class': 'form-control'},
choices=self.Meta.model.DISCOUNT_RATE)
self.fields['tax'].widget = Select(attrs={'class': 'form-control'},
choices=self.Meta.model.TAX)
self.fields['invoice_status'].widget = Select(
attrs={'class': 'form-control'},
choices=self.Meta.model.INVOICE_STATUS)
self.fields['invoice_number'] = CharField(widget=HiddenInput(
)) # to pass ID to view when updating existing inst.
self.fields['invoice_emailed'].widget = CheckboxInput(
attrs={'class': 'form-control'})
self.fields['receipt_emailed'].widget = CheckboxInput(
attrs={'class': 'form-control'})
self.fields['recurring'] = ChoiceField(choices=Invoice.RECURRING)
self.fields['recurring'].widget = Select(
attrs={'class': 'form-control'}, choices=Invoice.RECURRING)
self.fields['recurring'].help_text = _(
'Is this to be a recurring invoice?')
# # extra form fields (not included model)
self.fields['form_hidden_field_post_action'] = CharField(
widget=HiddenInput()) # for view's routing of POST request
self.fields['client'] = CharField(
widget=HiddenInput()) # to pass client if a new invoice
# set required to False for all fields, to avoid validation issues when updating.
for k, v in self.fields.items():
self.fields[k].required = False
class RemindForm(forms.Form):
to_pay = CharField(max_length=100, help_text="Enter reminding information")
amount = DecimalField(max_digits=8, decimal_places=4)
date = DateField()
class SettingsForm(ModelForm):
start_date = DateField(widget=DateInput(format='%d.%m.%Y'), input_formats=('%d.%m.%Y',))
class Meta:
model = SettingsModel
#fields = ('work_time_mon', 'work_time_tur', 'work_time_wed', 'work_time_thu', 'work_time_fri', 'work_time_sat', 'work_time_sun', 'start_date',)
exclude = ('created_at', 'user_id',)
class MovieForm(Form): title = CharField(max_length=128) genre = ModelChoiceField(queryset=Genre.objects) rating = IntegerField(min_value=1, max_value=10) released = DateField() description = CharField(widget=Textarea, required=False)
class QueryBuilderForm(forms.Form):
"""
Form to build an SQL query using a web interface.
Works hand in hand with ``querybuilder.js`` on the client side; q.v.
"""
database = CharField(label="Schema", required=False)
schema = CharField(label="Schema", required=True)
table = CharField(label="Table", required=True)
column = CharField(label="Column", required=True)
datatype = CharField(label="Data type", required=True)
offer_where = BooleanField(label="Offer WHERE?", required=False)
# BooleanField generally needs "required=False", or you can't have False!
where_op = CharField(label="WHERE comparison", required=False)
date_value = DateField(label="Date value (e.g. 1900-01-31)",
required=False)
int_value = IntegerField(label="Integer value", required=False)
float_value = FloatField(label="Float value", required=False)
string_value = CharField(label="String value", required=False)
file = FileField(label="File (for IN)", required=False)
def __init__(self, *args, **kwargs) -> None:
self.file_values_list = [] # type: List[Any]
super().__init__(*args, **kwargs)
def get_datatype(self) -> Optional[str]:
return self.data.get('datatype', None)
def is_datatype_unknown(self) -> bool:
return self.get_datatype() == QB_DATATYPE_UNKNOWN
def offering_where(self) -> bool:
if self.is_datatype_unknown():
return False
return self.data.get('offer_where', False)
def get_value_fieldname(self) -> str:
datatype = self.get_datatype()
if datatype == QB_DATATYPE_INTEGER:
return "int_value"
if datatype == QB_DATATYPE_FLOAT:
return "float_value"
if datatype == QB_DATATYPE_DATE:
return "date_value"
if datatype in QB_STRING_TYPES:
return "string_value"
if datatype == QB_DATATYPE_UNKNOWN:
return ""
raise ValueError("Invalid field type")
def get_cleaned_where_value(self) -> Any:
# Only call this if you've already cleaned/validated the form!
return self.cleaned_data[self.get_value_fieldname()]
def clean(self) -> None:
# Check the WHERE information is sufficient.
if 'submit_select' in self.data or 'submit_select_star' in self.data:
# Form submitted via the "Add" method, so no checks required.
# http://stackoverflow.com/questions/866272/how-can-i-build-multiple-submit-buttons-django-form # noqa
return
if not self.offering_where():
return
cleaned_data = super().clean()
if not cleaned_data['where_op']:
self.add_error('where_op',
forms.ValidationError("Must specify comparison"))
# No need for a value for NULL-related comparisons. But otherwise:
where_op = cleaned_data['where_op']
if where_op not in SQL_OPS_VALUE_UNNECESSARY + SQL_OPS_MULTIPLE_VALUES:
# Can't take 0 or many parameters, so need the standard single
# value:
value_fieldname = self.get_value_fieldname()
value = cleaned_data.get(value_fieldname)
if not value:
self.add_error(
value_fieldname,
forms.ValidationError("Must specify WHERE condition"))
# ---------------------------------------------------------------------
# Special processing for file upload operations
# ---------------------------------------------------------------------
if where_op not in SQL_OPS_MULTIPLE_VALUES:
return
fileobj = cleaned_data['file']
# ... is an instance of InMemoryUploadedFile
if not fileobj:
self.add_error('file', forms.ValidationError("Must specify file"))
return
datatype = self.get_datatype()
if datatype in QB_STRING_TYPES:
form_to_python_fn = str
elif datatype == QB_DATATYPE_DATE:
form_to_python_fn = html_form_date_to_python
elif datatype == QB_DATATYPE_INTEGER:
form_to_python_fn = int_validator
elif datatype == QB_DATATYPE_FLOAT:
form_to_python_fn = float_validator
else:
# Safe defaults
form_to_python_fn = str
# Or: http://www.dabeaz.com/generators/Generators.pdf
self.file_values_list = [] # type: List[Any]
for line in fileobj.read().decode("utf8").splitlines():
raw_item = line.strip()
if not raw_item or raw_item.startswith('#'):
continue
try:
value = form_to_python_fn(raw_item)
except (TypeError, ValueError):
self.add_error('file', forms.ValidationError(
f"File contains bad value: {raw_item!r}"))
return
self.file_values_list.append(value)
if not self.file_values_list:
self.add_error('file', forms.ValidationError(
"No values found in file"))
class form_add_task(ModelForm):
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user', None)
super(form_add_task, self).__init__(*args, **kwargs)
instance = getattr(self, 'instance', None)
if instance and instance.id:
if self.user != instance.author:
self.fields['title'].required = False
self.fields['title'].widget.attrs['disabled'] = 'disabled'
self.fields['description'].required = False
self.fields['description'].widget.attrs[
'disabled'] = 'disabled'
self.fields['executors'].required = False
self.fields['executors'].widget.attrs['disabled'] = 'disabled'
self.fields['Date_limit'].required = False
self.fields['Date_limit'].widget.attrs['disabled'] = 'disabled'
self.fields['Time_limit'].required = False
self.fields['Time_limit'].widget.attrs['disabled'] = 'disabled'
self.fields['high_importance'].required = False
self.fields['high_importance'].widget.attrs[
'disabled'] = 'disabled'
self.fields['confirmation'].required = False
self.fields['confirmation'].widget.attrs[
'disabled'] = 'disabled'
self.fields['status'].queryset = status_task.objects.exclude(
slug__in=['open', 'confirmation', 'control', 'canceled'])
else:
if instance.status.slug == 'open' or instance.status.slug == 'work':
self.fields['status'].required = False
self.fields[
'status'].queryset = status_task.objects.filter(
slug__in=['canceled'])
elif instance.status.slug == 'control':
self.fields[
'status'].queryset = status_task.objects.filter(
slug__in=['confirmation', 'canceled'])
else:
self.fields['status'].required = False
self.fields['status'].widget.attrs['disabled'] = 'disabled'
else:
self.fields['status'].initial = status_task.objects.get(
slug='open')
self.fields['status'].required = False
self.fields['status'].widget.attrs['disabled'] = 'disabled'
self.fields['work_desc'].required = False
self.fields['work_desc'].widget.attrs['disabled'] = 'disabled'
profile = Profile.objects.get(user=self.user)
self.fields['executors'].queryset = GroupProfile.objects.filter(
factory__in=profile.factory.all())
self.fields['read'].required = False
self.fields['read'].widget.attrs['disabled'] = 'disabled'
Date_limit = DateField(input_formats=('%Y-%m-%d', ),
initial=datetime.today(),
widget=DateInput(format='%Y-%m-%d',
attrs={'type': 'date'}))
Time_limit = TimeField(input_formats=('%H:%M', ),
initial=datetime.now(),
widget=TimeInput(format='%H:%M',
attrs={'type': 'time'}))
description = CharField(required=False,
label='Описание задачи',
widget=forms.widgets.Textarea(attrs={'rows': 3}))
work_desc = CharField(required=False,
label='Описание выполнения',
widget=forms.widgets.Textarea(attrs={'rows': 3}))
class Meta:
model = user_task
fields = [
'title', 'description', 'executors', 'Date_limit', 'Time_limit',
'high_importance', 'status', 'work_desc', 'read', 'confirmation'
]
class RemindForm(forms.Form):
# self = forms.Form
to_pay=CharField(max_length=100,help_text="Enter reminding information")
amount=CharField(max_length=8)
date=DateField()
class HelperDateForm(Form):
'''
A helper form used in the workout log view
'''
date = DateField(input_formats=DATE_FORMATS, widget=Html5DateInput())
class DocumentSearchForm(Form):
# number = IntegerField(required=False)
document_exists = BooleanField(required=False)
document_parsed = BooleanField(required=False)
date_parsed_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_parsed',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_parsed_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'date_parsed',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
order_number_gte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__order_number',
'filter_method': '__gte',
}))
order_number_lte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__order_number',
'filter_method': '__lte',
# 'filter_method': '__icontains',
}))
first_order_number_gte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__first_order_number',
'filter_method': '__gte',
}))
first_order_number_lte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__first_order_number',
'filter_method': '__lte',
}))
order_register_number_gte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__order_register_number',
'filter_method': '__gte',
}))
order_register_number_lte = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__order_register_number',
'filter_method': '__lte',
}))
status = CharField(required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__status',
'filter_method': '__icontains',
}))
# applicant = CharField(required=False, widget=TextInput(
# attrs={
# 'filter_field': 'documentparse__applicant',
# 'filter_method': '__icontains',
# }
# ))
address = CharField(required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__address',
'filter_method': '__icontains',
}))
copyright_holder = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__copyright_holder',
'filter_method': '__icontains',
}))
# patent_atty = CharField(required=False, widget=TextInput(
# attrs={
# 'filter_field': 'documentparse__patent_atty',
# 'filter_method': '__icontains',
# }
# ))
date_refreshed_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_refreshed',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_refreshed_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_refreshed',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_created_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_created',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_created_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_created',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
# date_publish_lte = DateField(required=False, widget=TextInput(
# attrs={
# 'filter_field': 'documentparse__date_publish',
# 'filter_method': '__lte',
# 'data-mask': "0000-00-00",
# 'placeholder': 'YYYY-MM-DD'
# }
# ))
# date_publish_gte = DateField(required=False, widget=TextInput(
# attrs={
# 'filter_field': 'documentparse__date_publish',
# 'filter_method': '__gte',
# 'data-mask': "0000-00-00",
# 'placeholder': 'YYYY-MM-DD'
# }
# ))
date_exclusive_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_exclusive',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_exclusive_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_exclusive',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_gos_reg_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_gos_reg',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_gos_reg_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_gos_reg',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_changes_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_changes',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
date_changes_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'documentparse__date_changes',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
service_items_list = CharField(
required=False,
widget=TextInput(
attrs={
# 'filter_field': 'documentparse__serviceitem_set',
'filter_method': '__in',
'placeholder': 'comma separated'
}))
service_items_values = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'serviceitem__text',
'filter_method': '__icontains',
# 'placeholder': 'comma separated'
}))
documentizv_izv_type = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__izv_type',
'filter_method': '__icontains'
}))
documentizv_address = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__address',
'filter_method': '__icontains'
}))
documentizv_last_copyright_holder = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__last_copyright_holder',
'filter_method': '__icontains'
}))
documentizv_last_copyright_holder_name = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__last_copyright_holder_name',
'filter_method': '__icontains'
}))
documentizv_copyright_holder = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__copyright_holder',
'filter_method': '__icontains'
}))
documentizv_transferor = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__transferor',
'filter_method': '__icontains'
}))
documentizv_contract_type = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__contract_type',
'filter_method': '__icontains'
}))
documentizv_contract_terms = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__contract_terms',
'filter_method': '__icontains'
}))
documentizv_grantor = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__grantor',
'filter_method': '__icontains'
}))
documentizv_granted = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__granted',
'filter_method': '__icontains'
}))
documentizv_licensee = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__licensee',
'filter_method': '__icontains'
}))
documentizv_sublicensee = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izv__sublicensee',
'filter_method': '__icontains'
}))
documentizv_date_changes_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_changes',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_date_changes_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_changes',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_date_publish_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_publish',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_date_publish_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_publish',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_date_renewal_lte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_renewal',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_date_renewal_gte = DateField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__date_renewal',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
izvitem_key = CharField(
required=False,
widget=TextInput(attrs={
'filter_field': 'izvitem__key',
'filter_method': '__icontains'
}))
izvitem_date_lte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'izvitem__date',
'filter_method': '__lte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
izvitem_date_gte = DateField(required=False,
widget=TextInput(
attrs={
'filter_field': 'izvitem__date',
'filter_method': '__gte',
'data-mask': "0000-00-00",
'placeholder': 'YYYY-MM-DD'
}))
documentizv_service_items_list = CharField(
required=False,
widget=TextInput(
attrs={
'filter_field': 'izv__service_items',
'filter_method': '__in',
'placeholder': 'comma separated'
}))
def __init__(self, *args, **kwargs):
super(DocumentSearchForm, self).__init__(*args, **kwargs)
for key in self.fields:
self.fields[key].label = fields_dict[key]
class GetTopForm(Form):
start_date = DateField()
end_date = DateField()
class GetDate(Form):
mydate = DateField(widget=SelectDateWidget)
def test_datefield_2(self):
f = DateField(required=False)
self.assertIsNone(f.clean(None))
self.assertEqual('None', repr(f.clean(None)))
self.assertIsNone(f.clean(''))
self.assertEqual('None', repr(f.clean('')))
def test_datefield_1(self):
f = DateField()
self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
self.assertEqual(date(2006, 10, 25),
f.clean(datetime(2006, 10, 25, 14, 30)))
self.assertEqual(date(2006, 10, 25),
f.clean(datetime(2006, 10, 25, 14, 30, 59)))
self.assertEqual(date(2006, 10, 25),
f.clean(datetime(2006, 10, 25, 14, 30, 59, 200)))
self.assertEqual(date(2006, 10, 25), f.clean('2006-10-25'))
self.assertEqual(date(2006, 10, 25), f.clean('10/25/2006'))
self.assertEqual(date(2006, 10, 25), f.clean('10/25/06'))
self.assertEqual(date(2006, 10, 25), f.clean('Oct 25 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('October 25 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('October 25, 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('25 October 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('25 October, 2006'))
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('2006-4-31')
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('200a-10-25')
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('25/10/06')
with self.assertRaisesMessage(ValidationError,
"'This field is required.'"):
f.clean(None)
class dates(forms.Form):
date = DateField(widget=SelectDateWidget(empty_label=("Choose Year",
"Choose Month",
"Choose Day")),
initial=datetime.date.today)
def _hasher(self, instance):
date_field = DateField(input_formats=["%d-%m-%Y"], required=False)
return instance['id'], \
PriceField().clean(instance['initialContractualPrice']), \
date_field.clean(instance['signingDate'])
def test_datefield_2(self):
f = DateField(required=False)
self.assertIsNone(f.clean(None))
self.assertEqual('None', repr(f.clean(None)))
self.assertIsNone(f.clean(''))
self.assertEqual('None', repr(f.clean('')))
def test_datefield_1(self):
f = DateField()
self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59)))
self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59, 200)))
self.assertEqual(date(2006, 10, 25), f.clean('2006-10-25'))
self.assertEqual(date(2006, 10, 25), f.clean('10/25/2006'))
self.assertEqual(date(2006, 10, 25), f.clean('10/25/06'))
self.assertEqual(date(2006, 10, 25), f.clean('Oct 25 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('October 25 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('October 25, 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('25 October 2006'))
self.assertEqual(date(2006, 10, 25), f.clean('25 October, 2006'))
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('2006-4-31')
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('200a-10-25')
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('25/10/06')
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
def test_datefield_3(self):
f = DateField(input_formats=['%Y %m %d'])
self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
self.assertEqual(date(2006, 10, 25),
f.clean(datetime(2006, 10, 25, 14, 30)))
self.assertEqual(date(2006, 10, 25), f.clean('2006 10 25'))
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('2006-10-25')
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('10/25/2006')
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('10/25/06')
class logAcessoApiForm(forms.ModelForm):
acessado_em = DateField(input_formats='%Y-%m-%d')
class Meta:
model = log_Acesso
fields = ('id_paroquia', 'acessado_em',)
class HelperDateForm(Form):
'''
A helper form with only a date input
'''
date = DateField(input_formats=DATE_FORMATS)
def test_datefield_5(self):
# Test null bytes (#18982)
f = DateField()
with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
f.clean('a\x00b')
class GetDateShowHiddenInitial(Form):
mydate = DateField(widget=SelectDateWidget,
show_hidden_initial=True)
def test_datefield_5(self):
# Test null bytes (#18982)
f = DateField()
with self.assertRaisesMessage(ValidationError,
"'Enter a valid date.'"):
f.clean('a\x00b')
class PlanningForm(forms.Form):
date = DateField(input_formats=["%d.%m.%Y"],
initial=datetime.today().strftime("%d.%m.%Y"))
start_time = TimeField(input_formats=['%H:%M'])
end_time = TimeField(input_formats=['%H:%M'])
description = CharField(max_length=500, required=False)
def test_datefield_changed(self):
format = '%d/%m/%Y'
f = DateField(input_formats=[format])
d = date(2007, 9, 17)
self.assertFalse(f.has_changed(d, '17/09/2007'))
class DateTicketForm(Form):
date = DateField(widget=SelectDateWidget(),
help_text="Select the date before which their membership should have been verified." + \
"Note that this will only select those who are currently members of the society.")
elections = ModelMultipleChoiceField(
Election.objects.filter(archived=False))
