class WeightModel(Model): name = TextField(default='unknown') classificator_provider = TextField(blank=False) shape = BinaryField(blank=True) body = BinaryField() accuracy = FloatField(default=-1) lambda_value = FloatField(default=-1) learn_rate = FloatField(default=-1)
class TestData(Resource, TitleMixin): """ 测试数据。 评测机在评测提交时将使用此表中的数据。 """ # 编号 id = BigAutoField(primary_key=True) # 所属题元 meta_problem = ForeignKey(MetaProblem, related_name='test_data', to_field='id') # 测试输入的大小 in_size = IntegerField() # 测试输出的大小 out_size = IntegerField() # 测试输入(二进制数据) test_in = BinaryField(null=True) # 测试输出(二进制数据) test_out = BinaryField(null=True) # 有多少题目使用了此测试数据 number_problem = IntegerField(default=0) def __str__(self): return '<TestData ' + str(self.id) + ' in MetaProblem ' + str( self.meta_problem_id) + '>' def get_test_in(self): """ 读取测试输入,将二进制数据转换为字符串。 :return: 字符串,测试输入。 """ if self.test_in is None: return None else: return bytes(self.test_in).decode('utf-8', 'ignore')[:_INPUT_MAX] def get_test_out(self): """ 读取测试输出,将二进制数据转换为字符串。 :return: 字符串,测试输出。 """ if self.test_out is None: return None else: return bytes(self.test_out).decode('utf-8', 'ignore')[:_INPUT_MAX]
class Test(Model): name = CharField(max_length=20) owner = ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=CASCADE) public = BooleanField(default=False) date = DateField(null=True, blank=True) datetime = DateTimeField(null=True, blank=True) permission = ForeignKey('auth.Permission', null=True, blank=True, on_delete=CASCADE) # We can’t use the exact names `float` or `decimal` as database column name # since it fails on MySQL. a_float = FloatField(null=True, blank=True) a_decimal = DecimalField(null=True, blank=True, max_digits=5, decimal_places=2) bin = BinaryField(null=True, blank=True) ip = GenericIPAddressField(null=True, blank=True) duration = DurationField(null=True, blank=True) uuid = UUIDField(null=True, blank=True) class Meta(object): ordering = ('name', )
class Test(Model): name = CharField(max_length=20) owner = ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=SET_NULL) public = BooleanField(default=False) date = DateField(null=True, blank=True) datetime = DateTimeField(null=True, blank=True) permission = ForeignKey('auth.Permission', null=True, blank=True, on_delete=PROTECT) # We can’t use the exact names `float` or `decimal` as database column name # since it fails on MySQL. a_float = FloatField(null=True, blank=True) a_decimal = DecimalField(null=True, blank=True, max_digits=5, decimal_places=2) bin = BinaryField(null=True, blank=True) ip = GenericIPAddressField(null=True, blank=True) duration = DurationField(null=True, blank=True) uuid = UUIDField(null=True, blank=True) try: from django.db.models import JSONField json = JSONField(null=True, blank=True) except ImportError: pass class Meta: ordering = ('name', )
class Resource(Model): def __str__(self): return u"{}: {}".format(self.relative_url, self.file) question = ForeignKey('Question', on_delete=CASCADE) relative_url = CharField(max_length=255) file = FileField(null=True, upload_to='resources') resource_type = CharField(max_length=255) mimetype = CharField(max_length=255) data = BinaryField(null=True) part_of_solution = BooleanField(default=False) def url(self): return self.file.url def as_bytes(self): s = bytes() if self.file: self.file.open() s = self.file.read() self.file.close() elif self.data is not None: fname = os.path.join('resources', self.question.identifier, self.relative_url) self.file.name = fname ensure_dir_exists(self.file.path) with open(self.file.path, 'wb') as f: f.write(self.data) s = self.data return s def as_base64(self): return base64.b64encode(self.as_bytes())
class SpecialJudge(Resource, TitleMixin): """ 特殊评测。 由于废弃字段等原因,一道题目下可以出现多个特殊评测代码,未被废弃的编号最大的特殊评测将作为题目的特殊评测, 若题目下无特殊评测或特殊评测均未废弃状态,则题目被设定为不存在特殊评测。 """ # 所属题目 problem = ForeignKey(Problem, related_name='special_judge', to_field='id') # 特殊评测代码是属于哪个编程环境的(HUSTOJ仅支持C/C++的代码) environment = ForeignKey('Environment', related_name='special_judge', to_field='id') # 特殊评测代码(二进制数据) code = BinaryField() def __str__(self): return '<Special Judge %s of Problem %s>' % (self.id, self.problem.id) def get_code(self): """ 获取特殊评测代码,将二进制数据转换为字符串。 :return: 字符串,特殊评测代码。 """ return bytes(self.code).decode('utf-8', 'ignore')
class AccessToken(Model): class ParseError(Exception): pass # project = models.ForeignKey(Project, on_delete=models.CASCADE) project_id = TextField() token = BinaryField(max_length=encryption.TOKEN_SIZE) valid_until = DateTimeField() def is_valid(self, now=None) -> bool: if now is None: now = now_utc() return self.valid_until > now @staticmethod def _token_by_proj_id(project_id: str): return AccessToken.objects.filter(project_id=project_id) @staticmethod def _purge_old_tokens(project_id: str): now = now_utc() for token in AccessToken._token_by_proj_id(project_id): if not token.is_valid(now): token.delete() @staticmethod def get_project_token(project_id: str) -> Optional["AccessToken"]: AccessToken._purge_old_tokens(project_id) return AccessToken._token_by_proj_id(project_id).first() @staticmethod def create_new(project_id: str) -> "AccessToken": tok, valid_until = generate_token() return AccessToken.objects.create(project_id=project_id, token=tok, valid_until=valid_until) @staticmethod def get_from_base64(b64_token): try: tok = b64decode(b64_token) except (binascii.Error, ValueError): # could not parse base64 string raise AccessToken.ParseError() token = AccessToken.objects.get(token=tok) if token is None or not token.is_valid(): return None return token def as_base64(self): """ get this token as base64 encoded string """ return b64encode(self.token).decode()
class Resource(Model): id = UUIDField(primary_key=True, default=uuid4, editable=False) name = CharField(max_length=255) extension = CharField(max_length=255, blank=True) content = BinaryField() content_type = CharField(max_length=255) created_at = DateTimeField(auto_now_add=True)
class StoredMessage(Model): type = PositiveSmallIntegerField() timestamp = DateTimeField() data = BinaryField() task_id = CharField(max_length = MESSAGE_TASK_ID_MAX_LENGTH, null = True, blank = True) subtask_id = CharField(max_length = MESSAGE_TASK_ID_MAX_LENGTH, null = True, blank = True) created_at = DateTimeField(auto_now_add=True) def __str__(self): return 'StoredMessage #{}, type:{}, {}'.format(self.id, self.type, self.timestamp)
class PendingEthereumTransaction(Model): """ Represents pending Ethereum transaction state. """ nonce = DecimalField(max_digits=78, decimal_places=0) gasprice = DecimalField(max_digits=78, decimal_places=0) startgas = DecimalField(max_digits=78, decimal_places=0) value = DecimalField(max_digits=78, decimal_places=0) to = BinaryField(max_length=20) data = BinaryField() v = IntegerField() r = DecimalField(max_digits=78, decimal_places=0) s = DecimalField(max_digits=78, decimal_places=0) created_at = DateTimeField(auto_now_add=True)
class PaymentInfo(Model): """ Stores the information needed to construt a PaymentCommitted message """ class RecipientType(ChoiceEnum): Provider = 'provider' Requestor = 'requestor' payment_ts = DateTimeField() task_owner_key = BinaryField() provider_eth_account = CharField(max_length=ETHEREUM_ADDRESS_LENGTH) amount_paid = IntegerField() recipient_type = CharField(max_length=32, choices=RecipientType.choices()) amount_pending = IntegerField() pending_response = ForeignKey(PendingResponse, related_name='payments') def clean(self): if self.task_owner_key == self.provider_eth_account: raise ValidationError({ 'provider_eth_account': 'Provider ethereum account address must be diffrent than task owner key' }) if not isinstance(self.amount_pending, int) or self.amount_pending <= 0: raise ValidationError({ 'amount_pending': 'Amount pending must be an integer and bigger than 0' }) if not isinstance(self.amount_paid, int) or self.amount_paid < 0: raise ValidationError({ 'amount_paid': 'Amount paid must be an integer and bigger than or equal 0' }) if not isinstance(self.task_owner_key, bytes) or not len( self.task_owner_key) == TASK_OWNER_KEY_LENGTH: raise ValidationError({ 'task_owner_key': f'Task owner key must be a bytes string with {TASK_OWNER_KEY_LENGTH} characters' }) if not isinstance(self.provider_eth_account, str) or not len( self.provider_eth_account) == ETHEREUM_ADDRESS_LENGTH: raise ValidationError({ 'provider_eth_account': f'Provider ethereum account address must be a string with {ETHEREUM_ADDRESS_LENGTH} characters' }) if not isinstance(self.pending_response, PendingResponse): raise ValidationError({ 'pending_response': 'PaymentInfo should be related with Pending Response' })
def get_destinations(application_id, user_type=None): """ Get destinations for an open application. For gov users they are ordered based on flag priority and alphabetized by name. """ if user_type == UserType.EXPORTER: countries_on_application = (CountryOnApplication.objects. select_related("country").prefetch_related( "flags", "country__flags").filter( application=application_id)) else: countries_on_application = ( CountryOnApplication.objects.select_related( "country").prefetch_related( "country__flags", "flags").filter(application=application_id).annotate( highest_flag_priority=Min("country__flags__priority"), contains_flags=Case(When(country__flags__isnull=True, then=0), default=1, output_field=BinaryField()), ).order_by("-contains_flags", "highest_flag_priority", "country__name")) destinations = [] for coa in countries_on_application: destinations.append({ "id": coa.id, "country": { "id": coa.country.id, "name": coa.country.name, "flags": [{ "colour": f.colour, "name": f.name, "label": f.label, "id": f.id } for f in coa.country.flags.all() if f.status == FlagStatuses.ACTIVE], }, "flags": [{ "id": f.id, "name": f.name } for f in coa.flags.all()], "contract_types": coa.contract_types, "other_contract_type_text": coa.other_contract_type_text, }) return {"type": "countries", "data": destinations}
def filter_queryset(self, queryset): users_team_first = self.request.GET.get("users_team_first", False) name = self.request.GET.get("name") if name: queryset = queryset.filter(name__icontains=name) if str_to_bool(users_team_first): queryset = queryset.annotate(users_team=( Case(When(team=self.request.user.govuser.team, then=1), default=0, output_field=BinaryField()))).order_by("-users_team") return queryset
class WaitingAction(CremeModel): action = CharField( _(u'Action'), max_length=100 ) # Action (i.e: create, update...) # TODO: int instead ?? # TODO: split into 2 CharFields 'fetcher' & 'input' ? # NB: - If default backend (subject="*"): fetcher_name. # - If not 'fetcher_name - input_name' (i.e: email - raw, email - infopath, sms - raw...). source = CharField(_(u'Source'), max_length=100) # raw_data = TextField(blank=True, null=True) # Pickled data raw_data = BinaryField(blank=True, null=True) # Pickled data ct = CTypeForeignKey(verbose_name=_( u'Type of resource')) # Redundant, but faster bd recovery subject = CharField(_(u'Subject'), max_length=100) user = CremeUserForeignKey(verbose_name=_(u'Owner'), blank=True, null=True, default=None) # If sandbox per user class Meta: app_label = 'crudity' verbose_name = _(u'Waiting action') verbose_name_plural = _(u'Waiting actions') # def get_data(self): @property def data(self): # data = loads(self.raw_data.encode('utf-8')) data = loads(self.raw_data) # if isinstance(data, dict): # data = { # k: v.decode('utf8') if isinstance(v, str) else v # for k, v in data.items() # } return data # def set_data(self, data): @data.setter def data(self, data): self.raw_data = dumps(data) def can_validate_or_delete(self, user): """self.user not None means that sandbox is by user""" if self.user is not None and self.user != user and not user.is_superuser: return False, ugettext( u'You are not allowed to validate/delete the waiting action <{}>' ).format(self.id) return True, ugettext(u'OK')
class WaitingAction(CremeModel): # Action (i.e: create, update...) # TODO: int instead ?? action = CharField(_('Action'), max_length=100) # TODO: split into 2 CharFields 'fetcher' & 'input' ? # NB: - If default backend (subject="*"): fetcher_name. # - If not 'fetcher_name - input_name' (eg: email - raw, email - infopath, sms - raw...). source = CharField(_('Source'), max_length=100) raw_data = BinaryField(blank=True, null=True) # Pickled data # Redundant, but faster bd recovery ct = creme_fields.CTypeForeignKey(verbose_name=_('Type of resource')) subject = CharField(_('Subject'), max_length=100) # If sandbox per user user = creme_fields.CremeUserForeignKey( verbose_name=_('Owner'), blank=True, null=True, default=None, ) class Meta: app_label = 'crudity' verbose_name = _('Waiting action') verbose_name_plural = _('Waiting actions') @property def data(self) -> dict: return loads(self.raw_data) @data.setter def data(self, data: dict): self.raw_data = dumps(data) def can_validate_or_delete(self, user) -> Tuple[bool, str]: """self.user not None means that sandbox is by user""" if self.user is not None and self.user != user and not user.is_superuser: return ( False, gettext( 'You are not allowed to validate/delete the waiting action <{}>' ).format(self.id)) return True, gettext('OK')
class InstantContent(Model): """ The content that can be easily previewed and transmitted: contentType: IntegerField 1: 'text & image'([pure text] OR [pure image] OR [text + image]) 2: 'location' 3: 'voice' content: BinaryField binary version of the content, it should contain all the information of the InstantContent compressionMethod: CharField 1: 'gzip' textVersionContent: TextField text version of the content, the value should be: if the type is pure text: the original pure text if the type is pure image: blank if the type is text + image: only the text content if the type is location: GPS: (xxx.xxx,yyy.yyy,zzz.zzz) Location: provided by the user or Google API if the type is voice: the converted text content """ class ContentType(IntegerChoices): TYPE_TEXT_IMAGE = 1, _("Text & Image") TYPE_LOCATION = 2, _("Location") TYPE_VOICE = 3, _("Voice") class CompressionMethod(IntegerChoices): TYPE_GZIP = 1, _("gzip") user = ForeignKey(to=RecordedUser, on_delete=CASCADE, null=True) contentType = IntegerField(choices=ContentType.choices, null=True) content = BinaryField(null=True) compressionMethod = IntegerField(choices=CompressionMethod.choices, null=True) textVersionContent = TextField(null=True) def _str_(self): return self.title
class RequestProfile(Model): started_at = DateTimeField() created_at = DateTimeField() request_user = ForeignKey(User, on_delete=SET_NULL, null=True) request_path = TextField(blank=True) response_code = IntegerField() time_real = FloatField() time_user = FloatField() time_sys = FloatField() allocated_vm = BigIntegerField() peak_rss_use = BigIntegerField() data = BinaryField(null=True) data_json = BooleanField() data_path = TextField(blank=True) size_base = BigIntegerField(null=True) size_gzip = BigIntegerField(null=True) size_json = BigIntegerField(null=True)
class HubUser(AbstractUser): """ The HubUser is basically the standard Django user, but has an additional encrypted shared TOTP secret """ totp_secret = BinaryField( _('TOTP Secret'), max_length=1024, null=True, blank=False, default=create_encrypted_random_totp_secret, help_text=_('Encrypted TOTP Secret') ) def set_totp_secret(self, secret: bytes): """ Set the TOTP Secret The TOTP Secret will be encrypted before it is saved to the database. :param bytes secret: The TOTP secret to be encrypted and saved to the database """ if len(secret) < 32: raise ValueError(_('Secret must be at least 32 bytes long')) if len(secret) > 96: raise ValueError(_('Secret must not be larger than 96 bytes')) self.totp_secret = SymmetricCrypt().encrypt(secret) def get_totp_secret(self) -> Optional[bytes]: """ Get the TOTP Secret This method gives you the unencrypted (decrypted) TOTP secret :rtype: Optional[bytes] :returns: The unencrypted secret or None if no secret is set """ if self.totp_secret is None: return None return SymmetricCrypt().decrypt(self.totp_secret) def __str__(self): return '{}'.format(self.username)
class Activity(Model): ap_id = TextField() payload = BinaryField() created_at = DateField(auto_now_add=True) person = ForeignKey(Person, related_name='activities', on_delete=CASCADE) remote = BooleanField(default=False) @property def uris(self): if self.remote: ap_id = self.ap_id else: ap_id = uri("activity", self.person.username, self.id) return URIs(id=ap_id) def to_activitystream(self): payload = self.payload.decode("utf-8") data = json.loads(payload) data.update({"id": self.uris.id}) return data
class Event(Model): ctime = DateTimeField(auto_now_add=True, null=True) # Identify the object in the database and its version xref = CharField(_(u'External Ref'), max_length=XREF_LENGTH) xbus_message_correlation_id = CharField(_(u'Message correlation id'), max_length=36) # Event type event_type = CharField(_(u'Event type'), max_length=80) event_id = CharField(_(u'Event id'), max_length=80, null=True, blank=True) # Direction : incoming or outgoing DIRECTION_CHOICES = ( ('in', _(u'Incoming')), ('out', _(u'Outgoing')), ('immediate-out', _(u'Immediate-Out')), ) direction = CharField(_(u'Direction'), max_length=25, choices=DIRECTION_CHOICES) # State STATE_CHOICES = ( ('pending', _(u'Pending')), ('done', u'Done'), ('error', _(u'Error')), ) state = CharField(_(u'State'), max_length=20, choices=STATE_CHOICES) comment = TextField(_(u'Comment'), blank=True) # Binary in msgpack format item = BinaryField(_(u'Event item')) admin_url = CharField(max_length=250, default="", editable=False, null=True)
class PaymentInfo(Model): """ Stores the information needed to construt a PaymentCommitted message """ class RecipientType(ChoiceEnum): Provider = 'provider' Requestor = 'requestor' payment_ts = DateTimeField() task_owner_key = BinaryField(validators=[ MinLengthValidator(TASK_OWNER_KEY_LENGTH), MaxLengthValidator(TASK_OWNER_KEY_LENGTH), ]) provider_eth_account = CharField( max_length=ETHEREUM_ADDRESS_LENGTH, validators=[MinLengthValidator(ETHEREUM_ADDRESS_LENGTH)]) amount_paid = DecimalField(max_digits=BIG_ENDIAN_INT_MAX_DIGITS, decimal_places=0, validators=[MinValueValidator(0)]) recipient_type = CharField(max_length=32, choices=RecipientType.choices()) amount_pending = DecimalField(max_digits=BIG_ENDIAN_INT_MAX_DIGITS, decimal_places=0, validators=[MinValueValidator(0)]) @property def amount_paid_as_int(self) -> int: return int(self.amount_paid) @property def amount_pending_as_int(self) -> int: return int(self.amount_pending) def clean(self) -> None: if self.task_owner_key == self.provider_eth_account: raise ValidationError({ 'provider_eth_account': 'Provider Ethereum account address must be different than task owner key.' })
class WebhookData(ConcurrentTransitionMixin, Model): """Abstract base class for webhook data.""" class Meta: app_label = APP_LABEL abstract = True NEW = STATE.NEW PROCESSING = STATE.PROCESSING PROCESSED = STATE.PROCESSED ERROR = STATE.ERROR CHOICES = STATE.CHOICES # We know we always want to record the webhook source, and the # date we received it. status = FSMIntegerField(choices=CHOICES, default=NEW, protected=True) source = GenericIPAddressField(null=True) received = DateTimeField(default=timezone.now) headers = JSONField() # This is for storing the webhook payload exactly as received # (i.e. from request.body), which comes in handy for signature # verification. body = BinaryField() @transition(field=status, source=NEW, target=PROCESSING, on_error=ERROR) def start_processing(self): logger.debug('Processing webhook %s' % self.id) @transition(field=status, source=PROCESSING, target=PROCESSED, on_error=ERROR) def finish_processing(self): logger.debug('Finishing webhook %s' % self.id) @transition(field=status, source=PROCESSING, target=ERROR) def fail(self): logger.debug('Failed to process webhook %s' % self.id)
class RootKey(TimestampedModel): """A root key for signing macaroons.""" id = BigAutoField(primary_key=True, verbose_name='ID') material = BinaryField() expiration = DateTimeField()
class OToolkitDevice(Device): """ Abstract model for a :mod:`oath_toolkit`-based django-otp_ ``Device``. .. _django-otp: https://pypi.python.org/pypi/django-otp .. attribute:: secret Binary-encoded secret data. In :class:`django_otp.plugins.otp_totp.models.TOTPDevice`, this field is named ``key``, but this is a suboptimal choice, as ``key`` is a SQL keyword. Defaults to 40 random bytes. :type: :class:`django.db.models.BinaryField` .. attribute:: window The number of OTPs before and after the start OTP to test. In :class:`django_otp.plugins.otp_totp.models.TOTPDevice`, this field is named ``tolerance``. Defaults to ``1``. :type: :class:`django.db.models.PositiveSmallIntegerField` .. attribute:: digits The number of digits in the token. Defaults to ``6``. :type: :class:`django.db.models.PositiveSmallIntegerField` """ secret = BinaryField(max_length=SECRET_SIZE, default=_random_data) window = PositiveSmallIntegerField(default=1) digits = PositiveSmallIntegerField(default=6, choices=[(6, 6), (8, 8)]) class Meta: abstract = True def secret_qrcode(self, request): """ QR code image based on the secret. :rtype: :class:`qrcode.image.base.BaseImage` """ site = get_current_site(request) return qrcode.generate(self.oath_type, self.secret, self.user.username, site.name, border=2, box_size=4) @property def secret_base32(self): """ The secret, in a human-readable Base32-encoded string. :type: bytes """ return self.oath.base32_encode(self.secret, human_readable=True) @secret_base32.setter def secret_base32(self, value): self.secret = self.oath.base32_decode(value) @property def secret_hex(self): """ The secret, in a hex-encoded string. :type: bytes """ return hexlify(self.secret) @secret_hex.setter def secret_hex(self, value): self.secret = unhexlify(value) @property def oath(self): if not hasattr(self, '_oath'): self._oath = OATH() return self._oath def _do_verify_token(self, token, validator_func, *args): token = bytes(token) if len(token) != self.digits: token = token.rjust(self.digits, b'0') args += (self.window, token) try: return validator_func(bytes(self.secret), *args) except OATHError: return False
class File(models.Model): objects = FileManager() name = models.CharField( max_length=255, unique=True, blank=False, null=False, db_index=True ) size = models.PositiveIntegerField(db_index=True, blank=False, null=False) content = BinaryField(blank=False, null=False) created_datetime = models.DateTimeField( db_index=True, default=timezone.now, verbose_name="Created datetime" ) _content_hash = models.CharField( db_column="content_hash", db_index=True, max_length=128, blank=True, null=True ) class Meta: db_table = "binary_database_files_file" def __str__(self): return self.name def save(self, *args, **kwargs): # Check for and clear old content hash. if self.id: old = File.objects.get(id=self.id) if old.content != self.content: self._content_hash = None # Recalculate new content hash. self.content_hash return super(File, self).save(*args, **kwargs) @property def content_hash(self): if not self._content_hash and self.content: self._content_hash = utils.get_text_hash(self.content) return self._content_hash def dump(self, check_hash=False): """ Writes the file content to the filesystem. If check_hash is true, clears the stored file hash and recalculates. """ if is_fresh(self.name, self._content_hash): return write_file(self.name, self.content, overwrite=True) if check_hash: self._content_hash = None self.save() @classmethod def dump_files(cls, debug=True, verbose=False): """ Writes all files to the filesystem. """ if debug: tmp_debug = settings.DEBUG settings.DEBUG = False try: q = cls.objects.only("id", "name", "_content_hash").values_list( "id", "name", "_content_hash" ) total = q.count() if verbose: print("Checking %i total files..." % (total,)) i = 0 for (file_id, name, content_hash) in q.iterator(): i += 1 if verbose and not i % 100: print("%i of %i" % (i, total)) if not is_fresh(name=name, content_hash=content_hash): if verbose: print( ("File %i-%s is stale. Writing to local file " "system...") % (file_id, name) ) f = File.objects.get(id=file_id) write_file(f.name, f.content, overwrite=True) f._content_hash = None f.save() finally: if debug: settings.DEBUG = tmp_debug
def __init__(self, *args, **kwargs): self.profile = kwargs.pop('profile') self.read_only = kwargs.pop('read_only', False) self.modified_venue = kwargs.pop('dirty', None) super().__init__(*args, **kwargs) PLACE, FAMILY_MEMBERS, PHONE, PUBLIC_EMAIL = (vis.type() for vis in [ VisibilitySettingsForPlace, VisibilitySettingsForFamilyMembers, VisibilitySettingsForPhone, VisibilitySettingsForPublicEmail, ]) # Gathering all data items linked to the profile. what = Q() owned_places = self.profile.owned_places.exclude( deleted=True).prefetch_related('family_members') what |= Q(model_type=PLACE, place__in=owned_places) what |= Q(model_type=FAMILY_MEMBERS, family_members__in=[ place.pk for place in owned_places if len(place.family_members_cache()) != 0 and not place.family_is_anonymous ]) what |= Q(model_type=PHONE, phone__in=self.profile.phones.exclude(deleted=True)) what |= Q(model_type=PUBLIC_EMAIL, profile=self.profile) if self.profile.email else Q() qs = VisibilitySettings.objects.filter(what) # Forcing a specific sort order: places (with their corresponding family members), # then phones, then a public email if present. qs = qs.annotate( level_primary=Case( When(Q(model_type=PLACE) | Q(model_type=FAMILY_MEMBERS), then=1), When(model_type=PHONE, then=2), When(model_type=PUBLIC_EMAIL, then=3), default=9, output_field=BinaryField(), ), level_secondary=Case( When(model_type=PLACE, then=10), When(model_type=FAMILY_MEMBERS, then=11), output_field=BinaryField(), ), ) # Preparing presentation settings. qs = qs.annotate( hint=Case( When(model_type=PLACE, then=Value(str(_("A place in")))), When(model_type=PHONE, then=Value(str(_("Phone number")))), When(model_type=PUBLIC_EMAIL, then=Value(str(_("Email address")))), output_field=CharField(), ), indent=Case( When(model_type=FAMILY_MEMBERS, then=True), default=False, output_field=BooleanField(), ), ) self.queryset = qs.order_by('level_primary', 'model_id', 'level_secondary')
class AsWKB(GeoFunc): output_field = BinaryField() arity = 1
def test_BinaryField(self): lazy_func = lazy(lambda: b"", bytes) self.assertIsInstance(BinaryField().get_prep_value(lazy_func()), bytes)
def search( # noqa self, queue_id=None, is_work_queue=None, user=None, status=None, case_type=None, assigned_user=None, case_officer=None, include_hidden=None, organisation_name=None, case_reference=None, # gov case number exporter_application_reference=None, exporter_site_name=None, exporter_site_address=None, control_list_entry=None, flags=None, country=None, team_advice_type=None, final_advice_type=None, min_sla_days_remaining=None, max_sla_days_remaining=None, submitted_from=None, submitted_to=None, finalised_from=None, finalised_to=None, party_name=None, party_address=None, goods_related_description=None, sla_days_elapsed_sort_order=None, sla_days_elapsed=None, **kwargs, ): """ Search for a user's available cases given a set of search parameters. """ case_qs = (self.submitted().select_related( "status", "case_type").prefetch_related( "case_assignments", "case_assignments__user", "case_assignments__queue", )) if not include_hidden and user: EcjuQuery = get_model("cases", "ecjuquery") CaseReviewDate = get_model("cases", "casereviewdate") case_qs = case_qs.exclude(id__in=EcjuQuery.objects.filter( raised_by_user__team_id=user.team.id, responded_at__isnull=True).values("case_id").distinct()) # We hide cases that have a next review date that is set in the future (for your team) case_qs = case_qs.exclude(id__in=CaseReviewDate.objects.filter( team_id=user.team.id, next_review_date__gt=timezone.localtime().date()).values( "case_id")) if queue_id and user: case_qs = case_qs.filter_based_on_queue(queue_id=queue_id, team_id=user.team.id, user=user) if status: case_qs = case_qs.has_status(status=status) if case_type: case_type = CaseTypeEnum.reference_to_id(case_type) case_qs = case_qs.is_type(case_type=case_type) if assigned_user: if assigned_user == self.NOT_ASSIGNED: case_qs = case_qs.not_assigned_to_any_user() else: case_qs = case_qs.assigned_to_user(user=assigned_user) if case_officer: if case_officer == self.NOT_ASSIGNED: case_officer = None case_qs = case_qs.assigned_as_case_officer(user=case_officer) if case_reference: case_qs = case_qs.with_case_reference_code(case_reference) if exporter_application_reference: case_qs = case_qs.with_exporter_application_reference( exporter_application_reference) if organisation_name: case_qs = case_qs.with_organisation(organisation_name) if exporter_site_name: case_qs = case_qs.with_exporter_site_name(exporter_site_name) if exporter_site_address: case_qs = case_qs.with_exporter_site_address(exporter_site_address) if control_list_entry: case_qs = case_qs.with_control_list_entry(control_list_entry) if flags: case_qs = case_qs.with_flags(flags) if country: case_qs = case_qs.with_country(country) if team_advice_type: case_qs = case_qs.with_advice(team_advice_type, AdviceLevel.TEAM) if final_advice_type: case_qs = case_qs.with_advice(final_advice_type, AdviceLevel.FINAL) if min_sla_days_remaining or max_sla_days_remaining: case_qs = case_qs.with_sla_days_range( min_sla=min_sla_days_remaining, max_sla=max_sla_days_remaining) if sla_days_elapsed: case_qs = case_qs.with_sla_days_elapsed(sla_days_elapsed) if submitted_from or submitted_to: case_qs = case_qs.with_submitted_range( submitted_from=submitted_from, submitted_to=submitted_to) if finalised_from or finalised_to: case_qs = case_qs.with_finalised_range( finalised_from=finalised_from, finalised_to=finalised_to) if party_name: case_qs = case_qs.with_party_name(party_name) if party_address: case_qs = case_qs.with_party_address(party_address) if goods_related_description: case_qs = case_qs.with_goods_related_description( goods_related_description) if is_work_queue: case_qs = case_qs.annotate(case_order=Case( When(baseapplication__hmrcquery__have_goods_departed=False, then=0), default=1, output_field=BinaryField(), )) case_qs = case_qs.order_by("case_order", "submitted_at") else: case_qs = case_qs.order_by_date() if sla_days_elapsed_sort_order: if sla_days_elapsed_sort_order == SortOrder.ASCENDING: case_qs = case_qs.order_by("sla_days") else: case_qs = case_qs.order_by("-sla_days") return case_qs.distinct()
def get_ordered_parties(self, instance, party_type): """ Order the parties based on destination flag priority and where the party has no flag, by destination (party/country depending on standard/open application) name. """ parties_on_application = ( instance.all_parties() .filter(party__type=party_type, deleted_at__isnull=True) .annotate( highest_flag_priority=Min("party__flags__priority"), contains_flags=Case(When(party__flags__isnull=True, then=0), default=1, output_field=BinaryField()), ) .order_by("-contains_flags", "highest_flag_priority", "party__name") ) parties = [PartySerializer(poa.party).data for poa in parties_on_application] return parties