def __init__(self, initial=None, allow_past=False, **kwargs):
if initial is None:
initial = (None, None)
if len(initial) != 2:
raise ValueError(
_("Initial data tuple was expected to have " +
" exactly two dates."))
fields = (
DateTimeField(
initial=initial[0],
input_formats=[
DATETIME_INPUT_FORMAT,
],
**kwargs,
),
DateTimeField(
initial=initial[1],
input_formats=[
DATETIME_INPUT_FORMAT,
],
**kwargs,
),
)
super(DateTimeRangeField, self).__init__(fields,
initial=initial,
**kwargs)
# Allow a time_range to be in the past
self.allow_past = allow_past
def test_use_24_hour_time_format_en(self):
field = DateTimeField()
supported_custom_examples = [
'10/25/2006 2:30:59',
'10/25/2006 2:30',
'10/25/2006 14:30:59',
'10/25/2006 14:30',
]
for example in supported_custom_examples:
try:
result = field.to_python(example)
self.assertIsInstance(result, datetime.datetime)
except ValidationError:
self.fail('Format of "{}" not recognized!'.format(example))
with self.assertRaises(ValidationError):
field.to_python('invalid date string!')
dt = datetime.datetime(year=2011, month=11, day=4, hour=23, minute=5,
second=59)
self.assertEqual(
date_format(dt, 'DATETIME_FORMAT'), 'Nov. 4, 2011, 23:05:59')
dt = datetime.datetime(year=2011, month=11, day=4, hour=2, minute=5,
second=59)
self.assertEqual(
date_format(dt, 'SHORT_DATETIME_FORMAT'), '11/04/2011 2:05:59')
t = datetime.time(hour=16, minute=2, second=25)
self.assertEqual(time_format(t), '16:02:25')
def __init__(self, *args, **kwargs):
super(MetaInlineForm, self).__init__(*args, **kwargs)
self.show_edit_url = False # shows edit button if set to True
core_signals.request_finished.connect(
receiver=MetaInlineForm.reset_export_enumerator)
existing_object = False
new_object = False
id_initial = None
from_initial = to_initial = ''
export_initial = None
position_initial = None
#export_qs = models.Export.objects.all()
if 'instance' in kwargs and 'data' not in kwargs:
existing_object = True
instance = kwargs['instance']
if instance:
initial = self.get_initial_data(instance)
id_initial = initial['pk']
from_initial = initial['visible_from']
to_initial = initial['visible_to']
export_initial = initial['export_pk']
position_initial = initial['position']
elif 'data' not in kwargs:
new_object = True
self.assign_init_field(
'position_id',
HiddenIntegerField(initial=id_initial, label=u'', required=False))
self.assign_init_field(
'position_from',
DateTimeField(initial=from_initial,
label=_('Visible From'),
widget=widgets.DateTimeWidget))
self.assign_init_field(
'position_to',
DateTimeField(initial=to_initial,
label=_('Visible To'),
widget=widgets.DateTimeWidget,
required=False))
self.assign_init_field(
'position',
IntegerField(initial=position_initial,
label=_('Position'),
required=False))
export_field = fields.AdminSuggestField(
models.ExportPosition._meta.get_field('export'),
required=True,
label=_('Export'),
model=models.Export,
lookup=(
'title',
'slug',
),
initial=export_initial)
#modelforms.ModelChoiceField(export_qs, initial=export_initial, label=_('Export'), show_hidden_initial=True)
self.assign_init_field('export', export_field)
def listings_clean(self, data):
# get listing category, publish_from and publish_to
pub_from = data.getlist(self.get_part_id('publish_from'))
listings = self.cleaned_data['listings']
if len(pub_from) and (len(pub_from) != len(listings)):
raise ValidationError(_('Amount of publish_from input fields should be the same as category fields. With kind regards Your PlacementInline and his ListingCustomWidget.'))
for lst, pub in zip(listings, pub_from):
if not pub:
#raise ValidationError(_('This field is required'))
continue
dt_field = DateTimeField()
publish_from = dt_field.clean(pub)
def fc_events(request):
"""
Returns events in JSON for FullCalendar
It returns validated reservations between start and end GET parameters
"""
# Get only events corresponding to the time slot
start_time = request.GET.get('start')
end_time = request.GET.get('end')
if start_time and end_time:
start = DateTimeField().clean(start_time.replace('T', ' '))
end = DateTimeField().clean(end_time.replace('T', ' '))
queryset = Reservation.objects.filter(
start_time__lt=end,
end_time__gt=start,
)
else:
queryset = Reservation.objects
data = []
# Add user reservation
for reservation in queryset.filter(in_charge=request.user):
event = {
'resourceId': reservation.room.id,
'title': reservation.purpose_title,
'start': timezone.localtime(reservation.start_time),
'end': timezone.localtime(reservation.end_time),
'url': reverse('edit', args=(reservation.id, )),
}
if reservation.validation:
event['comment'] = _('Validated')
event['color'] = 'green'
elif reservation.validation is None:
event['comment'] = _('Being validated')
event['color'] = 'black'
else:
event['comment'] = _('Denied')
event['color'] = 'red'
data.append(event)
# Add all other reservation
for reservation in \
queryset.filter(validation=True).exclude(in_charge=request.user):
event = {
'resourceId': reservation.room.id,
'title': reservation.purpose_title,
'start': timezone.localtime(reservation.start_time),
'end': timezone.localtime(reservation.end_time),
}
data.append(event)
return JsonResponse(data, safe=False)
def listings_clean(self, placement_publish_from, data):
# get listing category, publish_from and publish_to
pub_from = data.getlist(self.get_part_id('publish_from'))
listings = self.cleaned_data['listings']
if pub_from and len(pub_from) != len(listings):
raise ValidationError(_('Duplicate listings'))
for lst, pub in zip(listings, pub_from):
if not pub:
#raise ValidationError(_('This field is required'))
continue
dt_field = DateTimeField()
publish_from = dt_field.clean(pub)
if publish_from < placement_publish_from:
raise ValidationError(_('No listing can start sooner than main listing'))
def listings_clean(self, placement_publish_from, data):
# get listing category, publish_from and publish_to
pub_from = data.getlist(self.get_part_id("publish_from"))
listings = self.cleaned_data["listings"]
if pub_from and len(pub_from) != len(listings):
raise ValidationError(_("Duplicate listings"))
for lst, pub in zip(listings, pub_from):
if not pub:
# raise ValidationError(_('This field is required'))
continue
dt_field = DateTimeField()
publish_from = dt_field.clean(pub)
if publish_from < placement_publish_from:
raise ValidationError(_("No listing can start sooner than main listing"))
def test_datetime_input_formats(self):
field = DateTimeField()
supported_custom_examples = [
'01/20/2020 9:30 AM',
'01/20/2020 9:30:03 AM',
'10/01/2020 11:30 PM',
'10/01/2020 11:30:03 AM',
]
for example in supported_custom_examples:
result = field.to_python(example)
self.assertIsInstance(result, datetime.datetime)
with self.assertRaises(ValidationError):
field.to_python('invalid date string!')
def test_format_translation(self):
translations = {
'%Y-%m-%d': 'yyyy-mm-dd',
'%m/%d/%Y': 'mm/dd/yyyy',
'%m/%d/%y': 'mm/dd/yy',
'%b %d %Y': 'M dd yyyy',
'%b %d, %Y': 'M dd, yyyy',
'%d %b %Y': 'dd M yyyy',
'%d %b, %Y': 'dd M, yyyy',
'%B %d %Y': 'MM dd yyyy',
'%B %d, %Y': 'MM dd, yyyy',
'%d %B %Y': 'dd MM yyyy',
'%d %B, %Y': 'dd MM, yyyy',
'%Y-%m-%d %H:%M:%S': 'yyyy-mm-dd hh:ii:ss',
'%Y-%m-%d %H:%M': 'yyyy-mm-dd hh:ii',
'%m/%d/%Y %H:%M:%S': 'mm/dd/yyyy hh:ii:ss',
'%m/%d/%Y %H:%M': 'mm/dd/yyyy hh:ii',
'%m/%d/%y %H:%M:%S': 'mm/dd/yy hh:ii:ss',
'%m/%d/%y %H:%M': 'mm/dd/yy hh:ii',
}
for input_format, output_format in translations.items():
field = DateTimeField(input_formats=[input_format])
result = viewform.datepicker_format(field)
self.assertEqual(output_format, result)
class SharedForm(forms.Form):
# name = forms.CharField(label='Your Email', max_length=200, required=True)
dest = forms.CharField(label='Destination', max_length=100, required=True)
earliest_arrival = DateTimeField(input_formats=['%Y-%m-%dT%H:%M'],
widget=DateTimeInput(
format='%Y-%m-%dT%H:%M',
attrs={'type': 'datetime-local'}))
latest_arrival = DateTimeField(input_formats=['%Y-%m-%dT%H:%M'],
widget=DateTimeInput(
format='%Y-%m-%dT%H:%M',
attrs={'type': 'datetime-local'}))
pnum = forms.IntegerField(
label='Number of Passengers',
required=True,
validators=[MinValueValidator(1),
MaxValueValidator(6)])
def to_python(self, value):
try:
date = dateutil.parser.parse(value)
except ValueError:
#Date utils couldn't figure it out. Let the default parser have a
#swing at it and throw errors as necessary.
date = value
return DateTimeField.to_python(self, date)
def factory_method(cls, **kwargs) -> Message:
translation = {
"identifier": "identifier",
"object_user": "******",
"object_channel": "channel",
"date": "date",
"content": "content",
"author_id": "author_id",
"references_id": "references_id",
}
translated_args = cls.translate_kwargs(cls,
translation=translation,
args=kwargs)
date = DateTimeField().clean(translated_args["date"])
tz = pytz.timezone("Europe/Paris")
date.replace(tzinfo=tz)
translated_args["date"] = date
return Message(**translated_args)
def test_datetime_input_formats(self):
update_en_us_date_formats()
field = DateTimeField()
supported_custom_examples = [
"01/20/2020 9:30 AM",
"01/20/2020 9:30:03 AM",
"10/01/2020 11:30 PM",
"10/01/2020 11:30:03 AM",
]
for example in supported_custom_examples:
try:
result = field.to_python(example)
self.assertIsInstance(result, datetime.datetime)
except ValidationError:
self.fail('Format of "{}" not recognized!'.format(example))
with self.assertRaises(ValidationError):
field.to_python("invalid date string!")
class Post(db.Document):
id = Integer(primary_key=True)
title = StringField(required=True)
date_posted = DateTime(nullable=False, default=datetime.utcnow())
content = StringField(Text, nullable=False)
last_updated = DateTimeField(default=datetime.datetime.now())
user_id = Integer(ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
def test_use_24_hour_time_format(self):
update_en_gb_date_formats()
field = DateTimeField()
supported_custom_examples = [
"25/10/2006 2:30:59",
"25/10/2006 2:30",
"25/10/2006 14:30:59",
"25/10/2006 14:30",
]
for example in supported_custom_examples:
try:
result = field.to_python(example)
self.assertIsInstance(result, datetime.datetime)
except ValidationError:
self.fail('Format of "{}" not recognized!'.format(example))
with self.assertRaises(ValidationError):
field.to_python("invalid date string!")
dt = datetime.datetime(year=2011,
month=11,
day=4,
hour=23,
minute=5,
second=59)
self.assertEqual(date_format(dt, "DATETIME_FORMAT"),
"4 November 2011 23:05:59")
dt = datetime.datetime(year=2011,
month=11,
day=4,
hour=2,
minute=5,
second=59)
self.assertEqual(date_format(dt, "SHORT_DATETIME_FORMAT"),
"04/11/2011 02:05")
t = datetime.time(hour=16, minute=2, second=25)
self.assertEqual(time_format(t), "16:02")
def get_incidents_for_period(self, period):
today = timezone.now()
datem = datetime(today.year, today.month, 1)
from_date = datem - relativedelta(months=+(period - 1) * 3)
to_date = datem - relativedelta(months=+(period * 3))
period = "%(from)s - %(to)s" % {
"from": from_date.strftime("%B %Y"),
"to": (to_date + relativedelta(months=+1)).strftime("%B %Y")
}
from_date = datetime(from_date.year, from_date.month, 1)
to_date = datetime(to_date.year, to_date.month, 1)
incidents = []
while from_date > to_date:
current_incidents = []
incidents_list = self.__incident_entity.get_incident_on_month(
DateTimeField().clean(from_date))
for incident in incidents_list:
current_incidents.append({
"uri":
incident.uri,
"subject":
incident.name,
"class":
"text-danger",
"status":
incident.status,
"final_update":
_("This incident has been resolved.") if incident.status
== "closed" else _("This incident is still open."),
"period":
self.__get_incident_period(incident)
})
current_date = from_date.strftime("%B %Y")
incidents.append({
"date": current_date,
"incidents": current_incidents
})
from_date -= relativedelta(months=+1)
return {"period": period, "incidents": incidents}
class RequestForm(forms.Form):
destination = forms.CharField(label='Destination',
max_length=100,
required=True)
arrival_time = DateTimeField(input_formats=['%Y-%m-%dT%H:%M'],
widget=DateTimeInput(
format='%Y-%m-%dT%H:%M',
attrs={'type': 'datetime-local'}))
party_size = forms.IntegerField(
label='Number of Passengers',
required=True,
validators=[MinValueValidator(1),
MaxValueValidator(6)])
vehicle = forms.ChoiceField(label='Vehicle Type',
choices=(("Sedan", "Sedan"), ("SUV", "SUV")))
sharable = forms.BooleanField(required=False)
special_request = forms.CharField(label='Special Request',
max_length=100,
required=False)
def setUpTestData(cls):
''' Set up localized deadline-date for tasks, create dummy tasks '''
cls.deadline_date = DateTimeField().clean('2030-06-04 13:00')
TaskUtilsTestCase.deadline_date = TaskUtilsTestCase.deadline_date.replace(tzinfo=None)
tz = pytz.timezone('Europe/Berlin')
tz.localize(TaskUtilsTestCase.deadline_date)
cls.date = timezone.now()
cls.person = Person.objects.create_user(username = '******', password = '******', position = 'BOS')
cls.task1 = Task.objects.create(priority = 'LOW',assigned_employee = cls.person, task_name = 'dummy task',
task_description = 'dummy_task', created_date = TaskUtilsTestCase.date,
deadline_date = TaskUtilsTestCase.deadline_date)
cls.task2 = Task.objects.create(priority = 'LOW',assigned_employee = cls.person, task_name = 'dummy task',
task_description = 'dummy_task', created_date = TaskUtilsTestCase.date,
deadline_date = TaskUtilsTestCase.date)
cls.task3 = Task.objects.create(priority = 'HIG',assigned_employee = cls.person, task_name = 'dummy task',
task_description = 'dummy_task', created_date = TaskUtilsTestCase.date,
deadline_date = TaskUtilsTestCase.deadline_date)
cls.task4 = Task.objects.create(priority = 'CRI',assigned_employee = cls.person, task_name = 'dummy task',
task_description = 'dummy_task', created_date = TaskUtilsTestCase.date,
deadline_date = TaskUtilsTestCase.deadline_date)
cls.task5 = Task.objects.create(priority = 'MED',assigned_employee = cls.person, task_name = 'dummy task',
task_description = 'dummy_task', created_date = TaskUtilsTestCase.date,
deadline_date = TaskUtilsTestCase.deadline_date)
class ServiceCallContext(SoColissimoSchema):
soap_type_name = "ServiceCallContextV2"
dateDeposite = DateTimeField(required=True)
commercialName = CharField(required=True)
VATCode = ChoiceField(required=False,
choices=[(vat, vat) for vat in range(3)])
VATPercentage = IntegerField(required=False, min_value=0, max_value=9999)
VATAmount = IntegerField(required=False, min_value=0)
transportationAmount = IntegerField(required=False, min_value=0)
totalAmount = IntegerField(required=False, min_value=0)
commandNumber = CharField(required=False)
def _set_constants(self, service):
service.dateValidation = datetime.datetime.today(
) + datetime.timedelta(7)
service.returnType = 'CreatePDFFile'
service.serviceType = 'SO'
service.crbt = False
service.portPaye = False
service.languageConsignor = "FR"
service.languageConsignee = "FR"
def get_publish_date(self, pub_from):
" Tries to save publish_from field specified either by POST parameter or by Placement (self.instance). "
if pub_from:
dt_field = DateTimeField()
return dt_field.clean(pub_from)
return self.instance.publish_from
class MetaInlineForm(modelforms.ModelForm):
_export_stack = dict()
position_id = HiddenIntegerField(required=False)
position_from = DateTimeField(label=_('Visible From'),
widget=widgets.DateTimeWidget)
position_to = DateTimeField(label=_('Visible To'),
widget=widgets.DateTimeWidget,
required=False)
position = IntegerField(required=False)
export = fields.AdminSuggestField(
models.ExportPosition._meta.get_field('export'),
required=True,
label=_('Export'),
model=models.Export,
lookup=(
'title',
'slug',
),
)
# override base_fields and include all the other declared fields
declared_fields = SortedDict(
(('title', HiddenIntegerField(label=u'', required=False)),
('position_id', HiddenIntegerField(label=u'', required=False)),
('position_from',
DateTimeField(label=_('Visible From'),
widget=widgets.DateTimeWidget)),
('position_to',
DateTimeField(label=_('Visible To'),
widget=widgets.DateTimeWidget,
required=False)), ('position',
IntegerField(required=False)),
('export',
fields.AdminSuggestField(
models.ExportPosition._meta.get_field('export'),
required=True,
label=_('Export'),
model=models.Export,
lookup=(
'title',
'slug',
),
))))
def __init__(self, *args, **kwargs):
super(MetaInlineForm, self).__init__(*args, **kwargs)
self.show_edit_url = False # shows edit button if set to True
core_signals.request_finished.connect(
receiver=MetaInlineForm.reset_export_enumerator)
existing_object = False
new_object = False
id_initial = None
from_initial = to_initial = ''
export_initial = None
position_initial = None
#export_qs = models.Export.objects.all()
if 'instance' in kwargs and 'data' not in kwargs:
existing_object = True
instance = kwargs['instance']
if instance:
initial = self.get_initial_data(instance)
id_initial = initial['pk']
from_initial = initial['visible_from']
to_initial = initial['visible_to']
export_initial = initial['export_pk']
position_initial = initial['position']
elif 'data' not in kwargs:
new_object = True
self.assign_init_field(
'position_id',
HiddenIntegerField(initial=id_initial, label=u'', required=False))
self.assign_init_field(
'position_from',
DateTimeField(initial=from_initial,
label=_('Visible From'),
widget=widgets.DateTimeWidget))
self.assign_init_field(
'position_to',
DateTimeField(initial=to_initial,
label=_('Visible To'),
widget=widgets.DateTimeWidget,
required=False))
self.assign_init_field(
'position',
IntegerField(initial=position_initial,
label=_('Position'),
required=False))
export_field = fields.AdminSuggestField(
models.ExportPosition._meta.get_field('export'),
required=True,
label=_('Export'),
model=models.Export,
lookup=(
'title',
'slug',
),
initial=export_initial)
#modelforms.ModelChoiceField(export_qs, initial=export_initial, label=_('Export'), show_hidden_initial=True)
self.assign_init_field('export', export_field)
def assign_init_field(self, field_name, value):
self.fields[field_name] = self.base_fields[field_name] = value
def get_initial_data(self, instance):
" @return dict (visible_from, visible_to, export_initial, position) "
positions = models.ExportPosition.objects.filter(object=instance)
out = {
'pk': '',
'visible_from': '',
'visible_to': None,
'export_pk': None,
'position': ''
}
if not positions:
return out
pcount = positions.count()
if pcount > 1 and not MetaInlineForm._export_stack.get(
instance, False):
MetaInlineForm._export_stack[instance] = list()
map(lambda p: MetaInlineForm._export_stack[instance].insert(0, p),
positions)
if pcount == 1:
pos = positions[0]
elif pcount > 1:
pos = MetaInlineForm._export_stack[instance].pop()
out.update({
'pk': pos.pk,
'visible_from': pos.visible_from,
'visible_to': pos.visible_to,
'export_pk': pos.export.pk,
'position': pos.position
})
return out
@staticmethod
def reset_export_enumerator(*args, **kwargs):
" Clears _export_stack at the end of HTTP request. "
core_signals.request_finished.disconnect(
receiver=MetaInlineForm.reset_export_enumerator)
MetaInlineForm._export_stack.clear()
def get_date_field_key(self, field):
return '%s-%s' % (self.prefix, field)
def clean(self):
"""
if not self.is_valid() or not self.cleaned_data or not self.instance:
return self.cleaned_data
"""
self.cleaned_data['position_id'] = self.data[self.get_date_field_key(
'position_id')]
self.cleaned_data['position_from'] = self.data[self.get_date_field_key(
'position_from')]
self.cleaned_data['position'] = self.data[self.get_date_field_key(
'position')]
data_position_to = self.data[self.get_date_field_key('position_to')]
if data_position_to:
self.cleaned_data['position_to'] = data_position_to
self.cleaned_data['export'] = self.data[self.get_date_field_key(
'export')]
return self.cleaned_data
def save(self, commit=True):
out = super(MetaInlineForm, self).save(commit=commit)
def save_them():
export = models.Export.objects.get(
pk=int(self.cleaned_data['export']))
positions = models.ExportPosition.objects.filter(
object=self.instance, export=export)
if not self.cleaned_data['position_id']:
position = models.ExportPosition(object=self.instance, )
else:
pos_id = int(self.cleaned_data['position_id'])
position = models.ExportPosition.objects.get(pk=pos_id)
position.export = export
position.visible_from = self.cleaned_data['position_from']
position.visible_to = self.cleaned_data['position_to']
if self.cleaned_data['position'].isdigit():
position.position = int(self.cleaned_data['position'])
position.save()
if commit:
save_them()
else:
save_m2m = getattr(self, 'save_m2m', None)
def save_all():
if save_m2m:
save_m2m()
save_them()
self.save_m2m = save_all
return out
def post(self, request, incident_id, update_id):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__request.set_request(request)
request_data = self.__request.get_request_data("post", {
"status": "",
"notify_subscribers": "",
"message": "",
"datetime": "",
})
self.__form.add_inputs({
'message': {
'value': request_data["message"],
'sanitize': {
'strip': {}
},
'validate': {
'length_between': {
'param': [1, 3000000],
'error': _('Error! Update message must be 1 to 3M characters long.')
}
}
},
'datetime': {
'value': request_data["datetime"],
'sanitize': {
'strip': {}
},
'validate': {
'sv_datetime': {
'error': _('Error! Datetime is invalid.')
}
}
},
'status': {
'value': request_data["status"],
'validate': {
'any_of': {
'param': [["investigating", "identified", "monitoring", "update", "resolved"]],
'error': _('Error! Status is invalid.')
}
}
},
'notify_subscribers': {
'value': request_data["notify_subscribers"],
'validate': {
'any_of': {
'param': [["on", "off"]],
'error': _('Error! Notify subscribers is invalid.')
}
}
}
})
self.__form.process()
if not self.__form.is_passed():
return JsonResponse(self.__response.send_errors_failure(self.__form.get_errors(), {}, self.__correlation_id))
result = self.__incident_update.update_one_by_id(update_id, {
"notify_subscribers": self.__form.get_sinput("notify_subscribers"),
"datetime": DateTimeField().clean(self.__form.get_sinput("datetime")),
"message": self.__form.get_sinput("message"),
"status": self.__form.get_sinput("status")
})
if result:
return JsonResponse(self.__response.send_private_success([{
"type": "success",
"message": _("Incident update updated successfully.")
}], {}, self.__correlation_id))
else:
return JsonResponse(self.__response.send_private_failure([{
"type": "error",
"message": _("Error! Something goes wrong while updating update.")
}], {}, self.__correlation_id))
def get_filter_params(self):
"""Preparing parameters for change list queryset, based on attached queries."""
filter_params = {}
exclude_params = {}
bundled_params = {}
field = DateTimeField()
for query in self.queries.all():
if query.model_field:
key = query.field
if query.criteria: # avoiding load of empty criteria
dates_criterias = [
'today', 'this_week', 'this_month', 'this_year',
'between', 'days_ago'
]
if query.criteria not in dates_criterias:
if type(query.field_value) is list:
if len(query.field_value) > 1:
key += '__in'
query.field_value = ','.join(query.field_value)
if query.field_type in ('datetime', 'date'):
field = DateTimeField()
query.value = field.to_python(
query.field_value)
else:
key += '__%s' % query.criteria
elif type(query.field_value) is list and len(
query.field_value
) > 1 and query.criteria not in dates_criterias:
if query.criteria != 'between':
key += '__in'
# preparing date-related criteria
if query.criteria in [
'today', 'this_week', 'this_month', 'this_year',
'days_ago'
]:
date = datetime.datetime.now()
value = None
if query.criteria == 'today':
value = date.strftime('%Y-%m-%d')
if query.criteria == 'this_month':
# we need to filter by current year to make sure we have only from this month,
# not all records with month with given number
filter_params[key + '__year'] = date.strftime('%Y')
key += '__month'
value = date.strftime('%m')
if query.criteria == 'this_year':
key += '__year'
value = date.strftime('%Y')
if query.criteria == 'this_week':
date = datetime.date.today()
start_week = date - datetime.timedelta(
date.weekday())
end_week = start_week + datetime.timedelta(7)
key += '__range'
value = [start_week, end_week]
filter_params[key] = value
if query.criteria == 'days_ago':
date = datetime.date.today() - datetime.timedelta(
days=int(query.field_value))
del (filter_params[key])
filter_params[key + '__year'] = date.year
filter_params[key + '__month'] = date.month
filter_params[key + '__day'] = date.day
elif query.criteria == 'between':
start_value = query.field_value[0]
end_value = query.field_value[0]
if query.field_type in ('date', 'datetime'):
start_value = field.to_python(
query.field_value[0]
) if start_value else start_value
end_value = field.to_python(
query.field_value[1]
) if end_value else end_value
if query.field_value[0]:
filter_params['%s__gt' % key] = start_value
if query.field_value[1]:
filter_params['%s__lte' % key] = end_value
elif query.criteria == '_notcontains':
exclude_params[key + '__icontains'] = query.field_value
elif query.criteria == 'not':
exclude_params[key[:-5]] = query.field_value
elif query.criteria == 'startswith':
filter_params[key + '__startswith'] = query.field_value
elif query.criteria == 'endswith':
filter_params[key + '__endswith'] = query.field_value
elif query.field_value: # avoiding load of empty filter value which causes database error
if query.model_field.get_internal_type(
) == 'BooleanField':
filter_params[key] = {
'true': True,
'false': False
}[query.field_value]
else:
if query.criteria in ('lt', 'gt'):
if not key.endswith('__' + query.criteria):
key = key + '__' + query.criteria
filter_params[key] = query.field_value
else:
filter_params[key] = query.field_value
if query.field_type in (
'date', 'datetime'
) and query.field_value and query.criteria not in (
'lt', 'gt'):
date = field.to_python(query.field_value)
# needed to cover case when field is datetime and time is not specified
if not date.hour and not date.minute and not date.second:
del (filter_params[key])
filter_params[query.field +
'__year'] = date.year
filter_params[query.field +
'__month'] = date.month
filter_params[query.field +
'__day'] = date.day
for query in self.bundled_queries.all():
bundled_params[query.field] = query.value
return filter_params, exclude_params, bundled_params
def post(self, request):
self.__correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__request.set_request(request)
request_data = self.__request.get_request_data("post", {
"name": "",
"status": "",
"datetime": "",
})
self.__form.add_inputs({
'name': {
'value': request_data["name"],
'sanitize': {
'strip': {}
},
'validate': {
'length_between': {
'param': [1, 200],
'error':
_('Error! Incident name must be 1 to 200 characters long.'
)
}
}
},
'datetime': {
'value': request_data["datetime"],
'sanitize': {
'strip': {}
},
'validate': {}
},
'status': {
'value': request_data["status"],
'validate': {
'any_of': {
'param': [["open", "closed"]],
'error': _('Error! Incident is invalid.')
}
}
}
})
self.__form.process()
if not self.__form.is_passed():
return JsonResponse(
self.__response.send_errors_failure(self.__form.get_errors(),
{}, self.__correlation_id))
result = self.__incident.insert_one({
"name":
self.__form.get_sinput("name"),
"status":
self.__form.get_sinput("status"),
"datetime":
DateTimeField().clean(self.__form.get_sinput("datetime")),
"uri":
self.__incident.generate_uri(6)
})
if result:
return JsonResponse(
self.__response.send_private_success(
[{
"type": "success",
"message": _("Incident created successfully.")
}], {}, self.__correlation_id))
else:
return JsonResponse(
self.__response.send_private_failure([{
"type":
"error",
"message":
_("Error! Something goes wrong while creating incident.")
}], {}, self.__correlation_id))
def get_publish_date(self, pub_from):
" Tries to save publish_from field specified either by POST parameter or by Placement (self.instance). "
if pub_from:
dt_field = DateTimeField()
return dt_field.clean(pub_from)
return self.instance.publish_from
def get_filter_params(self):
"""Preparing parameters for change list queryset, based on attached queries."""
filter_params = {}
exclude_params = {}
bundled_params = {}
field = DateTimeField()
for query in self.queries.all():
if query.model_field:
key = query.field
if query.criteria: # avoiding load of empty criteria
dates_criterias = ['today', 'this_week', 'this_month', 'this_year', 'between', 'days_ago']
if query.criteria not in dates_criterias:
if type(query.field_value) is list:
if len(query.field_value) > 1:
key += '__in'
query.field_value = ','.join(query.field_value)
if query.field_type in ('datetime', 'date'):
field = DateTimeField()
query.value = field.to_python(query.field_value)
else:
key += '__%s' % query.criteria
elif type(query.field_value) is list and len(query.field_value) > 1 and query.criteria not in dates_criterias:
if query.criteria != 'between':
key += '__in'
# preparing date-related criteria
if query.criteria in ['today', 'this_week', 'this_month', 'this_year', 'days_ago']:
date = datetime.datetime.now()
value = None
if query.criteria == 'today':
value = date.strftime('%Y-%m-%d')
if query.criteria == 'this_month':
# we need to filter by current year to make sure we have only from this month,
# not all records with month with given number
filter_params[key + '__year'] = date.strftime('%Y')
key += '__month'
value = date.strftime('%m')
if query.criteria == 'this_year':
key += '__year'
value = date.strftime('%Y')
if query.criteria == 'this_week':
date = datetime.date.today()
start_week = date - datetime.timedelta(date.weekday())
end_week = start_week + datetime.timedelta(7)
key += '__range'
value = [start_week, end_week]
filter_params[key] = value
if query.criteria == 'days_ago':
date = datetime.date.today() - datetime.timedelta(days=int(query.field_value))
del(filter_params[key])
filter_params[key + '__year'] = date.year
filter_params[key + '__month'] = date.month
filter_params[key + '__day'] = date.day
elif query.criteria == 'between':
start_value = query.field_value[0]
end_value = query.field_value[0]
if query.field_type in ('date', 'datetime'):
start_value = field.to_python(query.field_value[0]) if start_value else start_value
end_value = field.to_python(query.field_value[1]) if end_value else end_value
if query.field_value[0]:
filter_params['%s__gt' % key] = start_value
if query.field_value[1]:
filter_params['%s__lte' % key] = end_value
elif query.criteria == '_notcontains':
exclude_params[key + '__icontains'] = query.field_value
elif query.criteria == 'not':
exclude_params[key[:-5]] = query.field_value
elif query.criteria == 'startswith':
filter_params[key + '__startswith'] = query.field_value
elif query.criteria == 'endswith':
filter_params[key + '__endswith'] = query.field_value
elif query.field_value: # avoiding load of empty filter value which causes database error
if query.model_field.get_internal_type() == 'BooleanField':
filter_params[key] = {'true': True, 'false': False}[query.field_value]
else:
if query.criteria in ('lt', 'gt'):
if not key.endswith('__' + query.criteria):
key = key + '__' + query.criteria
filter_params[key] = query.field_value
else:
filter_params[key] = query.field_value
if query.field_type in ('date', 'datetime') and query.field_value and query.criteria not in ('lt', 'gt'):
date = field.to_python(query.field_value)
# needed to cover case when field is datetime and time is not specified
if not date.hour and not date.minute and not date.second:
del(filter_params[key])
filter_params[query.field + '__year'] = date.year
filter_params[query.field + '__month'] = date.month
filter_params[query.field + '__day'] = date.day
for query in self.bundled_queries.all():
bundled_params[query.field] = query.value
return filter_params, exclude_params, bundled_params
def datetimetype(s):
f = DateTimeField()
try:
return f.to_python(s)
except ValidationError as e:
raise argparse.ArgumentTypeError("Unrecognized datetime format") from e
def post(self, request, incident_id):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
self.__request.set_request(request)
request_data = self.__request.get_request_data("post", {
"status": "",
"notify_subscribers": "",
"message": "",
"datetime": "",
})
self.__form.add_inputs({
'message': {
'value': request_data["message"],
'sanitize': {
'strip': {}
},
'validate': {}
},
'datetime': {
'value': request_data["datetime"],
'sanitize': {
'strip': {}
},
'validate': {}
},
'status': {
'value': request_data["status"],
'validate': {
'any_of': {
'param': [["investigating", "identified", "monitoring", "update", "resolved"]],
'error': _('Error! Status is invalid.')
}
}
},
'notify_subscribers': {
'value': request_data["notify_subscribers"],
'validate': {
'any_of': {
'param': [["on", "off"]],
'error': _('Error! Notify subscribers is invalid.')
}
}
}
})
self.__form.process()
if not self.__form.is_passed():
return JsonResponse(self.__response.send_errors_failure(self.__form.get_errors(), {}, self.__correlation_id))
result = self.__incident_update.insert_one({
"notify_subscribers": self.__form.get_sinput("notify_subscribers"),
"datetime": DateTimeField().clean(self.__form.get_sinput("datetime")),
"total_suscribers": self.__subscriber.count_by_status(SubscriberModule.VERIFIED),
"message": self.__form.get_sinput("message"),
"status": self.__form.get_sinput("status"),
"incident_id": incident_id
})
if self.__form.get_sinput("status") == "resolved":
self.__incident.update_one_by_id(incident_id, {
"status": "closed"
})
else:
self.__incident.update_one_by_id(incident_id, {
"status": "open"
})
if result:
return JsonResponse(self.__response.send_private_success([{
"type": "success",
"message": _("Incident update created successfully.")
}], {}, self.__correlation_id))
else:
return JsonResponse(self.__response.send_private_failure([{
"type": "error",
"message": _("Error! Something goes wrong while creating update.")
}], {}, self.__correlation_id))
def save(self, *args, **kwargs):
params = self.data
if params.get('e'):
return
filter_ordering = params.getlist('ordering', None)
if '' in filter_ordering:
filter_ordering.remove('')
self.custom_filter.filter_ordering = filter_ordering
for query in self.custom_filter.bundled_queries.all():
query_instance = query.query_instance(None, {}, self.custom_filter.model, None)
if params.get('%s_enabled' % query_instance.parameter_name, None):
criteria = params.get('%s_criteria' % query_instance.parameter_name, None)
query.field = query_instance.parameter_name
query.value = criteria
query.save()
else:
query.delete()
for query in list(self.custom_filter.queries.all()) + self.new_fields:
if not isinstance(query, CustomQuery):
query = CustomQuery(custom_filter=self.custom_filter, field=query)
if params.get('%s_enabled' % query.field, None):
criteria = params.get('%s_criteria' % query.field, 'exact')
query.criteria = criteria
value = params.getlist('%s_value' % query.field, None)
# some sort of hack to detect if we have multiple values
if not query.is_multiple and not len(value):
value = params.get('%s_value' % query.field, None)
days_ago = params.get('%s_dago' % query.field, None)
field = DateTimeField()
if criteria == 'between':
if query.field_type == 'date':
start = params.get('%s_start' % query.field, '')
end = params.get('%s_end' % query.field, '')
else:
start = field.to_python('%s %s' % (params.get('%s_start_0' % query.field, ''), params.get('%s_start_1' % query.field, '')))
end = field.to_python('%s %s' % (params.get('%s_end_0' % query.field, ''), params.get('%s_end_1' % query.field, '')))
query.is_multiple = True
query.field_value = [str(start), str(end)]
elif criteria in ('lt', 'gt') and query.field_type in ('date', 'datetime'):
start = field.to_python('%s %s' % (params.get('%s_value_0' % query.field, ''), params.get('%s_value_1' % query.field, '')))
query.field_value = str(start)
elif criteria == 'days_ago':
query.field_value = days_ago
elif criteria == 'this_week':
value = None
elif days_ago and not value and criteria not in ['this_year']:
query.field_value = field.to_python('%s %s' % (params.get('%s_value_0' % query.field, ''), params.get('%s_value_1' % query.field, '')))
elif query.field_type == 'datetime' and criteria == 'exact':
query.field_value = field.to_python('%s %s' % (params.get('%s_value_0' % query.field, ''), params.get('%s_value_1' % query.field, '')))
else:
query.is_multiple = True if (isinstance(value, list) and len(value) > 1) else False
query.field_value = value
# some sort of hack to detect if we have multiple values
if not query.is_multiple and isinstance(value, list) and len(value) == 1:
query.value = value[0]
query.save()
else:
query.delete()
self.custom_filter.save()
class AccountForm(forms.Form):
create_after = DateTimeField(label='在此之后创建：',required=False, widget=MyDateInput())
name = CharField(label='开户人姓名',max_length=Customer._meta.get_field('name').max_length,required=False)
bank = ModelChoiceField(SubBank.objects.all(),label='所属支行',required=False)
def __init__(self, *args, **kwargs):
"""Preparing form - it consists of dynamic fields, except ordering."""
self.custom_filter = kwargs.pop('custom_filter', None)
self.custom_filters = kwargs.pop('custom_filters', None)
self.request = kwargs.pop('request', None)
self.model_admin = kwargs.pop('model_admin', None)
self.new_query = kwargs.pop('new_query', None)
super(CustomFilterForm, self).__init__(*args, **kwargs)
if type(self.data) == dict:
self.data = QueryDict(self.data)
self.skip_validation = True
self.params = args[0] if args else QueryDict('')
all_fields = [f.replace('_enabled', '') for f in self.data if f.endswith('_enabled')]
self.new_fields = [f for f in all_fields if f not in self.custom_filter.all_queries_names]
if self.new_query:
self.data['%s_enabled' % self.new_query] = 'on'
self.new_fields.append(self.new_query)
if isinstance(self.custom_filter.filter_ordering, list):
ordering_choices = self.custom_filter.ordering_choices
ordering_field = forms.MultipleChoiceField(required=False)
else:
widget = forms.Select(attrs={'class': 'single_ordering'})
ordering_choices = [('', '')] + self.custom_filter.ordering_choices
ordering_field = forms.ChoiceField(widget=widget, required=False)
self.fields['ordering'] = ordering_field
self.fields['ordering'].choices = ordering_choices
self.fields['ordering'].initial = self.custom_filter.filter_ordering
if self.custom_filter.choices:
self.fields[ADMINFILTERS_ADD_PARAM] = forms.ChoiceField(label=_(u'Add field to filter:'),
widget=forms.Select(attrs={'class': 'add_adminfilters'}),
required=False)
self.fields[ADMINFILTERS_ADD_PARAM].choices = [('', '')] + self.custom_filter.choices
if self.custom_filters:
self.fields[ADMINFILTERS_LOAD_PARAM] = forms.ChoiceField(label=_(u'Load preset:'),
widget=forms.Select(attrs={'class':'load_adminfilters'}))
self.fields[ADMINFILTERS_LOAD_PARAM].choices = [('', '')] + [(cf.id, cf.verbose_name) for cf in self.custom_filters]
self.field_rows = []
for query in self.custom_filter.bundled_queries.all():
query_instance = query.query_instance(None, {}, self.custom_filter.model, None)
if query_instance:
row = ['%s_enabled' % query_instance.parameter_name,
'%s_criteria' % query_instance.parameter_name]
self.fields['%s_enabled' % query_instance.parameter_name] = forms.BooleanField(label=query_instance.title.title(),
initial=True,
required=False,
widget=forms.CheckboxInput(attrs={'class':'enable'}))
query_criterias = [(p, t) for (p, t) in query_instance.lookups(None, self.custom_filter.model)]
self.fields['%s_criteria' % query_instance.parameter_name] = forms.ChoiceField(choices=query_criterias,
initial=query.value,
required=False,
widget=forms.Select(attrs={'class':'criteria'}))
self.field_rows.append(row)
for query in list(self.custom_filter.queries.all()) + self.new_fields:
if not isinstance(query, CustomQuery):
query = CustomQuery(custom_filter=self.custom_filter, field=query)
field = DateTimeField()
if query.model_field:
row = ['%s_enabled' % query.field,
'%s_criteria' % query.field]
self.fields['%s_enabled' % query.field] = forms.BooleanField(label=query.field_verbose_name,
initial=True,
required=False,
widget=forms.CheckboxInput(attrs={'class':'enable'}))
if query.criterias:
self.fields['%s_criteria' % query.field] = forms.ChoiceField(choices=query.criterias,
initial=query.criteria,
required=False,
widget=forms.Select(attrs={'class':'criteria'}))
if query.choices:
attrs = {'class': 'value'}
if query.is_multiple or len(self.params.getlist('%s_value' % query.field, None)) > 1:
widget = forms.SelectMultiple(attrs=attrs)
value_field = forms.MultipleChoiceField(choices=query.choices,
initial=query.value,
widget=widget)
else:
widget = forms.Select(attrs=attrs)
value_field = forms.ChoiceField(choices=query.choices,
initial=query.value,
widget=widget)
elif query.field_type in ['date', 'datetime']:
if query.is_multiple:
from datetime import datetime
value = datetime.now()
else:
try:
value = field.to_python(query.value)
except ValidationError:
value = field.to_python(query.value[:-7])
if query.field_type == 'date':
value_field = forms.DateField(initial=value, widget=widgets.AdminDateWidget())
elif query.field_type == 'datetime':
value_field = forms.DateTimeField(initial=value, widget=widgets.AdminSplitDateTime())
dwidget = forms.TextInput(attrs={'style': 'display: %s' % ('block' if query.criteria == 'days_ago' else 'none'),
'size': 5})
dfield = forms.CharField(initial=query.value,
widget=dwidget,
required=False)
else:
value_field = forms.CharField(initial=query.value, widget=forms.TextInput(attrs={'size':10}))
if value_field:
self.fields['%s_value' % query.field] = value_field
row.append('%s_value' % query.field)
if query.field_type in ['date', 'datetime', 'integer']:
row.append('%s_start' % query.field)
row.append('%s_end' % query.field)
self.fields['%s_start' % query.field] = value_field
self.fields['%s_end' % query.field] = value_field
if query.field_type in ['date', 'datetime']:
row.append('%s_dago' % query.field)
self.fields['%s_dago' % query.field] = dfield
if query.criteria == 'between':
default_value = ['', '']
bvalue = getattr(query, 'field_value') or default_value
self.initial['%s_start' % query.field] = field.to_python(bvalue[0]) if bvalue[0] else None
self.initial['%s_end' % query.field] = field.to_python(bvalue[1]) if bvalue[1] else None
self.initial['%s_dago' % query.field] = ''
self.initial['%s_value' % query.field] = ''
self.field_rows.append(row)
def post(self, request):
request_data = self.get_request_data(request, "post", {
"name": "",
"status": "",
"datetime": "",
})
self.form().add_inputs({
'name': {
'value': request_data["name"],
'sanitize': {
'strip': {}
},
'validate': {
'length_between': {
'param': [1, 200],
'error':
_('Error! Incident name must be 1 to 200 characters long.'
)
}
}
},
'datetime': {
'value': request_data["datetime"],
'sanitize': {
'strip': {}
},
'validate': {
'sv_datetime': {
'error': _('Error! Datetime is invalid.')
}
}
},
'status': {
'value': request_data["status"],
'validate': {
'any_of': {
'param': [["open", "closed"]],
'error': _('Error! Incident is invalid.')
}
}
}
})
self.form().process()
if not self.form().is_passed():
return self.json(self.form().get_errors())
result = self.__incident.insert_one({
"name":
self.form().get_sinput("name"),
"status":
self.form().get_sinput("status"),
"datetime":
DateTimeField().clean(self.form().get_sinput("datetime")),
"uri":
self.__incident.generate_uri(6)
})
if result:
return self.json([{
"type": "success",
"message": _("Incident created successfully.")
}])
else:
return self.json([{
"type":
"error",
"message":
_("Error! Something goes wrong while creating incident.")
}])