def get_sub_childrens(cls, value: List[Union[str, int]], level=1): if value: filters = models.Q(id__in=list(value)) for i in range(level - 1): filters |= models.Q(**{f"{'parent__'*i}parent__in": value}) return cls.objects.filter(filters) return cls.objects.none()
def filter(self, request, qs): qs = super(BoundaryListView, self).filter(request, qs) if 'intersects' in request.GET: try: (set_slug, slug) = request.GET['intersects'].split('/') shape = Boundary.objects.filter( slug=slug, set=set_slug).values_list('shape', flat=True)[0] except IndexError: raise Http404 except ValueError: raise BadRequest(_("Invalid value for intersects filter")) qs = qs.filter( models.Q(shape__covers=shape) | models.Q(shape__overlaps=shape)) if 'touches' in request.GET: try: (set_slug, slug) = request.GET['touches'].split('/') shape = Boundary.objects.filter( slug=slug, set=set_slug).values_list('shape', flat=True)[0] except IndexError: raise Http404 except ValueError: raise BadRequest(_("Invalid value for touches filter")) qs = qs.filter(shape__touches=shape) if 'sets' in request.GET: set_slugs = request.GET['sets'].split(',') qs = qs.filter(set__in=set_slugs) return qs
def get_accessible(cls, user=None): user = user or get_current_user() if user.is_authenticated(): queryset = Map.objects.filter( models.Q(owner=user) | models.Q(editors=user)) else: queryset = Map.objects.filter(share_status=Map.PUBLIC) return queryset
def get_query_set(self): qs = super(ApprovedUserManager, self).get_query_set() qs = qs.exclude( models.Q(birthday=None) & models.Q(birthday__lt=datetime.date.today() - relativedelta(years=self.model.AGE_MIN))) return qs
def search(self, qs, query): if query: query = SearchQuery(query, config=SEARCH_LANG) qs = qs.filter( models.Q(search_vector=query) | models.Q(pharma_company__search_vector=query) ) qs = self.add_annotations(qs) return qs
def create_from_input(self, **kwargs): """ Create an address with the given data, unless a duplicate existing address is found. Return a tuple of (created, addresses), where ``created`` is ``True`` if an address was newly created, and ``addresses`` is an iterable of exact-match addresses (will be length one if newly created). If the data is bad (e.g. unknown state) will raise ValidationError. """ user = kwargs.pop("user", None) street = kwargs.get("street", None) city = kwargs.get("city", None) state = kwargs.get("state", None) if state is not None: state = kwargs["state"] = compact_whitespace(state.upper().strip()) if street is not None: street = kwargs["input_street"] = clean_street( compact_whitespace(street.strip()).rstrip(".")) del kwargs["street"] if city is not None: city = kwargs["city"] = compact_whitespace(city.strip()) if None not in [street, city, state]: addresses = self.filter( ( models.Q(input_street=street) | models.Q(street=street) ) & models.Q(city=city) & models.Q(state=state) ) else: addresses = None created = False if not addresses: if kwargs.get("pl"): kwargs["mapped_by"] = user kwargs["mapped_timestamp"] = datetime.now() obj = self.model(**kwargs) obj.full_clean() obj.save(user=user) created = True addresses = [obj] return (created, addresses)
def create_keyword_condition(self, data): keyword_fields = self._meta.keyword_fields if not keyword_fields: return models.Q() value = data.get(self._meta.keyword_field_name, None) if not value: return models.Q() conditions = models.Q() for field_name in keyword_fields: conditions |= models.Q(**{field_name + '__icontains': value}) return conditions
class ReportImage(models.Model): image = models.ImageField(upload_to='uploads/reportimgs/') thumbnail = ImageSpecField(source='image', processors=[ResizeToFill(320, 240)], format='JPEG', options={'quality': 75}) content_type = models.ForeignKey( ContentType, on_delete=models.CASCADE, limit_choices_to=models.Q(app_label='reports', model='report') | models.Q(app_label='reports', model='onlinereport')) object_id = models.PositiveIntegerField(null=True) content_object = GenericForeignKey('content_type', 'object_id')
class Content(models.Model): game = models.ForeignKey(Game, on_delete=models.CASCADE, related_name="contents") content_type = models.ForeignKey( ContentType, on_delete=models.CASCADE, related_name="content_of", limit_choices_to=models.Q(app_label='character') | models.Q(app_label='things')) content_id = models.PositiveIntegerField() content = GenericForeignKey('content_type', 'content_id') position = models.PointField(null=True, blank=True) created = models.DateTimeField(default=timezone.now)
class Meta: unique_together = ( ('feature', 'layer_extra_geom'), ) indexes = [ models.Index(fields=['layer_extra_geom', 'identifier']), GistIndex(name='feg_geom_gist_index', fields=['layer_extra_geom', 'geom']), GinIndex(name='feg_properties_gin_index', fields=['properties']), ] constraints = [ # geometry should be valid models.CheckConstraint(check=models.Q(geom__isvalid=True), name='geom_extra_is_valid'), # geometry should not be empty models.CheckConstraint(check=models.Q(geom__isempty=False), name='geom_extra_is_empty') ]
def Q_member(self, member): UserAuth = auth.get_user_model() if isinstance(member, UserAuth): member = member.profile profile_ids = [member.id] + [team['id'] for team in member.teams.values('id')] return models.Q(owner_id__in=profile_ids)
def __init__(self, model, query=None, using=None): # the model needs to be defined so that we can construct our custom # query if query is None: query = GeoQuery(model) query.add_q(geo_models.Q(effective_to__isnull=True)) return super(ActiveGeoQuerySet, self).__init__(model, query, using)
def filter_by_index(self, key, *values): matches_any_values_clause = reduce( operator.or_, [models.Q(indexed_values__value=value) for value in values]) return self\ .filter(indexed_values__index__attr_name=key)\ .filter(matches_any_values_clause)
def statistics(self): queryset = self.viewpoints.annotate( missing=models.Count('pk', filter=models.Q( pictures__isnull=True )), pending=models.Count('pictures', filter=models.Q( pictures__state=STATES.DRAFT )), refused=models.Count('pictures', filter=models.Q( pictures__state=STATES.REFUSED )), ).values('missing', 'pending', 'refused') try: return queryset[0] except IndexError: return {'missing': 0, 'pending': 0, 'refused': 0}
def with_stats(self): return self.annotate( viewpoints_total=models.Count("viewpoints", distinct=True), pictures_submited=models.Count( "pictures__pk", filter=models.Q(pictures__state=Picture.SUBMITTED), distinct=True, ), pictures_accepted=models.Count( "pictures__pk", filter=models.Q(pictures__state=Picture.ACCEPTED), distinct=True, ), pictures_missing=models.F("viewpoints_total") - models.F("pictures_submited") - models.F("pictures_accepted"), )
def get_boundaries(self, sets=None): r = {'boundaries_concordance': [], 'boundaries_centroid': []} concordances = PostcodeConcordance.objects.filter( code=self.code).values_list('boundary', flat=True) if sets: concordances = [ boundary for boundary in concordances if boundary.split('/')[0] in sets ] concordance_sets = set() if concordances: q = ((models.Q(set=concordance.split('/')[0]) & models.Q(slug=concordance.split('/')[1])) for concordance in concordances) boundaries = Boundary.objects.filter(reduce(lambda a, b: a | b, q)) boundaries = Boundary.prepare_queryset_for_get_dicts(boundaries) boundaries = Boundary.get_dicts(boundaries) r['boundaries_concordance'] = boundaries for boundary in boundaries: concordance_sets.add(boundary['related']['boundary_set_url']) if self.centroid: q = models.Q(shape__contains=self.centroid) if sets: q &= models.Q(set__in=sets) boundaries = Boundary.objects.filter(q) boundaries = Boundary.prepare_queryset_for_get_dicts(boundaries) boundaries = Boundary.get_dicts(boundaries) r['boundaries_centroid'] = [ boundary for boundary in boundaries if boundary['related'] ['boundary_set_url'] not in concordance_sets ] return r
def filter_products(self, **kwargs): q = kwargs['query'].get('q') ql = kwargs['query'].get('l') qc = kwargs['query'].get('c') lat = kwargs['query'].get('lat') lon = kwargs['query'].get('lon') if lon and lat: location = Point(float(lon), float(lat), srid=4326) # import pdb; pdb.set_trace() data = self.filter( models.Q(name__icontains=q) | models.Q(description__icontains=q)) if qc != 'all': return data.filter(category__slug=qc) if ql == 'nearby_store': return data.annotate( distance=Distance('location', location)).order_by('distance') else: return data
class Meta: ordering = ['id'] indexes = [ models.Index(fields=['layer', ]), models.Index(fields=['updated_at', ]), models.Index(fields=['updated_at', 'layer', ]), models.Index(fields=['layer', 'identifier']), models.Index(fields=['id', 'layer', ]), models.Index(fields=['source', 'layer', ]), models.Index(fields=['target', 'layer', ]), models.Index(fields=['source', 'target', 'layer']), GistIndex(fields=['layer', 'geom']), GinIndex(name='properties_gin_index', fields=['properties']), ] constraints = [ # geometry should be valid models.CheckConstraint(check=models.Q(geom__isvalid=True), name='geom_is_valid'), # geometry should not be empty models.CheckConstraint(check=models.Q(geom__isempty=False), name='geom_is_empty') ]
def get_geography(self, date): if len(self.geographies.all()) == 0: return None elif len(self.geographies.all()) == 1: return self.geographies.all()[0] else: if date < self.start_date: raise ValueError( "date %s is before organisation start_date (%s)" % (date.isoformat(), self.start_date.isoformat())) if self.end_date and date > self.end_date: raise ValueError( "date %s is after organisation end_date (%s)" % (date.isoformat(), self.end_date.isoformat())) try: return self.geographies.get((models.Q(start_date__lte=date) | models.Q(start_date=None)) & (models.Q(end_date__gte=date) | models.Q(end_date=None))) except OrganisationGeography.DoesNotExist: return None
class EquipmentTag(models.Model): created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) tag_category = models.IntegerField( choices=TagCategory.TAG_CATEGORY_CHOICES, default=TagCategory.TRAILER) tag_type = models.IntegerField(choices=TagType.TAG_TYPE_CHOICES, default=TagType.FLATBED) assignee_limit = models.Q( models.Q(app_label='shipments', model='shipment') | models.Q(app_label='shipments', model='genericuser')) assignee_content_type = models.ForeignKey( ContentType, limit_choices_to=assignee_limit, related_name='equipment_tag_assignee') assignee_id = models.PositiveIntegerField() assignee = GenericForeignKey('assignee_content_type', 'assignee_id') assigner = models.ForeignKey('GenericUser', null=True, blank=True) @property def tag_category_label(self): return filter(lambda x: x[0] == self.tag_category, TagCategory.TAG_CATEGORY_CHOICES)[0][1] @property def tag_type_label(self): return filter(lambda x: x[0] == self.tag_type, TagType.TAG_TYPE_CHOICES)[0][1] class Meta: ordering = ('tag_category', ) unique_together = (('assignee_id', 'assignee_content_type', 'tag_type', 'tag_category'), ) def clean(self): ct = ContentType.objects.get(model=self.assignee_content_type) codename = 'change_%s' % ct.model if not self.assigner.user.has_perm(codename, self.assignee): raise ValidationError( _('Assigner must have permission to update assignee'))
class Meta: verbose_name = "Time series" verbose_name_plural = "Time series" ordering = ("type",) unique_together = ["timeseries_group", "type", "time_step"] constraints = [ models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=100), name="only_one_raw_timeseries_per_group", ), models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=200), name="only_one_checked_timeseries_per_group", ), models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=300), name="only_one_regularized_timeseries_per_group", ), ]
class Meta: verbose_name = pgettext_lazy("Singular", "Time series") verbose_name_plural = pgettext_lazy("Plural", "Time series") ordering = ("type", ) unique_together = ["timeseries_group", "type", "time_step"] constraints = [ models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=100), name="only_one_initial_timeseries_per_group", ), models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=200), name="only_one_checked_timeseries_per_group", ), models.UniqueConstraint( fields=["timeseries_group"], condition=models.Q(type=300), name="only_one_regularized_timeseries_per_group", ), ]
def anything(self, lookup_type, value, fields=anything_fields): queries = [ models.Q(**{'%s__%s' % (field, lookup_type): value}) for field in fields ] # Take one Q object from the list query = queries.pop() # Or the Q object with the ones remaining in the list for item in queries: query |= item return self.filter(query)
def create_condition(self, field_name, lookup, value): if not value: return models.Q() key = field_name + '__' + lookup if lookup else field_name return models.Q(**{key: value})
def get_for(user): return AdminLevel.objects.filter( models.Q(admin_level__region__public=True) | models.Q(admin_level__region__created_by=user) | models.Q(admin_level__region__project__members=user) ).distinct()
def get_for(user): return Region.objects.filter( models.Q(public=True) | models.Q(created_by=user) | models.Q(project__members=user) ).distinct()
def filter_by_id_or_slug(self, id_or_slug): return self.filter(models.Q(pk=id_or_slug) | models.Q(slug=id_or_slug))
def get_by_id_or_slug(self, id_or_slug): return self.get(models.Q(pk=id_or_slug) | models.Q(slug=id_or_slug))
class Meta: constraints = [ models.CheckConstraint( name='%(app_label)s_%(class)s_file_source_value_matches_type', check=( models.Q( models.Q(type=FileSourceType.FILE_FIELD, file__regex=r'.+') & models.Q(models.Q(url__in=['', None]) | models.Q(url__isnull=True)) ) | models.Q( models.Q(type=FileSourceType.URL) & models.Q(models.Q(url__isnull=False) & models.Q(url__regex=r'.+')) & models.Q(models.Q(file__in=['', None]) | models.Q(file__isnull=True)) ) ), ) ]
def filter_by_date(self, date): return self.filter( models.Q(divisionset__start_date__lte=date) & (models.Q(divisionset__end_date__gte=date) | models.Q(divisionset__end_date=None)))