Exemplo n.º 1
0
    def contribute_to_class(self, cls, name):
        self.name = self.attname = name
        cls._meta.add_virtual_field(self)

        self.inherit_flag_name = INHERIT_FLAG_NAME % name
        self.value_field_name = VALUE_FIELD_NAME % name

        if not self.inherit_only:
            flag_field = BooleanField(default=True)
            flag_field.creation_counter = self.creation_counter

            # Adjust the creation_counter
            # cls.add_to_class(self.inherit_flag_name, flag_field)
            flag_field.contribute_to_class(cls, self.inherit_flag_name)

            signals.class_prepared.connect(
                curry(self.add_value_field, name=name),
                sender=cls,
                weak=False
            )

        setattr(cls, name, self)
        display_name = 'get_%s_display' % name
        setattr(cls, display_name, curry(self.get_field_display, name=name))
        getattr(cls, display_name).__dict__['short_description'] = name.replace('_', ' ')

        if not hasattr(cls, 'FIELD_INHERITANCE_MAP'): #TODO: test
            cls.FIELD_INHERITANCE_MAP = {}

        cls.FIELD_INHERITANCE_MAP[name] = (self.parent_object_field_name, self.inherited_field_name_in_parent or name)
        signals.class_prepared.connect(self.patch_manager, sender=cls)
Exemplo n.º 2
0
    def contribute_to_class(self, model, name):
        super(MongoUserManager, self).contribute_to_class(model, name)
        self.dj_model = self.model
        self.model = get_user_document()

        self.dj_model.USERNAME_FIELD = self.model.USERNAME_FIELD
        username = CharField(_('username'), max_length=30, unique=True)
        username.contribute_to_class(self.dj_model, self.dj_model.USERNAME_FIELD)

        self.dj_model.REQUIRED_FIELDS = self.model.REQUIRED_FIELDS
        for name in self.dj_model.REQUIRED_FIELDS:
            field = CharField(_(name), max_length=30)
            field.contribute_to_class(self.dj_model, name)

        is_staff = BooleanField(_('is_staff'), default=False)
        is_staff.contribute_to_class(self.dj_model, 'is_staff')

        is_active = BooleanField(_('is_active'), default=False)
        is_active.contribute_to_class(self.dj_model, 'is_active')

        is_superuser = BooleanField(_('is_superuser'), default=False)
        is_superuser.contribute_to_class(self.dj_model, 'is_superuser')

        last_login = DateTimeField(_('last_login'), auto_now_add=True)
        last_login.contribute_to_class(self.dj_model, 'last_login')

        date_joined = DateTimeField(_('date_joined'), auto_now_add=True)
        date_joined.contribute_to_class(self.dj_model, 'date_joined')
Exemplo n.º 3
0
class Patient(Model):
    """Stores basic information for a single patient."""
    # Basic identifiers
    first_name = CharField(max_length=32, blank=False)
    middle_name = CharField(max_length=32, blank=True)
    last_name = CharField(max_length=128, blank=False)
    mrn = CharField(max_length=32, unique=True)

    # Demographics information
    birthdate = DateField(null=True)
    gender = CharField(
        choices=(
            ('female', 'female'),
            ('male', 'male'),
            ('other', 'other or N/A'),
        ),
        max_length=16,
        null=True,
    )

    # Indicates that this patient object is a test / prototype sample and not a
    # real patient
    is_sample = BooleanField()

    # Patient History
    icds = ManyToManyField(ICD, through='ICDInstance')
    labs = ManyToManyField(Lab, through='LabInstance')
    cpts = ManyToManyField(CPT, through='CPTInstance')
    # Also available: meds, docs

    def __repr__(self):
        fmt = '{}(first_name={}, last_name={})'
        cls_name = self.__class__.__name__
        return fmt.format(cls_name, self.first_name, self.last_name)

    def __str__(self):
        return f'{self.last_name}, {self.first_name}'
