class Booking(models.Model):
room = models.ForeignKey(Room,
on_delete=models.CASCADE,
related_name='bookings')
guest = models.ForeignKey(User,
related_name='bookings',
on_delete=models.CASCADE)
duration = DateTimeRangeField(db_index=True)
price = models.DecimalField(max_digits=100,
decimal_places=2,
blank=True,
null=True) #t
total = models.DecimalField(max_digits=100,
decimal_places=2,
blank=True,
null=True) #t
status = models.CharField(max_length=120,
default='created',
choices=BOOKING_STATUS_CHOICES)
active = models.BooleanField(default=True)
create_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return "{} booking for {}".format(self.guest.first_name,
self.room.name)
class Election(models.Model):
"""
An election, which keeps track of the options to vote for, and who has voted within it.
"""
title = models.CharField(max_length=255, default="")
description = MarkdownxField(default="")
created = models.DateTimeField(auto_now_add=True)
voters = models.ManyToManyField(User, blank=True)
open_time = DateTimeRangeField()
aber_only = models.BooleanField(default=False)
def get_absolute_url(self):
return reverse("voting:election_details",
kwargs={"election_id": self.id})
def __str__(self):
return self.title
def is_open(self):
"""
Is this election currently open (as in, can users vote in it right now)
"""
return pytz.utc.localize(datetime.datetime.now()) in self.open_time
def can_vote(self, user):
"""
Check that the election is currently open and that the user has not already voted
:param user: The user to check has voted
:return: True if the user can vote
"""
return self.is_open() \
and user not in self.voters \
and user.is_aber_student() if self.aber_only else True
class NursingSchedule(models.Model):
class Meta:
db_table = "patient_nursing_schedule"
objects = ScheduleManager()
patient = models.ForeignKey(Profile, related_name='nursing_schedule', on_delete=models.CASCADE)
employee = models.ForeignKey("employee.Profile", related_name='nursing_schedule', on_delete=models.CASCADE)
schedule = DateTimeRangeField()
flow_control = models.DateTimeField(null=True)
def today_courses(self):
return self.patient.course_schedule.extra(
where=("(weekly_mask & (1 << EXTRACT(DOW FROM current_timestamp AT TIME ZONE 'Asia/Taipei')::int)) > 0", ))
def fetch_next_question(self):
courses_id = self.patient.course_schedule.extra(
where=("(weekly_mask & (1 << EXTRACT(DOW FROM current_timestamp AT TIME ZONE 'Asia/Taipei')::int)) > 0", )
).values_list('table_id', flat=True)
items = CourseQuestion.objects.filter(table_id__in=courses_id).extra(
where=("care_course_question.scheduled_at > (SELECT (flow_control AT TIME ZONE 'Asia/Taipei')::Time FROM patient_nursing_schedule WHERE id = %i)" % self.id,
"care_course_question.scheduled_at <= (SELECT (UPPER(schedule) AT TIME ZONE 'Asia/Taipei')::Time FROM patient_nursing_schedule WHERE id = %i)" % self.id)
).select_related("question").order_by('scheduled_at')
t = None
for it in items:
if not t:
yield it
t = it.scheduled_at
elif it.scheduled_at == t:
yield it
else:
return
def __str__(self):
return "%s#班表 %s/%s@%s" % (self.id, self.patient, self.employee, self.schedule.lower)
class Booking(models.Model):
""" bookings model """
guest = models.ForeignKey(CustomUser,
on_delete=models.CASCADE,
related_name='guest')
num_guests = models.IntegerField(default=2, null=False)
listing = models.ForeignKey(Listing, on_delete=models.CASCADE)
price_type = models.CharField(max_length=20,
choices=PRICE_TYPE,
null=False,
default="daily")
total_price = models.IntegerField(validators=[MinValueValidator(0)])
date_time_range = DateTimeRangeField(null=True)
duration = models.DurationField(default=timedelta(days=1))
confirmed = models.BooleanField(null=False, default=False)
@classmethod
def calculate_duration(cls, date_time_range):
""" calculate end_time - start_time """
return date_time_range.upper - date_time_range.lower
@classmethod
def calculate_total_price(cls, duration, price_type, listing):
""" Calculate price * duration """
if price_type == 'hourly':
return duration.hours * listing.price_per_hour
if price_type == 'daily':
return duration.days * listing.price_per_day
if price_type == 'monthly':
return duration.months * listing.price_per_month
def __str__(self):
return f"Booking {self.id}"
class drs(models.Model):
period = DateTimeRangeField()
account = models.ForeignKey(Account, on_delete=models.CASCADE)
cb = models.DecimalField(max_digits=14, decimal_places=3)
def __str__(self):
return f"{self.period} {self.account.name} {self.cb} "
class Listener(models.Model):
ip_address = models.GenericIPAddressField(verbose_name='IP address')
stream = models.ForeignKey(Stream, on_delete=models.PROTECT)
session = DateTimeRangeField()
duration = models.DurationField()
referer = models.CharField(max_length=255)
user_agent = models.ForeignKey(UserAgent,
on_delete=models.SET_NULL,
null=True)
country = CountryField(null=True)
city = models.CharField(max_length=255, null=True)
latitude = models.DecimalField(max_digits=9, decimal_places=6, null=True)
longitude = models.DecimalField(max_digits=9, decimal_places=6, null=True)
class Meta:
unique_together = ('ip_address', 'stream', 'session', 'user_agent')
ordering = ('-session', )
indexes = [
GistIndex(fields=[
'session',
]),
]
@property
def connected_at(self):
return self.session.lower
@property
def disconnected_at(self):
return self.session.upper
def __str__(self):
return self.ip_address
class AppointmentSchedule(models.Model):
"""
Model represent schedule for booked appointment.
The end of appointment will automatic calculated from treatments duration
"""
class Meta:
db_table = 'appointment_schedules'
appointment = models.OneToOneField(Appointment, related_name='schedule')
doctor = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name='appointment_schedules')
duration = DateTimeRangeField(null=True)
def __str__(self):
return "Appointment {} for doctor {} at {}".format(
self.appointment_id, self.doctor, self.duration)
@staticmethod
def create_from(appointment: Appointment):
appointment = Appointment.objects.get(pk=appointment.pk)
treatments_duration = sum(
[getattr(t, 'duration', 0) for t in appointment.treatments.all()])
start_time = appointment.date_time
end_time = start_time + timedelta(minutes=treatments_duration)
try:
appointment_schedule = AppointmentSchedule.objects.get(
appointment=appointment)
except AppointmentSchedule.DoesNotExist:
appointment_schedule = AppointmentSchedule(appointment=appointment)
appointment_schedule.doctor = appointment.doctor
appointment_schedule.duration = DateTimeTZRange(start_time, end_time)
appointment_schedule.save()
return appointment_schedule
class Product(CreatedUpdatedModel, UUIDModel):
class Meta:
verbose_name = 'Product'
verbose_name_plural = 'Products'
ordering = ['available_in', 'price']
category = models.ForeignKey('shop.ProductCategory',
related_name='products')
name = models.CharField(max_length=150)
slug = models.SlugField()
price = models.IntegerField(
help_text=_('Price of the product (in DKK, including VAT).'))
description = models.TextField()
available_in = DateTimeRangeField(help_text=_(
'Which period is this product available for purchase? | '
'(Format: YYYY-MM-DD HH:MM) | Only one of start/end is required'))
objects = ProductQuerySet.as_manager()
def __str__(self):
return '{} ({} DKK)'.format(
self.name,
self.price,
)
def is_available(self):
now = timezone.now()
return now in self.available_in
class ResourceDailyOpeningHours(models.Model):
"""
Calculated automatically for each day the resource is open
"""
resource = models.ForeignKey(Resource,
related_name='opening_hours',
on_delete=models.CASCADE,
db_index=True)
open_between = DateTimeRangeField()
def clean(self):
super().clean()
if self.objects.filter(resource=self.resource,
open_between__overlaps=self.open_between):
raise ValidationError(_("Overlapping opening hours"))
class Meta:
unique_together = [('resource', 'open_between')]
indexes = [GistIndex(fields=['open_between'])]
def __str__(self):
if isinstance(self.open_between, tuple):
lower = self.open_between[0]
upper = self.open_between[1]
else:
lower = self.open_between.lower
upper = self.open_between.upper
return "%s: %s -> %s" % (self.resource, lower, upper)
class TeamShift(CampRelatedModel):
class Meta:
ordering = ("shift_range", )
team = models.ForeignKey(
'teams.Team',
related_name='shifts',
on_delete=models.PROTECT,
help_text='The team this shift belongs to',
)
shift_range = DateTimeRangeField()
team_members = models.ManyToManyField(
TeamMember,
blank=True,
)
people_required = models.IntegerField(default=1)
@property
def camp(self):
""" All CampRelatedModels must have a camp FK or a camp property """
return self.team.camp
camp_filter = 'team__camp'
def __str__(self):
return "{} team shift from {} to {}".format(self.team.name,
self.shift_range.lower,
self.shift_range.upper)
@property
def users(self):
return [member.user for member in self.team_members.all()]
class PostgresModel(Model):
int_array = ArrayField(IntegerField(null=True, blank=True),
size=3,
null=True,
blank=True)
hstore = HStoreField(null=True, blank=True)
try:
from django.contrib.postgres.fields import JSONField
json = JSONField(null=True, blank=True)
except ImportError:
pass
int_range = IntegerRangeField(null=True, blank=True)
try:
from django.contrib.postgres.fields import FloatRangeField
float_range = FloatRangeField(null=True, blank=True)
except ImportError:
pass
try:
from django.contrib.postgres.fields import DecimalRangeField
decimal_range = DecimalRangeField(null=True, blank=True)
except ImportError:
pass
date_range = DateRangeField(null=True, blank=True)
datetime_range = DateTimeRangeField(null=True, blank=True)
class Meta:
# Tests schema name in table name.
db_table = '"public"."cachalot_postgresmodel"'
class SubscriptionPeriodItem(StarterModel):
subscription = models.ForeignKey(Subscription,
on_delete=models.CASCADE,
related_name='subscription_period_items')
date_range = DateTimeRangeField()
payment_status = EnumChoiceField(PaymentStatus,
default=PaymentStatus.PENDING,
max_length=32)
class PostgreFieldsModel(models.Model):
date_range_field = DateRangeField()
datetime_range_field = DateTimeRangeField()
integer_range_field = IntegerRangeField()
decimal_range_field = DecimalRangeField()
class Meta:
app_label = 'tests'
class FieldHistory(models.Model):
"""Model for a column/field history table"""
entity = None # type: models.ForeignKey
effective = DateTimeRangeField()
vclock = IntegerRangeField()
class Meta:
abstract = True
class Ad(BaseModel):
"""
Ads model.
"""
class Type:
dating = 'DATING'
meeting = 'MEETING'
travel = 'TRAVEL'
choices = (
(dating, _('Dating')),
(meeting, _('Meeting')),
(travel, _('Travel')),
)
user = models.ForeignKey(get_user_model(),
related_name='ads',
on_delete=models.CASCADE,
help_text=_('Ad creator.'))
type = models.CharField(max_length=16,
choices=Type.choices,
help_text=_('Ad type.'))
address = models.CharField(max_length=256, help_text=_('Ad address.'))
point = models.PointField(
help_text=_('Geolocation point (in GeoJSON format).'))
sex = models.CharField(max_length=1,
choices=get_user_model().Sex.choices,
default=get_user_model().Sex.none,
help_text=_('Valid values: M, F, N'))
ages = IntegerRangeField(help_text=_('Ad age range'))
title = models.CharField(max_length=128, help_text=_('Title'))
text = models.TextField(help_text=_('Ad description'))
period = DateTimeRangeField(default=default_period,
help_text=_('Ad period'))
favorited_for = ArrayField(
models.CharField(max_length=36),
help_text=_("Favorite for this users (list of UUIDs)."),
default=list)
viewed_by = ArrayField(models.CharField(max_length=36),
help_text=_("View by this users (list of UUIDs)."),
default=list)
is_active = models.BooleanField(default=False,
help_text=_('As is publicly published.'))
is_blocked = models.BooleanField(default=False,
help_text=_('Is blocked by moderator'))
objects = AdManager()
class Meta:
db_table = 'ads'
ordering = ('-created_at', )
@cached_property
def owner(self):
return self.user
@property
def short_text(self):
return truncatewords(self.text, 6)
class Datastream(models.Model):
"""
Datatsream model type definition. Related fields are defined it related models.
"""
name = models.TextField("Name")
description = models.TextField("Description")
unitOfMeasurement = JSONField(verbose_name="Unit of Measurement")
observationType = models.TextField(
verbose_name="Observation Type",
choices=OBSERVATION_TYPES,
default=
"http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Observation")
observedArea = models.PolygonField(blank=True,
null=True,
verbose_name="Observed Area")
phenomenonTime = DateTimeRangeField(
blank=True,
null=True,
# validators=[Validators.validate_interval],
verbose_name="Phenomenon Time")
resultTime = DateTimeRangeField(
blank=True,
null=True,
# validators=[Validators.validate_interval],
verbose_name="Result Time")
Thing = models.ForeignKey(Thing,
on_delete=models.CASCADE,
related_name="Datastream",
verbose_name='Thing')
Sensor = models.ForeignKey("Sensor",
on_delete=models.CASCADE,
related_name="Datastream",
verbose_name="Sensor")
ObservedProperty = models.ForeignKey("ObservedProperty",
on_delete=models.CASCADE,
related_name="Datastream",
verbose_name="Observed Property")
class Meta:
verbose_name = "Datastream"
verbose_name_plural = "Datastreams"
def __str__(self):
return self.name
class Subscriptions(models.Model):
account = models.ForeignKey(Account, on_delete=models.PROTECT)
plan = models.CharField(max_length=30, blank=False)
period = DateTimeRangeField(null=True, blank=True)
def __str__(self):
return f'{self.account} {self.plan} {self.period}'
class Meta:
verbose_name_plural = 'Subscriptions'
class StopSuspension(models.Model):
dates = DateTimeRangeField(null=True, blank=True)
text = models.TextField(blank=True)
stops = models.ManyToManyField('busstops.StopPoint')
service = models.ForeignKey('busstops.Service',
models.CASCADE,
null=True,
blank=True)
def __str__(self):
return self.text or str(self.dates)
class Experiment(Model):
__slots__ = ['experiment_id', 'name', 'qgroup', 'consent_file', 'priority', 'time_range', 'description']
experiment_id = AutoField(primary_key=True)
name = CharField(max_length=64)
qgroup = ForeignKey(QGroup)
consent_file = CharField(max_length=64)
priority = PositiveSmallIntegerField(default=0)
time_range = DateTimeRangeField()
description = TextField(default=None)
def __unicode__(self):
return '%s [%s] - [%s]' % (self.experiment_id, self.name, self.qgroup.qgroup_id)
class PostgresModel(Model):
int_array = ArrayField(IntegerField(null=True, blank=True),
size=3,
null=True,
blank=True)
hstore = HStoreField(null=True, blank=True)
int_range = IntegerRangeField(null=True, blank=True)
float_range = FloatRangeField(null=True, blank=True)
date_range = DateRangeField(null=True, blank=True)
datetime_range = DateTimeRangeField(null=True, blank=True)
class UserProfession(models.Model):
user = models.ForeignKey(User,
related_name="professions",
on_delete=models.CASCADE,
db_index=True)
profession = models.ForeignKey(Profession,
blank=True,
null=True,
on_delete=models.CASCADE)
period = DateTimeRangeField()
objects = UserProfessionQuerySet.as_manager()
class Channel(models.Model):
name = models.CharField(max_length=254, verbose_name='Ex. FR.CHMF.00.BHZ')
span = DateTimeRangeField(
verbose_name='Date time range (start/end)',
help_text='If no end date for the moment, just add start date')
states = models.ManyToManyField('gissmo.State')
def __str__(self):
return '%s' % self.name
def __unicode__(self):
return '%s' % self.name
class TeamTask(CampRelatedModel):
team = models.ForeignKey(
"teams.Team",
related_name="tasks",
on_delete=models.PROTECT,
help_text="The team this task belongs to",
)
name = models.CharField(max_length=100,
help_text="Short name of this task")
slug = models.SlugField(max_length=255,
blank=True,
help_text="url slug, leave blank to autogenerate")
description = models.TextField(
help_text="Description of the task. Markdown is supported.")
when = DateTimeRangeField(
blank=True,
null=True,
help_text="When does this task need to be started and/or finished?",
)
completed = models.BooleanField(
help_text="Check to mark this task as completed.", default=False)
class Meta:
ordering = ["completed", "when", "name"]
unique_together = (("name", "team"), ("slug", "team"))
def get_absolute_url(self):
return reverse_lazy(
"teams:task_detail",
kwargs={
"camp_slug": self.team.camp.slug,
"team_slug": self.team.slug,
"slug": self.slug,
},
)
@property
def camp(self):
""" All CampRelatedModels must have a camp FK or a camp property """
return self.team.camp
camp_filter = "team__camp"
def save(self, **kwargs):
# generate slug if needed
if not self.slug:
self.slug = unique_slugify(
self.name,
slugs_in_use=self.__class__.objects.filter(
team=self.team).values_list("slug", flat=True),
)
super().save(**kwargs)
class Statistics(models.Model):
name = models.CharField(max_length=256)
active = DateTimeRangeField(null=True, blank=True)
terminals = models.ManyToManyField("Terminal")
class Meta:
ordering = ("id", )
permissions = ((("view_statistics",
_("View Statistics")), ) if django.VERSION <
(2, 1) else tuple())
def __str__(s):
return f"{s.name} ({s.terminals.count()} Terminals / {s.active})"
class Product(CreatedUpdatedModel, UUIDModel):
class Meta:
verbose_name = 'Product'
verbose_name_plural = 'Products'
ordering = ['available_in', 'price', 'name']
category = models.ForeignKey('shop.ProductCategory',
related_name='products')
name = models.CharField(max_length=150)
slug = models.SlugField(unique=True, max_length=100)
price = models.IntegerField(
help_text=_('Price of the product (in DKK, including VAT).'))
description = models.TextField()
available_in = DateTimeRangeField(help_text=_(
'Which period is this product available for purchase? | '
'(Format: YYYY-MM-DD HH:MM) | Only one of start/end is required'))
ticket_type = models.ForeignKey('tickets.TicketType',
null=True,
blank=True)
objects = ProductQuerySet.as_manager()
def __str__(self):
return '{} ({} DKK)'.format(
self.name,
self.price,
)
def clean(self):
if self.category.name == 'Tickets' and not self.ticket_type:
raise ValidationError(
'Products with category Tickets need a ticket_type')
def is_available(self):
now = timezone.now()
return now in self.available_in
def is_old(self):
now = timezone.now()
if hasattr(self.available_in, 'upper') and self.available_in.upper:
return self.available_in.upper < now
return False
def is_upcoming(self):
now = timezone.now()
return self.available_in.lower > now
class Match(models.Model):
created_time = models.DateTimeField(_('created time'), auto_now_add=True)
updated_time = models.DateTimeField(_('updated time'), auto_now=True)
is_enable = models.BooleanField(_('is enable'), default=True)
title = models.CharField(_('title'), max_length=80)
execute_time_range = DateTimeRangeField(_('execute time range'))
stadium = models.ForeignKey('Stadium', verbose_name=_('stadium'), on_delete=models.CASCADE, related_name='matches')
class Meta:
verbose_name = _("Match")
verbose_name_plural = _("Matches")
def __str__(self):
return self.title
class FacilityOpeningHours(
ExportModelOperationsMixin("facility_opening_hours"),
CampRelatedModel,
):
"""
This model contains opening hours for facilities which are not always open.
If a facility has zero entries in this model it means is always open.
If a facility has one or more periods of opening hours defined in this model
it is considered closed outside of the period(s) defined in this model.
"""
class Meta:
ordering = ["when"]
constraints = [
# we do not want overlapping hours for the same Facility
ExclusionConstraint(
name="prevent_facility_opening_hours_overlaps",
expressions=[
("when", RangeOperators.OVERLAPS),
("facility", RangeOperators.EQUAL),
],
),
]
facility = models.ForeignKey(
"facilities.Facility",
related_name="opening_hours",
on_delete=models.PROTECT,
help_text="The Facility to which these opening hours belong.",
)
when = DateTimeRangeField(
db_index=True,
help_text="The period when this facility is open.",
)
notes = models.TextField(
blank=True,
help_text=
"Any notes for this period like 'no hot food after 20' or 'no alcohol sale after 02'. Optional.",
)
@property
def camp(self):
return self.facility.camp
camp_filter = "facility__facility_type__responsible_team__camp"
@property
def duration(self):
return self.when.upper - self.when.lower
class State(models.Model):
equipment = models.ForeignKey('gissmo.Equipment',
related_name='states',
on_delete=models.DO_NOTHING)
span = DateTimeRangeField(
verbose_name='Date time range (start/end)',
help_text='If no end date for the moment, just add start date')
data = JSONField()
def __str__(self):
return '%s - %s' % (self.equipment.name, self.span)
def __unicode__(self):
return '%s - %s' % (self.equipment.name, self.span)
class Ticket(GenericDatetimeModel):
mentor = models.ForeignKey(Mentor,
verbose_name='멘토',
null=True,
on_delete=models.SET_NULL)
sale_period = DateTimeRangeField('판매 기간')
is_active = models.BooleanField('활성화 여부', default=False)
class Meta:
db_table = 'tickets'
verbose_name = '티켓'
verbose_name_plural = '티켓들'
class TeamTask(CampRelatedModel):
team = models.ForeignKey(
'teams.Team',
related_name='tasks',
on_delete=models.PROTECT,
help_text='The team this task belongs to',
)
name = models.CharField(
max_length=100,
help_text='Short name of this task',
)
slug = models.SlugField(
max_length=255,
blank=True,
help_text='url slug, leave blank to autogenerate',
)
description = models.TextField(
help_text='Description of the task. Markdown is supported.')
when = DateTimeRangeField(
blank=True,
null=True,
help_text='When does this task need to be started and/or finished?')
completed = models.BooleanField(
help_text='Check to mark this task as completed.', default=False)
class Meta:
ordering = ['completed', 'when', 'name']
unique_together = (('name', 'team'), ('slug', 'team'))
def get_absolute_url(self):
return reverse_lazy('teams:task_detail',
kwargs={
'camp_slug': self.team.camp.slug,
'team_slug': self.team.slug,
'slug': self.slug
})
@property
def camp(self):
""" All CampRelatedModels must have a camp FK or a camp property """
return self.team.camp
camp_filter = 'team__camp'
def save(self, **kwargs):
# generate slug if needed
if not self.slug:
self.slug = slugify(self.name)
super().save(**kwargs)
