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 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 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 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)
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 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 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 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 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')
class AuthToken(UUIDModel, OwnerModel, StatusModel, DateTimeFramedModel, SoftDeletableModel): """仿照 rest_framework.authtoken 自定义 token """ STATUS = Choices(STATUS_DRAFT, STATUS_PUBLISHED, STATUS_OFFLINE) name = models.CharField(verbose_name='秘钥名称', max_length=50) token = models.CharField(verbose_name='认证秘钥', max_length=32, default=uuid4().hex) class Meta: verbose_name_plural = verbose_name = '- 密钥认证' ordering = ['owner__username'] def __str__(self): return "%s_%s" % (self.owner, self.name)