Exemplo n.º 4
0
class TaskStatus(TimeStampedModel):  # TODO: rename to TaskInteraction
    class Meta:
        verbose_name = _("Task Status")
        verbose_name_plural = _("Task Statuses")

    interacted = BooleanField(default=False)  # TODO: remove as mere existence of the model indicates truthfulness
    user = ForeignKey(
        settings.AUTH_USER_MODEL,
        related_name='interacted_tasks',  # TODO: rename related_name='interactions'
        on_delete=CASCADE,
    )
    task = ForeignKey(
        Task,
        related_name='task_status',  # TODO: rename related_name='interactions'
        on_delete=CASCADE,
    )

    def __str__(self):
        return f"#{self.user_id} " \
               f"{'interacted' if self.interacted else 'did not interact'} " \
               f"with #{self.task_id} " \
               f"(#{self.pk})"

    def clean(self):
        self._validate_task_not_expired()

    def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
        self.full_clean()
        super().save(force_insert, force_update, using, update_fields)

    def _validate_task_not_expired(self):
        if self.task.expired:
            raise ValidationError(
                _("Task #%(task_id)s expired."),
                code=BUSINESS_LOGIC_ERROR_CODE,
                params={'task_id': self.task_id},
            )
class User(AbstractUser):
    """Default user for Bug Tracker v2.
    """

    #: First and last name do not cover name patterns around the globe
    name = CharField(_("Name of User"), blank=True, max_length=255)
    is_manager = BooleanField(default=False)
    last_viewed_project_pk = IntegerField(null=True, blank=True, default=None)
    notification_settings = JSONField(null=True, blank=True, default=dict)

    # adding custom validation to username: no '@' symbol
    username_validator = MyUnicodeUsernameValidator()

    # this is identical to the field definition in Django's AbstractUser class except for the removal of "@" from the help_text attribute.
    # The primary change is in the username_validator attribute above, using my customized Validator.
    username = models.CharField(
        _('username'),
        max_length=150,
        unique=True,
        help_text=_('Required. 150 characters or fewer. Letters, digits and ./+/-/_ only.'),
        validators=[username_validator],
        error_messages={
            'unique': _("A user with that username already exists."),
        },
    )

    def get_absolute_url(self):
        """Get url for user's detail view.

        Returns:
            str: URL for user detail.

        """
        return reverse("users:detail", kwargs={"username": self.username})

    def get_pending_invitations_count(self):
        return self.teaminvitation_set.filter(status=1).count()
Exemplo n.º 6
0
class Edital(Model):
    PERIODO = (
        (1, '1º Período'),
        (2, '2º Período'),
    )

    tipo = ForeignKey(Tipo, verbose_name='Tipo', on_delete=CASCADE)
    programa = ForeignKey(Programa, verbose_name='Programa', on_delete=CASCADE)
    numero = CharField('Número', max_length=50)
    sigla_uo = CharField('Unidade organizacional', max_length=100, help_text='Ex.: DG-EAD/IFRN')
    link_edital = URLField('URL', max_length=300, help_text='Informe o LINK onde está o edital')
    grupo = CharField('Grupo', max_length=200, null=True)
    descricao = CharField('Descrição', max_length=300)
    ano = PositiveIntegerField('Ano', help_text='Digite o ano')
    periodo = PositiveIntegerField('Período letivo', choices=PERIODO)
    data_publicacao = DateField('Data de publicação')
    existe_taxa = BooleanField('Existe taxa?', default=False)
    valor_taxa = DecimalField('Valor da taxa', max_digits=7, decimal_places=2)
    vencimento_boleto = DateField('Vencimento do boleto')
    anotacoes = TextField('Anotações')

    class Meta:
        verbose_name = "Edital"
        verbose_name_plural = "Editais"
        unique_together = ("numero", "sigla_uo")


    def nome_curto(self):
        return "%s %s-%s" % (self.tipo, self.numero, self.sigla_uo)
    nome_curto.short_description = 'Identificação'

    def nome_longo(self):
        return "%s %s" % (self.nome_curto(), self.descricao)
    nome_longo.short_description = 'Nome'

    def __str__(self):
        return self.nome_curto()
Exemplo n.º 7
0
class User(CreatedModified, AbstractUser):
    uuid = UUIDField(default=uuid.uuid4, editable=False, primary_key=True)

    account_number = CharField(blank=True, max_length=VERIFY_KEY_LENGTH)
    display_name = CharField(max_length=250)
    github_username = CharField(blank=True, max_length=250)
    profile_image = URLField(blank=True, max_length=500)
    discord_username = CharField(blank=True, max_length=250)

    # Auth
    is_email_verified = BooleanField(default=False)

    class Meta(AbstractUser.Meta):
        swappable = 'AUTH_USER_MODEL'

    def __str__(self):
        return f'#{self.pk}: {self.display_name}'

    @property
    def username(self):
        return self.email

    @property
    def first_name(self):
        return self.display_name

    @first_name.setter
    def first_name(self, val):
        self.display_name = val

    @property
    def last_name(self):
        return None

    @last_name.setter
    def last_name(self, val):
        pass
