class Contributor(models.Model):
first_name = CICharField(max_length=100, blank=True, default='', db_index=True)
last_name = CICharField(max_length=100, db_index=True)
middle_name = CICharField(max_length=100, blank=True, default='', db_index=True)
# should be set to true when correctness of name parts is verified
verified = models.BooleanField(default=False)
objects = ContributorManager()
def __str__(self):
return self.full_name()
def full_name(self):
return ' '.join(filter(lambda x: x, (self.first_name, self.middle_name, self.last_name)))
class ChallengeSeries(models.Model):
name = CICharField(max_length=64, blank=False, unique=True)
url = models.URLField(blank=True)
class Meta:
ordering = ("name",)
verbose_name_plural = "Challenge Series"
def __str__(self):
return f"{self.name}"
@property
def filter_tag(self):
cls = re.sub(r"\W+", "", self.name)
return f"series-{cls}"
@property
def badge(self):
return format_html(
(
'<span class="badge badge-info above-stretched-link" '
'title="Associated with {0}"><i class="fas fa-globe fa-fw">'
"</i> {0}</span>"
),
self.name,
)
class TaskType(models.Model):
"""Stores the task type options, eg, Segmentation, Regression, etc."""
type = CICharField(max_length=16, blank=False, unique=True)
class Meta:
ordering = ("type",)
def __str__(self):
return self.type
@property
def filter_tag(self):
cls = re.sub(r"\W+", "", self.type)
return f"task-{cls}"
@property
def badge(self):
return format_html(
(
'<span class="badge badge-light above-stretched-link" '
'title="{0} challenge"><i class="fas fa-tasks fa-fw">'
"</i> {0}</span>"
),
self.type,
)
class ImagingModality(models.Model):
"""Store the modality options, eg, MR, CT, PET, XR."""
modality = CICharField(max_length=16, blank=False, unique=True)
class Meta:
ordering = ("modality",)
def __str__(self):
return self.modality
@property
def filter_tag(self):
cls = re.sub(r"\W+", "", self.modality)
return f"modality-{cls}"
@property
def badge(self):
return format_html(
(
'<span class="badge badge-secondary above-stretched-link" '
'title="Uses {0} data"><i class="fas fa-microscope fa-fw">'
"</i> {0}</span>"
),
self.modality,
)
class Tag(TimeStampedModel):
class Meta:
verbose_name = 'Тег'
verbose_name_plural = 'Теги'
ordering = ['title']
title_validator = TitleValidator()
title = CICharField(verbose_name='Тег',
validators=[title_validator],
max_length=20,
unique=True)
back_color = ColorField(verbose_name='Цвет бэкграунда тега',
default='#000000')
title_color = ColorField(verbose_name='Цвет тега', default='#FFFFFF')
def __str__(self):
return self.title
@cached_property
def events_num(self):
"""
Cached object property that calculates num of events with this Tag.
Returns:
(int): num of events with this tag
"""
return Event.objects.filter(tags=self).count()
class Company(ParanoidModel, CitixenModel):
"""Company model."""
nit = models.CharField(max_length=50)
name = CICharField(max_length=120, unique=True)
email = models.EmailField(max_length=100)
country = models.ForeignKey(Country,
on_delete=models.PROTECT,
related_name='companies')
image_url = models.ImageField(
upload_to=RandomFileName('companies/images/'))
namespace = models.CharField(max_length=60, unique=True)
is_active = models.BooleanField(default=False)
uuid = models.UUIDField(default=uuid4, primary_key=True)
created_by = models.ForeignKey('users.User',
on_delete=models.PROTECT,
related_name='companies')
default_manager = models.Manager()
class Meta:
"""Meta options."""
ordering = ('name', )
def __str__(self):
return self.name
class Supplier(models.Model):
name = CICharField(max_length=150, unique=True)
email = models.EmailField(blank=True)
phone = PossiblePhoneNumberField(blank=True, default="")
address = models.CharField(max_length=255, blank=True)
class Meta:
permissions = ((SupplierPermissions.MANAGE_SUPPLIERS.codename,
"Manage suppliers"), )
def __str__(self):
return self.name
def save(self, *args, **kwargs):
"""
Always save the email as lowercase. Helps identifying unique email
addresses.
The de jure standard is that the local component of email addresses is
case sensitive however the de facto standard is that they are not. In
practice what happens is user confusion over why an email address
entered with camel casing one day does not match an email address
"""
if self.email:
self.email = self.email.strip().lower()
return super().save(*args, **kwargs)
class Collection(SeoModel, PublishableModel):
name = CICharField(max_length=250, unique=True)
slug = models.SlugField(max_length=255, unique=True)
products = models.ManyToManyField(
"products.Product",
blank=True,
related_name="collections",
through="CollectionProduct",
through_fields=("collection", "product"),
)
background_image = VersatileImageField(
upload_to=UploadToPathAndRename(path="collection-backgrounds",
field="name"),
blank=True,
null=True,
)
background_image_alt = models.CharField(max_length=128, blank=True)
description = JSONField(blank=True, default=dict)
class Meta:
ordering = ("slug", )
permissions = ((CollectionPermissions.MANAGE_COLLECTIONS.codename,
"Manage collections"), )
def __str__(self):
return self.name
class BodyStructure(models.Model):
"""Store the organ name and what region it belongs to."""
structure = CICharField(max_length=16, blank=False, unique=True)
region = models.ForeignKey(to=BodyRegion,
on_delete=models.CASCADE,
blank=False)
class Meta:
ordering = ("region", "structure")
def __str__(self):
return f"{self.structure} ({self.region})"
@property
def filter_tag(self):
cls = re.sub(r"\W+", "", self.structure)
return f"structure-{cls}"
@property
def badge(self):
return format_html(
('<span class="badge badge-dark above-stretched-link" '
'title="Uses {0} data"><i class="fas fa-child fa-fw">'
"</i> {0}</span>"),
self.structure,
)
class Tag(models.Model):
"""Descriptor to add to another model."""
name = CICharField(max_length=30, unique=True)
def __str__(self):
"""Convert the model to a human readable string."""
return str(self.name)
class CounterpartyBankAlias(models.Model):
counterparty = models.ForeignKey(Counterparty,
on_delete=models.CASCADE,
related_name='bank_aliases')
alias = CICharField(max_length=254, unique=True)
def __str__(self):
return self.alias
class BodyRegion(models.Model):
""" Stores the anatomy options, eg, Head, Neck, Thorax, etc """
region = CICharField(max_length=16, blank=False, unique=True)
class Meta:
ordering = ("region",)
def __str__(self):
return self.region
class ImagingModality(models.Model):
""" Stores the modality options, eg, MR, CT, PET, XR """
modality = CICharField(max_length=16, blank=False, unique=True)
class Meta:
ordering = ("modality",)
def __str__(self):
return self.modality
class Member(AbstractUser):
username_validator = printable_name
username = CICharField(
_("username"),
max_length=36,
unique=True,
help_text=
_("Required. 36 characters or fewer. Letters, digits and @/./+/-/_ only."
),
validators=[username_validator],
error_messages={
"unique": _("A user with that username already exists.")
},
)
email = models.EmailField(_("email address"), blank=True, unique=True)
state_actor = models.BooleanField(default=False)
is_visible = models.BooleanField(default=False)
is_bot = models.BooleanField(default=False)
is_verified = models.BooleanField(default=False)
bio = models.TextField(blank=True, max_length=400)
discord = models.CharField(blank=True, max_length=36)
discordid = models.CharField(blank=True, max_length=18)
twitter = models.CharField(blank=True, max_length=36)
reddit = models.CharField(blank=True, max_length=36)
team = models.ForeignKey("team.Team",
on_delete=SET_NULL,
null=True,
related_name="members")
email_verified = models.BooleanField(default=False)
email_token = models.CharField(max_length=64, default=secrets.token_hex)
password_reset_token = models.CharField(max_length=64,
default=secrets.token_hex)
points = models.IntegerField(default=0)
leaderboard_points = models.IntegerField(default=0)
last_score = models.DateTimeField(default=timezone.now)
def __str__(self):
return self.username
def can_login(self):
return (self.is_staff or config.get("enable_prelogin")
or (config.get("enable_login")
and config.get("start_time") <= time.time()))
def issue_token(self, owner=None):
from authentication.models import Token
token = Token(user=self, owner=owner)
token.save()
return token.key
def has_2fa(self):
return hasattr(self, 'totp_device') and self.totp_device.verified
def should_deny_admin(self):
return not self.has_2fa() and config.get("enable_force_admin_2fa")
class Counterparty(models.Model):
name = CICharField(max_length=100, unique=True)
is_reviewed = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
class Meta:
verbose_name_plural = _('counterparties')
def __str__(self):
return self.name + (' (archived)' if self.is_archived else '')
class GluuProduct(models.Model):
name = CICharField(max_length=20, unique=True)
version = ArrayField(models.CharField(max_length=20))
os = ArrayField(models.CharField(max_length=20))
def __str__(self):
return self.name
class Category(models.Model):
name = CICharField(max_length=30)
created = models.DateTimeField(auto_now=True)
related_coming = models.ManyToManyField('self',
symmetrical=False,
through='CategoryRelation',
related_name='related_going')
class Meta:
db_table = 'category'
class Project(models.Model):
created_at = models.DateTimeField(default=timezone.now)
name = CICharField(max_length=100, unique=True)
is_active = models.BooleanField(default=True)
def get_absolute_url(self):
return '{}?projects={}'.format(urls.reverse('buggy:bug_list'), self.id)
def __str__(self):
return self.name
class ProductType(models.Model):
name = CICharField(max_length=250, unique=True)
has_variants = models.BooleanField(default=True)
class Meta:
ordering = ("name",)
permissions = ((ProductPermissions.MANAGE_PRODUCT_TYPES.codename, "Manage product types"),)
def __str__(self):
return self.name
class Asset(models.Model):
"""A tradeable asset via Alpaca."""
ACTIVE = "active"
INACTIVE = "inactive"
STATUS_CHOICES = [
(ACTIVE, _("active")),
(INACTIVE, _("inactive")),
]
# Use UUID returned from Alpaca api as primary key
id = models.UUIDField(
primary_key=True,
editable=False,
unique=True,
)
name = models.CharField(
verbose_name=_("name"),
max_length=255,
blank=True,
null=True,
)
asset_class = models.ForeignKey(
AssetClass,
verbose_name=_("asset class"),
related_name="assets",
on_delete=models.CASCADE,
)
easy_to_borrow = models.BooleanField()
exchange = models.ForeignKey(
Exchange,
verbose_name=_("exchange"),
related_name="assets",
on_delete=models.CASCADE,
)
marginable = models.BooleanField()
shortable = models.BooleanField()
status = models.CharField(
verbose_name=_("status"),
choices=STATUS_CHOICES,
max_length=56,
)
symbol = CICharField(
verbose_name=_("symbol"),
unique=True,
max_length=56,
)
tradable = models.BooleanField()
class Meta:
verbose_name = _("asset")
verbose_name_plural = _("assets")
def __str__(self):
return f"{self.symbol}"
class User(AbstractBaseUser):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
email = CIEmailField(verbose_name="email",
max_length=100, unique=True)
username = CICharField(max_length=50, unique=True)
first_name = CICharField(max_length=100)
last_name = CICharField(max_length=100)
bio = TextField(blank=True, null=True)
date_joined = DateTimeField(
verbose_name='date joined', auto_now_add=True)
last_login = DateTimeField(verbose_name='last login', auto_now=True)
is_admin = BooleanField(default=False)
is_active = BooleanField(default=False)
is_staff = BooleanField(default=False)
is_superuser = BooleanField(default=False)
photo = ImageField(
upload_to='user_images', default='user_images/avatar.png')
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
objects = MyAccountManager()
def __str__(self):
return self.email
# for permissions, to keep it simple, all admins have all permissions
def has_perm(self, perm, obj=None):
return self.is_admin
# does this user has permission to view app, always yes for simplicity
def has_module_perms(self, app_label):
return True
def save(self, *args, **kwargs):
super(User, self).save(*args, **kwargs)
# change image dimensions before saving to ensure consistent displays
if self.photo:
image = Image.open(self.photo)
size = (1024, 683)
image = image.resize(size, Image.ANTIALIAS)
image.save(self.photo.path)
class TicketStatus(models.Model):
name = CICharField(max_length=30, unique=True)
slug = models.SlugField(max_length=30)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = 'Ticket Status'
class TaskType(models.Model):
"""
Stores the task type options, eg, Segmentation, Regression, Prediction, etc
"""
type = CICharField(max_length=16, blank=False, unique=True)
class Meta:
ordering = ("type",)
def __str__(self):
return self.type
class Color(models.Model):
class Meta:
verbose_name = _('Color')
verbose_name_plural = _('Colors')
definition = CICharField(max_length=30,
unique=True,
verbose_name=_('Definition'))
def __str__(self):
return self.definition
class Team(models.Model):
name = CICharField(max_length=36, unique=True, validators=[printable_name])
is_visible = models.BooleanField(default=True)
password = models.CharField(max_length=64)
owner = models.ForeignKey(get_user_model(),
on_delete=CASCADE,
related_name="owned_team")
description = models.TextField(blank=True, max_length=400)
points = models.IntegerField(default=0)
leaderboard_points = models.IntegerField(default=0)
last_score = models.DateTimeField(default=timezone.now)
size_limit_exempt = models.BooleanField(default=False)
class DenyListWord(models.Model):
word = CICharField(max_length=255, unique=True)
# A history of changes to this model, using django-simple-history.
history = HistoricalRecords()
def __str__(self):
return self.word
class Meta:
verbose_name = "Deny-list word"
verbose_name_plural = "Deny-list words"
class BodyStructure(models.Model):
""" Stores the organ name and what region it belongs to """
structure = CICharField(max_length=16, blank=False, unique=True)
region = models.ForeignKey(
to=BodyRegion, on_delete=models.CASCADE, blank=False,
)
class Meta:
ordering = ("region", "structure",)
def __str__(self):
return f"{self.structure} ({self.region})"
class Product(models.Model):
name = CICharField(max_length=254, unique=True)
type = models.ForeignKey(ProductType,
on_delete=models.PROTECT,
related_name='products')
description = models.TextField(null=True, blank=True, default='')
unit = models.ForeignKey(Unit,
on_delete=models.PROTECT,
related_name='products')
is_archived = models.BooleanField(default=False)
def __str__(self):
return self.name + (' (archived)' if self.is_archived else '')
class City(CitixenModel):
"""location model."""
class Types(models.TextChoices):
locality = 'locality', _('Locality')
administrative_area_level_1 = 'administrative_area_level_1', _(
'Administrative Area Level 1')
administrative_area_level_2 = 'administrative_area_level_2', _(
'Administrative Area Level 2')
administrative_area_level_3 = 'administrative_area_level_3', _(
'Administrative Area Level 3')
administrative_area_level_4 = 'administrative_area_level_4', _(
'Administrative Area Level 4')
administrative_area_level_5 = 'administrative_area_level_5', _(
'Administrative Area Level 5')
code = models.IntegerField(null=True)
name = models.CharField(max_length=120)
flag = models.ImageField(upload_to=RandomFileName('locations/images/'))
country = models.ForeignKey(Country, on_delete=models.PROTECT)
type = models.CharField(max_length=60,
choices=Types.choices,
default=Types.locality)
bounds = JSONField(
null=True,
blank=True,
validators=[
JSONSchemaValidator(limit_value=schema_location_area_bound)
])
parent = models.ForeignKey('self',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='locations')
# Zoom
zoom_desktop = models.IntegerField(default=14)
zoom_mobile = models.IntegerField(default=13)
# Google data
google_map_key = CICharField(max_length=150, unique=True)
geo_code_json = JSONField(null=True, blank=True)
class Meta:
"""Meta options."""
ordering = ('name', )
unique_together = [['country', 'code']]
def __str__(self):
return f'{self.name} is a location of {self.country}'
class Band(TimeStampedModel):
# data_created default now
name = CICharField("Band / Artist Name", max_length=64)
catalogue_name = CICharField(max_length=72, blank=True)
slug = AutoSlugField("Band Address",
unique=True,
always_update=False,
populate_from="name")
profile = models.TextField("Profile", blank=True)
#hometown =
homecounty = models.ForeignKey('County',
null=False,
blank=False,
on_delete=models.DO_NOTHING)
#category
def save(self, *args, **kwargs):
self.catalogue_name = de_article(self.name)
super().save(*args, **kwargs)
def __str__(self):
return self.name
