class ClearPassLoginAttempt(Model):
ACCEPT_RESULT = 0
REJECT_RESULT = 1
TIMEOUT_RESULT = 2
RESULT_CHOICES = (
(ACCEPT_RESULT, 'ACCEPT'),
(REJECT_RESULT, 'REJECT'),
(TIMEOUT_RESULT, 'TIMEOUT'),
)
username = CharField(max_length=50, blank=True, null=True, db_index=True)
time = DateTimeField()
service = CharField(max_length=100)
roles = ArrayField(CharField(max_length=50))
client_mac_address = MACAddressField(db_index=True)
enforcement_profiles = ArrayField(CharField(max_length=100))
result = PositiveSmallIntegerField(choices=RESULT_CHOICES)
clearpass_ip = GenericIPAddressField()
alerts = TextField(null=True, blank=True)
def __str__(self):
return ('Username: '******', Service: '
+ str(self.service) + ', Roles: ' + str(self.roles) + '\n')
@cached_property
def client_mac_address_formatted(self):
from .utils import mac_address_with_colons # noqa
return mac_address_with_colons(self.client_mac_address)
class Meta:
verbose_name = 'ClearPass Login Attempt'
class PostModel(models.Model):
title_of_post = models.CharField(max_length=100)
description_of_post = models.TextField(max_length=None)
post_made_by = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
date_created = models.DateTimeField(verbose_name="date published",
auto_now_add=True)
application_deadline = models.DateField(
verbose_name="Application Deadline",
auto_now=False,
auto_now_add=False,
default=timezone.now)
skills_needed = models.TextField(max_length=None, blank=True)
num_of_positions = models.IntegerField(max_length=None)
genres = ArrayField(models.CharField(max_length=50, blank=True),
default=list)
current_num_of_accepted_applicants = models.IntegerField(max_length=None,
default=0)
application_completed = models.BooleanField(default=False)
applicants = ArrayField(models.IntegerField(), default=list, blank=True)
accepted_applicants = ArrayField(models.IntegerField(),
default=list,
blank=True)
application_questions = ArrayField(models.TextField(max_length=None,
blank=True),
default=list,
blank=True)
def __str__(self):
return self.title_of_post
class Account(AbstractBaseUser):
profile_pic = models.ImageField(upload_to='media',default ='/media/default_profile.png')
email = models.EmailField(verbose_name="email", max_length=60,unique=True)
first_name = models.CharField(verbose_name="first_name",max_length=20,blank=True)
last_name = models.CharField(verbose_name="last_name",max_length=20,blank=True)
bio = models.TextField(default='No Bio At The Moment')
university = models.CharField(verbose_name="university",max_length = 1000,default ="")
major = models.CharField(verbose_name="major",max_length=1000,default="")
school_year = models.CharField(choices = (("1", "Freshman"),("2", "Sophomore"),("3", "Junior"),("4", "Senior"), ("5", "Other")),default="",max_length=1)
chat_keys = ArrayField(models.BigIntegerField(), default=list, blank=True)
friends = ArrayField(models.IntegerField(), default=list, blank=True)
date_joined = models.DateTimeField(verbose_name="date joined",auto_now_add=True)
last_login = models.DateTimeField(verbose_name="last login", auto_now_add=True)
is_admin = models.BooleanField(default=False)
is_active = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
is_superuser = models.BooleanField(default=False)
show_to_public = ArrayField(models.BooleanField(), default=[True, True, True, True, True, True, True, True])
#[profile_pic, email, first_name, last_name, university, major, school_year, date_joined]
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name','last_name','university','major','school_year']
objects = MyAccountManager()
def __str__(self):
return self.email
def has_perm(self,perm,obj=None):
return self.is_admin
def has_module_perms(self, app_label):
return True
class ChatModel(models.Model):
users = ArrayField(models.IntegerField(), default=list, blank=True)
owner = models.IntegerField(default=-1)
url = models.TextField(blank=True, max_length=50)
key = models.BigIntegerField(blank=False, default=0)
chat_name = models.CharField(max_length=50, blank=True, default='Chat')
messages = ArrayField(models.TextField(), default=[])
last_updated = models.DateTimeField(verbose_name="date_updated",
default=timezone.now())
class MutationalSignatureMinimisationResult(models.Model):
mutational_signature = models.ForeignKey(MutationalSignature, on_delete=CASCADE)
result_type = models.CharField(max_length=1, choices=MinimisationResultType.choices)
iteration = models.IntegerField()
solution_array = ArrayField(FloatField())
fit_data = ArrayField(FloatField())
diff_data = ArrayField(FloatField())
ls_sum_diff = models.FloatField()
la_sum_diff = models.FloatField()
class Meta:
unique_together = ("mutational_signature", "result_type", "iteration")
class WorkStudyApplication(models.Model):
registration_entry = models.OneToOneField(RegistrationEntry,
on_delete=models.CASCADE,
related_name='work_study')
nickname_and_pronouns = models.CharField(max_length=255, blank=True)
phone_number = models.CharField(max_length=50)
can_receive_texts_at_phone_number = models.TextField(choices=YesNo.choices)
home_timezone = models.TextField() # We'll specify choices in the form
other_timezone = models.CharField(max_length=255, blank=True)
# Do we need "which conclave program are you enrolling in?"
has_been_to_conclave = models.TextField(choices=YesNo.choices)
has_done_work_study = models.TextField(choices=YesNo.choices)
student_info = models.TextField(blank=True)
job_preferences = ArrayField(
models.CharField(max_length=100, choices=WorkStudyJob.choices))
relevant_job_experience = models.TextField()
other_skills = models.TextField(blank=True)
other_info = models.TextField(blank=True)
def clean(self) -> None:
super().clean()
if len(self.job_preferences) < 2:
raise ValidationError(
{'job_preferences': 'Please choose at least two options.'})
class Comment(models.Model):
class Meta:
db_table = "comments"
verbose_name = 'Комментарий'
verbose_name_plural = 'Комментарии'
path = ArrayField(models.IntegerField())
article_id = models.ForeignKey(Article, on_delete=models.PROTECT)
author_id = models.ForeignKey(User, on_delete=models.PROTECT)
content = models.TextField('Комментарий')
pub_date = models.DateTimeField('Дата комментария', default=timezone.now)
def __str__(self):
return self.content[0:200]
def get_offset(self):
level = len(self.path) - 1
if level > 5:
level = 5
return level
def get_col(self):
level = len(self.path) - 1
if level > 5:
level = 5
return 12 - level
class Paciente(models.Model):
no_expediente = models.IntegerField('Número de expediente',
validators=[
RegexValidator(
regex=r"^[0-9]+$",
message='Solo números.')
],
unique=True)
tipo_sangre = models.CharField(
'Tipo de sangre',
validators=[
RegexValidator(
regex=r"^(A|B|AB|O)[+-]$",
message=
'Solo se admite el tipo de sangre (A+|A-|B+|B-|C+|C-|AB+|AB-).'
)
],
max_length=3)
"""
Se implementa el validador custom en el campo JSONField
y se pasa como parametro un Schema JSON valido, que realizara
la comprobación de lo que guarde sea valido.
"""
alergias = ArrayField(JSONField(validators=[
JSONFieldSchemaValidator(
limit_value=get_schema.get_schema('schemas/alergias.json'))
]),
size=3)
def __str__(self):
return str(self.no_expediente) + ' - ' + self.tipo_sangre + ' - ' + [
' - '.join(list(alergia.values())) for alergia in self.alergias
][0]
class TransactionInput(TimeStampedModel):
transaction = models.ForeignKey(
"transactions.Transaction",
related_name="vin",
on_delete=models.CASCADE,
)
txid = HexField(max_length=64,
help_text="transaction hash in hex (32 bytes)")
vout = models.BigIntegerField()
sequence = models.BigIntegerField()
script_sig = HexField(max_length=20000)
# witness stack items
witness = ArrayField(HexField(max_length=20000), null=True)
def serialize(self):
raw_tx = b""
raw_tx += bytes.fromhex(self.txid)
raw_tx += self.vout.to_bytes(4, "little")
script_sig_as_bytes = bytes.fromhex(self.script_sig)
raw_tx += encode_as_varint(len(script_sig_as_bytes))
raw_tx += script_sig_as_bytes
return raw_tx
class KeysTransform(Transform):
lookup_name = 'keys'
output_field = ArrayField(TextField())
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs)
return 'akeys(%s)' % lhs, params
class ValuesTransform(Transform):
lookup_name = 'values'
output_field = ArrayField(TextField())
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return 'avals(%s)' % lhs, params
class Employee(models.Model):
class SenorityType(models.TextChoices):
INTERN = 'INTERN', 'Internship'
ENTRY = 'ENTRY', 'Entry-Level'
ASSOCIATE = 'ASSOCIATE', 'Associate'
SENIOR = 'SENIOR', 'Senior'
DIRECTOR = 'DIRECTOR', 'Director'
user = models.OneToOneField(
User, verbose_name=_("user"), on_delete=models.CASCADE)
senority = models.CharField(_("Senority"), max_length=10,
choices=SenorityType.choices, default=SenorityType.INTERN)
industry = models.CharField(_("Industry"), max_length=50)
skills = ArrayField(base_field=models.CharField(
_("Skill-tags"), max_length=200), blank=True, null=True)
objects = EmployeeManager()
class Meta:
verbose_name = _("Employee")
verbose_name_plural = _("Employees")
def __str__(self):
return self.user.username
def save(self, *args, **kwargs):
if not self.pk:
self.type = User.Types.EMPLOYEE
return super().save(*args, **kwargs)
def get_absolute_url(self):
return reverse("Employee_detail", kwargs={"pk": self.pk})
class InstrumentBringing(models.Model):
class Meta:
order_with_respect_to = 'registration_entry'
registration_entry = models.ForeignKey(
RegistrationEntry,
on_delete=models.CASCADE,
related_name='instruments_bringing',
)
size = models.CharField(max_length=100, choices=InstrumentChoices.choices)
name_if_other = models.CharField(max_length=100, blank=True)
level = models.TextField(choices=Level.choices[1:])
clefs = ArrayField(models.CharField(max_length=50, choices=Clef.choices))
def clean(self) -> None:
super().clean()
if self.size == InstrumentChoices.other and not self.name_if_other:
raise ValidationError({'name_if_other': 'This field is required'})
def __str__(self) -> str:
if self.size == InstrumentChoices.other:
return self.name_if_other
return InstrumentChoices(self.size).label
class NotificationModel(models.Model):
account = models.ForeignKey(Account, on_delete=models.CASCADE)
notified_message = models.TextField(max_length=None)
date_created = models.DateTimeField(auto_now=True)
url = models.CharField(blank=True, max_length=100, default='#')
data = ArrayField(models.TextField(max_length=None),
blank=True,
default=list)
class Invoice(models.Model):
PENDING = 'pending'
PROCESSING = 'processing'
SUCCESS = 'success'
ERROR = 'error'
STATUS = (
(PENDING, 'Pending'),
(PROCESSING, 'Processing'),
(SUCCESS, 'Success'),
(ERROR, 'Error'),
)
travel = models.ForeignKey(
'Travel', related_name='invoices', verbose_name=_('Travel'),
on_delete=models.CASCADE,
)
reference_number = models.CharField(max_length=32, unique=True, verbose_name=_('Reference Number'))
business_area = models.CharField(max_length=32, verbose_name=_('Business Area'))
vendor_number = models.CharField(max_length=32, verbose_name=_('Vendor Number'))
currency = models.ForeignKey(
'publics.Currency', related_name='+', verbose_name=_('Currency'),
on_delete=models.CASCADE,
)
amount = models.DecimalField(max_digits=20, decimal_places=4, verbose_name=_('Amount'))
status = models.CharField(max_length=16, choices=STATUS, verbose_name=_('Status'))
messages = ArrayField(models.TextField(default='', blank=True), default=[], verbose_name=_('Messages'))
vision_fi_id = models.CharField(max_length=16, default='', blank=True, verbose_name=_('Vision FI ID'))
def save(self, **kwargs):
if self.pk is None:
# This will lock the travel row and prevent concurrency issues
travel = Travel.objects.select_for_update().get(id=self.travel_id)
invoice_counter = travel.invoices.all().count() + 1
self.reference_number = '{}/{}/{:02d}'.format(self.business_area,
self.travel.reference_number,
invoice_counter)
super(Invoice, self).save(**kwargs)
@property
def posting_key(self):
return 'credit' if self.amount >= 0 else 'debit'
@property
def normalized_amount(self):
return abs(self.amount.normalize())
@property
def message(self):
return '\n'.join(self.messages)
def __str__(self):
return self.reference_number
class Meta:
ordering = ["pk", ]
class StitchNodeNode(models.Model):
node_id_a = models.IntegerField()
node_type_b = models.IntegerField()
node_id_b = models.IntegerField()
combined_score = models.SmallIntegerField()
evidence_scores = ArrayField(models.TextField())
class Meta:
db_interaction_div = "stitch"
db_table = "node_node_links"
class MailingList(models.Model):
name = models.CharField("Descriptive name", max_length=255)
addresses = ArrayField(models.EmailField(max_length=255))
new_mailfrom = models.EmailField(max_length=255,
null=False,
blank=True,
default="")
def __str__(self) -> str:
return self.name
class Transaction(models.Model):
account_id = models.CharField(max_length=128)
account_owner = models.CharField(max_length=128,
null=True) # todo: can be an object
amount = models.DecimalField(default=0, max_digits=10, decimal_places=2)
transaction_id = models.CharField(max_length=128, unique=True)
transaction_date = models.DateTimeField()
category_id = models.CharField(max_length=64)
category = ArrayField(models.CharField(max_length=64), default=list)
user = models.ForeignKey(User, on_delete=models.CASCADE)
class CirconscriptionConsulaire(models.Model):
objects = SearchQueryset.as_manager()
nom = models.CharField(
verbose_name="Nom de la circonscription",
max_length=300,
blank=False,
editable=False,
null=False,
)
pays = CountryField(
"Pays de la circonscription",
multiple=True,
blank=True,
null=False,
blank_label="(sélectionner un ou plusieurs pays)",
)
consulats = ArrayField(
verbose_name="Consulats inclus",
base_field=models.CharField(max_length=200),
blank=False,
null=False,
editable=False,
)
nombre_conseillers = models.PositiveSmallIntegerField(
verbose_name="Nombre de conseillers",
blank=False,
null=False,
editable=False)
search = SearchVectorField(verbose_name="Champ de recherche", null=True)
def as_dict(self):
return {
"nom":
self.nom,
"pays": [{
"name": p.name,
"code": p.code
} for p in self.pays] if self.pays else None,
"consulats":
self.consulats,
"nombre_conseillers":
self.nombre_conseillers,
}
def __str__(self):
return f"Circonscription «\u00A0{self.nom}\u00A0»"
class Meta:
verbose_name_plural = "circonscriptions consulaires"
indexes = (GinIndex(fields=["search"]), )
class NodeNodeLinks(models.Model):
node_id_a = models.IntegerField()
node_type_b = models.IntegerField(null=True, blank=True)
node_id_b = models.IntegerField()
combined_score = models.SmallIntegerField(null=True, blank=True)
evidence_scores = ArrayField(models.TextField())
evidence = {}
class Meta:
db_interaction_div = "string"
db_table = 'node_node_links'
class Post(models.Model):
author = models.TextField()
title = models.TextField()
created_at_utc = models.DateTimeField(auto_now_add=True)
content_warnings = ArrayField(models.TextField(), null=True, blank=True)
url = models.TextField(primary_key=True)
html = models.TextField()
num_views = models.IntegerField(default=0)
objects = PostManager()
class Meta:
db_table = "post"
class MembershipSubscription(_CreatedAndUpdatedTimestamps, models.Model):
owner = models.OneToOneField(User,
on_delete=models.CASCADE,
related_name='owned_subscription')
# family_members is the reverse lookup of a foreign key defined in User.
valid_until = models.DateTimeField(null=True)
membership_type = models.CharField(max_length=50,
choices=MembershipType.choices)
years_renewed = ArrayField(models.IntegerField(), blank=True, default=list)
def __str__(self) -> str:
return (
f'MembershipSubscription {self.owner.last_name}, {self.owner.first_name} '
f'{self.owner.username}')
class AuthenticatorValidateStage(Stage):
"""Validate user's configured OTP Device."""
not_configured_action = models.TextField(
choices=NotConfiguredAction.choices, default=NotConfiguredAction.SKIP)
configuration_stage = models.ForeignKey(
Stage,
null=True,
blank=True,
default=None,
on_delete=models.SET_DEFAULT,
related_name="+",
help_text=
_(("Stage used to configure Authenticator when user doesn't have any compatible "
"devices. After this configuration Stage passes, the user is not prompted again."
)),
)
device_classes = ArrayField(
models.TextField(choices=DeviceClasses.choices),
help_text=_("Device classes which can be used to authenticate"),
default=default_device_classes,
)
@property
def serializer(self) -> BaseSerializer:
from authentik.stages.authenticator_validate.api import (
AuthenticatorValidateStageSerializer, )
return AuthenticatorValidateStageSerializer
@property
def type(self) -> Type[View]:
from authentik.stages.authenticator_validate.stage import (
AuthenticatorValidateStageView, )
return AuthenticatorValidateStageView
@property
def component(self) -> str:
return "ak-stage-authenticator-validate-form"
class Meta:
verbose_name = _("Authenticator Validation Stage")
verbose_name_plural = _("Authenticator Validation Stages")
class Account(AbstractBaseUser):
GENDER = (
('male', 'Male'),
('female', 'Female'),
('others', 'Others'),
)
STATUS = (
('active', 'Active'),
('archived', 'Archived'),
('deleted', 'Deleted'),
)
first_name = models.CharField(max_length=255, )
last_name = models.CharField(max_length=255, )
is_active = models.BooleanField(default=True, )
is_staff = models.BooleanField(default=False, )
is_superuser = models.BooleanField(default=False, )
gender = models.CharField(max_length=20, choices=GENDER, default='male')
email = models.CharField(max_length=150, unique=True)
password = models.CharField(max_length=150)
status = models.CharField(max_length=20, choices=STATUS, default='active')
username = models.CharField(max_length=20)
groups = ArrayField(models.CharField(max_length=100),
default=list,
null=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [
'first_name', 'last_name', 'gender', 'is_superuser', 'is_staff',
'is_active', 'status'
]
objects = UserManager()
last_login = None
def __str__(self):
return self.email
def has_perm(self, app_label):
return self.is_superuser
def has_module_perms(self, app_label):
return self.is_superuser
class Meta:
db_table = 'accounts'
class MutationalSignature(models.Model):
sample = models.ForeignKey(Sample, on_delete=CASCADE)
calculator = models.ForeignKey(MutationalSignatureCalculator, on_delete=CASCADE)
import_status = models.CharField(max_length=1, choices=ImportStatus.choices, default=ImportStatus.CREATED)
summary = models.TextField()
mean = ArrayField(FloatField(), null=True)
num_snps = models.IntegerField(null=True)
class Meta:
unique_together = ("sample", "calculator")
def __str__(self):
if self.import_status == ImportStatus.SUCCESS:
description = self.summary
else:
import_status = self.get_import_status_display()
description = f"MutationalSignature {self.pk}, import_status={import_status}"
return description
class User(AbstractBaseUser):
GENDER = (
('male', 'Male'),
('female', 'Female'),
('others', 'Others'),
)
STATUS = (
('active', 'Active',),
('archived', 'Archived'),
('deleted', 'Deleted'),
)
first_name = models.CharField(max_length=55, )
last_name = models.CharField(max_length=55, )
is_active = models.BooleanField(default=True, )
is_staff = models.BooleanField(default=False, )
is_superuser = models.BooleanField(default=False, )
password = models.CharField(max_length=150, null=True, blank=True, )
email = models.CharField(max_length=255, unique=True)
gender = models.CharField(max_length=20, choices=GENDER, default='male', )
status = models.CharField(max_length=20, choices=STATUS, default='active', )
groups = ArrayField(models.CharField(max_length=100), default=list)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', 'last_name', 'is_active', 'is_staff', 'is_superuser', 'gender', 'status', 'groups', ]
objects = CustomUserManager()
last_login = None
def __str__(self):
return self.email
class Meta:
db_table = 'users'
verbose_name = 'User'
verbose_name_plural = 'Users'
class Asn(models.Model):
number = models.IntegerField(primary_key=True)
name = models.CharField(max_length=1000)
blocks = ArrayField(models.GenericIPAddressField())
class Meta:
db_table = 'asn'
ordering = ['number']
def __str__(self):
return "Number = " + str(
self.number) + ", Name = " + self.name + ", Bloques = " + str(
self.blocks)
def number_of_addresses(self):
size = 0
if self.blocks is None:
return size
for block in self.blocks:
size += 2**(32 - int(block.split('/')[1]))
return size
class Question(UidMixin, models.Model):
created_at = models.DateTimeField(auto_now_add=True,
verbose_name='Fecha de Ingreso')
last_modified = models.DateTimeField(auto_now=True,
verbose_name='Fecha de modificacion')
text = models.CharField(max_length=600)
options = JSONField(verbose_name='opciones', default={})
topic = models.ForeignKey(Topic, related_name='questions')
date_show = models.CharField(max_length=100, blank=True)
year_show = models.IntegerField(default=0, verbose_name='Año de pregunta')
argument_answer = models.TextField(
blank=True, verbose_name='Argumento de la respuesta')
bookmarked_by = ArrayField(models.IntegerField(), default=[], blank=True)
verified = models.BooleanField(default=True)
source_number = models.IntegerField(null=True, blank=True)
def __str__(self):
return self.text
class Meta:
verbose_name = "Pregunta"
verbose_name_plural = "Preguntas"
class Article(models.Model):
STATUS_DRAFT = 'D'
STATUS_PUBLISHED = 'P'
STATUS_PRIVATE = 'I'
STATUS_CHOICES = (
(STATUS_DRAFT, '草稿'),
(STATUS_PUBLISHED, '已发布'),
(STATUS_PRIVATE, '私密'),
)
TOP_CHOICES = zip(range(3, -4, -1), map(str, range(3, -4, -1)))
title = models.CharField('标题', max_length=200)
content = models.TextField('正文')
abstract = models.CharField('摘要', max_length=250)
status = models.CharField('状态',
max_length=1,
default=STATUS_PUBLISHED,
choices=STATUS_CHOICES)
order = models.PositiveSmallIntegerField('排序',
default=0,
choices=TOP_CHOICES)
tags = ArrayField(models.CharField(max_length=20),
size=10,
verbose_name='标签')
create_at = models.DateTimeField('创建时间', auto_now_add=True)
updata_at = models.DateTimeField('更新时间', auto_now=True)
objects = ArticleManager()
class Meta:
verbose_name = '文章'
verbose_name_plural = '文章'
ordering = ['-order', '-create_at']
def __str__(self):
return self.title
class AntecedenteFamiliar(BaseModel):
ciudadano = models.ForeignKey(Ciudadano)
ciex = models.CharField(max_length=8, blank=True, null=True)
parentesco = ArrayField(models.PositiveSmallIntegerField(
choices=PARENTESCO_CHOICES, blank=True, null=True),
null=True)
fecha_inicio = models.DateField(blank=True, null=True)
fecha_fin = models.DateField(blank=True, null=True)
observaciones = models.TextField(blank=True, null=True)
registro_antecedente = models.CharField(
max_length=1,
choices=REGISTRO_ANTECEDENTE_CHOICES,
default=REGISTRO_ANTECEDENTE_POSITIVO)
grupo_antecedente = models.CharField(max_length=1,
default=GRUPO_ANTECEDENTES_FAMILIARES)
subgrupo_antecedente = models.CharField(
max_length=1,
blank=True,
null=True,
choices=SUBGRUPO_ANTECEDENTES_CHOICES)
consulta_paciente = models.UUIDField(blank=True, null=True)
codigo_antecedente_sugerido = models.CharField(max_length=6,
blank=True,
null=True)
nombre_antecedente_sugerido = models.CharField(max_length=255,
blank=True,
null=True)
def delete(self, using=None, keep_parents=False):
self.es_removido = True
self.save()
@property
def ciex_descripcion(self):
try:
return CatalogoCIE.objects.get(id_ciex=self.ciex).desc_ciex
except CatalogoCIE.DoesNotExist:
return '-'