Exemplo n.º 8
0
class ConversationParticipant(BaseModel, UpdatedAtMixin):
    """The join table between Conversation and User."""

    objects = ConversationParticipantQuerySet.as_manager()

    user = ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    conversation = ForeignKey(Conversation, on_delete=models.CASCADE)
    seen_up_to = ForeignKey(
        'ConversationMessage',
        null=True,
        on_delete=models.SET_NULL,
        related_name='conversationparticipants_seen_up_to',
    )
    notified_up_to = ForeignKey(
        'ConversationMessage',
        null=True,
        on_delete=models.SET_NULL,
        related_name='conversationparticipants_notified_up_to',
    )
    muted = BooleanField(default=False)

    @property
    def notifications(self):
        if self.id is None:
            # participant does not exist in database
            return ConversationNotificationStatus.NONE.value
        if self.muted:
            return ConversationNotificationStatus.MUTED.value
        return ConversationNotificationStatus.ALL.value

    def unseen_and_unnotified_messages(self):
        messages = self.conversation.messages.exclude_replies()
        if self.seen_up_to_id is not None:
            messages = messages.filter(id__gt=self.seen_up_to_id)
        if self.notified_up_to_id is not None:
            messages = messages.filter(id__gt=self.notified_up_to_id)
        return messages
Exemplo n.º 9
0
class Term(Model):
    name = CharField(
        _('name'), max_length=100, unique=True, help_text=_(
            'Variants of the name can be specified with a “|” separator '
            '(e.g. “name|names|to name”).'))
    case_sensitive = BooleanField(_('case sensitive'), default=False)
    definition = TextField(_('definition'), blank=True,
                           help_text=_('Accepts HTML tags.'))
    url = CharField(_('link'), max_length=200, blank=True,
                    help_text=_('Address to which the term will redirect '
                                '(instead of redirecting to the definition).'))

    objects = TermManager()

    class Meta(object):
        verbose_name = _('term')
        verbose_name_plural = _('terms')
        ordering = ('name',)

    def __str__(self):
        return self.original_name

    def save(self, *args, **kwargs):
        cache.delete_many(CACHE_KEYS)
        super(Term, self).save(*args, **kwargs)

    def get_absolute_url(self):
        if self.url:
            return self.url
        return reverse('term', kwargs={'pk': self.pk})

    def name_variants(self, variant_slice=slice(0, None)):
        return self.name.replace('&', '&').split('|')[variant_slice]

    @property
    def original_name(self):
        return self.name_variants(0)
Exemplo n.º 10
0
class Education(Model):
    HSI = "HSI"
    HS = "HS"
    AS = "AS"
    AAS = "AAS"
    BS = "BS"
    BA = "BA"
    MS = "MS"
    MA = "MA"
    PH = "Phd"
    DEGREE_CHOICES = (
        (HSI, "Incomplete High School"),
        (HS, "High School"),
        (AS, "Associate of Science"),
        (AAS, "Associate of Applied Science"),
        (BS, "Bachelor of Science"),
        (BA, "Bachelor of Arts"),
        (MS, "Masters of Science"),
        (MA, "Masters of Arts"),
        (PH, "Doctorate"),
    )
    degree_type = CharField(
        max_length=3,
        choices=DEGREE_CHOICES,
    )
    degree = CharField(max_length=100)
    slug = AutoSlugField(max_length=50, populate_from=["id", "degree_type"])
    institution = CharField(max_length=250)
    started_at = DateField()
    ended_at = DateField(blank=True, null=True)
    current = BooleanField()

    class Meta:
        ordering = ("-ended_at", "-started_at")

    def __str__(self):
        return (f"{self.degree_type} at {self.institution.name}")
