def test_datetime_timezone_awareness(self):
# parsed datetimes should obey USE_TZ
f = IsoDateTimeField()
r = make_aware(self.reference_dt, get_default_timezone())
d = f.strptime(self.reference_str + "+01:00", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d.tzinfo, tzinfo))
self.assertEqual(d, r + r.utcoffset() - d.utcoffset())
d = f.strptime(self.reference_str + "", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d.tzinfo, tzinfo))
self.assertEqual(d, r)
def test_datetime_timezone_naivety(self):
# parsed datetimes should obey USE_TZ
f = IsoDateTimeField()
r = self.reference_dt.replace()
d = f.strptime(self.reference_str + "+01:00", IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r - timedelta(hours=1))
d = f.strptime(self.reference_str + "", IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r)
def test_datetime_timezone_naivety(self):
# parsed datetimes should obey USE_TZ
f = IsoDateTimeField()
r = self.reference_dt.replace()
# It's necessary to override this here, since the field class is parsed
# when USE_TZ = True.
f.default_timezone = None
d = f.strptime(self.reference_str + "+01:00", IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r - timedelta(hours=1))
d = f.strptime(self.reference_str + "", IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r)
def test_datetime_timezone_naivety(self):
# parsed datetimes should obey USE_TZ
f = IsoDateTimeField()
r = self.reference_dt.replace()
# It's necessary to override this here, since the field class is parsed
# when USE_TZ = True.
f.default_timezone = None
d = f.strptime(self.reference_str + "+01:00",
IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r - timedelta(hours=1))
d = f.strptime(self.reference_str + "", IsoDateTimeField.ISO_8601)
self.assertTrue(d.tzinfo is None)
self.assertEqual(d, r)
class TransmissionForm(forms.Form):
after = IsoDateTimeField(required=False)
before = IsoDateTimeField(required=False)
def clean_after(self):
after = self.cleaned_data.get('after')
if after is None:
return timezone.now().replace(day=1)
return after
def clean_before(self):
before = self.cleaned_data.get('before')
if before is None:
return self.clean_after() + datetime.timedelta(days=31)
return before
def clean(self):
cleaned_data = super().clean()
if self.clean_after() > self.clean_before():
self.add_error('before', 'must be later than after')
def _validate_history_date(self):
params = {'lt': timedelta.max, 'gt': timedelta.max}
for param_name in self.HISTORY_DATE_PARAMS:
param_name = 'history_date__' + param_name
param_value = self.query_params.get(param_name)
if param_value is None:
param_value = self.query_params.get(param_name + 'e')
if param_value:
try:
validator = IsoDateTimeField()
param_value = validator.strptime(param_value,
validator.ISO_8601)
except ValueError:
pass
else:
params[param_name.rsplit('_', 1)[1]] = param_value
allowed_timedelta = timedelta(
days=settings.ONLY_LAST_VERSION_ALLOWED_DAYS_RANGE)
if abs(params['lt'] - params['gt']) > allowed_timedelta:
raise DRFValidationError(self.ONLY_LAST_VERSION_ERROR_MSG)
def test_datetime_wrong_format(self):
f = IsoDateTimeField()
with self.assertRaises(ValueError):
f.strptime('19-07-2015T51:34:13.759', IsoDateTimeField.ISO_8601)
def test_datetime_zulu(self):
f = IsoDateTimeField()
d = f.strptime(self.reference_str + "Z", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
def test_datetime_string_with_timezone_is_parsed(self):
f = IsoDateTimeField()
d = f.strptime(self.reference_str + "+01:00",
IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
class EntityEstimatedSalesForm(forms.Form):
GROUPING_CHOICES = [
('store', 'Store'),
('category', 'Category'),
('product', 'Product'),
('entity', 'Entity'),
]
grouping = forms.ChoiceField(choices=GROUPING_CHOICES, required=False)
ORDERING_CHOICES = [
('count', 'Lead count'),
('normal_price_sum', 'Sum of normal prices'),
('offer_price_sum', 'Sum of offer prices'),
]
ordering = forms.ChoiceField(choices=ORDERING_CHOICES, required=False)
timestamp_0 = IsoDateTimeField(required=False)
timestamp_1 = IsoDateTimeField(required=False)
def estimated_sales(self, qs, request):
entity_values = qs.select_related(
'store',
'product__instance_model__model__category',
'category', 'currency')\
.estimated_sales(self.cleaned_data['timestamp_0'],
self.cleaned_data['timestamp_1'])
preferred_currency = request.user.preferred_currency_or_default()
grouping = self.cleaned_data['grouping']
if not grouping:
grouping = 'entity'
conversion_dict = {
'store': {
'field': 'store',
'serializer': create_generic_serializer('store-detail'),
},
'category': {
'field': 'category',
'serializer': create_generic_serializer('category-detail')
},
'product': {
'field': 'product',
'serializer': serializer_wrapper(NestedProductSerializer),
},
'entity': {
'field':
None,
'serializer':
serializer_wrapper(EntityWithInlineProductSerializer),
}
}
field = conversion_dict[grouping]['field']
group_values_dict = {}
for entry in entity_values:
entity = entry['entity']
exchange_rate = preferred_currency.exchange_rate / \
entity.currency.exchange_rate
if field:
group = getattr(entity, field)
else:
group = entity
if not group:
continue
if group not in group_values_dict:
group_values_dict[group] = {
'count': 0,
'normal_price_sum': 0,
'offer_price_sum': 0
}
group_values_dict[group]['count'] += entry['count']
group_values_dict[group]['normal_price_sum'] += \
exchange_rate * entry['normal_price_sum']
group_values_dict[group]['offer_price_sum'] += \
exchange_rate * entry['offer_price_sum']
ordering = self.cleaned_data['ordering']
if not ordering:
ordering = 'count'
sorted_result = sorted(group_values_dict.items(),
key=lambda x: x[1][ordering],
reverse=True)
serializer_klass = conversion_dict[grouping]['serializer']
serialized_groups_dict = serializer_klass(group_values_dict.keys(),
request).to_dict()
result = []
for group, values in sorted_result:
group_values = {
grouping: serialized_groups_dict[group.id],
'count': values['count'],
'normal_price_sum': values['normal_price_sum'],
'offer_price_sum': values['offer_price_sum'],
}
result.append(group_values)
return result
def test_datetime_non_iso_format(self):
f = IsoDateTimeField()
parsed = f.strptime('19-07-2015T51:34:13.759', '%d-%m-%YT%S:%M:%H.%f')
self.assertTrue(isinstance(parsed, datetime))
self.assertEqual(parsed, self.reference_dt)
def test_datetime_string_with_timezone_is_parsed(self):
f = IsoDateTimeField()
d = f.strptime("2015-07-19T13:34:51.759+01:00",
IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
def test_datetime_non_iso_format(self):
f = IsoDateTimeField()
parsed = f.strptime('19-07-2015T51:34:13.759', '%d-%m-%YT%S:%M:%H.%f')
self.assertTrue(isinstance(parsed, datetime))
self.assertEqual(parsed, self.reference_dt)
class IsoDateTimeFieldTests(TestCase):
reference_str = "2015-07-19T13:34:51.759"
reference_dt = datetime(2015, 7, 19, 13, 34, 51, 759000)
field = IsoDateTimeField()
def parse_input(self, value):
return self.field.strptime(value, IsoDateTimeField.ISO_8601)
def test_datetime_string_is_parsed(self):
d = self.parse_input(self.reference_str)
self.assertTrue(isinstance(d, datetime))
def test_datetime_string_with_timezone_is_parsed(self):
d = self.parse_input(self.reference_str + "+01:00")
self.assertTrue(isinstance(d, datetime))
def test_datetime_zulu(self):
d = self.parse_input(self.reference_str + "Z")
self.assertTrue(isinstance(d, datetime))
@override_settings(TIME_ZONE='UTC')
def test_datetime_timezone_awareness(self):
utc, tokyo = pytz.timezone('UTC'), pytz.timezone('Asia/Tokyo')
# by default, use the server timezone
reference = utc.localize(self.reference_dt)
parsed = self.parse_input(self.reference_str)
self.assertIsInstance(parsed.tzinfo, tzinfo)
self.assertEqual(parsed, reference)
# if set, use the active timezone
reference = tokyo.localize(self.reference_dt)
with timezone.override(tokyo):
parsed = self.parse_input(self.reference_str)
self.assertIsInstance(parsed.tzinfo, tzinfo)
self.assertEqual(parsed.tzinfo.zone, tokyo.zone)
self.assertEqual(parsed, reference)
# if provided, utc offset should have precedence
reference = utc.localize(self.reference_dt - timedelta(hours=1))
parsed = self.parse_input(self.reference_str + "+01:00")
self.assertIsInstance(parsed.tzinfo, tzinfo)
self.assertEqual(parsed, reference)
@override_settings(USE_TZ=False)
def test_datetime_timezone_naivety(self):
reference = self.reference_dt.replace()
parsed = self.parse_input(self.reference_str + "+01:00")
self.assertIsNone(parsed.tzinfo)
self.assertEqual(parsed, reference - timedelta(hours=1))
parsed = self.parse_input(self.reference_str)
self.assertIsNone(parsed.tzinfo)
self.assertEqual(parsed, reference)
def test_datetime_non_iso_format(self):
f = IsoDateTimeField()
parsed = f.strptime('19-07-2015T51:34:13.759', '%d-%m-%YT%S:%M:%H.%f')
self.assertTrue(isinstance(parsed, datetime))
self.assertEqual(parsed, self.reference_dt)
def test_datetime_wrong_format(self):
with self.assertRaises(ValueError):
self.parse_input('19-07-2015T51:34:13.759')
def test_datetime_string_with_timezone_is_parsed(self):
f = IsoDateTimeField()
d = f.strptime("2015-07-19T13:34:51.759+01:00", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
class GpxFileForm(Form):
start_time = IsoDateTimeField(label='시작 시간')
end_time = IsoDateTimeField(label='끝 시간')
def __init__(self, *args, **kwargs):
fields = (IsoDateTimeField(), IsoDateTimeField())
super(IsoDateTimeRangeField, self).__init__(fields, *args, **kwargs)
def test_datetime_zulu(self):
f = IsoDateTimeField()
d = f.strptime(self.reference_str + "Z", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
def test_datetime_string_with_timezone_is_parsed(self):
f = IsoDateTimeField()
d = f.strptime(self.reference_str + "+01:00", IsoDateTimeField.ISO_8601)
self.assertTrue(isinstance(d, datetime))
