def razzia_wizard(request):
if request.method == 'POST':
return redirect(
reverse("razzia_view") + "?start={0}-{1}-{2}&end={3}-{4}-{5}&products={6}&username=&razzia_title={7}"
.format(int(request.POST['start_year']),
int(request.POST['start_month']),
int(request.POST['start_day']),
int(request.POST['end_year']), int(request.POST['end_month']),
int(request.POST['end_day']),
request.POST.get('products'),
request.POST.get('razzia_title')))
suggested_start_date = timezone.now() - datetime.timedelta(days=-180)
suggested_end_date = timezone.now()
start_date_picker = fields.DateField(
widget=extras.SelectDateWidget(years=[x for x in range(2000, timezone.now().year + 1)]))
end_date_picker = fields.DateField(
widget=extras.SelectDateWidget(years=[x for x in range(2000, timezone.now().year + 1)]))
return render(request, 'admin/stregsystem/razzia/wizard.html',
{
'start_date_picker': start_date_picker.widget.render("start", suggested_start_date),
'end_date_picker': end_date_picker.widget.render("end", suggested_end_date)},
)
python类datetime()的实例源码
def test_multibuy_hint_two_buys_applicable(self):
member = Member.objects.get(username="jokke")
coke = Product.objects.create(
name="coke",
price=100,
active=True
)
with freeze_time(timezone.datetime(2018, 1, 1)) as frozen_time:
for i in range(1, 3):
Sale.objects.create(
member=member,
product=coke,
price=100,
)
frozen_time.tick()
give_multibuy_hint, sale_hints = stregsystem_views._multibuy_hint(timezone.datetime(2018, 1, 1, tzinfo=pytz.UTC), member)
self.assertTrue(give_multibuy_hint)
self.assertEqual(sale_hints, "{} {}:{}".format("jokke", coke.id, 2))
def test_order_execute_single_no_remaining(self, fulfill):
self.product.sale_set.create(
price=100,
member=self.member
)
self.product.start_date = datetime.date(year=2017, month=1, day=1)
self.product.quantity = 1
order = Order(self.member, self.room)
item = OrderItem(self.product, order, 1)
order.items.add(item)
with self.assertRaises(NoMoreInventoryError):
order.execute()
fulfill.was_not_called()
def test_order_execute_multi_some_remaining(self, fulfill):
self.product.sale_set.create(
price=100,
member=self.member
)
self.product.start_date = datetime.date(year=2017, month=1, day=1)
self.product.quantity = 2
order = Order(self.member, self.room)
item = OrderItem(self.product, order, 2)
order.items.add(item)
with self.assertRaises(NoMoreInventoryError):
order.execute()
fulfill.was_not_called()
def test_invoice_get_rates_inconsistent_hourly_paidtask_rates(member):
PAID_TASK_RATE_ONE = 0.5
PAID_TASK_RATE_TWO = 0.2
month = timezone.datetime(2014, 04, 01)
paid_task_kwargs = {
'rate': PAID_TASK_RATE_ONE, # Note how this doesn't match user's rate
'datetime': month,
'user': member,
'task_type': PaidTaskTypes.HOURLY_WORK,
}
PaidTaskFactory(**paid_task_kwargs)
PaidTaskFactory(**dict(paid_task_kwargs, rate=PAID_TASK_RATE_TWO))
invoice = Invoice(member, FAKE_CONFIG, month=month)
with pytest.raises(ValueError) as e:
invoice.get_rates()
assert (
'Multiple HOURLY_WORK rate values for user %s' % (member.username)
in e.value.message
)
def _check_single_paidtask(invoice, amount):
local_now = timezone.localtime(invoice.now)
current_month_start = local_now.replace(day=1, hour=0, minute=0, second=0)
PaidTask.objects.get(
task_type=PaidTaskTypes.CORRECTION,
amount=(-1) * amount,
datetime=invoice.month_end,
description='Carryover to the next month',
user=invoice.user,
)
PaidTask.objects.get(
task_type=PaidTaskTypes.CORRECTION,
amount=amount,
datetime=current_month_start,
description='Carryover from the previous month',
user=invoice.user,
)
assert PaidTask.objects.filter(task_type=PaidTaskTypes.CORRECTION).count() == 2
def test_telescope_availability_spans_interval(self, mock_intervals):
mock_intervals.return_value = [(datetime(2016, 9, 30, 18, 30, 0, tzinfo=timezone.utc),
datetime(2016, 9, 30, 21, 0, 0, tzinfo=timezone.utc)),
(datetime(2016, 10, 1, 18, 30, 0, tzinfo=timezone.utc),
datetime(2016, 10, 1, 19, 0, 0, tzinfo=timezone.utc)),
(datetime(2016, 10, 1, 19, 10, 0, tzinfo=timezone.utc),
datetime(2016, 10, 1, 19, 20, 0, tzinfo=timezone.utc)),
(datetime(2016, 10, 2, 18, 30, 0, tzinfo=timezone.utc),
datetime(2016, 10, 2, 21, 0, 0, tzinfo=timezone.utc))]
start = datetime(2016, 9, 30, tzinfo=timezone.utc)
end = datetime(2016, 10, 2, tzinfo=timezone.utc)
telescope_availability = get_telescope_availability_per_day(start, end)
self.assertIn(self.tk1, telescope_availability)
self.assertIn(self.tk2, telescope_availability)
doma_available_time = (datetime(2016, 10, 1, 19, 0, 0) - datetime(2016, 10, 1, 18, 30, 0)).total_seconds()
doma_available_time += (datetime(2016, 10, 1, 19, 20, 0) - datetime(2016, 10, 1, 19, 10, 0)).total_seconds()
doma_total_time = doma_available_time
doma_expected_availability = doma_available_time / doma_total_time
self.assertAlmostEqual(doma_expected_availability, telescope_availability[self.tk1][0][1])
domb_expected_availability = 1.0
self.assertAlmostEqual(domb_expected_availability, telescope_availability[self.tk2][0][1])
def test_get_for_closing(self):
now = arrow.now().floor('day').to('UTC').datetime
event_before = Event()
event_before.begin = now - timezone.timedelta(days=3)
event_before.end = now - timezone.timedelta(days=4)
event_before.title = 'test_title_now'
event_before.status = 'open'
event_before.save()
event_after = copy.copy(event_before)
event_after.id = None
event_after.begin = now + timezone.timedelta(days=3)
event_after.end = now + timezone.timedelta(days=4)
event_after.save()
queryset = Event.objects.get_for_closing()
self.assertTrue(event_before in queryset)
self.assertTrue(event_after not in queryset)
self.assertEqual(queryset.count(), 2)
for event in queryset:
self.assertTrue(event.end < now)
self.assertTrue(event.paid >= event.total)
def test_calendar(self):
calendar = Calendar()
now = arrow.now().floor('day').to('UTC').datetime
week = now + timezone.timedelta(days=settings.EVENTS_CALENDAR_PERIOD)
self.assertEqual(now, calendar.begin)
self.assertEqual(week, calendar.end)
event = Event()
event.begin = now + timezone.timedelta(days=3)
event.end = now + timezone.timedelta(days=4)
event.title = 'test_title_now'
event.status = 'open'
event.save()
days = calendar.get_days()
self.assertEqual(settings.EVENTS_CALENDAR_PERIOD, len(days))
for element in days:
if event.begin <= element.date < event.end:
self.assertIn(event, element.events)
for hour in element.hours:
if event.begin <= hour.date < event.end:
self.assertIn(event, hour.events)
def get_channel_schedule(self, url):
"""Get movie schedule from CJ E&M channels."""
schedule = self.get_original_data(url).find('div', class_='scheduler')
date_text = schedule.find('em').text[:-4].strip()
date_split = date_text.split(".")
# If date is different from the day of argument, return None.
if "".join(date_split) != url[-8:]:
return None
schedule_date = timezone.datetime(int(date_split[0]), int(date_split[1]), int(date_split[2]))
schedule_table = schedule.find('tbody').find_all('tr')
if len(schedule_table) == 0:
# If no schedule exists
return None
return self.parse_daily_schedule(schedule_table, schedule_date)
def parse_daily_schedule(self, table, date):
"""Get daily schedule for t.cast channel."""
date_format = timezone.datetime.strftime(date, "%Y%m%d")
next_date = date + timezone.timedelta(days=1)
daily_schedule = []
# Get schedule
for hour in range(24):
date_hour_string = date_format + '{:02d}'.format(hour)
cell = table.find('td', id=date_hour_string)
if cell is None:
return None
schedules = cell.find_all('div', class_='con active')
for schedule in schedules:
if hour in range(self.start_hour):
# Next day's schedule.
daily_schedule.append(self.parse_schedule_item(schedule, next_date))
else:
daily_schedule.append(self.parse_schedule_item(schedule, date))
# Add to list
return daily_schedule
def test_should_notify_set(self):
""" Notifications: Test should_notify()'s output when service is set """
settings = NotificationSetting.get_solo()
settings.send_notification = True
settings.notification_service = NotificationSetting.NOTIFICATION_NMA
settings.save()
self.assertTrue(settings.send_notification)
# Should fail because we haven't set an API key
self.assertFalse(dsmr_notification.services.should_notify(settings))
settings.api_key = 'es7sh2d-DSMR-Reader-Rulez-iweu732'
settings.save()
self.assertTrue(dsmr_notification.services.should_notify(settings))
settings.next_notification = None
dsmr_notification.services.set_next_notification(
settings, timezone.make_aware(timezone.datetime(2116, 11, 16)))
self.assertFalse(dsmr_notification.services.should_notify(settings))
def test_set_next_notification_date(self, now_mock):
""" Notifications: Test if next notification date is set """
now_mock.return_value = timezone.make_aware(
timezone.datetime(2016, 11, 16))
now = timezone.localtime(timezone.now())
tomorrow = (timezone.localtime(timezone.now()) +
timezone.timedelta(hours=24)).date()
settings = NotificationSetting.get_solo()
settings.next_notification = now
settings.save()
dsmr_notification.services.set_next_notification(settings, now)
self.assertEqual(settings.next_notification, tomorrow)
def test_notification_api_fail(self, now_mock, requests_post_mock):
""" Notifications: Test API failure for notify() """
now_mock.return_value = timezone.make_aware(
timezone.datetime(2016, 11, 17, hour=0, minute=5))
requests_post_mock.return_value = mock.MagicMock(
status_code=403, text='Forbidden')
settings = NotificationSetting.get_solo()
settings.send_notification = True
settings.notification_service = NotificationSetting.NOTIFICATION_NMA
settings.api_key = 'es7sh2d-DSMR-Reader-Rulez-iweu732'
settings.next_notification = timezone.localtime(timezone.now())
settings.save()
if self.fixtures:
with self.assertRaises(AssertionError):
dsmr_notification.services.notify()
else:
# When having no data, this should NOT raise an exception.
return dsmr_notification.services.notify()
with self.assertRaisesMessage(
AssertionError, 'Notify API call failed: Forbidden (HTTP403)'):
dsmr_notification.services.notify()
def test_grouping(self, now_mock):
""" Test grouping per minute, instead of the default 10-second interval. """
now_mock.return_value = timezone.make_aware(
timezone.datetime(2015, 11, 10, hour=21)
)
# Make sure to verify the blocking of read ahead.
dr = DsmrReading.objects.get(pk=3)
dr.timestamp = timezone.now()
dr.save()
dsmr_consumption.services.compact_all()
self.assertEqual(DsmrReading.objects.unprocessed().count(), 1)
self.assertTrue(DsmrReading.objects.unprocessed().exists())
self.assertEqual(ElectricityConsumption.objects.count(), 1)
if self.support_gas_readings:
self.assertEqual(GasConsumption.objects.count(), 1)
else:
self.assertEqual(GasConsumption.objects.count(), 0)
def test_reading_values(self, now_mock):
""" Test whether dsmr_datalogger reads the correct values. """
now_mock.return_value = timezone.make_aware(timezone.datetime(2017, 2, 1, hour=0, minute=0, second=0))
self._fake_dsmr_reading()
self.assertTrue(DsmrReading.objects.exists())
reading = DsmrReading.objects.get()
self.assertEqual(
reading.timestamp,
timezone.datetime(2017, 1, 10, 19, 40, 57, tzinfo=pytz.UTC)
)
self.assertEqual(reading.electricity_delivered_1, Decimal('9012.345'))
self.assertEqual(reading.electricity_returned_1, Decimal('9123.456'))
self.assertEqual(reading.electricity_delivered_2, Decimal('9067.890'))
self.assertEqual(reading.electricity_returned_2, Decimal('9789.012'))
self.assertEqual(reading.electricity_currently_delivered, Decimal('0.320'))
self.assertEqual(reading.electricity_currently_returned, Decimal('0'))
self.assertEqual(
reading.extra_device_timestamp,
timezone.datetime(2017, 1, 10, 19, 40, 9, tzinfo=pytz.UTC)
)
self.assertEqual(reading.extra_device_delivered, Decimal('123.456'))
def reading_timestamp_to_datetime(string):
"""
Converts a string containing a timestamp to a timezone aware datetime.
"""
timestamp = re.search(r'(\d{2,2})(\d{2,2})(\d{2,2})(\d{2,2})(\d{2,2})(\d{2,2})([WS])+', string)
meter_timestamp = timezone.datetime(
year=2000 + int(timestamp.group(1)),
month=int(timestamp.group(2)),
day=int(timestamp.group(3)),
hour=int(timestamp.group(4)),
minute=int(timestamp.group(5)),
second=int(timestamp.group(6)),
)
is_dst = timestamp.group(7) == 'S'
local_timezone = pytz.timezone(settings.TIME_ZONE)
return local_timezone.localize(meter_timestamp, is_dst=is_dst).astimezone(pytz.utc)
def count_active_days(enable_date, disable_date):
"""Return the number of days the segment has been active.
:param enable_date: The date the segment was enabled
:type enable_date: timezone.datetime
:param disable_date: The date the segment was disabled
:type disable_date: timezone.datetime
:returns: The amount of days a segment is/has been active
:rtype: int
"""
if enable_date is not None:
if disable_date is None or disable_date <= enable_date:
# There is no disable date, or it is not relevant.
delta = timezone.now() - enable_date
return delta.days
if disable_date > enable_date:
# There is a disable date and it is relevant.
delta = disable_date - enable_date
return delta.days
return 0
def print_counter(self, user):
obj = PrintCounterDocumentAlbaran()
obj.albaran = self
obj.user = user
obj.date = datetime.datetime.now()
if self.lock:
obj.status_document = STATUS_PRINTER_DOCUMENT_DEFINITVE
else:
obj.status_document = STATUS_PRINTER_DOCUMENT_TEMPORARY
obj.save()
return PrintCounterDocumentAlbaran.objects.filter(
status_document=STATUS_PRINTER_DOCUMENT_DEFINITVE,
albaran=self
).count()
# lineas de albaranes
def setUp(self):
self.room = Room.objects.create(
name="test"
)
self.jokke = Member.objects.create(
username="jokke"
)
self.coke = Product.objects.create(
name="coke",
price=100,
active=True
)
self.flan = Product.objects.create(
name="flan",
price=200,
active=True
)
self.sales = []
with freeze_time(timezone.datetime(2000, 1, 1)) as frozen_time:
for i in range(1, 4):
self.sales.append(
Sale.objects.create(
member=self.jokke,
product=self.coke,
price=100,
)
)
frozen_time.tick()
self.payments = []
with freeze_time(timezone.datetime(2000, 1, 1)) as frozen_time:
for i in range(1, 3):
self.payments.append(
Payment.objects.create(
member=self.jokke,
amount=100,
)
)
frozen_time.tick()
def test_is_active_active_not_expired(self):
product = Product.objects.create(
active=True,
price=100,
deactivate_date=(timezone.now()
+ datetime.timedelta(hours=1))
)
self.assertTrue(product.is_active())
def test_is_active_active_out_of_stock(self):
product = Product.objects.create(
active=True,
price=100,
quantity=1,
start_date=datetime.date(year=2017, month=1, day=1)
)
product.sale_set.create(
price=100,
member=self.jeff
)
self.assertFalse(product.is_active())
def test_is_active_active_in_stock(self):
product = Product.objects.create(
active=True,
price=100,
quantity=2,
start_date=datetime.date(year=2017, month=1, day=1)
)
product.sale_set.create(
price=100,
member=self.jeff
)
self.assertTrue(product.is_active())
def test_is_active_deactive_expired(self):
product = Product.objects.create(
active=False,
price=100,
deactivate_date=(timezone.now()
- datetime.timedelta(hours=1))
)
self.assertFalse(product.is_active())
def test_is_active_deactive_out_of_stock(self):
product = Product.objects.create(
active=False,
price=100,
quantity=1,
start_date=datetime.date(year=2017, month=12, day=1)
)
product.sale_set.create(
price=100,
member=self.jeff
)
self.assertFalse(product.is_active())
def test_is_active_deactive_in_stock(self):
product = Product.objects.create(
active=False,
price=100,
quantity=2,
start_date=datetime.date(year=2017, month=12, day=1)
)
product.sale_set.create(
price=100,
member=self.jeff
)
self.assertFalse(product.is_active())
def test_promille_staggered_female(self):
user = Member.objects.create(username="test", gender='F')
# (330 ml * 4.6%) = 15.18
alcoholic_drink = (
Product.objects.create(
name="øl",
price=2.0,
alcohol_content_ml=15.18,
active=True))
with freeze_time(timezone.datetime(year=2000, month=1, day=1, hour=0,
minute=0)) as ft:
for i in range(5):
ft.tick(delta=datetime.timedelta(minutes=10))
user.sale_set.create(
product=alcoholic_drink,
price=alcoholic_drink.price)
# The last drink was at 2000/01/01 00:50:00
with freeze_time(timezone.datetime(year=2000, month=1, day=1, hour=0,
minute=50)) as ft:
self.assertAlmostEqual(
1.15,
user.calculate_alcohol_promille(),
places=2
)
def test_sales_to_user_in_period(self):
res = views._sales_to_user_in_period(
self.alan.username,
timezone.datetime(2017, 2, 1, 0, 0, tzinfo=pytz.UTC),
timezone.datetime(2017, 2, 17, 0, 0, tzinfo=pytz.UTC),
[self.flan.id, self.flanmad.id],
{self.flan.name: 0, self.flanmad.name: 0},
)
self.assertEqual(2, res[self.flan.name])
self.assertEqual(1, res[self.flanmad.name])
def test_sales_to_user_no_results_out_of_period(self):
res = views._sales_to_user_in_period(
self.bob.username,
timezone.datetime(2017, 2, 1, 0, 0, tzinfo=pytz.UTC),
timezone.datetime(2017, 2, 17, 0, 0, tzinfo=pytz.UTC),
[self.flan.id, self.flanmad.id],
{self.flan.name: 0, self.flanmad.name: 0},
)
self.assertEqual(0, res[self.flan.name])
self.assertEqual(0, res[self.flanmad.name])
def fjule_party(year):
first_december = timezone.datetime(
year,
12,
1,
22,
tzinfo=pytz.timezone("Europe/Copenhagen")
)
days_to_add = (11 - first_december.weekday()) % 7
return first_december + datetime.timedelta(days=days_to_add)