Exemplo n.º 11
0
 def annotate_is_complete(self, queryset):
     """Add an annotation to a queryset to specify if an Asset is complete or not"""
     return queryset.annotate(is_complete=Case(When(Q(
         Q(name__isnull=False), Q(
             department__isnull=False), Q(purpose__isnull=False),
         Q(
             Q(purpose='research', owner__isnull=False)
             | ~Q(purpose='research')),
         Q(
             Q(purpose='other', purpose_other__isnull=False)
             | ~Q(purpose='other')),
         Q(
             Q(personal_data=False)
             | Q(Q(personal_data=True),
                 ~Q(data_subject=[]),
                 ~Q(data_category=[]),
                 recipients_outside_uni__isnull=False,
                 recipients_outside_eea__isnull=False,
                 retention__isnull=False)),
         Q(
             Q(recipients_outside_uni='yes',
               recipients_outside_uni_description__isnull=False)
             | ~Q(recipients_outside_uni='yes')),
         Q(
             Q(recipients_outside_eea='yes',
               recipients_outside_eea_description__isnull=False)
             | ~Q(recipients_outside_eea='yes')), ~Q(risk_type=[]),
         Q(storage_location__isnull=False), ~Q(storage_format=[]),
         Q(~Q(storage_format__contains='paper')
           | Q(Q(storage_format__contains='paper'), ~Q(
               paper_storage_security=[]))),
         Q(~Q(storage_format__contains='digital')
           | Q(Q(storage_format__contains='digital'), ~Q(
               digital_storage_security=[])))),
                                                    then=Value(True)),
                                               default=Value(False),
                                               output_field=BooleanField()))
Exemplo n.º 12
0
class LoginInfor(CoreModel):
    session_id = CharField(max_length=64,
                           verbose_name="会话标识",
                           null=True,
                           blank=True)
    browser = CharField(max_length=64, verbose_name="浏览器")
    ipaddr = CharField(max_length=32,
                       verbose_name="ip地址",
                       null=True,
                       blank=True)
    loginLocation = CharField(max_length=64,
                              verbose_name="登录位置",
                              null=True,
                              blank=True)
    msg = TextField(verbose_name="操作信息", null=True, blank=True)
    os = CharField(max_length=64, verbose_name="操作系统", null=True, blank=True)
    status = BooleanField(default=False, verbose_name="登录状态")

    class Meta:
        verbose_name = '登录日志'
        verbose_name_plural = verbose_name

    def __str__(self):
        return f"{self.creator and self.creator.name}"
Exemplo n.º 13
0
class JNF(Model):
    class Meta:
        permissions = [
            ('apply_jnf', 'Can apply for the job notified by jnf'),
            ('approve_jnf', 'Can approve jnf'),
        ]

    company = ForeignKey(Company,
                         on_delete=PROTECT,
                         related_name='jnf',
                         related_query_name='jnf')
    min_ctc = CharField("Minimum CTC offered (annual)",
                        null=True,
                        blank=True,
                        max_length=32)
    city = CharField("City(Cities) of Posting", max_length=40)
    designation = CharField(max_length=20)
    job_description = CharField(
        max_length=1000,
        null=True,
        blank=True,
    )
    skills_required = CharField(
        max_length=255,
        null=True,
        blank=True,
    )
    remarks = CharField(
        max_length=255,
        null=True,
        blank=True,
    )
    approved = BooleanField(null=False, default=False, blank=True)

    def get_absolute_url(self):
        return reverse("recruiters:jnf_detail", kwargs={'pk': self.pk})
Exemplo n.º 14
0
class UserChannel(Model):
    """
    This class represents a chat message. It has a owner (user), timestamp and
    the message body.

    """
    user = ForeignKey(get_user_model(), on_delete=CASCADE,
                      verbose_name='user', db_index=True)
    channel = CharField(max_length=150)
    room = CharField(max_length=150, null=True, blank=True)
    created = DateTimeField(auto_now_add=True,
                            editable=False,
                            db_index=True)
    last_seen = DateTimeField(auto_now=True)
    status = BooleanField(default=True)

    def change_status(self):
        self.status = not self.status
        self.save(update_fields=['status'])

        # Inform client there is a new message.
        notification = {
            'type': 'operator_status_changed',
            'user': self.user.pk,
            'status': self.status
        }
        channel_layer = get_channel_layer()
        async_to_sync(channel_layer.group_send)(self.room,
                                                notification)


    # Meta
    class Meta:
        verbose_name = 'Canale Utente'
        verbose_name_plural = 'Canali Utenti'
        ordering = ('-created',)
