def threadProcessNumeroSorteo():
threading.Timer(60.0, threadProcessNumeroSorteo).start()
d = datetime.now()
print('Process run numero % s ' % d)
if 8 < d.hour < 19:
try:
if d.time().minute >= 55:
hora = time(d.hour + 1, 0, 0)
else:
hora = time(d.hour, d.minute + 5, 0)
init = time(7, 0, 0)
end = time(d.hour, d.minute, d.second)
sorteo = Sorteo.objects.get(fecha_sorteo=d.date(),
sorteoHoras__hora_sorteo=hora)
ventas = Venta.objects.filter(fecha=d.date(),
time__gte=init,
time__lte=end)
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
estado_sistema.estado = False
estado_sistema.save()
n = 0
if sorteo.numero_ganador == 0:
if len(ventas) != 0:
detalles = lista_ventas(ventas, sorteo)
list_elements = lista_items(detalles)
rifa_detalles = RifaLista.objects.filter(
rifa__id=sorteo.rifa.id)
valores = []
for item in rifa_detalles:
sum_val = 0
for element in list_elements:
if item.id == element.detalle_rifa.id:
sum_val = sum_val + element.valor_apuesta
valores.append((int(item.id), int(sum_val)))
min_val_tuple = minVal(valores)
win = RifaLista.objects.get(id=min_val_tuple[0])
n = win.posicion
print('numero ganador con items en venta %s' % n)
else:
n = random.randint(1, 36)
print('numero ganado sin items en venta %s' % n)
sorteo.numero_ganador = n
sorteo.save()
jugadasGanadoras(ventas, sorteo)
else:
print('este sorteo ya se jugó')
except Exception as e:
print(e)
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
estado_sistema.estado = True
estado_sistema.save()
else:
print(d)
def test_safe_strftime(self):
self.assertEqual(
date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'),
'1899-12-31 (weekday 0)')
self.assertEqual(
date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'),
'1900-01-01 (weekday 1)')
self.assertEqual(
datetime(
*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'1899-12-31 23:59:59 (weekday 0)')
self.assertEqual(
datetime(
*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'1900-01-01 00:00:00 (weekday 1)')
self.assertEqual(
time(*self.just_time).strftime('%H:%M:%S AM'), '11:30:59 AM')
# %y will error before this date
self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
self.assertEqual(
date(1850, 8, 2).strftime("%Y/%m/%d was a %A"),
'1850/08/02 was a Friday')
def test_combined_times_all_from_line2(self):
date = timezone.now().replace(hour=17, minute=1)
day = dayname(date)
self.station1.register_daily_times([day], [time(11, 1), time(11, 11), time(11, 21), time(11, 31)])
self.station2.register_daily_times([day], [time(17, 6), time(17, 26), time(17, 46), time(18, 6)])
times = self._linetimes(self.location.next_daily_times(date))
expected = [
(self.line2, time(17, 6)),
(self.line2, time(17, 26)),
(self.line2, time(17, 46)),
(self.line2, time(18, 6)),
]
self.assertEquals(expected, times)
def test_safe_strftime(self):
self.assertEqual(
date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'),
'0999-12-31 (weekday 2)')
self.assertEqual(
date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'),
'1000-01-01 (weekday 3)')
self.assertEqual(
datetime(
*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'0999-12-31 23:59:59 (weekday 2)')
self.assertEqual(
datetime(
*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'),
'1000-01-01 00:00:00 (weekday 3)')
self.assertEqual(
time(*self.just_time).strftime('%H:%M:%S AM'), '11:30:59 AM')
# %y will error before this date
self.assertEqual(date(*self.percent_y_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.percent_y_safe).strftime('%y'), '00')
with self.assertRaisesMessage(
TypeError, 'strftime of dates before 1000 does not handle %y'):
datetime(*self.just_unsafe).strftime('%y')
self.assertEqual(
date(1850, 8, 2).strftime("%Y/%m/%d was a %A"),
'1850/08/02 was a Friday')
def test_serialize_datetime_safe(self):
self.assertSerializedResultEqual(datetime_safe.date(
2014, 3, 31), ("datetime.date(2014, 3, 31)", {'import datetime'}))
self.assertSerializedResultEqual(datetime_safe.time(
10, 25), ("datetime.time(10, 25)", {'import datetime'}))
self.assertSerializedResultEqual(
datetime_safe.datetime(2014, 3, 31, 16, 4, 31),
("datetime.datetime(2014, 3, 31, 16, 4, 31)", {'import datetime'}))
def test_serialize_datetime_safe(self):
self.assertSerializedResultEqual(
datetime_safe.date(2014, 3, 31), ("datetime.date(2014, 3, 31)", {"import datetime"})
)
self.assertSerializedResultEqual(datetime_safe.time(10, 25), ("datetime.time(10, 25)", {"import datetime"}))
self.assertSerializedResultEqual(
datetime_safe.datetime(2014, 3, 31, 16, 4, 31),
("datetime.datetime(2014, 3, 31, 16, 4, 31)", {"import datetime"}),
)
def test_compare_datetimes(self):
self.assertEqual(original_datetime(*self.more_recent), datetime(*self.more_recent))
self.assertEqual(original_datetime(*self.really_old), datetime(*self.really_old))
self.assertEqual(original_date(*self.more_recent), date(*self.more_recent))
self.assertEqual(original_date(*self.really_old), date(*self.really_old))
self.assertEqual(original_date(*self.just_safe).strftime('%Y-%m-%d'), date(*self.just_safe).strftime('%Y-%m-%d'))
self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d'))
self.assertEqual(original_time(*self.just_time).strftime('%H:%M:%S'), time(*self.just_time).strftime('%H:%M:%S'))
def test_combined_times_all_from_line1(self):
date = timezone.now().date()
day = dayname(date)
other_date = date + timedelta(days=1)
other_day = dayname(other_date)
self.station1.register_daily_times([day], [time(17, 1), time(17, 11), time(17, 21), time(17, 31)])
self.station2.register_daily_times([other_day], [time(17, 6), time(17, 26), time(17, 46), time(18, 6)])
times = self._linetimes(self.location.next_daily_times(date))
expected = [
(self.line1, time(17, 1)),
(self.line1, time(17, 11)),
(self.line1, time(17, 21)),
(self.line1, time(17, 31)),
]
self.assertEquals(expected, times)
def test_safe_strftime(self):
self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)')
self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)')
self.assertEqual(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)')
self.assertEqual(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)')
self.assertEqual(time(*self.just_time).strftime('%H:%M:%S AM'), '11:30:59 AM')
# %y will error before this date
self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
def test_compare_datetimes(self):
self.assertEqual(original_datetime(*self.more_recent), datetime(*self.more_recent))
self.assertEqual(original_datetime(*self.really_old), datetime(*self.really_old))
self.assertEqual(original_date(*self.more_recent), date(*self.more_recent))
self.assertEqual(original_date(*self.really_old), date(*self.really_old))
self.assertEqual(
original_date(*self.just_safe).strftime('%Y-%m-%d'), date(*self.just_safe).strftime('%Y-%m-%d')
)
self.assertEqual(
original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d')
)
self.assertEqual(
original_time(*self.just_time).strftime('%H:%M:%S'), time(*self.just_time).strftime('%H:%M:%S')
)
def setUp(self):
self.professional = User.objects.get(pk=3)
self.final = User.objects.get(pk=4)
self.hire_service_1 = HireService.objects.create(
client=self.final,
professional=self.professional,
date=datetime.now() + timedelta(days=2),
time=time(),
address='address',
city='city',
region='region',
zip_code='zip_code',
country='country',
status=PENDING)
self.hire_service_1.total = Money(100, 'EUR')
self.hire_service_1.save()
self.hire_service_2 = HireService.objects.create(
client=self.final,
professional=self.professional,
date=datetime.now() + timedelta(hours=13),
time=datetime.now() + timedelta(hours=13),
address='address',
city='city',
region='region',
zip_code='zip_code',
country='country',
status=PENDING)
self.hire_service_2.total = Money(200, 'EUR')
self.hire_service_2.save()
self.hire_service_3 = HireService.objects.create(
client=self.final,
professional=self.professional,
date=datetime.now() + timedelta(hours=11),
time=datetime.now() + timedelta(hours=11),
address='address',
city='city',
region='region',
zip_code='zip_code',
country='country',
status=PENDING)
self.hire_service_3.total = Money(300, 'EUR')
self.hire_service_3.save()
def test_safe_strftime(self):
self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '0999-12-31 (weekday 2)')
self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1000-01-01 (weekday 3)')
self.assertEqual(
datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '0999-12-31 23:59:59 (weekday 2)'
)
self.assertEqual(
datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1000-01-01 00:00:00 (weekday 3)'
)
self.assertEqual(time(*self.just_time).strftime('%H:%M:%S AM'), '11:30:59 AM')
# %y will error before this date
self.assertEqual(date(*self.percent_y_safe).strftime('%y'), '00')
self.assertEqual(datetime(*self.percent_y_safe).strftime('%y'), '00')
with self.assertRaisesMessage(TypeError, 'strftime of dates before 1000 does not handle %y'):
datetime(*self.just_unsafe).strftime('%y')
self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
def tiketsGanadores(ventas, sorteo):
d = datetime.now()
hora = time(d.hour, d.minute + 5, 0)
for v in ventas:
sum_ganadores = 0
sum_items = 0
ventasDetalles = VentaDetalle.objects.filter(venta=v)
for item in ventasDetalles:
if item.sorteo == sorteo:
sum_items += 1
if item.estado == 'GANADO':
sum_ganadores += 1
if len(ventasDetalles) == sum_items:
if sum_ganadores > 0:
v.estado = 'GANADO'
elif sum_ganadores == 0:
v.estado = 'PERDIDO'
v.save()
else:
print('Todavia hay items en juegos %s' % v.id)
class TestMemModel(MemModel):
pkey = models.IntegerField(primary_key=True)
title = models.CharField(max_length=50, verbose_name='Title')
content = models.TextField(blank=True, null=True)
floatval = models.FloatField()
urlval = models.URLField()
boolval = models.BooleanField(default=False)
bintval = models.BigIntegerField(verbose_name='BigIntegerField')
dateval = models.DateField(default=datetime.today)
dtval = models.DateTimeField(default=timezone.now)
timeval = models.TimeField(default=time(16, 0))
emailval = models.EmailField()
pintval = models.PositiveIntegerField(default=200)
psintval = models.PositiveSmallIntegerField()
sintval = models.SmallIntegerField()
uuidval = models.UUIDField(default=uuid.uuid4)
def __str__(self):
result = []
for field in self._meta.local_fields:
result.append('%s(%s)' % (field.name, getattr(self, field.name)))
return ', '.join(result)
def test_time_gte_last_for_last(self):
times = [time(0, 0), time(5, 5), time(7, 7)]
self.assertEquals(times[-1:], times_gte(times, times[-1]))
def display_date(date, format='%Y-%m-%d'):
return display_time(make_aware(datetime.combine(date, time())), format)
def test_serialize(self):
"""
Tests various different forms of the serializer.
This does not care about formatting, just that the parsed result is
correct, so we always exec() the result and check that.
"""
# Basic values
self.assertSerializedEqual(1)
self.assertSerializedEqual(1.2)
self.assertTrue(math.isinf(self.serialize_round_trip(float("inf"))))
self.assertTrue(math.isinf(self.serialize_round_trip(float("-inf"))))
self.assertTrue(math.isnan(self.serialize_round_trip(float("nan"))))
self.assertSerializedEqual(None)
self.assertSerializedEqual(b"foobar")
string, imports = MigrationWriter.serialize(b"foobar")
self.assertEqual(string, "b'foobar'")
self.assertSerializedEqual("föobár")
string, imports = MigrationWriter.serialize("foobar")
self.assertEqual(string, "'foobar'")
self.assertSerializedEqual({1: 2})
self.assertSerializedEqual(["a", 2, True, None])
self.assertSerializedEqual({2, 3, "eighty"})
self.assertSerializedEqual({"lalalala": ["yeah", "no", "maybe"]})
self.assertSerializedEqual(_('Hello'))
# Builtins
self.assertSerializedEqual([list, tuple, dict, set])
string, imports = MigrationWriter.serialize([list, tuple, dict, set])
self.assertEqual(string, "[list, tuple, dict, set]")
self.assertEqual(imports, set())
# Functions
with six.assertRaisesRegex(self, ValueError,
'Cannot serialize function: lambda'):
self.assertSerializedEqual(lambda x: 42)
self.assertSerializedEqual(models.SET_NULL)
string, imports = MigrationWriter.serialize(models.SET(42))
self.assertEqual(string, 'models.SET(42)')
self.serialize_round_trip(models.SET(42))
# Datetime stuff
self.assertSerializedEqual(datetime.datetime.utcnow())
self.assertSerializedEqual(datetime.datetime.utcnow)
self.assertSerializedEqual(datetime.datetime.today())
self.assertSerializedEqual(datetime.datetime.today)
self.assertSerializedEqual(datetime.date.today())
self.assertSerializedEqual(datetime.date.today)
self.assertSerializedEqual(datetime.datetime.now().time())
self.assertSerializedEqual(
datetime.datetime(2014, 1, 1, 1, 1, tzinfo=get_default_timezone()))
self.assertSerializedEqual(
datetime.datetime(2014, 1, 1, 1, 1, tzinfo=FixedOffset(180)))
safe_date = datetime_safe.date(2014, 3, 31)
string, imports = MigrationWriter.serialize(safe_date)
self.assertEqual(string, repr(datetime.date(2014, 3, 31)))
self.assertEqual(imports, {'import datetime'})
safe_time = datetime_safe.time(10, 25)
string, imports = MigrationWriter.serialize(safe_time)
self.assertEqual(string, repr(datetime.time(10, 25)))
self.assertEqual(imports, {'import datetime'})
safe_datetime = datetime_safe.datetime(2014, 3, 31, 16, 4, 31)
string, imports = MigrationWriter.serialize(safe_datetime)
self.assertEqual(string,
repr(datetime.datetime(2014, 3, 31, 16, 4, 31)))
self.assertEqual(imports, {'import datetime'})
timezone_aware_datetime = datetime.datetime(2012,
1,
1,
1,
1,
tzinfo=utc)
string, imports = MigrationWriter.serialize(timezone_aware_datetime)
self.assertEqual(string,
"datetime.datetime(2012, 1, 1, 1, 1, tzinfo=utc)")
self.assertEqual(
imports,
{'import datetime', 'from django.utils.timezone import utc'})
# Django fields
self.assertSerializedFieldEqual(models.CharField(max_length=255))
self.assertSerializedFieldEqual(models.TextField(null=True,
blank=True))
# Setting references
self.assertSerializedEqual(
SettingsReference(settings.AUTH_USER_MODEL, "AUTH_USER_MODEL"))
self.assertSerializedResultEqual(
SettingsReference("someapp.model", "AUTH_USER_MODEL"), (
"settings.AUTH_USER_MODEL",
{"from django.conf import settings"},
))
self.assertSerializedResultEqual(((x, x * x) for x in range(3)), (
"((0, 0), (1, 1), (2, 4))",
set(),
))
def set_number_sorteo():
d = datetime.now()
print('sorteo en proceso %s ' % d)
if 7 < d.hour < 23:
try:
if d.minute >= 55:
hora = time(d.hour + 1, 0, 0)
else:
hora = time(d.hour, d.minute + 5, 0)
# CronTabLog.objects.create(hora=d.time(), descripcion=hora)
# init = time(7, 0, 0)
# end = time(d.hour, d.minute, d.second)
# n = 0
sorteo = Sorteo.objects.get(fecha_sorteo=d.date(), sorteoHoras__hora_sorteo=hora)
ventas = Venta.objects.filter(fecha=d.date(), estado='EN JUEGO')
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
estado_sistema.estado = False
estado_sistema.save()
if sorteo.numero_ganador == 0:
if len(ventas) != 0:
first_day = datetime.now().replace(day=1)
now = datetime.now()
total_venta_value = 0
total_ganancia_value = 0
total_venta = Venta.objects.filter(fecha__gte=first_day, fecha__lte=now)
for v in total_venta:
total_venta_value += v.total_apostado
if v.estado == 'GANADO' or v.estado == 'PAGADO':
total_ganancia_value += v.total_ganancia
# apuesta_unica = False
total_ganancia = total_venta_value - total_ganancia_value
porcentaje_ganancias = float(total_ganancia_value) / float(total_venta_value)
detalles = lista_ventas(ventas, sorteo)
list_elements = lista_items(detalles)
dict_valores = get_values_bet(list_elements)
direct_values = get_direct_bets(list_elements)
direct_values_no_bet = get_direct_no_bet(list_elements)
list_directs = get_directs_list(list_elements)
min_val_tuple = min_val(dict_valores)
n = get_number_winner(min_val_tuple, direct_values, list_directs, direct_values_no_bet,
total_ganancia, porcentaje_ganancias)
CronTabLog.objects.create(hora=d.time(), descripcion='numero ganador con items en venta %s' % n)
else:
n = random.randint(1, 36)
# print(n)
CronTabLog.objects.create(hora=d.time(), descripcion='numero ganador sin items en venta %s' % n)
sorteo.numero_ganador = n
sorteo.save()
jugadas_ganadoras(ventas, sorteo)
tikets_ganadores(ventas, sorteo)
# new code
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
if estado_sistema.estado is not True:
estado_sistema.estado = True
estado_sistema.save()
# new code
else:
# CronTabLog.objects.create(hora=d.time(), descripcion='este sorteo ya se jugó')
# print('este sorteo ya se jugó')
# new code
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
if estado_sistema.estado is not True:
estado_sistema.estado = True
estado_sistema.save()
# new code
except Exception as e:
print (e.message)
CronTabLog.objects.create(hora=d.time(), descripcion=e.message)
estado_sistema = EstadoSistema.objects.get(nombre='activar venta')
if estado_sistema.estado is not True:
estado_sistema.estado = True
estado_sistema.save()
else:
print(d)
def test_serialize(self):
"""
Tests various different forms of the serializer.
This does not care about formatting, just that the parsed result is
correct, so we always exec() the result and check that.
"""
# Basic values
self.assertSerializedEqual(1)
self.assertSerializedEqual(1.2)
self.assertTrue(math.isinf(self.serialize_round_trip(float("inf"))))
self.assertTrue(math.isinf(self.serialize_round_trip(float("-inf"))))
self.assertTrue(math.isnan(self.serialize_round_trip(float("nan"))))
self.assertSerializedEqual(None)
self.assertSerializedEqual(b"foobar")
string, imports = MigrationWriter.serialize(b"foobar")
self.assertEqual(string, "b'foobar'")
self.assertSerializedEqual("föobár")
string, imports = MigrationWriter.serialize("foobar")
self.assertEqual(string, "'foobar'")
self.assertSerializedEqual({1: 2})
self.assertSerializedEqual(["a", 2, True, None])
self.assertSerializedEqual({2, 3, "eighty"})
self.assertSerializedEqual({"lalalala": ["yeah", "no", "maybe"]})
self.assertSerializedEqual(_('Hello'))
# Builtins
self.assertSerializedEqual([list, tuple, dict, set])
string, imports = MigrationWriter.serialize([list, tuple, dict, set])
self.assertEqual(string, "[list, tuple, dict, set]")
self.assertEqual(imports, set())
# Functions
with six.assertRaisesRegex(self, ValueError, 'Cannot serialize function: lambda'):
self.assertSerializedEqual(lambda x: 42)
self.assertSerializedEqual(models.SET_NULL)
string, imports = MigrationWriter.serialize(models.SET(42))
self.assertEqual(string, 'models.SET(42)')
self.serialize_round_trip(models.SET(42))
# Datetime stuff
self.assertSerializedEqual(datetime.datetime.utcnow())
self.assertSerializedEqual(datetime.datetime.utcnow)
self.assertSerializedEqual(datetime.datetime.today())
self.assertSerializedEqual(datetime.datetime.today)
self.assertSerializedEqual(datetime.date.today())
self.assertSerializedEqual(datetime.date.today)
self.assertSerializedEqual(datetime.datetime.now().time())
self.assertSerializedEqual(datetime.datetime(2014, 1, 1, 1, 1, tzinfo=get_default_timezone()))
self.assertSerializedEqual(datetime.datetime(2014, 1, 1, 1, 1, tzinfo=FixedOffset(180)))
safe_date = datetime_safe.date(2014, 3, 31)
string, imports = MigrationWriter.serialize(safe_date)
self.assertEqual(string, repr(datetime.date(2014, 3, 31)))
self.assertEqual(imports, {'import datetime'})
safe_time = datetime_safe.time(10, 25)
string, imports = MigrationWriter.serialize(safe_time)
self.assertEqual(string, repr(datetime.time(10, 25)))
self.assertEqual(imports, {'import datetime'})
safe_datetime = datetime_safe.datetime(2014, 3, 31, 16, 4, 31)
string, imports = MigrationWriter.serialize(safe_datetime)
self.assertEqual(string, repr(datetime.datetime(2014, 3, 31, 16, 4, 31)))
self.assertEqual(imports, {'import datetime'})
timezone_aware_datetime = datetime.datetime(2012, 1, 1, 1, 1, tzinfo=utc)
string, imports = MigrationWriter.serialize(timezone_aware_datetime)
self.assertEqual(string, "datetime.datetime(2012, 1, 1, 1, 1, tzinfo=utc)")
self.assertEqual(imports, {'import datetime', 'from django.utils.timezone import utc'})
# Django fields
self.assertSerializedFieldEqual(models.CharField(max_length=255))
self.assertSerializedFieldEqual(models.TextField(null=True, blank=True))
# Setting references
self.assertSerializedEqual(SettingsReference(settings.AUTH_USER_MODEL, "AUTH_USER_MODEL"))
self.assertSerializedResultEqual(
SettingsReference("someapp.model", "AUTH_USER_MODEL"),
(
"settings.AUTH_USER_MODEL",
{"from django.conf import settings"},
)
)
self.assertSerializedResultEqual(
((x, x * x) for x in range(3)),
(
"((0, 0), (1, 1), (2, 4))",
set(),
)
)
def test_time_gte_all_for_first(self):
times = [time(0, 0), time(5, 5), time(7, 7)]
self.assertEquals(times, times_gte(times, time.min))
def test_time_gte_some(self):
times = [time(0, 0), time(5, 5), time(7, 7)]
self.assertEquals(times[1:], times_gte(times, times[1]))
def test_time_gte_none_for_max(self):
times = [time(0, 0), time(5, 5), time(7, 7)]
self.assertEquals([], times_gte(times, time.max))
def sort_schichten_in_templates(self):
splitted_templates = []
templates = get_schicht_templates(asn=self.request.user.assistenznehmer, order_by='beginn')
# Todo Sub-Templates und verschobene Templates
for template in templates:
if template.beginn < template.ende:
splitted_templates.append(
{
'beginn': template.beginn,
'ende': template.ende
}
)
else:
splitted_templates.append(
{
'beginn': template.beginn,
'ende': time(0)
}
)
splitted_templates.append(
{
'beginn': time(0),
'ende': template.ende
}
)
splitted_templates = sorted(splitted_templates, key=lambda j: j['beginn'])
start = self.act_date
# schichtsammlung durch ergänzung von leeren Tagen zu Kalender konvertieren
end = shift_month(self.act_date, step=1)
monatsletzter = (end - timedelta(days=1)).day
schichten = get_sliced_schichten_by_asn(
start=self.act_date,
end=end,
asn=self.request.user.assistenznehmer
)
table_array = {}
for i in range(1, monatsletzter + 1):
datakey = datetime(year=self.act_date.year, month=self.act_date.month, day=i)
template_counter = 0
table_array[datakey] = {}
for template in splitted_templates:
temp_beginn = timezone.make_aware(datetime.combine(datakey, template['beginn']))
if template['ende'] == time(0):
temp_ende = timezone.make_aware(
datetime.combine(
datakey + timedelta(days=1),
template['ende']
)
)
else:
temp_ende = timezone.make_aware(datetime.combine(datakey, template['ende']))
table_array[datakey][template_counter] = []
schicht_counter = 0
for schicht in schichten:
# print(temp_beginn)
# print(schicht['beginn'])
# print(temp_ende)
# print(schicht['ende'])
# print('--------------------')
if schicht['beginn'] == temp_beginn and schicht['ende'] == temp_ende:
# Wenn sich mehrere Assistenten um die gleiche Schicht "bewerben",
# können mehrere Schichten im selben Template stehen
table_array[datakey][template_counter].append(schicht)
schichten.remove(schicht)
schicht_counter += 1
if schicht_counter == 0:
table_array[datakey][template_counter] = []
template_counter += 1
print(schichten)
print('---hurz-----')
return splitted_templates, table_array
