class Person(models.Model):
# this is awkward, use the notes field!
GENDER_CHOICES = [('man', 'man'), ('woman', 'woman'),
('non-binary', 'non-binary'),
('other', 'other - describe in notes field'),
('unknown', 'unknown')]
name = models.CharField(max_length=100)
display_name = models.CharField(max_length=100, blank=True, null=True)
birth_date = DateRangeField(blank=True, null=True)
death_date = DateRangeField(blank=True, null=True)
gender = models.CharField(max_length=15,
choices=GENDER_CHOICES,
blank=True,
null=True)
home_state = models.ForeignKey(State,
models.SET_NULL,
blank=True,
null=True)
viaf = models.URLField(max_length=100, blank=True, null=True)
wikipedia = models.URLField(max_length=100, blank=True, null=True)
getty = models.URLField(max_length=100, blank=True, null=True)
notes = models.TextField(blank=True, null=True)
def __str__(self):
return self.name
class Feature(models.Model):
geom = models.GeometryField()
orig_daterange = DateRangeField()
canonical_daterange = DateRangeField()
orig_status = models.CharField(max_length=2083)
canonical_status = models.CharField(max_length=2083)
source_ref = models.ForeignKey(API_element)
source_name = models.CharField(max_length=2083)
data = models.TextField(default=None)
class Feature(models.Model):
geom = models.GeometryField()
orig_daterange = DateRangeField(null=True, blank=True)
canonical_daterange = DateRangeField(null=True, blank=True)
orig_status = models.CharField(max_length=2083, null=True, default='')
canonical_status = models.CharField(max_length=2083, null=True, default='')
source_ref = models.ForeignKey(API_element)
source_name = models.CharField(max_length=2083)
data = models.TextField(default=None)
neighborhood = models.ForeignKey(Neighborhood, default=None, null=True)
def __str__(self):
return ("{} -- {} {} {}".format(self.id, self.source_name,
self.canonical_daterange, self.geom))
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 IstoriaViazen(models.Model):
title = models.CharField(max_length=80, null=False)
description = models.TextField(null=False)
duration_of_trip = DateRangeField()
created_at = models.DateTimeField(null=False,
blank=False,
default=timezone.now)
creator = models.ForeignKey(User,
related_name='istoria',
on_delete=models.CASCADE)
modified_at = models.DateTimeField(auto_now=True)
def __str__(self):
return f'{self.title}, {self.pk}'
def to_json(self):
duration_of_trip = json.dumps(self.duration_of_trip, default=str)
return {
"pk": self.pk,
"title": self.title,
"description": self.description,
"created_at": self.created_at,
"modified_at": self.modified_at,
"duration_of_trip": duration_of_trip,
"creator": {
"pk": self.creator.pk,
"username": self.creator.username,
"fullname": self.creator.get_full_name(),
}
}
class RoleAssignment(models.Model):
id = PrimaryKeyUUIDField()
role = TreeForeignKey(
"people.Role",
on_delete=models.CASCADE,
related_name="role_assignments",
verbose_name=_("role"),
)
person = models.ForeignKey(
"people.Person",
on_delete=models.CASCADE,
related_name="role_assignments",
verbose_name=_("person"),
)
period = DateRangeField(verbose_name=_("period"))
trial = models.BooleanField()
legacy_table = models.CharField(max_length=64, blank=True)
legacy_start_id = models.CharField(max_length=64, blank=True)
legacy_end_id = models.CharField(max_length=64, blank=True)
class Meta:
ordering = ["period"]
def __str__(self):
return f"{self.person.short_name}: {self.role} ({self.period.lower}–{self.period.upper})"
class ContentPlacement(CreationTrailModel):
""""""
package = models.ForeignKey(Package,
related_name='placements',
on_delete=models.CASCADE)
destination = models.ForeignKey(PrintPublication,
related_name='placed_content',
on_delete=models.CASCADE)
placement_types = ArrayField(
models.CharField(max_length=100, blank=True, null=True),
blank=True,
null=True,
)
page_number = models.PositiveSmallIntegerField(blank=True, null=True)
placement_details = models.CharField(blank=True,
null=True,
max_length=25,
help_text='E.G., print page number.')
run_date = DateRangeField()
external_slug = models.CharField(max_length=250, blank=True, null=True)
is_finalized = models.BooleanField(default=False)
def __str__(self):
"""String formatting."""
return '{} in {}'.format(self.package.full_slug, self.destination.name)
class CalendarDate(models.Model):
calendar = models.ForeignKey(Calendar, models.CASCADE)
start_date = models.DateField(db_index=True)
end_date = models.DateField(null=True, blank=True, db_index=True)
dates = DateRangeField(null=True)
operation = models.BooleanField(db_index=True)
special = models.BooleanField(default=False, db_index=True)
def contains(self, date):
return self.start_date <= date and (not self.end_date
or self.end_date >= date)
def relevant(self, operating_period):
if self.end_date:
if self.end_date < self.start_date:
return False
if operating_period.start > self.end_date:
return False
if operating_period.end and operating_period.end < self.start_date:
return False
return True
def __str__(self):
if not self.operation:
prefix = 'Not'
elif self.special:
prefix = 'Also'
else:
prefix = 'Only'
if self.start_date == self.end_date:
return f'{prefix} {self.start_date}'
return f'{prefix} {self.start_date} to {self.end_date}'
class Route(models.Model):
source = models.ForeignKey('busstops.DataSource', models.CASCADE)
code = models.CharField(max_length=255) # qualified filename
service_code = models.CharField(max_length=255, blank=True)
registration = models.ForeignKey('vosa.Registration', models.SET_NULL, null=True, blank=True)
line_brand = models.CharField(max_length=255, blank=True)
line_name = models.CharField(max_length=255, blank=True)
revision_number = models.PositiveSmallIntegerField(null=True, blank=True)
description = models.CharField(max_length=255, blank=True)
origin = models.CharField(max_length=255, blank=True)
destinaton = models.CharField(max_length=255, blank=True)
via = models.CharField(max_length=255, blank=True)
start_date = models.DateField(null=True, blank=True)
end_date = models.DateField(null=True, blank=True)
dates = DateRangeField(null=True, blank=True)
service = models.ForeignKey('busstops.Service', models.CASCADE)
geometry = models.MultiLineStringField(null=True, blank=True, editable=False)
def contains(self, date):
if not self.start_date or self.start_date <= date:
if not self.end_date or self.end_date >= date:
return True
class Meta:
unique_together = ('source', 'code')
index_together = (
('start_date', 'end_date'),
)
def __str__(self):
return ' – '.join(part for part in (self.line_name, self.line_brand, self.description) if part)
def get_absolute_url(self):
return reverse('route_xml', args=(self.source_id, self.code.split('#')[0]))
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 MandatAbstrait(UniqueWithinDates, MandatHistoryMixin, models.Model):
objects = MandatQueryset.as_manager()
person = models.ForeignKey("people.Person",
verbose_name="Élu",
on_delete=models.CASCADE)
dates = DateRangeField(
verbose_name="Début et fin du mandat",
help_text=
"La date de fin correspond à la date théorique de fin du mandat si elle est dans le futur et à la"
" date effective sinon.",
)
email_officiel = models.ForeignKey(
to="people.PersonEmail",
on_delete=models.SET_NULL,
null=True,
verbose_name="Adresse email officielle",
help_text=
"L'adresse avec laquelle contacter l'élu pour des questions officielles",
)
statut = models.CharField(
"Statut",
max_length=3,
choices=StatutMandat.choices,
default=StatutMandat.CONTACT_NECESSAIRE,
help_text=
"Indique la qualité de l'information sur cet⋅te élu⋅e, indépendamment des questions politiques et de"
" son appartenance au réseau des élus. Une valeur « Vérifié » signifie que : 1) il a été vérifié que le mandat"
" existe réellement et 2) le compte éventuellement associé appartient bien à la personne élue.",
)
def besoin_validation_personne(self):
"""Indique que le mandat n'a pas été validé par la personne concernée elle-même."""
return self.statut in [
StatutMandat.IMPORT_AUTOMATIQUE,
StatutMandat.CONTACT_NECESSAIRE,
]
def actif(self):
return timezone.now().date() in self.dates
def passe(self):
return timezone.now().date() >= self.dates.upper
@cached_property
def distance(self):
return (self._meta.default_manager.annotate_distance().values(
"distance").get(pk=self.id)["distance"])
@property
def nom_conseil(self):
return self.conseil.nom
class Meta:
abstract = True
class StylistDateRangeDiscount(models.Model):
stylist = models.ForeignKey(
Stylist, on_delete=models.CASCADE, related_name='date_range_discounts')
discount_percent = models.PositiveIntegerField(validators=[MaxValueValidator(100)])
dates = DateRangeField()
# TODO: enforce uniqueness on date range. Django doesn't support it directly
class Meta:
db_table = 'stylist_date_range_discount'
class DateRange(Func):
"""
Expression used to setup PostgreSQL specific database constraints for
models that defines a date range using 2 fields instead of the native
PostgreSQL DateRangeField.
https://docs.djangoproject.com/en/3.1/ref/contrib/postgres/constraints/
"""
function = "daterange"
output_field = DateRangeField()
class SpecialDaysOperation(models.Model):
vehicle_journey = models.ForeignKey(VehicleJourney,
related_name='special_days_operation',
on_delete=models.CASCADE)
days = DateRangeField()
operates = models.BooleanField()
class Meta:
indexes = [
models.Index(fields=['vehicle_journey', 'days', 'operates']),
]
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 TeamAlias(models.Model):
aliasid = models.IntegerField(
db_column='AliasID', primary_key=True) # Field name made lowercase.
period = DateRangeField(
db_column='Period'
) # Field name made lowercase. This field type is a guess.
aliasname = models.CharField(
max_length=200, db_column='AliasName') # Field name made lowercase.
class Meta:
managed = False
db_table = 'team_alias'
class Project(Exp):
profile = models.ForeignKey(Profile,
on_delete=models.CASCADE,
related_name="projects",
blank=True,
null=True)
parent = models.ForeignKey("Project",
on_delete=models.CASCADE,
related_name="projects",
blank=True,
null=True)
date_ranges = ArrayField(DateRangeField(null=True), blank=True, null=True)
class Holiday(models.Model):
"""
Model to store holiday data.
"""
name = models.CharField("Наименование", max_length=255)
dates = DateRangeField("Даты С-По")
class Meta:
verbose_name = "Праздник"
verbose_name_plural = "Праздники"
def __str__(self):
return self.name
class Affiliation(models.Model):
class Meta:
app_label = 'arcsecond'
person = models.ForeignKey(Person,
null=True,
blank=True,
related_name="affiliations")
organisation = models.ForeignKey(Organisation,
null=True,
blank=True,
related_name="affiliations")
dates = DateRangeField(null=True, blank=True)
class AnnualInspectionPlan(TenantModelBase):
"""设备年度检验计划"""
id = models.UUIDField('计划编号', default=uuid.uuid4, editable=False, primary_key=True)
planned_time = DateRangeField('计划预定时间')
is_active = models.BooleanField('是否启用', default=False, blank=True)
executors = models.ManyToManyField('base.User', verbose_name='执行人', blank=True)
desc = models.TextField('备注', blank=True)
def __str__(self):
return str(self.id)
class Meta:
db_table = 'annual_inspection_plan'
verbose_name = verbose_name_plural = '年度检验计划'
class ResumeExperience(Orderable):
title = models.CharField(max_length=100)
url = models.URLField(null=True, blank=True)
description = RichTextField()
when = DateRangeField()
page = ParentalKey('ResumePage', related_name='experience', on_delete=models.CASCADE)
panels = [
FieldPanel("title"),
FieldPanel("url"),
FieldPanel("when"),
FieldPanel("description", classname="full")
]
class IstoriaViazen(models.Model):
title = models.CharField(max_length=80, null=False)
description = models.TextField(null=False)
duration_of_trip = DateRangeField()
created_at = models.DateTimeField(null=False,
blank=False,
default=timezone.now)
creator = models.ForeignKey(User,
related_name='istoria',
on_delete=models.CASCADE)
modified_at = models.DateTimeField(auto_now=True)
def __str__(self):
return f'{self.title}, {self.pk}'
class Reservation(models.Model):
room_id = models.ForeignKey(Room, on_delete=models.CASCADE)
date_range = DateRangeField()
client_name = models.CharField(max_length=256)
client_surname = models.CharField(max_length=256)
contact_number = models.CharField(max_length=16)
email = models.EmailField()
comment = models.TextField(null=True)
def __str__(self):
return f'{self.room_id}, {self.client_name} {self.client_surname}, {self.date_range}'
class Meta:
constraints = [UniqueConstraint(fields=['room_id'], condition=Q(), name='unique_draft_user')]
class Employment(models.Model):
user = models.ForeignKey("accounts.CustomUser",
on_delete=models.PROTECT,
related_name="employments")
shop = models.ForeignKey("Shop",
on_delete=models.PROTECT,
related_name="shop_employments")
role = models.CharField(
max_length=20,
choices=EmployeeRoleChoices.choices,
)
timespan = DateRangeField(null=True)
def __str__(self):
return f"{self.user.first_name} {self.user.last_name} {self.shop.slug}"
class PostgresModel(Model):
int_array = ArrayField(IntegerField(null=True, blank=True), size=3,
null=True, blank=True)
hstore = HStoreField(null=True, blank=True)
json = JSONField(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 Meta:
# Tests schema name in table name.
db_table = '"public"."cachalot_postgresmodel"'
class Calendar(models.Model):
mon = models.BooleanField()
tue = models.BooleanField()
wed = models.BooleanField()
thu = models.BooleanField()
fri = models.BooleanField()
sat = models.BooleanField()
sun = models.BooleanField()
start_date = models.DateField()
end_date = models.DateField(null=True, blank=True)
dates = DateRangeField(null=True)
class Meta:
index_together = (('start_date', 'end_date'), )
def allows(self, date):
if getattr(self, date.strftime('%a').lower()):
for calendar_date in self.calendardate_set.all():
if not calendar_date.operation and calendar_date.contains(
date):
return False
return True
for calendar_date in self.calendardate_set.all():
if calendar_date.operation and calendar_date.special and calendar_date.contains(
date):
return True
def __str__(self):
day_keys = (
'Monday',
'Tuesday',
'Wednesday',
'Thursday',
'Friday',
'Saturday',
'Sunday',
)
day_values = (self.mon, self.tue, self.wed, self.thu, self.fri,
self.sat, self.sun)
days = [day_keys[i] for i, value in enumerate(day_values) if value]
if not days:
return ''
if len(days) == 1:
return f'{days[0]}s only'
if days[0] == 'Monday' and days[-1] == day_keys[len(days) - 1]:
return f'{days[0]} to {days[-1]}'
return f"{'s, '.join(days[:-1])}s and {days[-1]}s"
class Item(models.Model):
# Choice lists used in fields below
DATE_CERTAINTY_CHOICES = [(0, "undated"), (1, "cannot be verified"),
(2, "uncertain"), (3, "possible"), (4, "likely"),
(5, "verified")]
DIGITIZATION_CHOICES = [('yes', 'yes'), ('no', 'no'), ('maybe', 'maybe')]
RECORD_STATUS_CHOICES = [('complete', 'Complete'),
('incomplete', 'Incomplete'),
('review', 'Review'), ('reviewed', 'Reviewed')]
IONA_HOLDINGS_CHOICES = [('original', 'original'), ('copy', 'copy'),
('original_copy', 'original and copy')]
accession_number = models.CharField(max_length=100, blank=True, null=True)
short_title = models.CharField(max_length=50)
title = models.TextField(blank=True, null=True)
pub_date = DateRangeField(blank=True, null=True)
pub_date_certainty = models.SmallIntegerField(
choices=DATE_CERTAINTY_CHOICES, default=0)
size = models.CharField(max_length=100, blank=True, null=True)
physical_description = models.TextField(blank=True, null=True)
tgm_genre = models.ForeignKey(TGM_Genre,
models.SET_NULL,
blank=True,
null=True)
other_description = models.TextField(blank=True, null=True)
condition_notes = models.CharField(max_length=765, blank=True, null=True)
edition = models.CharField(max_length=200, blank=True, null=True)
original_source = models.ForeignKey(Original_Source,
models.SET_NULL,
blank=True,
null=True)
digitization_recommendation = models.CharField(
max_length=20, choices=DIGITIZATION_CHOICES, blank=True, null=True)
volume = models.CharField(max_length=50, blank=True, null=True)
number = models.CharField(max_length=50, blank=True, null=True)
record_status = models.CharField(max_length=20,
choices=RECORD_STATUS_CHOICES)
iona_holdings = models.CharField(max_length=20,
choices=IONA_HOLDINGS_CHOICES,
blank=True,
null=True)
pub_places = models.ManyToManyField(Location, blank=True)
oclc_permalink = models.URLField(max_length=200, blank=True, null=True)
notes = models.TextField(blank=True, null=True)
def __str__(self):
return self.short_title
class MandatAbstrait(UniqueWithinDates, MandatHistoryMixin, models.Model):
person = models.ForeignKey("people.Person",
verbose_name="Élu",
on_delete=models.CASCADE)
dates = DateRangeField(
verbose_name="Début et fin du mandat",
help_text=
"La date de fin correspond à la date théorique de fin du mandat si elle est dans le futur et à la"
" date effective sinon.",
)
email_officiel = models.ForeignKey(
to="people.PersonEmail",
on_delete=models.SET_NULL,
null=True,
verbose_name="Adresse email officielle",
help_text=
"L'adresse avec laquelle contacter l'élu pour des questions officielles",
)
statut = models.CharField(
"Statut",
max_length=3,
choices=STATUT_CHOICES,
default=STATUT_A_VERIFIER_ADMIN,
help_text=
"Indique la qualité de l'information sur cet⋅te élu⋅e, indépendamment des questions politiques et de"
" son appartenance au réseau des élus. Une valeur « Vérifié » signifie que : 1) il a été vérifié que le mandat"
" existe réellement et 2) le compte éventuellement associé appartient bien à la personne élue.",
)
def besoin_validation_personne(self):
return self.statut in [
STATUT_A_VERIFIER_IMPORT, STATUT_A_VERIFIER_ADMIN
]
def actif(self):
return timezone.now().date() in self.dates
@property
def nom_conseil(self):
return self.conseil.nom
class Meta:
abstract = True
class Record(models.Model):
"""A particular span of time and associated data.
The data may contain feature IDs to associate that data with particular
geospatial data, eg a particular NH county. The data can be arbitrarily
complex. For instance, weather observations for a given week, which could
include mean high temperature, mean cloud cover, and total precipitation.
"""
table = models.ForeignKey(GeoKitTable)
date_range = DateRangeField(null=True)
properties = JSONField(null=True)
def __unicode__(self):
"""Explicitly convert primary key to unicode & return it."""
return unicode(self.pk)
def date(self):
return self.date_range.lower
class SeasonalDiscount(DeletableModel):
name = models.CharField(max_length=50, unique=True, verbose_name=_('Name'))
name_ar = models.CharField(max_length=50,
unique=True,
verbose_name=_('Arabic Name'))
name_en = models.CharField(max_length=50,
unique=True,
verbose_name=_('English Name'))
period = DateRangeField(verbose_name=_('Period'))
global_discount = models.DecimalField(max_digits=5,
decimal_places=2,
null=True,
verbose_name=_('Discount'))
products = models.ManyToManyField('Product',
through='ProductOnSeasonalDiscount')
class Meta:
verbose_name = _('Seasonal Discount')
verbose_name_plural = _('Seasonal Discounts')