Exemplo n.º 15
0
class Client(Model):
    name = CharField(max_length=255, verbose_name="ScrapydClient")
    ip = CharField(max_length=255, verbose_name="ip地址")
    port = IntegerField(default=6800, verbose_name="端口")
    desc = TextField(blank=True, null=True, verbose_name="说明")
    auth = BooleanField(default=False, verbose_name="是否授权")
    # auth = IntegerField(default=0, blank=True, null=True, verbose_name="授权")
    username = CharField(max_length=255,
                         blank=True,
                         null=True,
                         verbose_name="用户名")
    password = CharField(max_length=255,
                         blank=True,
                         null=True,
                         verbose_name="密码")
    created_at = DateTimeField(auto_now_add=True, verbose_name="创建时间")
    updated_at = DateTimeField(auto_now=True, verbose_name="更新时间")

    class Meta:
        verbose_name = 'Scrapyd客户端'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name
Exemplo n.º 16
0
class HLSPlaybackEnabledFlag(ConfigurationModel):
    """
    Enables HLS Playback across the platform.
    When this feature flag is set to true, individual courses
    must also have HLS Playback enabled for this feature to
    take effect.
    """
    # this field overrides course-specific settings
    enabled_for_all_courses = BooleanField(default=False)

    @classmethod
    def feature_enabled(cls, course_id):
        """
        Looks at the currently active configuration model to determine whether
        the HLS Playback feature is available.

        If the feature flag is not enabled, the feature is not available.
        If the flag is enabled for all the courses, feature is available.
        If the flag is enabled and the provided course_id is for an course
            with HLS Playback enabled, the feature is available.

        Arguments:
            course_id (CourseKey): course id for whom feature will be checked.
        """
        if not HLSPlaybackEnabledFlag.is_enabled():
            return False
        elif not HLSPlaybackEnabledFlag.current().enabled_for_all_courses:
            feature = (CourseHLSPlaybackEnabledFlag.objects.filter(
                course_id=course_id).order_by('-change_date').first())
            return feature.enabled if feature else False
        return True

    def __unicode__(self):
        current_model = HLSPlaybackEnabledFlag.current()
        return u"HLSPlaybackEnabledFlag: enabled {is_enabled}".format(
            is_enabled=current_model.is_enabled())
Exemplo n.º 17
0
class Dog(Model):

    MALE = "m"
    FEMALE = "f"

    name        = CharField(max_length=256, null=False)
    sex         = CharField(max_length=1, choices=(
                                    (MALE, "Male"),
                                    (FEMALE, "Female")
                                ), null=False)
    age         = IntegerField(null=False)
    breed       = CharField(max_length=256, null=True)
    bio         = TextField(null=True)

    location    = ForeignKey(Location, on_delete=CASCADE, null=False)
    personality = ForeignKey(PersonalityQualities, on_delete=CASCADE, null=False)
    physical    = ForeignKey(PhysicalQualities, on_delete=CASCADE, null=False)
    
    has_shelter = BooleanField(default=False, null=False)
    owner       = ForeignKey(UserProfile, on_delete=CASCADE, null=True, blank=True)
    shelter     = ForeignKey(Shelter, on_delete=CASCADE, null=True, blank=True)

    def __str__(self):
        return 'Dog: {}, {}, {}, {}'.format(self.name, self.sex, self.age, self.breed)
Exemplo n.º 18
0
class Project(models.Model):

    # Fields
    name = CharField(max_length=255)
    slug = AutoSlugField(populate_from='name', blank=True)
    created = DateTimeField(auto_now_add=True, editable=False)
    last_updated = DateTimeField(auto_now=True, editable=False)
    date_started = DateField()
    date_ended = DateField(null=True, blank=True)
    description = TextField(blank=True, null=True)
    url = CharField(max_length=255, null=True, blank=True)
    is_current = BooleanField()

    class Meta:
        ordering = ('-created', )

    def __unicode__(self):
        return u'%s' % self.slug

    def get_absolute_url(self):
        return reverse('resume_project_detail', args=(self.slug, ))

    def get_update_url(self):
        return reverse('resume_project_update', args=(self.slug, ))
