def diaaberto_list(request):
d = DiaAberto.objects.all() # list of objects
dia = DiaAberto.objects.order_by('-ano').annotate(
hora_inicio=Value(datetime.time(23, 59), TimeField()),
hora_fim=Value(datetime.time(23, 59), TimeField()))
hora_inicio = Horario.objects.all()[0]
hora_fim = Horario.objects.all().order_by('-pk')[0]
horarios = HorarioHasDia.objects.all()
for de in dia:
de.hora_inicio = Horario.objects.all()[0].pk
de.hora_fim = Horario.objects.all().order_by('-pk')[0].pk
for horario in horarios:
if horario.dia_dia.pk.year == de.ano:
if horario.horario_hora.pk < de.hora_inicio:
de.hora_inicio = HorarioHasDia.objects.filter(
dia_dia=horario.dia_dia)[0].horario_hora.pk
if horario.horario_hora.pk > de.hora_fim:
de.hora_fim = HorarioHasDia.objects.filter(
dia_dia=horario.dia_dia).reverse()[0].horario_hora.pk
context = {
"diaaberto_list": dia,
"d": d,
'i': len(noti_not_checked(request)),
'not_checked': noti_not_checked(request)
}
return render(request, "DiaAberto/diaaberto_list.html", context)
class Queue(Model):
maxLength = IntegerField(null=True, blank=True, default=200)
isEmpty = BooleanField(default=True)
isFull = BooleanField(default=False)
size = IntegerField(null=True, blank=True)
# startTime = TimeField(auto_now_add=True)
startTime = TimeField(null=True, blank=True)
avgTime = TimeField(null=True, blank=True)
endTime = TimeField(null=True, blank=True)
subject = CharField(max_length=100, null=True)
lock = BooleanField(default=False)
flag = IntegerField(default=0)
created_at = DateTimeField(auto_now_add=True)
updated_at = DateTimeField(auto_now=True)
queueItems = ListCharField(
base_field=CharField(max_length=11),
size=100,
max_length=100 * 12,
null=True,
blank=True
)
location = OneToOneField(Location, on_delete=CASCADE, related_name="queue_location", null=True)
def __str__(self):
return "{} - {} items".format(self.subject, len(self.queueItems))
class ChitBatch(Model):
name = CharField(max_length=25, unique=True, blank=False)
members = ManyToManyField(Member)
no_of_members = SmallIntegerField(blank=False, default=0)
principal = IntegerField(blank=False)
commission_percent = IntegerField(default=5, blank=False)
balance = IntegerField(blank=False, default=0)
shortage = IntegerField(blank=False, default=0)
period = SmallIntegerField(blank=False)
dues = SmallIntegerField(blank=False)
start_date = DateField(blank=False)
start_time = TimeField(blank=False)
is_active = BooleanField(default=True)
end_date = TimeField(blank=True, null=True)
created_on = DateTimeField(auto_now_add=True)
@property
def commission(self):
return (self.principal * self.commission_percent) / 100
@property
def auction_amt(self):
return (self.principal - self.get_commission()) + self.balance
@property
def last_auction_date(self):
if self.next_auction != self.start_date:
return self.next_auction - relativedelta(months=+1)
def max_shortage(self, bid_amount):
possible_balance = self.balance + bid_amount - self.get_commission()
return (self.principal - bid_amount) - (possible_balance)
def update_balance(self, bid_amt):
self.balance = self.balance + bid_amt - self.get_commission()
def update_payment_record(self):
if self.next_auction:
if not self.is_multiple_auction:
paid = PaymentRecordEnum.UN_PAID
else:
paid = PaymentRecordEnum.CHIT_BENIFIT
prs = []
for member in self.members.all():
prs.append(
PaymentRecord(
chitbatch=self,
member=member,
bid_date=self.next_auction,
paid=paid,
))
PaymentRecord.objects.bulk_create(prs)
def is_another_auction_possible(self, bid_amount):
latest_balance = self.balance + (bid_amount - self.get_commission())
if (latest_balance - bid_amount) > (0.06 * self.principal):
return True
return False
class EquipementProblemsTable(Model):
report_id = IntegerField()
start_date = DateField()
start_time = TimeField()
end_date = DateField()
end_time = DateField()
status = BooleanField()
OPERATIONAL_STATUS_CHOICES = (
('OOS', 'Out of Service'),
('NM', 'Needs Maintenance'),
)
Operational_Status = CharField(max_length=120,
choices=OPERATIONAL_STATUS_CHOICES)
Description = TextField()
NotifOutside_Support = TextField()
System_Staff_Action = TextField()
Website_CCTV_Off_date = DateField()
Website_CCTV_On_date = DateField()
Website_CCTV_Off_time = TimeField()
Website_CCTV_Off_time = TimeField()
NITTEC_Employee = OneToOneField(NITTECEmployee,
null=True,
on_delete=models.SET_NULL)
Reporting_Name = OneToOneField(ReportingName,
null=True,
on_delete=models.SET_NULL)
Reporting_Member_Agency = OneToOneField(ReportingMemberAgency,
null=True,
on_delete=models.SET_NULL)
Phone_number = OneToOneField(PhoneNumber,
null=True,
on_delete=models.SET_NULL)
Ticket_number = OneToOneField(TicketNumber,
null=True,
on_delete=models.SET_NULL)
Equipement_name = OneToOneField(EquipementName,
null=True,
on_delete=models.SET_NULL)
Affected_system = OneToOneField(EquipementSystem,
null=True,
on_delete=models.SET_NULL)
Problem_type = OneToOneField(ProblemType,
null=True,
on_delete=models.SET_NULL)
Owning_agency = OneToOneField(OwningAgency,
null=True,
on_delete=models.SET_NULL)
Outside_support = OneToOneField(OutsideSupport,
null=True,
on_delete=models.SET_NULL)
def time( *args, **kwargs ): meta = _kwargs_( kwargs ) meta['type'] = 'time' field = TimeField( *args, **kwargs ) field.meta = meta return field
class TimeSlot(Model):
TimeSlotFr = TimeField(
blank=True,
null=True,
)
TimeSlotTo = TimeField(
blank=True,
null=True,
)
def __str__(self):
return self.TimeSlotFr.strftime('%H:%M %p')
class LocationHours(Model):
location = ForeignKey(Location, null=True, on_delete=CASCADE)
day_of_week = CharField(max_length=10,
choices=SQUARE_WEEKDAYS,
default=DAY_MONDAY)
start_local_time = TimeField(default=datetime.time(hour=9, minute=0))
end_local_time = TimeField(default=datetime.time(hour=5, minute=0))
def as_dict(self):
return dict(day_of_week=self.day_of_week,
start_local_time=self.start_local_time,
end_local_time=self.end_local_time)
class Stoptime(models.Model):
"""
Modelo para os horários dos transportes públicos em Portugal
Equivale ao stop_times.txt num feed GTFS
"""
trip = ForeignKey(Trip, models.DO_NOTHING, related_name='stoptimes')
stop = ForeignKey(Stop, models.DO_NOTHING, related_name='stoptimes')
stop_sequence = PositiveIntegerField(default=1)
arrival_time = TimeField()
departure_time = TimeField()
class Restaurant(Model):
name = CharField(max_length=64)
description = TextField(max_length=256)
lunch_start = TimeField('Lunch Start')
lunch_end = TimeField('Lunch End')
image = ImageField(null=True, blank=True)
location = ForeignKey(Location, on_delete=CASCADE, null=True, blank=True)
def __str__(self):
return self.name
class User(AbstractUser):
name = CharField(_("Name of User"), blank=True, max_length=255)
available_from = TimeField(null=True, blank=True)
available_to = TimeField(null=True, blank=True)
facebook_id = BigIntegerField(null=True, blank=True)
facebook_username = CharField(max_length=32, null=True, blank=True)
facebook_link = CharField(max_length=256, null=True, blank=True)
interests = TextField(null=True, blank=True)
def get_absolute_url(self):
return reverse("users:detail", kwargs={"username": self.username})
class Event(Action):
"""
## Event model
This object represents an event.
"""
location = CharField(
verbose_name=_("location"),
max_length=64,
blank=True,
null=True,
db_index=True,
)
departure_time = TimeField(
verbose_name=_("time"),
blank=True,
null=True,
db_index=True,
)
send_reminder = BooleanField(
verbose_name=_("Do you want a reminder to be sent ?"),
default=False,
db_index=True,
)
class Meta(Action.Meta): # pylint: disable=too-few-public-methods
"""Event Meta class"""
verbose_name = _("event")
verbose_name_plural = _("events")
class TestModelFields(Model):
big_int = BigIntegerField()
yesno = BooleanField()
title = CharField(max_length=150)
csv_data = CommaSeparatedIntegerField(max_length=255)
when = DateField()
when_accurate = DateTimeField()
amount = DecimalField(max_digits=8, decimal_places=4)
email = EmailField()
upload = FileField(upload_to='test')
path = FilePathField(path=d.APP_DIR, recursive=False, match=".json$")
inaccurate = FloatField()
img = ImageField(upload_to='test')
ip = IPAddressField()
better_ip = GenericIPAddressField(protocol='both')
yesnomaybe = NullBooleanField(default=None)
posint = PositiveIntegerField()
small_posint = PositiveSmallIntegerField()
slug = SlugField()
small_int = SmallIntegerField()
content = TextField()
when_time = TimeField()
web_address = URLField()
user = ForeignKey('auth.User')
groups = ManyToManyField('auth.Group')
one_to_one = OneToOneField('auth.Permission')
class Meta:
verbose_name = 'test model fields'
verbose_name_plural = 'test model fields'
def filter_open_or_close_shops(self, queryset, name, value):
time_now = datetime.datetime.now().time()
queryset = queryset.annotate(
time_now=Value(time_now, output_field=TimeField()))
if value == 1:
return queryset.filter(
Q(time_now__range=[
F('time_open'),
Case(When(time_open__lte=F('time_close'),
then='time_close'),
default=datetime.time(23, 59))
]) | Q(time_now__range=[
Case(When(time_open__lte=F('time_close'),
then='time_open'),
default=datetime.time(0, 0)),
F('time_close')
]))
elif value == 0:
return queryset.filter(
Q(time_now__range=[
F('time_close'),
Case(When(time_open__lte=F('time_close'),
then=datetime.time(23, 59)),
default='time_open')
]) | Q(time_now__range=[
Case(When(time_open__lte=F('time_close'),
then=datetime.time(0, 0)),
default='time_open'),
F('time_open')
]))
return queryset
def test_trunc_day_func(self):
start_datetime = microsecond_support(
datetime(2015, 6, 15, 14, 30, 50, 321))
end_datetime = truncate_to(
microsecond_support(datetime(2016, 6, 15, 14, 10, 50, 123)), 'day')
if settings.USE_TZ:
start_datetime = timezone.make_aware(start_datetime, is_dst=False)
end_datetime = timezone.make_aware(end_datetime, is_dst=False)
self.create_model(start_datetime, end_datetime)
self.create_model(end_datetime, start_datetime)
self.assertQuerysetEqual(
DTModel.objects.annotate(extracted=TruncDay(
'start_datetime')).order_by('start_datetime'), [
(start_datetime, truncate_to(start_datetime, 'day')),
(end_datetime, truncate_to(end_datetime, 'day')),
], lambda m: (m.start_datetime, m.extracted))
self.assertEqual(
DTModel.objects.filter(
start_datetime=TruncDay('start_datetime')).count(), 1)
with self.assertRaisesMessage(
ValueError,
"Cannot truncate TimeField 'start_time' to DateTimeField"):
list(DTModel.objects.annotate(truncated=TruncDay('start_time')))
with self.assertRaisesMessage(
ValueError,
"Cannot truncate TimeField 'start_time' to DateTimeField"):
list(
DTModel.objects.annotate(truncated=TruncDay(
'start_time', output_field=TimeField())))
class Event(Model):
game = ForeignKey(Game, on_delete=CASCADE)
eventnum = IntegerField()
period = IntegerField()
msg_type = IntegerField()
msg_action_type = IntegerField()
ev_real_time = TimeField()
ev_game_clock = DurationField()
home_desc = CharField(max_length=256, null=True)
neutral_desc = CharField(max_length=256, null=True)
visitor_desc = CharField(max_length=256, null=True)
home_score_after = IntegerField(default=0)
visitor_score_after = IntegerField(default=0)
home_team_fouls_after = IntegerField(default=0)
visitor_team_fouls_after = IntegerField(default=0)
person1_type = IntegerField(null=True)
player1 = ForeignKey(Player, null=True, related_name='p1', on_delete=CASCADE)
player1_team = ForeignKey(Team, null=True, related_name='p1_team', on_delete=CASCADE)
person2_type = IntegerField(null=True)
player2 = ForeignKey(Player, null=True, related_name='p2', on_delete=CASCADE)
player2_team = ForeignKey(Team, null=True, related_name='p2_team', on_delete=CASCADE)
person3_type = IntegerField(null=True)
player3 = ForeignKey(Player, null=True, related_name='p3', on_delete=CASCADE)
player3_team = ForeignKey(Team, null=True, related_name='p3_team', on_delete=CASCADE)
def __str__(self):
return ', '.join([desc for desc in [self.home_desc, self.neutral_desc, self.visitor_desc] if desc is not None]) + ' with %s left in period %s (#%s)' % (self.ev_game_clock, self.period, self.eventnum)
def desc_for_poss_dropdown(self):
return ', '.join([desc for desc in [self.home_desc, self.neutral_desc, self.visitor_desc] if desc is not None]) + ' with %s left in period %s' % (self.ev_game_clock, self.period)
class Meta:
db_table = 'event'
def validosPrimero(self, primeroValidos=True):
seleccionados = Q(
inicioFranjaHoraria__lt=F("finFranjaHoraria"),
inicioFranjaHoraria__lte=F("ahora"),
finFranjaHoraria__gte=F("ahora"),
) | Q(
Q(inicioFranjaHoraria__gt=F("finFranjaHoraria")),
R(
inicioFranjaHoraria__lte=F("ahora"),
finFranjaHoraria__gte=F("ahora")
)
)
validez = "-valido" if primeroValidos else "valido"
return self.annotate(
ahora=Value(
datetime.now().timetz(),
output_field=TimeField()
)
).annotate(
valido=Case(
When(seleccionados, then=True),
default=Value(False),
output_field=BooleanField()
)
).order_by(validez)
class GeneralEventsTable(Model):
report_id = IntegerField()
Operator = OneToOneField(Operators, null=True, on_delete=models.SET_NULL)
TYPE_CHOICES = (
('PSF', 'Public Safety Campaign'),
('SE', 'Special Event'),
)
Type = CharField(max_length=120, choices=TYPE_CHOICES)
status = BooleanField()
date = DateField()
time = TimeField()
Event_name = TextField()
caller_details = OneToOneField(CallerDetails,
null=True,
on_delete=models.SET_NULL)
start_date = DateField()
start_time = TimeField()
end_date = DateField()
end_time = DateField()
General_information = TextField()
Crossroads_ID = IntegerField()
Crossroads_activated_DMS = BooleanField()
Crossroads_activated_Fax_Email = BooleanField()
Crossroads_activated_Web = BooleanField()
Crossroads_deactivated_DMS = BooleanField()
Crossroads_deactivated_Fax_Email = BooleanField()
Crossroads_deactivated_Web = BooleanField()
Crossroads_Website_entered = BooleanField()
Crossroads_Website_deactivated = BooleanField()
DMS_Activation_time = BooleanField()
DMS_Deactivation_time = BooleanField()
PVMS_Activation_time = BooleanField()
PVMS_Deactivation_time = BooleanField()
HAR_Activation_time = BooleanField()
HAR_Deactivation_time = BooleanField()
class KeyTransform(Transform):
SPEC_MAP = {
date: 'DATE',
datetime: 'DATETIME',
float: 'DOUBLE',
int: 'INTEGER',
six.text_type: 'CHAR',
time: 'TIME',
dict: 'BINARY',
}
if six.PY2:
from __builtin__ import long # make source lintable on Python 3
SPEC_MAP[long] = 'INTEGER'
SPEC_MAP_NAMES = ', '.join(
sorted(x.__name__ for x in six.iterkeys(SPEC_MAP)))
TYPE_MAP = {
'BINARY': DynamicField,
'CHAR': TextField(),
'DATE': DateField(),
'DATETIME': DateTimeField(),
'DOUBLE': FloatField(),
'INTEGER': IntegerField(),
'TIME': TimeField(),
}
def __init__(self, key_name, data_type, *args, **kwargs):
subspec = kwargs.pop('subspec', None)
super(KeyTransform, self).__init__(*args, **kwargs)
self.key_name = key_name
self.data_type = data_type
try:
output_field = self.TYPE_MAP[data_type]
except KeyError: # pragma: no cover
raise ValueError("Invalid data_type '{}'".format(data_type))
if data_type == 'BINARY':
self.output_field = output_field(spec=subspec)
else:
self.output_field = output_field
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs)
return ("COLUMN_GET({}, %s AS {})".format(lhs, self.data_type),
params + [self.key_name])
if django.VERSION[:3] <= (1, 8, 2):
# Backport of bugfix for transforms with arguments, taken from:
# https://code.djangoproject.com/ticket/24744
def copy(self):
return copy(self)
def relabeled_clone(self, relabels):
copy = self.copy()
copy.lhs = self.lhs.relabeled_clone(relabels)
return copy
class VolunteerWindow(Model):
start = TimeField(blank=True)
end = TimeField(blank=True)
day = ForeignKey(ConferenceDay)
def __unicode__(self):
return "%s, %s to %s" % (str(self.day),
date_format(self.start, "TIME_FORMAT"),
date_format(self.end, "TIME_FORMAT"))
def start_timestamp(self):
return pytz.utc.localize(datetime.combine(self.day.day, self.start))
def end_timestamp(self):
return pytz.utc.localize(datetime.combine(self.day.day, self.end))
@property
def start_time(self):
''' same footprint as scheduler events'''
return self.start_timestamp()
@property
def end_time(self):
''' same footprint as scheduler events'''
return self.end_timestamp()
def check_conflict(self, start, end):
starttime = self.start_timestamp()
endtime = self.end_timestamp()
has_conflict = False
if start == starttime:
has_conflict = True
elif (start > starttime and
start < endtime):
has_conflict = True
elif (start < starttime and
end > starttime):
has_conflict = True
return has_conflict
class Meta:
ordering = ['day', 'start']
verbose_name = "Volunteer Window"
verbose_name_plural = "Volunteer Windows"
app_label = "gbe"
class TimeSlot(Model):
slot_no = IntegerField(
default=1, validators=[MinValueValidator(1),
MaxValueValidator(10)])
time = TimeField()
def __str__(self):
return str(self.slot_no)
class Preference(Model):
user = OneToOneField(User, on_delete=CASCADE, primary_key=True)
mondayStart = TimeField(default=datetime.time(8, 0, 0))
tuesdayStart = TimeField(default=datetime.time(8, 0, 0))
wednesdayStart = TimeField(default=datetime.time(8, 0, 0))
thursdayStart = TimeField(default=datetime.time(8, 0, 0))
fridayStart = TimeField(default=datetime.time(8, 0, 0))
mondayEnd = TimeField(default=datetime.time(20, 0, 0))
tuesdayEnd = TimeField(default=datetime.time(20, 0, 0))
wednesdayEnd = TimeField(default=datetime.time(20, 0, 0))
thursdayEnd = TimeField(default=datetime.time(20, 0, 0))
fridayEnd = TimeField(default=datetime.time(20, 0, 0))
mondayMax=IntegerField(default=12)
tuesdayMax=IntegerField(default=12)
wednesdayMax=IntegerField(default=12)
thursdayMax=IntegerField(default=12)
fridayMax=IntegerField(default=12)
def test_time_kind(kind, tzinfo=melb):
self.assertQuerysetEqual(
DTModel.objects.annotate(truncated=Trunc(
'start_time', kind, output_field=TimeField(),
tzinfo=melb)).order_by('start_datetime'),
[(start_datetime, truncate_to(start_datetime.time(), kind)),
(end_datetime, truncate_to(end_datetime.time(), kind))],
lambda m: (m.start_datetime, m.truncated))
class Supplier(Model):
name = CharField(max_length=100)
area = ForeignKey(
Tree,
related_name='area',
limit_choices_to={'tree_type': Tree.tree_type_choice[0][0]})
address = CharField(max_length=100)
coordinate_x = FloatField()
coordinate_y = FloatField()
photo = ImageField(blank=True, null=True, upload_to='photos/suppliers')
phone = CharField(max_length=100)
time_open = TimeField()
time_close = TimeField()
description = CharField(max_length=1000)
owner = ForeignKey(User)
def __str__(self):
return self.area.name + '-' + self.name
class TestModelPrimitiveFields(Model):
int_field = IntegerField()
float_field = FloatField()
string_char_field = CharField(max_length=50)
string_text_field = TextField()
bool_field = BooleanField()
date_field = DateField()
time_field = TimeField()
date_time_field = DateTimeField()
class FakeEventbriteEvent(Model):
name_text = TextField(default="Fake Eventbrite Event")
name_html = TextField(default="Fake Eventbrite Event")
description_text = TextField(blank=True,
null=True,
default="Fake Eventbrite Event Description")
description_html = TextField(blank=True,
null=True,
default="Fake Eventbrite Event Description")
day_specifier = TextField(default="today")
offset_specifier = TextField(default="")
duration_specfier = TextField(default="")
time = TimeField(default=NOON)
timezone = CharField(max_length=50, default="America/New_York")
eventbrite_id = CharField(max_length=20, default="1234567")
day_specifier = TextField()
offset_specifier = TextField()
duration_specifier = TextField() # not used atm
organization_id = BigIntegerField(default=settings.DEFAULT_ORGANIZATION_ID)
created = DateTimeField(auto_now_add=True)
changed = DateTimeField(auto_now=True)
published = DateTimeField(auto_now_add=True)
capacity = IntegerField(default=100)
capacity_is_custom = BooleanField(default=False)
status = TextField(choices=status_choices, default="live")
currency = CharField(max_length=5, default="USD")
listed = BooleanField(default=False)
shareable = BooleanField(default=True)
invite_only = BooleanField(default=False)
password = CharField(max_length=64, default="password")
online_event = BooleanField(default=False)
show_remaining = BooleanField(default=True)
tx_time_limit = IntegerField(default=480)
hide_start_date = BooleanField(default=False)
hide_end_date = BooleanField(default=False)
locale = CharField(max_length=10, default="en_US")
is_locked = BooleanField(default=False)
privacy_setting = CharField(max_length=20, default="unlocked")
is_series = BooleanField(default=False)
is_series_parent = BooleanField(default=False)
inventory_type: CharField(max_length=20, default="limited")
is_reserved_seating = BooleanField(default=False)
show_pick_a_seat = BooleanField(default=False)
show_seatmap_thumbnail = BooleanField(default=False)
show_colors_in_seatmap_thumbnail = BooleanField(default=False)
source = CharField(max_length=20, default="create_2.0")
is_free = BooleanField(default=False)
version = CharField(max_length=20, default="3.0.0")
summary = TextField(blank=True, null=True)
logo_id = CharField(max_length=20, blank=True, null=True)
organizer_id = CharField(max_length=20,
default=settings.DEFAULT_ORGANIZER_ID)
venue_id = CharField(max_length=20, default="7882563")
category_id = CharField(max_length=20, null=True, blank=True)
subcategory_id = CharField(max_length=20, null=True, blank=True)
format_id = CharField(max_length=20, null=True, blank=True)
is_externally_ticketed = BooleanField(default=False)
class ExtraActivity(Model):
title = CharField(max_length=255)
location = CharField(max_length=255)
start_time = TimeField()
day = CharField(max_length=15)
duration = IntegerField(default=2)
frequency = CharField(max_length=5)
priority = CharField(max_length=30)
description = TextField()
class Proxy(Model):
RESOURCE_TYPES = (("deployment", "deployment"), )
name = CharField(max_length=255)
scale_resource_name = CharField(max_length=255)
scale_resource_type = CharField(max_length=255, choices=RESOURCE_TYPES)
host = CharField(max_length=255)
start_at = TimeField(null=True)
ends_at = TimeField(null=True)
last_access_time = DateTimeField(null=True)
autostart = BooleanField(default=False)
is_on = BooleanField(default=True)
duration_threshold = IntegerField(default=60)
replicas = IntegerField(default=1)
service_name = CharField(max_length=255, null=True)
service_port = IntegerField(null=True)
https = BooleanField(default=True)
def should_turn_on(self):
if self.start_at is None or self.ends_at is None:
return True
date_start = pendulum.now().replace(hour=self.start_at.hour,
minute=self.start_at.minute)
date_end = pendulum.now().replace(hour=self.ends_at.hour,
minute=self.ends_at.minute)
period = pendulum.Period(date_start, date_end)
return now() in period
def to_dict(self):
return {
"name": self.name,
"scale_resource_name": self.scale_resource_name,
"scale_resource_type": self.scale_resource_type,
"start_at": self.start_at,
"ends_at": self.ends_at,
"duration_threshold": self.duration_threshold,
"host": self.host,
"https": self.https,
"is_on": self.is_on,
"service_name": self.service_name,
"service_port": self.service_port,
"autostart": self.autostart
}
class Tracking(Model):
"""
Modelo para los usuarios
"""
id_tracking = CharField(max_length=200)
id_resultado = ForeignKey(Resultados, on_delete=CASCADE)
x_axis = DecimalField(max_digits=7, decimal_places=6)
y_axis = DecimalField(max_digits=7, decimal_places=6)
no_movimiento = IntegerField()
hora = TimeField()
class qDefect(Model):
TimeSlot = ForeignKey(
TimeSlot,
blank=True,
null=True,
)
Airplane = ForeignKey(
Airplane,
blank=True,
null=True,
)
ProblemArea = CharField(
max_length=6,
blank=True,
null=True,
)
Defect = ForeignKey(
CaseHeader,
blank=True,
null=True,
)
Fixer = ForeignKey(
User,
blank=True,
null=True,
)
isPartAvailable = NullBooleanField(
blank=True,
null=True,
)
isPartSupplied = NullBooleanField(
blank=True,
null=True,
)
ServicingPort = CharField(max_length=100, blank=True, null=True)
CHOICES_STATUS = (
('SCHEDULED', 'SCHEDULED'),
('TRANSFERRED', 'TRANSFERRED'),
('EXTENDED', 'EXTENDED'),
)
Status = CharField(
max_length=100,
blank=True,
null=True,
choices=CHOICES_STATUS,
default='SCHEDULED',
)
DeadlineTime = TimeField(
blank=True,
null=True,
)
def __str__(self):
return str(self.id)
class TruncTime(TruncBase):
kind = 'time'
lookup_name = 'time'
output_field = TimeField()
def as_sql(self, compiler, connection):
# Cast to date rather than truncate to date.
lhs, lhs_params = compiler.compile(self.lhs)
tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
sql = connection.ops.datetime_cast_time_sql(lhs, tzname)
return sql, lhs_params
class ExtractMinute(Extract):
lookup_name = 'minute'
class ExtractSecond(Extract):
lookup_name = 'second'
DateField.register_lookup(ExtractYear)
DateField.register_lookup(ExtractMonth)
DateField.register_lookup(ExtractDay)
DateField.register_lookup(ExtractWeekDay)
DateField.register_lookup(ExtractWeek)
TimeField.register_lookup(ExtractHour)
TimeField.register_lookup(ExtractMinute)
TimeField.register_lookup(ExtractSecond)
DateTimeField.register_lookup(ExtractHour)
DateTimeField.register_lookup(ExtractMinute)
DateTimeField.register_lookup(ExtractSecond)
ExtractYear.register_lookup(YearExact)
ExtractYear.register_lookup(YearGt)
ExtractYear.register_lookup(YearGte)
ExtractYear.register_lookup(YearLt)
ExtractYear.register_lookup(YearLte)
class TruncBase(TimezoneMixin, Transform):
