class Activity(models.Model):
"""
Model for Activities done by a profile.
"""
content_object = GenericForeignKey('content_type', 'object_id')
content_type = models.ForeignKey(ContentType, on_delete=models.PROTECT)
created = AutoCreatedField()
fid = models.URLField(editable=False, max_length=255, unique=True)
object_id = models.PositiveIntegerField()
profile = models.ForeignKey("users.Profile", on_delete=models.CASCADE)
type = EnumField(ActivityType)
class Node(ModelBase):
blocked = models.BooleanField(default=False)
country = CountryField(blank=True)
features = JSONField(default={}, blank=True)
hide_from_list = models.BooleanField(default=False)
host = models.CharField(max_length=128, unique=True)
ip = models.GenericIPAddressField(blank=True, null=True)
last_success = models.DateTimeField(null=True, db_index=True)
name = models.CharField(max_length=300)
open_signups = models.BooleanField()
organization_account = models.CharField(max_length=256, blank=True)
organization_contact = models.CharField(max_length=256, blank=True)
organization_name = models.CharField(max_length=128, blank=True)
protocols = models.ManyToManyField('thefederation.Protocol', related_name='nodes', blank=True)
relay = EnumField(Relay, default=Relay.NONE)
server_meta = JSONField(default={}, blank=True)
services = models.ManyToManyField('thefederation.Service', related_name='nodes', blank=True)
platform = models.ForeignKey('thefederation.Platform', on_delete=models.PROTECT, related_name='nodes')
version = models.CharField(max_length=128, blank=True)
objects = NodeQuerySet.as_manager()
def __str__(self):
return f"{self.name} ({self.host})"
def save(self, *args, **kwargs):
clean_name = re.match(r'[a-zA-Z]*', self.name)
if clean_name:
if self.platform.name == clean_name[0].lower():
self.name = self.host
self.version = self.platform.clean_version(self.version)
super().save(*args, **kwargs)
@property
def clean_version(self):
"""
Get the version number cleaned as a number.
"""
if not self.version:
return
# Strip all non-numbers
cleaned_str = "".join([c for c in self.version if c.isnumeric() or c == "."])
# Split into tuple
return tuple([int(i) for i in cleaned_str.split(".")])
@cached_property
def preferred_method(self):
"""
Calls a function to get the preferred method.
Function is passed in the version.
:return:
"""
return self.platform.get_method(self.clean_version)
class EntityTypeState(EntityTypeBase):
""" Used to conglomerate AttributeTypes into a set """
entity_name = 'State'
dtype = 'state'
media = ManyToManyField(EntityTypeMediaBase)
markers = BooleanField(default=False)
interpolation = EnumField(InterpolationMethods,
default=InterpolationMethods.NONE)
association = CharField(max_length=64,
choices=AssociationTypes,
default=AssociationTypes[0][0])
class Membership(Model):
"""Stores a user and their access level for a project.
"""
project = ForeignKey(Project, on_delete=CASCADE)
user = ForeignKey(User, on_delete=CASCADE)
permission = EnumField(Permission,
max_length=1,
default=Permission.CAN_EDIT)
def __str__(self):
return f'{self.user} | {self.permission} | {self.project}'
class AtividadeLazer(Atividade):
dt_inicio = models.DateField()
dt_fim = models.DateField()
tipo_lazer = EnumField(TipoLazer, default=TipoLazer.DEFAULT)
Atividade.evento = models.ForeignKey(Evento,
on_delete=models.CASCADE,
related_name='atividades_lazer')
def validar_data_atividade_lazer(self):
if (dt_fim <= dt_inicio):
raise Exception("Data final invalida")
class Area(TimeStampedModel):
"""
In Finnish: Alue
"""
type = EnumField(AreaType, verbose_name=_("Area type"), max_length=31)
identifier = models.CharField(verbose_name=_("Identifier"), max_length=255)
external_id = models.CharField(verbose_name=_("External ID"),
max_length=255)
geometry = models.MultiPolygonField(srid=4326,
verbose_name=_("Geometry"),
null=True,
blank=True)
metadata = JSONField(verbose_name=_("Metadata"),
encoder=DjangoJSONEncoder,
null=True,
blank=True)
source = models.ForeignKey(
AreaSource,
verbose_name=_("Source"),
related_name="areas",
on_delete=models.PROTECT,
)
class Meta:
constraints = [
models.UniqueConstraint(
fields=["type", "identifier", "external_id", "source"],
name="leasing_area_type_identifier_externalid_source_key",
)
]
verbose_name = pgettext_lazy("Model name", "Area")
verbose_name_plural = pgettext_lazy("Model name", "Area")
def get_land_identifier(self):
return "{}-{}-{}-{}{}".format(
self.metadata.get("municipality", "0")
if self.metadata.get("municipality") else "0",
self.metadata.get("district", "0")
if self.metadata.get("district") else "0",
self.metadata.get("group", "0")
if self.metadata.get("group") else "0",
self.metadata.get("unit", "0")
if self.metadata.get("unit") else "0",
"-{}".format(self.metadata.get("mvj_unit", "0"))
if "mvj_unit" in self.metadata else "",
)
def get_normalized_identifier(self):
return normalize_identifier(self.get_land_identifier())
def get_denormalized_identifier(self):
return denormalize_identifier(self.identifier)
class ApoioEvento(models.Model):
evento = models.ForeignKey(Evento,
on_delete=models.CASCADE,
related_name='apoio_evento')
instituicao = models.ForeignKey(Instituicao, on_delete=models.CASCADE)
tipo_apoio = EnumField(TipoApoio, default=TipoApoio.APOIO)
def get_evento(self):
return self.evento
def get_instituicao(self):
return self.instituicao
class MatchParticipant(models.Model):
match = models.ForeignKey(Match,
on_delete=models.CASCADE,
related_name='participants')
player = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
index = models.PositiveSmallIntegerField()
score = models.IntegerField(default=0)
activity = models.TextField()
chat = models.CharField(max_length=200)
drawoffer = models.BooleanField(default=False)
movekind = EnumField(MoveKind, max_length=1, default=MoveKind.ATTACK)
class MyModel(models.Model):
color = EnumField(Color, max_length=1)
taste = EnumField(Taste, default=Taste.SWEET)
taste_null_default = EnumField(Taste, null=True, blank=True, default=None)
taste_int = NumEnumField(Taste, default=Taste.SWEET)
default_none = NumEnumField(Taste, default=None, null=True, blank=True)
nullable = NumEnumField(Taste, null=True, blank=True)
random_code = models.TextField(null=True, blank=True)
zero_field = NumEnumField(ZeroEnum, null=True, default=None, blank=True)
int_enum = NumEnumField(IntegerEnum, null=True, default=None, blank=True)
sub_int_enum = NumEnumSubField('int_enum',
SubIntegerEnum,
null=True,
default=None,
blank=True)
zero2 = NumEnumField(ZeroEnum, default=ZeroEnum.ZERO)
labeled_enum = EnumField(LabeledEnum, blank=True, null=True)
class HomeDevice(models.Model):
'''define meta data'''
class Meta:
db_table = 'home_device'
'''This is a list of lists that must be unique when considered together'''
unique_together = ['home', 'device_uid']
'''4 colmns in the table'''
home = models.ForeignKey(Home, on_delete=models.deletion.CASCADE)
device_uid = models.CharField(max_length=100, blank=False, null=False)
timestamp = models.DateTimeField(default=timezone.now)
type = EnumField(DeviceType, max_length=40)
class Errand(BaseClass):
title = models.CharField(null=False, blank=False, max_length=100)
description = models.TextField()
created_date = models.DateTimeField(null=True)
tags = models.TextField(null=True, blank=True)
priority = EnumField(Priority, max_length=1, default=Priority.Low)
def __str__(self):
return self.title
class Meta:
ordering = ('created_date', )
class TournamentRound(models.Model):
"""Database model for a Tournament Round"""
class Meta:
ordering = ['id']
tournament = models.ForeignKey(
Tournament,
on_delete=models.DO_NOTHING
)
name = EnumField(enums.TournamentRoundChoice, max_length=20)
class StateInformationFieldType(UUIDModel, TimestampModel):
slug = models.SlugField("Name", max_length=50, unique=True)
long_name = models.CharField("Long Name", max_length=200)
field_format = EnumField(
enums.StateFieldFormats, null=True, default=enums.StateFieldFormats.MARKDOWN
)
class Meta(object):
ordering = ["slug"]
def __str__(self):
return self.slug
class Order(models.Model):
name = models.CharField(max_length=40, null=False)
owner = models.ForeignKey(PersonProfile, on_delete=models.CASCADE, related_name="orders", null=False)
created = models.DateTimeField(auto_now_add=True)
status = EnumField(OrderStatus, default=OrderStatus.RECEBIDO)
dish_order = models.ManyToManyField(Dish, related_name="orders")
class Meta:
ordering=('name',)
def __str__(self):
return self.name
class GerenciaEvento(models.Model):
tipo_gerente = EnumField(TipoGerencia,
max_length=25,
default=TipoGerencia.PADRAO)
gerente = models.ForeignKey("user.Usuario",
related_name="usuario_gerente",
default="")
evento = models.ForeignKey("core.Evento",
related_name="evento_gerente",
default="")
class PersonContact(Contact):
default_tax_group_getter = CustomerTaxGroup.get_default_person_group
default_contact_group_identifier = DEFAULT_PERSON_GROUP_IDENTIFIER
default_contact_group_name = _("Person Contacts")
user = models.OneToOneField(
settings.AUTH_USER_MODEL, blank=True, null=True, related_name="contact",
verbose_name=_('user')
)
gender = EnumField(Gender, default=Gender.UNDISCLOSED, max_length=4, verbose_name=_('gender'))
birth_date = models.DateField(blank=True, null=True, verbose_name=_('birth date'))
first_name = models.CharField(max_length=30, blank=True, verbose_name=_('first name'))
last_name = models.CharField(max_length=50, blank=True, verbose_name=_('last name'))
# TODO: Figure out how/when/if the name and email fields are updated from users
class Meta:
verbose_name = _('person')
verbose_name_plural = _('persons')
def __init__(self, *args, **kwargs):
name = kwargs.get('name')
if name:
(first_name, last_name) = _split_name(name)
kwargs['first_name'] = first_name
kwargs['last_name'] = last_name
super(PersonContact, self).__init__(*args, **kwargs)
@property
def name(self):
names = (self.first_name, self.last_name)
return " ".join(x for x in names if x)
@name.setter
def name(self, value):
(self.first_name, self.last_name) = _split_name(value)
def save(self, *args, **kwargs):
if self.user_id and not self.pk: # Copy things
user = self.user
if not self.name:
self.name = user.get_full_name()
if not self.email:
self.email = user.email
if not self.first_name and not self.last_name:
self.first_name = user.first_name
self.last_name = user.last_name
return super(PersonContact, self).save(*args, **kwargs)
@property
def is_all_seeing(self):
if self.user_id:
return self.user.is_superuser
class Home(models.Model):
class Meta:
db_table = 'home'
def __unicode__(self):
return "Home - {0}".format(self.name)
name = models.CharField(max_length=100)
location = models.CharField(max_length=1000)
description = models.CharField(max_length=1000, null=True)
type = EnumField(HomeType, default=HomeType.UNKNOWN, max_length=20)
owner = models.ForeignKey(PowernetUser, on_delete=models.deletion.CASCADE)
class LeaseholdTransferParty(NameModel):
"""
In Finnish: Vuokraoikeuden siirron osapuoli
"""
# In Finnish: Tyyppi
type = EnumField(LeaseholdTransferPartyType)
transfer = models.ForeignKey(
LeaseholdTransfer,
verbose_name=_("Leasehold transfer"),
on_delete=models.CASCADE,
related_name="parties",
)
# In Finnish: Y-tunnus
business_id = models.CharField(
verbose_name=_("Business ID"),
max_length=255,
null=True,
blank=True,
validators=[validate_business_id],
)
# In Finnish: Henkilötunnus
national_identification_number = models.CharField(
verbose_name=_("National identification number"),
max_length=255,
null=True,
blank=True,
)
# In Finnish: Jaettava / Osoittaja
share_numerator = models.PositiveIntegerField(
verbose_name=_("Numerator"), null=True, blank=True
)
# In Finnish: Jakaja / Nimittäjä
share_denominator = models.PositiveIntegerField(
verbose_name=_("Denominator"), null=True, blank=True
)
class Meta(NameModel.Meta):
verbose_name = pgettext_lazy("Model name", "Leasehold transfer party")
verbose_name_plural = pgettext_lazy("Model name", "Leasehold transfer parties")
ordering = ("-type",)
def __str__(self):
if self.share_numerator and self.share_denominator:
return "{} {}/{}: {}".format(
self.type, self.share_numerator, self.share_denominator, self.name
)
return "{}: {}".format(self.type, self.name)
class MyModel(models.Model):
class Color(Enum):
RED = 'r'
GREEN = 'g'
BLUE = 'b'
color = EnumField(Color, max_length=1)
class Taste(Enum):
SWEET = 1
SOUR = 2
BITTER = 3
SALTY = 4
UMAMI = 5
class ZeroEnum(Enum):
ZERO = 0
ONE = 1
class IntegerEnum(IntEnum):
A = 0
B = 1
taste = EnumField(Taste, default=Taste.SWEET)
taste_null_default = EnumField(Taste, null=True, blank=True, default=None)
taste_int = EnumIntegerField(Taste, default=Taste.SWEET)
default_none = EnumIntegerField(Taste, default=None, null=True, blank=True)
nullable = EnumIntegerField(Taste, null=True, blank=True)
random_code = models.TextField(null=True, blank=True)
zero_field = EnumIntegerField(ZeroEnum,
null=True,
default=None,
blank=True)
int_enum = EnumIntegerField(IntegerEnum,
null=True,
default=None,
blank=True)
class SocialNetworkItem(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
client_branch = models.ForeignKey(
"ClientBranch",
on_delete=models.PROTECT,
db_column='client_branch',
blank=True,
null=True)
status = EnumField(
ItemStatusType, max_length=20, default=ItemStatusType.ACTIVE)
is_principal = models.BooleanField(default=True)
item = models.CharField(max_length=100, blank=True, null=True)
social_network_type = EnumField(
SocialNetworkItemType,
max_length=100,
default=SocialNetworkItemType.SKYPE)
author = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.PROTECT,
blank=True,
null=True,
editable=False)
creation_date = models.DateTimeField(blank=True, null=True, editable=False)
update_date = models.DateTimeField(blank=True, null=True, editable=False)
def save(self, *args, **kwargs):
if self.creation_date is None:
self.creation_date = timezone.now()
self.update_date = timezone.now()
self.author = get_request().user
super(SocialNetworkItem, self).save(*args, **kwargs)
def __str__(self):
return str(self.id)
class Meta:
app_label = 'client'
db_table = 'cli_social_network_item'
verbose_name = _(__name__ + ".table_name")
verbose_name_plural = _(__name__ + ".table_name_plural")
class MyModel(models.Model):
color = EnumField(Color, max_length=1)
color_not_editable = EnumField(Color,
max_length=1,
editable=False,
null=True)
taste = EnumField(Taste, default=Taste.SWEET)
taste_not_editable = EnumField(Taste, default=Taste.SWEET, editable=False)
taste_null_default = EnumField(Taste, null=True, blank=True, default=None)
taste_int = EnumIntegerField(Taste, default=Taste.SWEET)
default_none = EnumIntegerField(Taste, default=None, null=True, blank=True)
nullable = EnumIntegerField(Taste, null=True, blank=True)
random_code = models.TextField(null=True, blank=True)
zero_field = EnumIntegerField(ZeroEnum,
null=True,
default=None,
blank=True)
int_enum = EnumIntegerField(IntegerEnum,
null=True,
default=None,
blank=True)
int_enum_not_editable = EnumIntegerField(IntegerEnum,
default=IntegerEnum.A,
editable=False)
zero2 = EnumIntegerField(ZeroEnum, default=ZeroEnum.ZERO)
labeled_enum = EnumField(LabeledEnum, blank=True, null=True)
class BaseReportForm(forms.Form):
report = forms.CharField(widget=HiddenInput)
shop = forms.ChoiceField(label=_("Shop"),
help_text=_("Filter report results by shop."))
date_range = EnumField(DateRangeChoices).formfield(
form_class=ChoiceField,
label=_("Date Range"),
initial=DateRangeChoices.RUNNING_WEEK,
help_text=_("Filter report results by a date range."))
start_date = DateField(label=_("Start Date"),
required=False,
help_text=_("For a custom date range."))
end_date = DateField(label=_("End Date"),
required=False,
help_text=_("For a custom date range."))
writer = forms.ChoiceField(
label=_("Output Format"),
initial="html",
choices=[(name, name.title()) for name in sorted(get_writer_names())],
help_text=_("The format to show the report results."))
force_download = forms.BooleanField(
required=False,
label=_("Download"),
help_text=_("Check this to download the report."))
def __init__(self, *args, **kwargs):
super(BaseReportForm, self).__init__(*args, **kwargs)
self.fields["shop"].choices = [(shop.pk, shop.name)
for shop in Shop.objects.all()]
def clean(self):
data = self.cleaned_data
if data.get("date_range") == DateRangeChoices.CUSTOM:
try:
data["date_range"] = parse_date_range(
(data["start_date"], data["end_date"]))
except Exception as exc:
self.add_error("__all__", force_text(exc))
return data
def get_report_instance(self):
"""
:rtype: shuup.reports.reporter.base.ShuupReportBase
"""
from shuup.reports.report import get_report_class
data = self.cleaned_data
writer_name = data.pop("writer")
report_class = get_report_class(data["report"])
report = report_class(writer_name=writer_name, **data)
return report
class VehicleChangeHistory(Commentable):
create_timestamp = models.DateTimeField(
auto_now_add=True,
blank=True,
null=True,
db_comment='When the change was made')
create_user = models.ForeignKey(
'UserProfile',
related_name='history',
blank=True,
null=True,
on_delete=models.CASCADE,
db_comment='User who made the change to the record')
make_id = models.IntegerField(
db_comment="ID referencing the vehicle_make table")
vehicle_class_code_id = models.IntegerField(
db_comment="ID referencing the vehicle_class_code table")
vehicle_fuel_type_id = models.IntegerField(
db_comment="ID referencing the vehicle_class_code table")
range = models.IntegerField(db_comment="Vehicle Range in km")
model_name = models.CharField(blank=True,
db_comment="Model and trim of vehicle",
max_length=250,
null=True)
model_year_id = models.IntegerField(
db_comment="ID referencing the model_year table")
validation_status = EnumField(
VehicleDefinitionStatuses,
max_length=20,
null=True,
default=VehicleDefinitionStatuses.NEW,
db_comment="The validation status of the vehicle. Valid statuses: "
"{statuses}".format(
statuses=[c.name for c in VehicleDefinitionStatuses]))
vehicle = models.ForeignKey('Vehicle',
on_delete=models.CASCADE,
related_name='history')
user_role = ArrayField(
models.CharField(max_length=50, blank=False, null=True),
null=True,
db_comment="The role (or roles) assigned to the user at the time they "
"made a change to a vehicle record. Role values are "
"generated from Keycloak and are stored in a "
"comma-delimited string.")
class Meta:
db_table = 'vehicle_change_history'
db_table_comment = \
"Keeps track of the changes done on the vehicle table." \
"Each row should contain the last known values of the vehicle row, " \
"before it's updated or created."
class DecisionType(NameModel):
"""
In Finnish: Päätöksen tyyppi
"""
kind = EnumField(DecisionTypeKind,
verbose_name=_("Decision type kind"),
null=True,
blank=True,
max_length=30)
class Meta(NameModel.Meta):
verbose_name = pgettext_lazy("Model name", "Decision type")
verbose_name_plural = pgettext_lazy("Model name", "Decision types")
class CampaignContentRelation(models.Model):
campaign = models.ForeignKey(Campaign,
related_name='rel_campaign',
on_delete=models.CASCADE)
content = models.ForeignKey(Content,
related_name='rel_content',
on_delete=models.CASCADE)
type = EnumField(CampaignContentRelationType,
default=CampaignContentRelationType.CREATED_ON,
max_length=1000)
def __str__(self):
return str(self.content) + " | " + self.campaign.title
class Comment(models.Model):
content = models.TextField()
timestamp = models.DateTimeField(auto_now_add=True)
reply = models.ForeignKey('Comment', null=True, related_name='replies', on_delete=models.CASCADE)
rating = EnumField(Rating, max_length=8, null=True)
user = models.ForeignKey(User, on_delete=models.CASCADE)
post = models.ForeignKey(Post, on_delete=models.CASCADE)
class Meta:
db_table = 'Comment'
def __str__(self):
return '{} - {}'.format(self.user.username, str(self.content))
class GComponent(models.Model):
class ComponentType(Enum): # A subclass of Enum
Block = "Block"
Section = "Section"
Course = "Course"
Page = "Page"
link = models.CharField(max_length=2000)
mechanics = models.ManyToManyField(GMechanic)
interacting_users = models.ManyToManyField(Gamer)
component_type = EnumField(ComponentType,max_length=7)
class MyModel(models.Model):
class Color(Enum):
RED = 'r'
GREEN = 'g'
BLUE = 'b'
color = EnumField(Color, max_length=1)
class Taste(Enum):
SWEET = 1
SOUR = 2
BITTER = 3
SALTY = 4
UMAMI = 5
taste = EnumField(Taste, default=Taste.SWEET)
taste_int = EnumIntegerField(Taste, default=Taste.SWEET)
default_none = EnumIntegerField(Taste, default=None, null=True, blank=True)
nullable = EnumIntegerField(Taste, null=True, blank=True)
random_code = models.TextField(null=True, blank=True)
class ModelRun(models.Model):
def get_input_file_name(instance, filename):
return str(instance.uid)
uid = models.UUIDField(verbose_name=_("uid"), default=uuid.uuid4, editable=False, unique=True, db_index=True)
email = models.EmailField(verbose_name=_("email"))
input_file = models.FileField(verbose_name=_("input file"), upload_to=get_input_file_name)
task_id = models.CharField(verbose_name=_("celery task id"), max_length=100, null=True)
status = EnumField(ModelRunStatus, verbose_name=_("status"), default=ModelRunStatus.PENDING)
def execute(self):
self.task_id = tasks.run_model.delay(self.id).id
self.save()
class GithubIssueBounty(DateModel):
issue_nr = models.IntegerField()
url = models.URLField()
amount = MoneyField()
status = EnumField(GithubIssueBountyStatus, max_length=50)
@classmethod
def close(cls, issue_url: str) -> bool:
try:
bty = cls.objects.get(url=issue_url)
except cls.DoesNotExist:
return False
else:
return bty.delete()