Exemplo n.º 19
0
class OverviewPage(TitleSlugDescriptionModel, UUIDModel):
    """
    An overview page shows up as a main item in the top navigation menu and
    allows linking together of other objects.
    """

    detail_page_markdown = TextField(blank=True)

    algorithms = ManyToManyField("algorithms.Algorithm", blank=True)
    archives = ManyToManyField("archives.Archive", blank=True)
    challenges = ManyToManyField("challenges.Challenge", blank=True)
    reader_studies = ManyToManyField("reader_studies.ReaderStudy", blank=True)

    published = BooleanField(default=False)

    class Meta(TitleSlugDescriptionModel.Meta, UUIDModel.Meta):
        ordering = ("-created", )
        indexes = (Index(fields=["published"]), )

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        return reverse("overview-pages:detail", kwargs={"slug": self.slug})
Exemplo n.º 20
0
 def board(self):
     Role = apps.get_model("user", "Role")
     return (
         super()
         .get_queryset()
         .annotate(
             role_name=Subquery(
                 Role.objects.filter(
                     user_id=OuterRef("id"), ends_at__isnull=True
                 ).values("division__name")[:1],
                 output_field=CharField(),
             ),
             role_is_head=Subquery(
                 Role.objects.filter(
                     user_id=OuterRef("id"),
                     ends_at__isnull=True,
                     division__name=OuterRef("role_name"),
                 ).values("is_head")[:1],
                 output_field=BooleanField(),
             ),
         )
         .filter(role_name__isnull=False)
         .order_by("name", "surname")
     )
Exemplo n.º 21
0
class Message(Model):
    class Meta:
        ordering = ['-created']

    id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    thread = ForeignKey(Thread, related_name="messages", on_delete=CASCADE)
    alias = OneToOneField("Message",
                          null=True,
                          related_name="related_message",
                          on_delete=CASCADE)
    sender = ForeignKey(User,
                        verbose_name="Author",
                        related_name="messages",
                        on_delete=CASCADE)
    public_key_owner = ForeignKey(User,
                                  verbose_name="Public Key Owner",
                                  related_name="messages_by_pb_key",
                                  on_delete=CASCADE)
    text = TextField(verbose_name="Message text", max_length=4096)
    read = BooleanField(verbose_name="Read", default=False)
    created = DateTimeField(auto_now_add=True)

    def __str__(self):
        return str(self.id)
Exemplo n.º 22
0
    def _try_breadth_first(self, tasks):
        """Try to find tasks with maximum amount of annotations, since we are trying to label tasks as fast as possible
        """

        # =======
        # This commented part is trying to solve breadth-first in a bit different way:
        # it selects first task where any amount of annotations have been already created
        # we've left it here to be able to select it through the project settings later
        # =======
        # annotations = Annotation.objects.filter(task=OuterRef('pk'), ground_truth=False)
        # not_solved_tasks_labeling_started = tasks.annotate(labeling_started=Exists(annotations))
        # not_solved_tasks_labeling_started_true = not_solved_tasks_labeling_started.filter(labeling_started=True)
        # if not_solved_tasks_labeling_started_true.exists():
        #     # try to complete tasks that are already in progress
        #     next_task = self._get_random(not_solved_tasks_labeling_started_true)
        #     return next_task

        tasks = tasks.annotate(annotations_count=Count('annotations'))
        max_annotations_count = tasks.aggregate(
            Max('annotations_count'))['annotations_count__max']
        if max_annotations_count == 0:
            # there is no any labeled tasks found
            return

        # find any task with maximal amount of created annotations
        not_solved_tasks_labeling_started = tasks.annotate(
            reach_max_annotations_count=Case(When(
                annotations_count=max_annotations_count, then=Value(True)),
                                             default=Value(False),
                                             output_field=BooleanField()))
        not_solved_tasks_labeling_with_max_annotations = not_solved_tasks_labeling_started.filter(
            reach_max_annotations_count=True)
        if not_solved_tasks_labeling_with_max_annotations.exists():
            # try to complete tasks that are already in progress
            return self._get_random_unlocked(
                not_solved_tasks_labeling_with_max_annotations)
Exemplo n.º 23
0
class Conference(Model):
    conference_name = CharField(max_length=128)
    conference_slug = SlugField()
    status = CharField(choices=conference_statuses,
                       max_length=50,
                       default='upcoming')
    accepting_bids = BooleanField(default=False)
    act_style = CharField(choices=act_format, max_length=50, default='normal')

    def __unicode__(self):
        return self.conference_name

    @classmethod
    def current_conf(cls):
        return cls.objects.filter(status__in=('upcoming', 'ongoing')).first()

    @classmethod
    def by_slug(cls, slug):
        try:
            return cls.objects.get(conference_slug=slug)
        except cls.DoesNotExist:
            return cls.current_conf()

    @classmethod
    def all_slugs(cls):
        return cls.objects.order_by('-conference_slug').values_list(
            'conference_slug', flat=True)

    def windows(self):
        from gbe.models import VolunteerWindow
        return VolunteerWindow.objects.filter(day__conference=self)

    class Meta:
        verbose_name = "conference"
        verbose_name_plural = "conferences"
        app_label = "gbe"
