class OrderAnswer(Answer):
ORDER_FIRST_CHAIN = Choices(
(1, 'first', '1'),
(2, 'second', '2'),
(3, 'third', '3'),
(4, 'fourth', '4'),
)
ORDER_SECOND_CHAIN = Choices(
(1, 'first', 'A'),
(2, 'second', 'B'),
(3, 'third', 'C'),
(4, 'fourth', 'D'),
)
text = models.CharField(_('Text'), max_length=255)
number_1 = models.IntegerField(_("Answer FIRST Position"),
choices=ORDER_FIRST_CHAIN)
number_2 = models.IntegerField(_("Answer SECOND Position"),
choices=ORDER_SECOND_CHAIN)
class Meta:
verbose_name = _('Order Answer')
verbose_name_plural = _('Order Answers')
def __str__(self):
return '{}__{}:{}_{}'.format(self.question.id, self.id, self.number_1,
self.number_2)
class Subscription(TimeStampedModel):
PROTOCOL_CHOICES = Choices(('http', _('HTTP')), ('https', _('HTTPS')))
STATUS_CHOICES = Choices(('pending', _('Pending')),
('canceled', _('Canceled')),
('confirmed', _('Confirmed')))
topic = models.ForeignKey(Topic,
verbose_name=_('Topic'),
on_delete=models.CASCADE,
related_name='subscriptions')
token = models.CharField(_('Token'), max_length=10, default=generate_key)
protocol = models.CharField(_('Protocol'),
max_length=5,
choices=PROTOCOL_CHOICES)
status = models.CharField(_('Status'),
max_length=9,
editable=False,
choices=STATUS_CHOICES,
default=STATUS_CHOICES.pending)
endpoint = models.URLField(_('Endpoint'))
error_msg = models.TextField(verbose_name=_('Error message'),
null=True,
blank=True,
default=None)
attempts_count = models.PositiveSmallIntegerField(
verbose_name=_('Attempts count'), default=0)
class Meta:
verbose_name = _('Subscription')
verbose_name_plural = _('Subscriptions')
class LangRefSet(BaseSNOMEDCTModel):
REFSET_CHOICES = Choices(
# Just the most common ones
(900000000000509007, 'en_us', 'US English'),
(900000000000508004, 'en_gb', 'GB English'),
# possible many other
)
ACCEPTABILITY_CHOICES = Choices(
(900000000000548007, 'preferred', 'Preferred'),
(900000000000549004, 'acceptable', 'Acceptable'))
id = models.TextField(primary_key=True)
effective_time = models.DateField()
active = models.BooleanField()
module = models.ForeignKey(Concept,
on_delete=models.PROTECT,
related_name='+')
refset = models.ForeignKey(Concept,
on_delete=models.PROTECT,
choices=REFSET_CHOICES,
related_name='+')
referenced_component = models.ForeignKey(Description,
on_delete=models.PROTECT,
related_name='lang_refset')
acceptability = models.ForeignKey(Concept,
on_delete=models.PROTECT,
choices=ACCEPTABILITY_CHOICES,
related_name='+')
objects = SNOMEDCTModelManager()
class Meta:
managed = False
db_table = 'sct2_lang_refset'
class MappingAnswer(Answer):
FIRST_CHAIN_TYPES = Choices(
(1, 'first', '1'),
(2, 'second', '2'),
(3, 'third', '3'),
(4, 'fourth', '4'),
(0, 'zero', '0'),
)
SECOND_CHAIN_TYPES = Choices(
(1, 'first', 'A'),
(2, 'second', 'B'),
(3, 'third', 'C'),
(4, 'fourth', 'D'),
(5, 'fifth', 'E'),
)
number_1 = models.IntegerField(_("First chain"), choices=FIRST_CHAIN_TYPES)
number_2 = models.IntegerField(_("Second chain"),
choices=SECOND_CHAIN_TYPES)
text_1 = models.CharField(_('Text 1'),
null=True,
blank=True,
max_length=255)
text_2 = models.CharField(_('Text 2'), max_length=255)
class Meta:
verbose_name = _('Mapping Answer')
verbose_name_plural = _('Mapping Answers')
def __str__(self):
return '{}__{}:{}_{}'.format(self.question.id, self.id, self.number_1,
self.number_2)
class CreditRequest(models.Model):
STATUSES = Choices(('new', _('Новая')), ('sent', _('Отправлена')),
('received', _('Получена')),
('approved', _('Одобрено')), ('denied', _('Отказано')),
('issued', _('Выдано')))
status = models.CharField(_('Статус'),
choices=STATUSES,
default=STATUSES.new,
max_length=20)
created = models.DateTimeField(_('Создана'), auto_now_add=True)
sent_date = models.DateTimeField(_('Отправлена'), blank=True, null=True)
borrower = models.ForeignKey(Borrower,
verbose_name=_('Анкета клиента'),
on_delete=models.PROTECT)
offer = models.ForeignKey(Offer,
verbose_name=_('Предложение'),
on_delete=models.PROTECT)
class Meta:
verbose_name = _('Заявка в КО')
verbose_name_plural = _('Заявки в КО')
ordering = ('-created', )
def __str__(self):
return 'CreditRequest: {} / {}'.format(self.id, self.status)
class Comment(StatusModel, TimeStampedModel):
"""
A comment on a conversation.
"""
STATUS = Choices(
('PENDING', _('awaiting moderation')),
('APPROVED', _('approved')),
('REJECTED', _('rejected')),
)
conversation = models.ForeignKey(
'Conversation',
related_name='comments',
on_delete=models.CASCADE,
)
author = models.ForeignKey(
settings.AUTH_USER_MODEL,
related_name='comments',
on_delete=models.CASCADE,
)
content = models.TextField(
_('Content'),
blank=False,
validators=[MaxLengthValidator(140)],
)
rejection_reason = models.TextField(
_('Rejection reason'),
blank=True,
)
is_approved = property(lambda self: self.status == self.STATUS.APPROVED)
class Meta:
unique_together = ('conversation', 'content')
def __str__(self):
return self.content
def vote(self, author, value, commit=True):
"""
Cast a vote for the current comment.
"""
log.debug(f'Vote: {author} - {value}')
vote = Vote(author=author, comment=self, value=value)
vote.full_clean()
if commit:
vote.save()
return vote
def get_statistics(self):
"""
Return full voting statistics for given comment.
"""
return dict(
agree=votes_counter(self, Vote.AGREE),
disagree=votes_counter(self, Vote.DISAGREE),
skip=votes_counter(self, Vote.SKIP),
total=votes_counter(self),
)
class Project(models.Model):
maintainer = models.ForeignKey(PisiUser,
on_delete=models.DO_NOTHING,
related_name='%(class)s_project_leader')
contributors = models.ManyToManyField(
PisiUser, related_name='%(class)s_project_participant')
repos = models.ManyToManyField(Repository)
STATUS = Choices('abandoned', 'in development', 'maintained', 'on draft',
'complete')
status = StatusField()
progress = models.IntegerField(default=0,
validators=[
MinValueValidator(COMPLETION_ZERO),
MaxValueValidator(COMPLETION_DONE)
])
vacant_slots = models.IntegerField(
default=0, validators=[MinValueValidator(0),
MaxValueValidator(128)])
VISIBILITY_CHOICES = (
(1, _("Public")),
(2, _("Private")),
)
visibility = models.SmallIntegerField(choices=VISIBILITY_CHOICES,
default=1)
class PublishableLangModel(LangModel, StatusModel):
"""
Model with a language and a status field and a ``PublishableLangManager``
"""
_translated_choices = [(slug, _(name))
for (slug, name) in ptsettings.STATUS_CHOICES]
STATUS = Choices(*_translated_choices)
public = PublishableLangManager()
def _enabled(self):
warnings.warn("Depricated. Bad naming. Use ``is_published``.")
return self.status == ptsettings.STATUS_PUBLISHED
_enabled.boolean = True # type: ignore
_enabled.admin_order_field = "status" # type: ignore
enabled = property(_enabled)
def _is_published(self):
return self.status == ptsettings.STATUS_PUBLISHED
_is_published.boolean = True # type: ignore
_is_published.admin_order_field = "status" # type: ignore
is_published = property(_is_published)
class Meta:
abstract = True
class Offer(models.Model):
KIND = Choices(
('consumer_credit', _('Потребительский кредит')),
('mortgage', _('Ипотека')),
('car_loan', _('Автокредит')),
)
created = models.DateTimeField(_('Создано'), auto_now_add=True)
modified = models.DateTimeField(_('Изменено'), auto_now=True)
name = models.CharField(_('Название'), max_length=255)
company = models.ForeignKey(Company,
verbose_name=_('Кредитная организация'),
on_delete=models.PROTECT)
rotation_start = models.DateTimeField(_('Начало ротации'))
rotation_end = models.DateTimeField(_('Окончание ротации'))
kind = models.CharField(_('Тип предложения'), choices=KIND, max_length=20)
min_score = models.PositiveSmallIntegerField(
_('Минимальный скоринговый балл'))
max_score = models.PositiveSmallIntegerField(
_('Максимальный скоринговый балл'))
objects = OfferManager()
class Meta:
verbose_name = _('Предложение')
verbose_name_plural = _('Предложения')
ordering = ('-created', )
def __str__(self):
return '{} ({})'.format(self.name, self.company.name)
class TenantSpecificFieldDefinition(SingleTenantModelMixin):
name = models.CharField(max_length=255)
DATA_TYPES = Choices('char', 'text', 'integer', 'float', 'datetime',
'date')
data_type = StatusField(choices_name='DATA_TYPES')
is_required = models.BooleanField(default=False)
default_value = models.TextField()
validators = models.ManyToManyField('TenantSpecificFieldsValidator',
blank=True)
table_content_type = models.ForeignKey(ContentType,
on_delete=models.CASCADE)
table_id = models.PositiveIntegerField(blank=True, null=True)
class Meta:
unique_together = [('tenant', 'table_id', 'table_content_type', 'name')
]
def __str__(self):
content_type = '%s/%s' % (self.tenant.slug, str(
self.table_content_type))
if content_type == 'shared_schema_tenants.TenantSpecificTable':
content_type = str(self.table)
return '%s.%s' % (content_type, self.name)
class Order(UUIDModel, StatusModel):
STATUS = Choices(
"new",
"completed",
"cancelled",
)
customer = models.ForeignKey(
to="users.Customer",
on_delete=models.CASCADE,
related_name="orders",
)
class Meta:
verbose_name_plural = "orders"
def __str__(self):
return f"Order #{self.number} - {self.customer}"
@property
def number(self):
return str(self.id).zfill(4)
def _total(self):
return sum([i._line_total() for i in self.items.iterator()])
@property
def total(self):
return f"Z ${ic(self._total())}"
class ExporterChunk(TimeStampedModel):
STATUS_CHOICES = Choices(("created", _("created")),
("processing", _("processing")),
("success", _("success")), ("error", _("error")))
exporter = models.ForeignKey(Exporter, related_name="chunks")
page = models.IntegerField()
file = models.FileField(blank=True,
null=True,
default=None,
storage=default_storage)
status = models.CharField(max_length=16,
choices=STATUS_CHOICES,
default=STATUS_CHOICES.created)
done_at = MonitorField(monitor='status',
when=['success', 'error'],
default=None,
null=True)
objects = ExporterChunkManager()
def set_status(self, status):
""" Sets the status to one of the choices """
if status not in self.STATUS_CHOICES:
raise ExporterStatusException("Invalid status.")
self.status = status
self.save()
class Impuesto(TimeStampedModel):
abreviatura = models.CharField(max_length=10)
descripcion = models.CharField(max_length=50)
monto = models.DecimalField(max_digits=14, decimal_places=2)
fecha_inicio = models.DateField()
fecha_fin = models.DateField(null=True)
estado = models.BooleanField(default=True)
STATUS = Choices(('COM', _('COMPRA')),
('VEN', _('VEN')),
)
tipo_uso = models.CharField(choices=STATUS, default=STATUS.COM, max_length=20)
objects = NavegableQuerySet.as_manager()
class Meta:
permissions = (('ver_detalle_impuesto', 'Puede ver detalle Impuesto'),
('ver_tabla_impuestos', 'Puede ver tabla de Impuestos'),
('ver_reporte_impuestos_excel', 'Puede ver Reporte de Impuestos en excel'),)
ordering = ['abreviatura']
def anterior(self):
ant = Impuesto.objects.anterior(self)
return ant.pk
def siguiente(self):
sig = Impuesto.objects.siguiente(self)
return sig.pk
def __str__(self):
return self.descripcion
class Exporter(TimeStampedModel):
""" Exporter model handles the initial creation of the exportation. All the info needed for the exportation comes
from here """
STATUS_CHOICES = Choices(("created", _("created")),
("processing", _("processing")),
("done", _("done")), ("error", _("error")))
uuid = models.UUIDField(default=uuid4)
email = models.EmailField()
content_type = models.ForeignKey(ContentType)
query = models.FileField(blank=True,
null=True,
default=None,
storage=default_storage)
attrs = jsonfield.JSONField(blank=True, null=True, default=None)
limit_per_task = models.IntegerField(default=100)
total = models.IntegerField(editable=False)
file = models.FileField(blank=True,
null=True,
default=None,
storage=default_storage)
status = models.CharField(max_length=16,
choices=STATUS_CHOICES,
default=STATUS_CHOICES.created)
done_at = MonitorField(monitor='status',
when=['done', 'error'],
default=None,
null=True)
objects = ExporterManager()
def set_status(self, status):
""" Sets the status to one of the status choices """
if status not in self.STATUS_CHOICES:
raise ExporterStatusException("Invalid status.")
self.status = status
self.save()
@property
def chunks_is_successful(self):
""" Check if its chunks are completed succesful """
return self.chunks.filter(status=ExporterChunk.STATUS_CHOICES.success
).count() == self.chunks.all().count()
@property
def has_chunk_errors(self):
""" Check if any of the created chunks have returned errors """
return self.chunks.filter(
status=ExporterChunk.STATUS_CHOICES.error).exists()
@property
def is_pending(self):
""" Check if it is pending """
return self.status == self.STATUS_CHOICES.processing
@property
def is_done(self):
return self.status == self.STATUS_CHOICES.done
class Task(models.Model):
STATE = Choices(
('todo', 'TODO'),
('in_progress', 'In Progress'),
('done', 'Done'),
)
owner = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.SET_NULL,
related_name='tasks',
null=True,
blank=True)
name = models.CharField(max_length=200)
description = models.TextField()
state = models.CharField(choices=STATE, default=STATE.todo, max_length=20)
completed_by = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.SET_NULL,
related_name='completed_tasks',
null=True,
blank=True)
def __str__(self):
return self.name
@property
def is_done(self):
return self.state == self.STATE.done
class Event(UUIDModel, OwnerModel, DateTimeFramedModel, TimeStampedModel, StatusModel, SoftDeletableModel):
"""告警事件"""
STATUS = Choices(STATUS_NO_RESPONSE, STATUS_PROCESSING, STATUS_RESOLVED, STATUS_REVOKED, STATUS_TIMEOUT)
name = models.CharField(verbose_name='事件名称', max_length=120)
project = models.ForeignKey(Project, verbose_name='所属项目', on_delete=models.CASCADE)
host = models.CharField(verbose_name='主机标识', max_length=128)
level = models.PositiveSmallIntegerField(verbose_name='事件级别', choices=LEVEL_CHOICES, default=LEVEL_WARNING)
grade = models.ForeignKey(Project, verbose_name='通知级别',
on_delete=models.CASCADE,
blank=True,
related_name='grade_events')
messages = models.ManyToManyField(Message, verbose_name='关联消息')
receivers = models.ManyToManyField(settings.AUTH_USER_MODEL,
verbose_name='消息接收人',
related_name='receive_events',
blank=True)
responder = models.ForeignKey(settings.AUTH_USER_MODEL, verbose_name='响应人员', on_delete=models.SET_NULL,
null=True, blank=True, related_name='respond_event')
operators = models.ManyToManyField(settings.AUTH_USER_MODEL, verbose_name='处理人员', related_name='operate_events',
blank=True)
converge = models.ForeignKey(BurrConverge, verbose_name='毛刺收敛', on_delete=models.CASCADE)
tags = TaggableManager(through=TaggedUUIDItem, blank=True)
class Meta:
verbose_name_plural = verbose_name = '- 告警事件'
def __str__(self):
return self.name
def save(self, *args, **kwargs):
level = self.messages.order_by('-level').first().level
self.level = level
super(Event, self).save(*args, **kwargs)
def _process(self, choices, triple_collector=None, double_collector=None):
Choices._process(self, choices, triple_collector=triple_collector,
double_collector=double_collector)
self._triple_map = {
value: {
'component_tag': triple.replace('_', '-'),
'text': text
} for value, triple, text in self._triples
}
self._triple_map_component = {
triple.replace('_', '-'): {
'id': value,
'text': text
} for value, triple, text in self._triples
}
class Result(TimeStampedModel):
STATUS = Choices((0, 'unknown', _('Unknown')),
(1, 'ok', _('OK')),
(2, 'warning', _('Warning')),
(3, 'critical', _('Critical')))
slug = models.TextField(verbose_name=_('Module slug'))
identifier = models.CharField(max_length=256, verbose_name=_('Identifier'))
status = models.IntegerField(choices=STATUS,
default=STATUS.unknown, verbose_name=_('Status'))
data = JSONField(blank=True, default=dict, verbose_name=('Data'))
config = JSONField(blank=True, default=dict, verbose_name=_('Configuration'))
payload_description = models.TextField(verbose_name=_('Payload description'))
acknowledged_by = models.ForeignKey(to=settings.AUTH_USER_MODEL, null=True, blank=True,
verbose_name=_('Acknowledged by'),
related_name='acknowledged_by')
acknowledged_at = models.DateTimeField(null=True, blank=True, verbose_name=_('Acknowledged at'))
acknowledged_until = models.DateTimeField(null=True, blank=True, verbose_name=_('Acknowledged until'))
acknowledged_reason = models.TextField(blank=True, verbose_name=_('Acknowledge reason'))
assigned_to_user = models.ForeignKey(to=settings.AUTH_USER_MODEL, null=True, blank=True,
related_name='assigned_to_user')
assigned_to_group = models.ForeignKey(to='auth.Group', null=True, blank=True)
objects = ResultQuerySet.as_manager()
class Meta:
unique_together = ('slug', 'identifier')
permissions = (('view', 'Can view results dashboard and details'), ('acknowledge', 'Can acknowledge results'),
('config', 'Can change the configuration for results'), ('refresh', 'Can refresh results'))
def acknowledge(self, user, days, reason=None, commit=True):
if self.status in (self.STATUS.warning, self.STATUS.critical) and self.is_acknowledged():
raise AlreadyAcknowledged()
self.acknowledged_at = timezone.now()
self.acknowledged_by = user
self.acknowledged_until = timezone.now() + relativedelta.relativedelta(days=days)
self.acknowledged_reason = reason or ''
if commit:
self.save(update_fields=['acknowledged_at', 'acknowledged_by', 'acknowledged_until', 'acknowledged_reason'])
def is_acknowledged(self):
return self.acknowledged_until and self.acknowledged_until >= timezone.now()
def __str__(self):
return self.slug
def get_check_instance(self):
return datawatch.get_check_class(self.slug)()
def get_payload(self):
return self.get_check_instance().get_payload(self.identifier)
def get_formatted_data(self):
return datawatch.get_check_class(self.slug)().format_result_data(self)
class Robot(TimeStampedModel):
MARKET_TYPE = Choices(
("spots", _("Spots")),
("margin", _("Margin")),
("linear_delivery", _("Linear delivery contract")),
("linear_perpetual", _("Linear perpetual contract")),
("inverse_delivery", _("Inverse delivery contract")),
("inverse_perpetual", _("Inverse perpetual contract")),
)
name = models.CharField(_("name"), max_length=50)
pair = models.CharField(_("pair"), max_length=30)
market_type = models.CharField(_("market type"),
max_length=30,
choices=MARKET_TYPE)
enabled = models.BooleanField(_("enabled"), default=True)
start_time = models.DateTimeField(_("start time"), null=True, blank=True)
ping_time = models.DateTimeField(_("ping time"), null=True, blank=True)
credential = models.ForeignKey(
"credentials.Credential",
verbose_name=_("exchange credential"),
on_delete=models.CASCADE,
related_name="robots",
)
strategy = models.ForeignKey(
"strategies.Strategy",
verbose_name=_("strategy"),
on_delete=models.CASCADE,
blank=True,
null=True,
related_name="robots",
)
strategy_parameters = JSONField(_("strategy parameters"))
target_currency = models.CharField(_("target currency"),
max_length=10,
blank=True)
# for spots
base_currency = models.CharField(_("base currency"),
max_length=10,
blank=True)
quote_currency = models.CharField(_("quote currency"),
max_length=10,
blank=True)
objects: RobotManager = RobotManager()
class Meta:
verbose_name = _("robot")
verbose_name_plural = _("robots")
class JSONAPIMeta:
resource_name = "robots"
@property
def duration(self):
if self.start_time and self.ping_time:
return self.ping_time - self.start_time
class Sensor(Controller):
current_data = models.IntegerField(default=0)
MEASURE_CHOICE = Choices('C', '%')
unit_of_measure = models.CharField(
max_length=2,
choices=MEASURE_CHOICE,
default=MEASURE_CHOICE.C,
)
jobs = GenericRelation(Job, related_query_name='sensor')
class LightController(Controller):
TYPE_CHOICE = Choices('RGB', 'Singlecolor')
type = models.CharField(
max_length=12,
choices=TYPE_CHOICE,
default=TYPE_CHOICE.Singlecolor,
)
brightness = models.PositiveIntegerField()
jobs = GenericRelation(Job, related_query_name='lightcontroller')
class Description(BaseSNOMEDCTModel):
TYPE_CHOICES = Choices(
(900000000000003001, 'fully_specified_name', 'Fully specified name'),
(900000000000013009, 'synonym', 'Synonym'))
CASE_SIGNIFICANCE_CHOICES = Choices(
(900000000000020002, 'initial_char_case_insensitive',
'Initial character case insensitive'),
(900000000000017005, 'case_sensitive', 'Case sensitive'))
id = models.BigIntegerField(primary_key=True)
effective_time = models.DateField()
active = models.BooleanField()
module = models.ForeignKey(Concept,
on_delete=models.PROTECT,
related_name='module_descriptions',
db_index=False)
concept = models.ForeignKey(Concept,
on_delete=models.PROTECT,
related_name='descriptions',
db_index=False)
language_code = models.CharField(max_length=2)
type = models.ForeignKey(Concept,
on_delete=models.PROTECT,
choices=TYPE_CHOICES,
related_name='type_descriptions',
db_index=False)
term = models.CharField(max_length=255)
case_significance = models.ForeignKey(
Concept,
on_delete=models.PROTECT,
choices=CASE_SIGNIFICANCE_CHOICES,
related_name='case_significance_descriptions',
db_index=False)
objects = SNOMEDCTModelManager()
class Meta:
managed = False
db_table = 'sct2_description'
unique_together = (('id', 'effective_time', 'active'), )
def __str__(self):
return "%s: %s (%s)" % (self.language_code.upper(), self.term,
self.get_active_display())
class TimeConverge(UUIDModel, OwnerModel, TimeStampedModel, TimeFramedModel,
SoftDeletableModel, StatusModel):
"""每天固定时间段收敛: 每天固定时间段内的告警进行收敛"""
STATUS = Choices(STATUS_DRAFT, STATUS_PUBLISHED, STATUS_OFFLINE)
class Meta:
verbose_name_plural = verbose_name = '- 固定时间收敛'
def __str__(self):
return self.owner.username
class QuizQuestion(TimeStampedModel):
QUIZ_QUESTION_STATUS_TYPES = Choices(
(0, 'active', 'Active'),
(1, 'done', 'Done'),
(2, 'suspend', 'Suspend'),
)
quiz = models.ForeignKey(Quiz,
verbose_name=_('Quiz'),
on_delete=models.CASCADE,
related_name='quiz_questions')
question = models.ForeignKey(Question,
verbose_name=_('Question'),
on_delete=models.CASCADE,
related_name='quiz_questions')
status = models.IntegerField(_("Status"),
choices=QUIZ_QUESTION_STATUS_TYPES,
default=QUIZ_QUESTION_STATUS_TYPES.active)
class Meta:
verbose_name = _('Quiz Question')
verbose_name_plural = _('Quiz Questions')
def __str__(self):
return '{}:{}_{}'.format(self.id, self.quiz.student.full_name,
self.question.id)
@property
def ordered_quizanswers_by_position_two(self):
quizanswers_ids = self.quizanswer_set.values_list('id', flat=True)
if self.question.type == QUESTION_TYPES.common:
return QuizCommonAnswer.objects.filter(
id__in=quizanswers_ids).order_by('number')
elif self.question.type == QUESTION_TYPES.order:
return QuizOrderAnswer.objects.filter(
id__in=quizanswers_ids).order_by('number_2')
if self.question.type == QUESTION_TYPES.mapping:
return QuizMappingAnswer.objects.filter(
id__in=quizanswers_ids).order_by('number_2')
return self.quizanswer_set
@property
def ordered_quizanswers_by_position_one(self):
quizanswers_id_list = self.quizanswer_set.values_list('id', flat=True)
if self.question.type == QUESTION_TYPES.common:
return QuizCommonAnswer.objects.filter(
id__in=quizanswers_id_list).order_by('number')
elif self.question.type == QUESTION_TYPES.order:
return QuizOrderAnswer.objects.filter(
id__in=quizanswers_id_list).order_by('number_1')
if self.question.type == QUESTION_TYPES.mapping:
return QuizMappingAnswer.objects.filter(
id__in=quizanswers_id_list).order_by('number_1')
return self.quizanswer_set
class Profile(TimeStampedModel):
GRADE_NUMBER = Choices(
(9, 'nine', '9'),
(10, 'ten', '10'),
(11, 'eleven', '11'),
)
INSTITUTION_TYPE = Choices(
(1, 'school', _('School')),
(2, 'lyceum', _('Lyceum/Gymnasium')),
(3, 'college', _('College')),
(0, 'other', _('Other')),
)
user = models.OneToOneField(settings.AUTH_USER_MODEL,
verbose_name=_('User'),
on_delete=models.CASCADE)
full_name = models.CharField(_('full name'),
max_length=255,
help_text=_('Maximum length is 255 symbols'))
parent_full_name = models.CharField(
_('Parent fullname'),
max_length=255,
help_text=_('Maximum length is 255 symbols'))
parent_phone = PhoneNumberField(_('Parent phone'))
institution_name = models.CharField(
_('Institution name'),
max_length=255,
help_text=_('Maximum length is 255 symbols'))
institution_type = models.IntegerField(_("Institution type"),
choices=INSTITUTION_TYPE,
default=INSTITUTION_TYPE.school)
grade = models.IntegerField(_("Grade number"),
choices=GRADE_NUMBER,
null=True,
blank=True)
class Meta:
verbose_name = _('Profile')
verbose_name_plural = _('Profiles')
def __str__(self):
return self.full_name
class UserWorkoutPlan(TimeStampedModel, StatusModel):
STATUS = Choices('upcoming', 'inactive', 'current', 'past')
id = models.BigAutoField(primary_key=True)
assigned_user = models.ForeignKey(User,
on_delete='cascade',
related_name='assigned_workout_plans')
workout_plan = models.ForeignKey(WorkoutPlan, on_delete='cascade')
start_date = models.DateTimeField()
end_date = models.DateTimeField()
notes = models.TextField()
class MuscleGroup(TimeStampedModel):
BODY_PARTS = Choices(("upper", ("Upper")), ("lower", ("Lower")))
id = models.BigAutoField(primary_key=True)
muscle_name = models.TextField(null=False)
body_part = models.CharField(max_length=50,
choices=BODY_PARTS,
default=BODY_PARTS.upper)
def __str__(self):
return self.muscle_name
class Concept(BaseSNOMEDCTModel):
DEFINITION_STATUS_CHOICES = Choices(
(900000000000074008, 'primitive', 'Primitive'),
(900000000000073002, 'defined', 'Defined'))
id = models.BigIntegerField(primary_key=True)
effective_time = models.DateField()
active = models.BooleanField()
module = models.ForeignKey('self',
on_delete=models.PROTECT,
related_name='+',
db_index=False)
definition_status = models.ForeignKey('self',
on_delete=models.PROTECT,
choices=DEFINITION_STATUS_CHOICES,
related_name='+',
db_index=False)
objects = SNOMEDCTModelManager()
class Meta:
managed = False
db_table = 'sct2_concept'
unique_together = (('id', 'effective_time', 'active'), )
def __str__(self):
return "SCTID:%d (%s)" % (self.id, self.get_active_display())
def __get_fully_specified_name(self, lang):
return self.descriptions.get(
type=Description.TYPE_CHOICES.fully_specified_name,
lang_refset__acceptability=LangRefSet.ACCEPTABILITY_CHOICES.
preferred,
lang_refset__refset=getattr(LangRefSet.REFSET_CHOICES, lang))
def __get_preferred_term(self, lang):
return self.descriptions.get(type=Description.TYPE_CHOICES.synonym,
lang_refset__acceptability=LangRefSet.
ACCEPTABILITY_CHOICES.preferred,
lang_refset__refset=getattr(
LangRefSet.REFSET_CHOICES, lang))
def get_fully_specified_name(self, lang="en_us"):
return cache.get_or_set("fsn_%d" % self.id,
lambda: self.__get_fully_specified_name(lang),
None)
def get_preferred_term(self, lang="en_us"):
return cache.get_or_set("pt_%d" % self.id,
lambda: self.__get_preferred_term(lang), None)
class StitchesSource(CachedSource, ProjectionModel):
STITCHES_TYPE = Choices(('under', _(u'Под пуговицами')), ('over', _(u'Над пуговицами')))
type = models.CharField(verbose_name=_(u'Расположение'), choices=STITCHES_TYPE, default=STITCHES_TYPE.under,
blank=False, max_length=10)
image = models.FileField(verbose_name=_(u'Файл ниток'), storage=overwrite_storage,
upload_to=UploadComposingSource('stitches/%s/%s'))
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey('content_type', 'object_id')
class Meta:
unique_together = ('content_type', 'object_id', 'projection', 'type')
verbose_name = _(u'Модель сборки ниток')
verbose_name_plural = _(u'Модели сборки ниток')
class TyreModel(models.Model):
""" A tyre model """
# Constants
RADIUS_CHOICES = Choices(
(450, 'standard', _("standard")),
(296, 'small', _("small")),
(710, 'jumbo', _("jumbo")),
)
# Fields
uuid = models.UUIDField(default=uuid4, verbose_name=_("UUID"))
name = models.CharField(max_length=64, verbose_name=_("name"))
description = models.TextField(blank=True, verbose_name=_("description"))
manufacturer = models.ForeignKey('tyres.manufacturer',
related_name='tyre_models',
verbose_name=_("manufacturer"))
radius = models.FloatField(default=RADIUS_CHOICES.standard,
help_text=_("value in mm"),
verbose_name=_("radius"))
in_production = models.BooleanField(default=True,
verbose_name=_("in production"))
creation_date = models.DateTimeField(default=now,
verbose_name=pgettext_lazy(
'tyres.tyre', "created on"))
# Manager
objects = TyreModelQuerySet.as_manager()
# Metadata
class Meta:
verbose_name = _("tyre model")
verbose_name_plural = _("tyre models")
unique_together = ('name', 'manufacturer'),
app_label = 'tyres'
# Overrides
def __str__(self):
""" Return a string representation of the object """
return str(self.name)
def save(self, *args, **kwargs):
""" Save the object to the database """
super(self.__class__, self).save(*args, **kwargs)
def get_absolute_url(self):
""" Return the URL to access this model view page """
return reverse('index')