Exemplo n.º 24
0
    def apply(self, tests):
        """
        Convert JSON logic to queryset info, returns an Q object and fills self.annotations
        """
        if not tests:
            return Q()
        if isinstance(tests, bool):
            # not really a legal configuration but used in the test suite
            return Value(tests, output_field=BooleanField())

        operator = list(tests.keys())[0]
        values = tests[operator]

        # Easy syntax for unary operators, like {"var": "x"} instead of strict
        # {"var": ["x"]}
        if not isinstance(values, list) and not isinstance(values, tuple):
            values = [values]

        if operator in self.bool_ops:
            return self.bool_ops[operator](*[self.apply(v) for v in values])
        elif operator in self.comparison_ops:
            return self.comparison_ops[operator](*values)
        else:
            raise ValueError(f'Invalid operator {operator} on first level')
Exemplo n.º 25
0
class Role(CoreModel):
    DATASCOPE_CHOICES = (
        ('1', "全部数据权限"),
        ('2', "自定数据权限"),
        ('3', "本部门数据权限"),
        ('4', "本部门及以下数据权限"),
        ('5', "仅本人数据权限"),
    )
    roleName = CharField(max_length=64, verbose_name="角色名称")
    roleKey = CharField(max_length=64, verbose_name="权限字符")
    roleSort = IntegerField(verbose_name="角色顺序")
    status = CharField(max_length=8, verbose_name="角色状态")
    admin = BooleanField(default=False, verbose_name="是否为admin")
    dataScope = CharField(max_length=8,default='1', choices=DATASCOPE_CHOICES, verbose_name="权限范围",)
    remark = TextField(verbose_name="备注", help_text="备注", null=True, blank=True)
    dept = ManyToManyField(to='permission.Dept', verbose_name='数据权限-关联部门', db_constraint=False)
    menu = ManyToManyField(to='permission.Menu', verbose_name='关联菜单权限', db_constraint=False)

    class Meta:
        verbose_name = '角色管理'
        verbose_name_plural = verbose_name

    def __str__(self):
        return f"{self.roleName}"
Exemplo n.º 26
0
def notes(request, category_id=None):
    context = {}
    categories = Category.objects.all()
    notes_qs = (Note.objects.filter(status=Note.STATUS_PUBLISHED).annotate(
        is_favorite=Case(
            When(favorites__user__id=request.user.id, then=Value(True)),
            default=Value(False),
            output_field=BooleanField(),
        )).values('slug', 'title', 'is_favorite'))

    if category_id:
        category = get_object_or_404(Category, id=category_id)
        notes_qs = notes_qs.filter(category=category)
        context['category_id'] = int(category_id)

    notes_list = list(notes_qs)
    notes_draft = DraftNote.objects.filter(user=request.user)
    context.update({
        'notes': json.dumps(notes_list),
        'notes_draft': notes_draft,
        'categories': categories,
    })

    return render(request, template_name='notes/notes.html', context=context)
Exemplo n.º 27
0
def get_problematic_tweet_relations(annotator_id:int):
    from django.db.models import Case, When, Value,  BooleanField

    IN_PROGRESS_IDS = get_ids_in_cache('RESOLVE_TWEET_RELATION')

    subquery_ = Annotation.objects.filter(
        tweet_relation=OuterRef('id'),
        annotator=annotator_id
    )
    queryset = TweetRelation.objects \
        .filter(relevant=True, problematic=True) \
        .exclude(id__in=IN_PROGRESS_IDS) \
        .annotate(
            is_skipped_ANNOTATED=Case(
                When(revision__skipped=True, then=Value(True)),
                default=Value(False),
                output_field=BooleanField()
            ),
            has_been_annotated_by_user_ANNOTATED=Exists(
                subquery_
            ),
            has_revision_ANNOTATED=Exists(
                Revision.objects.filter(
                    tweet_relation=OuterRef('id'),
                )  
            ),
            has_revision_without_annotation_ANNOTATED=Exists(
                Revision.objects.filter(
                    tweet_relation=OuterRef('id'),
                    annotation=None
                )  
            )
        ) \
        .only('id')

    return list(queryset)
Exemplo n.º 28
0
class RelevancyBaseModel(Model, MessagesMixin):
    is_relevant = BooleanField(default=False)
    relevancy_exception = CharField(blank=True,
                                    max_length=255,
                                    verbose_name='exception')

    @property
    def may_be_relevant(self):
        return True

    @property
    def relevancy_warnings(self):
        return ''

    relevancy_warnings.fget.short_description = 'warnings'

    @property
    def relevancy_errors(self):
        return ''

    relevancy_errors.fget.short_description = 'errors'

    class Meta:
        abstract = True
Exemplo n.º 29
0
class User(BaseUser, ClassStr):
    company = ForeignKey('Company',
                         on_delete=models.CASCADE,
                         null=True,
                         blank=True)
    is_admin = BooleanField(default=False)
    email = CIEmailField('email', unique=True, blank=False)

    objects = BaseUserManager()

    def clean(self, *args, **kwargs):
        super().clean()
        # Validate company and is_admin not both set
        if self.company and self.is_admin:
            raise ValidationError("Company and is_admin cannot set both")

    def save(self, *args, **kwargs):
        # If this is a new user
        if not self.pk and not self.password:
            password = User.objects.make_random_password()
            self.set_password(password)

        self.full_clean()
        super().save(*args, **kwargs)
Exemplo n.º 30
0
def _build_filename_contains_raw_query(field, value):
    # It is not possible to use Django's ORM to query for if one item in a JSONB
    # list has has a key which contains a specified value.
    #
    # The closest thing the Django ORM provides is:
    #   queryset.filter(your_json_field__contains=[{"key":"value"}])
    # However this is an exact match, so in the above example [{"key":"value_etc"}]
    # would not match the filter.
    #
    # Instead we have to resort to RawSQL to use various built in PostgreSQL JSON
    # Array manipulation functions to be able to 'iterate' over a JSONB list
    # performing `like` on individual keys in said list.
    num_files_with_name_like_value = f"""
    EXISTS(
        SELECT attached_files ->> 'visible_name'
        FROM JSONB_ARRAY_ELEMENTS("field_{field.id}") as attached_files
        WHERE UPPER(attached_files ->> 'visible_name') LIKE UPPER(%s)
    )
"""
    return RawSQL(
        num_files_with_name_like_value,
        params=[f"%{value}%"],
        output_field=BooleanField(),
    )
Exemplo n.º 31
0
class Client(Model):
    """
    Scrapyd Server
    """
    name = CharField(max_length=100)
    ip = CharField(max_length=100)
    port = IntegerField(default=6800)
    auth = BooleanField(default=False)
    username = CharField(max_length=100, blank=True, null=True, default=None)
    password = CharField(max_length=100, blank=True, null=True, default=None)
    created_at = DateTimeField(auto_now_add=True)
    updated_at = DateTimeField(default=timezone.now)
    spider_amount = IntegerField(default=0)

    def __str__(self):
        """
        to string
        :return: name
        """
        return self.name

    def remove_spider(self, amount):
        """
        remove spider
        :param amount: amount of spider
        """
        self.spider_amount -= amount
        self.save()

    def add_spider(self, amount):
        """
        add spider
        :param amount: amount of spider
        """
        self.spider_amount += amount
        self.save()
Exemplo n.º 32
0
class GraphSession(models.Model):
    created = DateTimeField('created', default=timezone.now)

    listidx = IntegerField(default=0)
    title = CharField(max_length=200, default="", blank=True, null=True)
    description = TextField(blank=True, null=True)
    loglines = TextField(blank=True, null=True)
    logheader = TextField(blank=True, null=True)

    example = BooleanField(default=False)
    excomment = CharField(max_length=200, default="", blank=True, null=True)

    username = CharField(max_length=200)
    quicksaved = DateTimeField('quicksaved', blank=True, null=True)
    stashed = DateTimeField('stashed', blank=True, null=True)

    graphdef = TextField(blank=True)

    # stashed live data on top of quicksave
    stashed_pickle = TextField(blank=True)
    stashed_matfile = CharField(max_length=200, default="", blank=True)

    # restore point / quick save
    quicksave_pickle = TextField(blank=True)
    quicksave_matfile = CharField(max_length=200, default="", blank=True)

    def __str__(self):
        return 'session %s, idx %s, %s' % (self.id, self.listidx, self.title)

    def reset(self):
        self.stashed_pickle = "reset"
        self.quicksave_pickle = "reset"
        self.loglines = ""
        self.logheader = ""
        self.stashed_matfile = ""
        self.quicksave_matfile = ""