class TasksFilter(filters.FilterSet):
id = filters.NumberFilter(name='id', lookup_type='exact')
parent_task = filters.NumberFilter(name='parent_task', lookup_type='exact')
type = filters.CharFilter(name='type', lookup_type='icontains')
status = filters.CharFilter(name='status', lookup_type='icontains')
manager_comment = filters.CharFilter(name='manager_comment',
lookup_type='icontains')
is_demo = filters.BooleanFilter(name='is_demo', lookup_type='exact')
is_active = filters.BooleanFilter(name='is_active', lookup_type='exact')
created_by = filters.NumberFilter(name='created_by', lookup_type='exact')
project = filters.NumberFilter(name='project', lookup_type='exact')
passage = filters.NumberFilter(name='passage', lookup_type='exact')
annotator = filters.NumberFilter(name='annotator', lookup_type='exact')
class Meta:
model = Tasks
fields = {
'id',
'parent_task',
'type',
'status',
'project',
'passage',
'annotator',
'manager_comment',
'is_demo',
'created_by',
'is_active',
}
class TeamMemberFilter(filters.FilterSet):
user_id = filters.CharFilter(name='user_id')
username = filters.CharFilter(name='username')
is_partner = filters.BooleanFilter(name='is_partner')
is_associate = filters.BooleanFilter(name='is_associate')
email = filters.CharFilter(name='email')
phone = filters.CharFilter(name='phone')
first_name = filters.CharFilter(name='first_name')
last_name = filters.CharFilter(name='last_name')
bio = filters.CharFilter(name='bio')
title = filters.CharFilter(name='title')
class Meta:
model = TeamMember
fields = [
'id',
'user_id',
'username',
'is_partner',
'is_associate',
'email',
'phone',
'first_name',
'last_name',
'bio',
'title',
]
class AbsenceCategoryFilter(filters.FilterSet):
name = filters.AllLookupsFilter()
created_at = filters.DateFilter()
created__gte = filters.DateFilter(name='created_at', lookup_expr='gte')
created__lte = filters.DateFilter(name='created_at', lookup_expr='lte')
created__gt = filters.DateFilter(name='created_at', lookup_expr='gt')
created__lt = filters.DateFilter(name='created_at', lookup_expr='lt')
billable = filters.BooleanFilter()
active = filters.BooleanFilter()
class Meta:
model = AbsenceCategory
class ClientFilter(UserProfileFilter):
bid_statistics = filters.RelatedFilter(UserBidStatisticsFilter, name="bid_statistics", queryset=UserBidStatistics.objects.all())
is_bidding = filters.BooleanFilter(name="bidlist", method="filter_is_bidding")
is_in_panel = filters.BooleanFilter(name="bidlist", method="filter_is_in_panel")
is_on_post = filters.BooleanFilter(name="bidlist", method="filter_is_on_post")
is_bidding_no_handshake = filters.BooleanFilter(name="bidlist", method="filter_is_bidding_no_handshake")
def filter_is_bidding(self, queryset, name, value):
value = bool(value)
if value:
return queryset.exclude(bidlist=None)
else:
return queryset.filter(bidlist=None)
def filter_is_in_panel(self, queryset, name, value):
value = bool(value)
if value:
return queryset.filter(bidlist__status=Bid.Status.in_panel)
else:
return queryset.exclude(bidlist__status=Bid.Status.in_panel)
def filter_is_on_post(self, queryset, name, value):
value = bool(value)
if value:
return queryset.exclude(assignments__current_for_position=None)
else:
return queryset.filter(assignments__current_for_position=None)
def filter_is_bidding_no_handshake(self, queryset, name, value):
value = bool(value)
if value:
return queryset.exclude(bidlist=None).filter(bidlist__handshake_offered_date=None).distinct()
else:
return queryset.exclude(bidlist=None).exclude(bidlist__handshake_offered_date=None).distinct()
# Full text search across multiple fields
q = filters.CharFilter(name="user", method=full_text_search(
fields=[
"user__first_name",
"user__last_name",
"user__username",
"skills__code",
"skills__description",
"skills__cone__name",
"language_qualifications__language__short_description",
"primary_nationality__name",
"secondary_nationality__name"
]
))
class OrganizationFilter(filters.FilterSet):
bureau_organization = filters.RelatedFilter(
'talentmap_api.organization.filters.OrganizationFilter',
name='bureau_organization',
queryset=Organization.objects.all())
parent_organization = filters.RelatedFilter(
'talentmap_api.organization.filters.OrganizationFilter',
name='parent_organization',
queryset=Organization.objects.all())
location = filters.RelatedFilter(
'talentmap_api.organization.filters.LocationFilter',
name='location',
queryset=Location.objects.all())
# Name here must be a valid field, but it is ignored when overriden by the method parameter
is_available = filters.BooleanFilter(
name="bureau_positions",
method=multi_field_filter(
fields=["bureau_positions", "organization_positions"],
lookup_expr="isnull",
exclude=True))
class Meta:
model = Organization
fields = {
"code": ALL_TEXT_LOOKUPS,
"long_description": ALL_TEXT_LOOKUPS,
"short_description": ALL_TEXT_LOOKUPS,
"is_bureau": ['exact'],
"is_regional": ['exact'],
"bureau_organization": FOREIGN_KEY_LOOKUPS,
"parent_organization": FOREIGN_KEY_LOOKUPS,
"location": FOREIGN_KEY_LOOKUPS
}
class TagFilter(filters.FilterSet):
keyword = filters.CharFilter(label=_('Keyword'),
name='keyword',
method='filter_keyword')
name = filters.CharFilter(lookup_expr='icontains')
is_active = filters.BooleanFilter(label=_('Is Active'),
name='is_active',
method='filter_is_actvie')
class Meta:
model = models.Tag
exclude = []
def filter_is_actvie(self, queryset, name, value):
''' True(value=1), False(value=0)'''
q = Q(slug='') | Q(name='') | Q(mytaggit_taggeditem_items__isnull=True)
if value == 1:
return queryset.exclude(q)
elif value == 0:
return queryset.filter(q)
return queryset
def filter_keyword(self, queryset, name, value):
print("filter_keyword", name, value)
# q = Q(slug='') | Q(name='') | Q(mytaggit_taggeditem_items__isnull=True)
return value and queryset.filter(
Q(name__icontains=value) | Q(slug__icontains=value)) or queryset
class MessagingSettingsFilter(filters.FilterSet):
user_id = filters.CharFilter(name='user_id')
duplicate_private = filters.BooleanFilter(name='duplicate_private')
class Meta:
model = MessagingSettings
fields = ['id', 'duplicate_private', 'user_id']
class NotificationFilter(filters.FilterSet):
class Meta:
model = Notification
fields = {
'type': [
'in',
'exact',
],
'title': [
'contains',
],
'content': [
'contains',
],
'related_article': [
'in',
'exact',
],
'related_comment': [
'in',
'exact',
],
}
is_read = filters.BooleanFilter(
name='is_read',
label='조회 여부',
method='get_is_read',
)
@staticmethod
def get_is_read(queryset, name, value):
return queryset.filter(notification_read_log_set__is_read=value, )
class NotificationFilter(filters.FilterSet):
unread = filters.BooleanFilter(field_name='unread')
class Meta:
model = Notification
fields = ['unread']
class GradeFilter(filters.FilterSet):
is_available = filters.BooleanFilter(name="positions",
lookup_expr="isnull",
exclude=True)
class Meta:
model = Grade
fields = {"code": ALL_TEXT_LOOKUPS}
class SourcesFilter(filters.FilterSet):
id = filters.NumberFilter(name='id', lookup_type='exact')
text = filters.CharFilter(name='text', lookup_type='icontains')
name = filters.CharFilter(name='name', lookup_type='icontains')
is_default = filters.BooleanFilter(name='is_default', lookup_type='exact')
is_active = filters.BooleanFilter(name='is_active', lookup_type='exact')
created_by = filters.NumberFilter(name='created_by', lookup_type='exact')
source = filters.NumberFilter(name='source', lookup_type='exact')
class Meta:
model = Sources
fields = {
'id',
'text',
'name',
'created_by',
'is_active',
}
class CategoriesFilter(filters.FilterSet):
id = filters.NumberFilter(name='id', lookup_type='exact')
name = filters.CharFilter(name='name', lookup_type='icontains')
description = filters.CharFilter(name='description', lookup_type='icontains')
tooltip = filters.CharFilter(name='tooltip', lookup_type='icontains')
abbreviation = filters.CharFilter(name='abbreviation', lookup_type='exact')
is_default = filters.BooleanFilter(name='is_default', lookup_type='exact')
is_active = filters.BooleanFilter(name='is_active', lookup_type='exact')
created_by = filters.NumberFilter(name='created_by', lookup_type='exact')
class Meta:
model = Categories
fields = {
'id',
'name',
'description',
'tooltip',
'abbreviation',
'is_default',
'created_by',
'is_active',
}
class TourOfDutyFilter(filters.FilterSet):
is_available = filters.BooleanFilter(
name="posts__positions", method=negate_boolean_filter("isnull"))
class Meta:
model = TourOfDuty
fields = {
"code": ALL_TEXT_LOOKUPS,
"long_description": ALL_TEXT_LOOKUPS,
"short_description": ALL_TEXT_LOOKUPS,
"months": INTEGER_LOOKUPS
}
class EntityFilter(CollectionFilter):
"""Filter the Entity endpoint."""
collections = filters.ModelChoiceFilter(queryset=Collection.objects.all())
descriptor_completed = filters.BooleanFilter()
tags = TagsFilter()
class Meta(CollectionFilter.Meta):
"""Filter configuration."""
model = Entity
fields = BaseResolweFilter.Meta.fields + ['collections', 'descriptor_completed', 'tags']
class LayersFilter(filters.FilterSet):
id = filters.NumberFilter(name='id', lookup_type='exact')
parent_layer_id = filters.NumberFilter(name='parent_layer_id', lookup_type='exact')
name = filters.CharFilter(name='name', lookup_type='icontains')
type = filters.CharFilter(name='type', lookup_type='icontains')
description = filters.CharFilter(name='description', lookup_type='icontains')
tooltip = filters.CharFilter(name='tooltip', lookup_type='icontains')
is_default = filters.BooleanFilter(name='is_default', lookup_type='exact')
is_active = filters.BooleanFilter(name='is_active', lookup_type='exact')
created_by = filters.NumberFilter(name='created_by', lookup_type='exact')
class Meta:
model = Layers
fields = {
'id',
'parent_layer_id',
'name',
'type',
'description',
'tooltip',
'is_default',
'created_by',
'is_active',
}
class LanguageFilter(filters.FilterSet):
# Convenience filter of "name" which will perform a contains lookup on the description
name = filters.CharFilter(name="long_description", lookup_expr="contains")
is_available = filters.BooleanFilter(
name="qualifications__positions",
method=negate_boolean_filter("isnull"))
class Meta:
model = Language
fields = {
"code": ALL_TEXT_LOOKUPS,
"long_description": ALL_TEXT_LOOKUPS,
"short_description": ALL_TEXT_LOOKUPS
}
class ProcessFilter(BaseResolweFilter):
"""Filter the Process endpoint."""
category = filters.CharFilter(name='category', lookup_expr='startswith')
type = filters.CharFilter(name='type', lookup_expr='startswith')
scheduling_class = filters.AllLookupsFilter()
is_active = filters.BooleanFilter()
class Meta(BaseResolweFilter.Meta):
"""Filter configuration."""
model = Process
fields = BaseResolweFilter.Meta.fields + [
'category', 'type', 'scheduling_class', 'is_active'
]
class PackageFilter(filters.FilterSet):
id = filters.CharFilter(name='id')
title = filters.CharFilter(name='title')
fees = filters.CharFilter(name='fees')
price = filters.CharFilter(name='price')
is_available = filters.BooleanFilter(name='is_available')
description = filters.CharFilter(name='description')
state = filters.CharFilter(name='state')
package_type = filters.CharFilter(name='package_type')
class Meta:
model = Package
fields = ['id', 'title', 'fees', 'price',
'is_available', 'description',
'state', 'package_type', 'notes']
class CourseFilter(filters.FilterSet):
STATUS_CHOICES = [
('noarchiving', '不包含已归档'),
]
STATUS_CHOICES.extend(list(Courseware.STATUS_CHOICES))
status = filters.ChoiceFilter(choices=STATUS_CHOICES, method='filter_status')
recommend = filters.BooleanFilter(field_name='recommend')
def filter_status(self, queryset, name, value):
if value == 'noarchiving':
return queryset.exclude(status='已归档')
return queryset
class Meta:
model = Courseware
fields = ['status', 'recommend']
class SkillFilter(filters.FilterSet):
is_available = filters.BooleanFilter(name="positions",
lookup_expr="isnull",
exclude=True)
cone = filters.RelatedFilter(
'talentmap_api.position.filters.SkillConeFilter',
name='cone',
queryset=SkillCone.objects.all())
class Meta:
model = Skill
fields = {
"code": ALL_TEXT_LOOKUPS,
"description": ALL_TEXT_LOOKUPS,
"cone": FOREIGN_KEY_LOOKUPS
}
class PostFilter(filters.FilterSet):
subs_only = filters.BooleanFilter(method='subs_only_filter')
class Meta:
model = Post
fields = ['tags']
def subs_only_filter(self, queryset, name, value):
if not self.request.user:
return queryset
subscription_users = self.request.user.subscription_users.all()
query = None
for user in subscription_users:
if query == None:
query = Q(author=user)
else:
query = Q(author=user) | query
return queryset.filter(query)
class UsersFilter(filters.FilterSet):
id = filters.NumberFilter(name='id', lookup_type='exact')
first_name = filters.CharFilter(name='first_name', lookup_type='icontains')
last_name = filters.CharFilter(name='last_name', lookup_type='icontains')
email = filters.CharFilter(name='email', lookup_type='icontains')
organization = filters.CharFilter(name='organization',
lookup_type='icontains')
affiliation = filters.CharFilter(name='affiliation',
lookup_type='icontains')
role = filters.CharFilter(name='role__name', lookup_type='exact')
is_active = filters.BooleanFilter(name='is_active', lookup_type='exact')
created_by = filters.NumberFilter(name='created_by', lookup_type='exact')
class Meta:
model = Users
fields = {
'id', 'first_name', 'last_name', 'email', 'organization',
'affiliation', 'role__name', 'is_active', 'created_by'
}
class UnitFilter(filters.FilterSet):
type = filters.RelatedFilter(UnitTypeFilter, field_name='type', queryset=models.UnitType.objects.all())
site = filters.RelatedFilter(SiteFilter, field_name='site', queryset=models.Site.objects.all())
date_acceptance_min = MinDateFilter(field_name="date_acceptance")
date_acceptance_max = MaxDateFilter(field_name="date_acceptance")
install_date_min = MinDateFilter(field_name="install_date")
install_date_max = MaxDateFilter(field_name="install_date")
active = filters.BooleanFilter()
class Meta:
model = models.Unit
fields = {
"number": ['exact', 'in'],
"name": ['exact', 'icontains', 'contains', 'in'],
"serial_number": ['exact', 'icontains', 'contains', 'in'],
"location": ['exact', 'icontains', 'contains', 'in'],
"install_date": ['exact'],
"date_acceptance": ['exact'],
}
class InitiativeFilter(filters.FilterSet):
name = filters.AllLookupsFilter(field_name='name')
isnull = filters.BooleanFilter(field_name='pk', lookup_expr='isnull')
geographic_scope = filters.RelatedFilter(
'api.filters.locations.RegionFilter',
queryset=Country.objects.all(),
field_name='geographic_scope')
principal_agent = filters.RelatedFilter(
'api.filters.facts.OrganizationFilter',
queryset=Organization.objects.all(),
field_name='principal_agent')
class Meta:
model = Initiative
fields = {
'founding_year': '__all__',
'founding_month': '__all__',
'founding_day': '__all__',
}
class CaseFilter(filters.FilterSet):
"""Filter cases on the "expired" field."""
expired = filters.BooleanFilter(method="filter_expired",
label=gettext("Udgået"))
case_worker = filters.RelatedFilter(
UserForCaseFilter,
field_name="case_worker",
label=gettext("Sagsbehandler"),
queryset=User.objects.all(),
)
class Meta:
model = Case
fields = "__all__"
def filter_expired(self, queryset, name, value):
"""Filter out cases according to value."""
if value:
return queryset.expired()
else:
return queryset.ongoing()
class PostFilter(filters.FilterSet):
tour_of_duty = filters.RelatedFilter(TourOfDutyFilter,
name='tour_of_duty',
queryset=TourOfDuty.objects.all())
location = filters.RelatedFilter(LocationFilter,
name='location',
queryset=Location.objects.all())
is_available = filters.BooleanFilter(name="positions",
lookup_expr="isnull",
exclude=True)
# Full text search across multiple fields
q = filters.CharFilter(name="position_number",
method=full_text_search(fields=[
"rest_relaxation_point",
"location__code",
"location__country__name",
"location__country__code",
"location__city",
"location__state",
]))
class Meta:
model = Post
fields = {
"cost_of_living_adjustment": INTEGER_LOOKUPS,
"differential_rate": INTEGER_LOOKUPS,
"danger_pay": INTEGER_LOOKUPS,
"rest_relaxation_point": ALL_TEXT_LOOKUPS,
"has_consumable_allowance": ["exact"],
"has_service_needs_differential": ["exact"],
"tour_of_duty": FOREIGN_KEY_LOOKUPS,
"location": FOREIGN_KEY_LOOKUPS,
"obc_id": ALL_TEXT_LOOKUPS,
}
class ProficiencyFilter(filters.FilterSet):
at_least = filters.CharFilter(name="code", method="filter_at_least")
at_most = filters.CharFilter(name="code", method="filter_at_most")
is_available = filters.BooleanFilter(
name="reading_qualifications",
method=multi_field_filter(
fields=["reading_qualifications", "spoken_qualifications"],
lookup_expr="isnull",
exclude=True))
def filter_at_most(self, queryset, name, value):
'''
Evaluates if a proficiency is of at most a certain level
F > X > P > 0 > 0+ . . . 5
'''
value = value.replace("plus", "+")
index = Proficiency.RANKING.index(value) + 1
valid_ranks = Proficiency.RANKING[:index]
lookup = LOOKUP_SEP.join([name, "in"])
return queryset.filter(Q(**{lookup: valid_ranks}))
def filter_at_least(self, queryset, name, value):
'''
Evaluates if a proficiency is of at least a certain level
F > X > P > 0 > 0+ . . . 5
'''
value = value.replace("plus", "+")
index = Proficiency.RANKING.index(value)
valid_ranks = Proficiency.RANKING[index:]
lookup = LOOKUP_SEP.join([name, "in"])
return queryset.filter(Q(**{lookup: valid_ranks}))
class Meta:
model = Proficiency
fields = {"code": ALL_TEXT_LOOKUPS, "description": ALL_TEXT_LOOKUPS}
class AthleteFilter(filters.FilterSet):
session = filters.NumberFilter(name='split__timingsession', distinct=True)
primary_team = filters.BooleanFilter(name='team__primary_team',
distinct=True)
team_name = filters.CharFilter(name='team__name')
min_age = filters.MethodFilter()
max_age = filters.MethodFilter()
registered_to_session = filters.NumberFilter(name='timingsession',
distinct=True)
class Meta:
model = Athlete
fields = ('session', 'gender', 'tfrrs_id', 'primary_team', 'team',
'team_name', 'min_age', 'max_age', 'registered_to_session')
def filter_min_age(self, queryset, value):
"""Minimum age."""
try:
age = int(value)
except ValueError:
return queryset.none()
athlete_ids = ([
athlete.id for athlete in queryset if athlete.age() >= age
])
return queryset.filter(pk__in=athlete_ids)
def filter_max_age(self, queryset, value):
"""Maximum age."""
try:
age = int(value)
except ValueError:
return queryset.none()
athlete_ids = ([
athlete.id for athlete in queryset if athlete.age() <= age
])
return queryset.filter(pk__in=athlete_ids)
class QualificationFilter(filters.FilterSet):
language = filters.RelatedFilter(LanguageFilter,
name='language',
queryset=Language.objects.all())
reading_proficiency = filters.RelatedFilter(
ProficiencyFilter,
name='reading_proficiency',
queryset=Proficiency.objects.all())
spoken_proficiency = filters.RelatedFilter(
ProficiencyFilter,
name='spoken_proficiency',
queryset=Proficiency.objects.all())
is_available = filters.BooleanFilter(name="positions",
lookup_expr="isnull",
exclude=True)
class Meta:
model = Qualification
fields = {
"language": FOREIGN_KEY_LOOKUPS,
"reading_proficiency": FOREIGN_KEY_LOOKUPS,
"spoken_proficiency": FOREIGN_KEY_LOOKUPS
}
class ДокументFilter(filters.FilterSet):
disqualification = filters.BooleanFilter(name='СвЮЛ__СведДолжнФЛ__СвДискв',
lookup_expr='isnull')
codeEduMethod = filters.CharFilter(
name='СвЮЛ__СвОбрЮЛ__СпОбрЮЛ__КодСпОбрЮЛ')
region = filters.CharFilter(name='СвЮЛ__СвАдресЮЛ__АдресРФ__КодРегион')
search = filters.CharFilter(method='complex_search_filter')
fio = filters.CharFilter(method='complex_fio_filter')
reg_start_date = filters.DateFilter(name='СвЮЛ__ДатаОГРН',
lookup_expr='gte')
reg_end_date = filters.DateFilter(name='СвЮЛ__ДатаОГРН', lookup_expr='lte')
state = filters.CharFilter(name='СвЮЛ__СвСтатус__Св_Статус__КодСтатусЮЛ')
isactive = filters.BooleanFilter(method='is_active_filter')
isAddrFalsity = filters.BooleanFilter(method='check_addr_falsity')
isAddrChange = filters.BooleanFilter(method='check_addr_сhange')
isemail = filters.BooleanFilter(method='check_email_filter')
email = filters.CharFilter(name='СвЮЛ__СвАдрЭлПочты__E_mail',
lookup_expr='icontains')
index = filters.CharFilter(name='СвЮЛ__СвАдресЮЛ__АдресРФ__Индекс',
lookup_expr='icontains')
codeKLADR = filters.CharFilter(
name='СвЮЛ__СвАдресЮЛ__АдресРФ__КодАдрКладр', lookup_expr='icontains')
area = filters.CharFilter(
name='СвЮЛ__СвАдресЮЛ__АдресРФ__Район__НаимРайон',
lookup_expr='icontains')
city = filters.CharFilter(
name='СвЮЛ__СвАдресЮЛ__АдресРФ__Город__НаимГород',
lookup_expr='icontains')
locality = filters.CharFilter(
name='СвЮЛ__СвАдресЮЛ__АдресРФ__НаселПункт__НаимНаселПункт',
lookup_expr='icontains')
street = filters.CharFilter(
name='СвЮЛ__СвАдресЮЛ__АдресРФ__Улица__НаимУлица',
lookup_expr='icontains')
regNum = filters.CharFilter(name='СвЮЛ__СвОбрЮЛ__РегНом',
lookup_expr='icontains')
startregDate = filters.DateFilter(name='СвЮЛ__СвОбрЮЛ__ДатаРег',
lookup_expr='gte')
endregDate = filters.DateFilter(name='СвЮЛ__СвОбрЮЛ__ДатаРег',
lookup_expr='lte')
isChartCapital = filters.BooleanFilter(method='check_isChartCapital')
nameCapital = filters.CharFilter(name='СвЮЛ__СвУстКап__НаимВидКап',
lookup_expr='icontains')
summCap = filters.CharFilter(name='СвЮЛ__СвУстКап__СумКап',
lookup_expr='lte')
isSvUprOrg = filters.BooleanFilter(method='check_isSvUprOrg')
nameUprOrg = filters.CharFilter(method='complex_UprOrg_filter')
isSvWithoutAtt = filters.BooleanFilter(method='check_isSvWithoutAtt')
fioWA = filters.CharFilter(method='complex_fioWA_filter')
isFounder = filters.BooleanFilter(method='check_isFounder')
isFRus = filters.BooleanFilter(method='check_isFRus')
isFFl = filters.BooleanFilter(method='check_isFFl')
isFGOS = filters.BooleanFilter(method='check_isFGOS')
isFIn = filters.BooleanFilter(method='check_isFIn')
okved = filters.CharFilter(method='okved_filter')
okvedtxt = filters.CharFilter(method='okved_filter')
numberL = filters.CharFilter(name='СвЮЛ__СвЛицензия__НомЛиц',
lookup_expr='icontains',
distinct=True)
startLicense = filters.DateFilter(name='СвЮЛ__СвЛицензия__ДатаНачЛиц',
lookup_expr='gte',
distinct=True)
endLicense = filters.DateFilter(name='СвЮЛ__СвЛицензия__ДатаОкончЛиц',
lookup_expr='lte',
distinct=True)
nameL = filters.CharFilter(method='license_filter')
grn = filters.CharFilter(name='СвЮЛ__СвЗапЕГРЮЛ__ГРН',
lookup_expr='icontains',
distinct=True)
startRecord = filters.DateFilter(name='СвЮЛ__СвЗапЕГРЮЛ__ДатаЗап',
lookup_expr='gte',
distinct=True)
endRecord = filters.DateFilter(name='СвЮЛ__СвЗапЕГРЮЛ__ДатаЗап',
lookup_expr='lte',
distinct=True)
declarer = filters.CharFilter(method='complex_declarer_filter')
documents = filters.CharFilter(
name='СвЮЛ__СвЗапЕГРЮЛ__СведПредДок__НаимДок',
lookup_expr='icontains',
distinct=True)
class Meta:
model = Документ
fields = {
'id',
'ИдДок',
'СвЮЛ',
}
def complex_search_filter(self, qs, name, value):
#print(qs.count())
if value.find(' ') == -1:
qs_ = qs.filter(
Q(СвЮЛ__ОГРН__icontains=value) | Q(СвЮЛ__ИНН__icontains=value)
| Q(СвЮЛ__СвНаимЮЛ__НаимЮЛСокр__icontains=value)
| Q(СвЮЛ__СвНаимЮЛ__НаимЮЛПолн__icontains=value)).distinct()
else:
qs_ = qs.filter(СвЮЛ__СвНаимЮЛ__search_vector=SearchQuery(
value, config='russian'))
# qs2 = qs.filter(СвЮЛ__ИНН__icontains=value)
#print(qs_.count())
return qs_
def complex_UprOrg_filter(self, qs, name, value):
# print(qs.count())
if value.find(' ') == -1:
qs_ = qs.filter(
Q(СвЮЛ__СвУпрОрг__НаимИННЮЛ__ОГРН__icontains=value)
| Q(СвЮЛ__СвУпрОрг__НаимИННЮЛ__ИНН__icontains=value)
| Q(СвЮЛ__СвУпрОрг__НаимИННЮЛ__НаимЮЛПолн__icontains=value)
).distinct()
else:
qs_ = qs.filter(СвЮЛ__СвУпрОрг__search_vector=SearchQuery(
value, config='russian'))
# qs2 = qs.filter(СвЮЛ__ИНН__icontains=value)
# print(qs_.count())
return qs_
def complex_fio_filter(self, qs, name, value):
#print(qs.count(), name, value)
qs1 = qs.filter(
Q(СвЮЛ__СвУчредит__УчрФЛ__СвФЛ__search_vector=SearchQuery(
value, config='russian'))
| Q(СвЮЛ__СвУчредит__УчрФЛ__СвФЛ__ИННФЛ__icontains=value)
| Q(СвЮЛ__СвУчредит__УчрФЛ__СвДовУпрФЛ__СвФЛ__search_vector=
SearchQuery(value, config='russian')) |
Q(СвЮЛ__СвУчредит__УчрФЛ__СвДовУпрФЛ__СвФЛ__ИННФЛ__icontains=value)
).distinct()
#qs2 = qs.filter(
#qs_ = qs1.union(qs2).all()
#print(qs1.count())
#print(qs2.count())
#print(qs_.count())
#Q(СвЮЛ__СвУчредит__УчрФЛ__СвДовУпрФЛ__СвФЛ__search_vector=SearchQuery(value, config='russian')) |
#Q(СвЮЛ__СвУчредит__УчрФЛ__ЛицоУпрНасл__СвФЛ__search_vector=SearchQuery(value, config='russian')) |
#Q(СвЮЛ__СвУчредит__УчрРФСМО__СвФЛОсущПр__СвФЛ__search_vector=SearchQuery(value, config='russian')) |
#Q(СвЮЛ__СвКФХПредш__СвФЛ__search_vector=SearchQuery(value, config='russian')) |
#Q(СвЮЛ__СвКФХПреем__СвФЛ__search_vector=SearchQuery(value, config='russian')))
#print(len(qs_))
return qs1
def complex_fioWA_filter(self, qs, name, value):
# print(qs.count(), name, value)
#qs1 = qs.filter(СвЮЛ__СведДолжнФЛ__СвФЛ__ИННФЛ__icontains=value)
qs1 = qs.filter(
Q(СвЮЛ__СведДолжнФЛ__СвФЛ__search_vector=SearchQuery(
value, config='russian'))
| Q(СвЮЛ__СведДолжнФЛ__СвФЛ__ИННФЛ__icontains=value)).distinct()
return qs1
def complex_declarer_filter(self, qs, name, value):
# print(qs.count(), name, value)
# qs1 = qs.filter(СвЮЛ__СведДолжнФЛ__СвФЛ__ИННФЛ__icontains=value)
qs1 = qs.filter(
Q(СвЮЛ__СвЗапЕГРЮЛ__СвЗФЛ__СвФЛ__СвФИОИНН__search_vector=
SearchQuery(value, config='russian'))
| Q(СвЮЛ__СвЗапЕГРЮЛ__СвЗФЛ__СвФЛ__СвФИОИНН__ИННФЛ__icontains=value
)).distinct()
return qs1
def okved_filter(self, qs, name, value):
# qs1 = qs.filter(СвЮЛ__СведДолжнФЛ__СвФЛ__ИННФЛ__icontains=value)
qs1 = qs.filter(
Q(СвЮЛ__СвОКВЭД__СвОКВЭДОсн__КодОКВЭД__exact=value)
| Q(СвЮЛ__СвОКВЭД__СвОКВЭДДоп__КодОКВЭД__exact=value)
| Q(СвЮЛ__СвОКВЭД__СвОКВЭДОсн__search_vector=SearchQuery(
value, config='russian'))
| Q(СвЮЛ__СвОКВЭД__СвОКВЭДДоп__search_vector=SearchQuery(
value, config='russian'))).distinct()
#Q(СвЮЛ__СвОКВЭД__СвОКВЭДОсн__КодОКВЭД__search_vector=SearchQuery(value, config='russian')) |
return qs1
def license_filter(self, qs, name, value):
qs1 = qs.filter(СвЮЛ__СвЛицензия__search_vector=SearchQuery(
value, config='russian')).distinct()
return qs1
def check_addr_сhange(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(
СвЮЛ__СвАдресЮЛ__СвРешИзмМН__isnull=False).distinct()
return qs_
def check_addr_falsity(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(
СвЮЛ__СвАдресЮЛ__СвНедАдресЮЛ__isnull=False).distinct()
return qs_
def check_email_filter(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвАдрЭлПочты__isnull=False).distinct()
return qs_
def check_isChartCapital(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУстКап__isnull=False).distinct()
return qs_
def check_isSvUprOrg(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУпрОрг__isnull=False).distinct()
return qs_
def check_isSvWithoutAtt(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СведДолжнФЛ__isnull=False).distinct()
return qs_
def check_isFounder(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУчредит__isnull=False).distinct()
return qs_
def check_isFRus(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУчредит__УчрЮЛРос__isnull=False).distinct()
return qs_
def check_isFFl(self, qs, name, value):
# print(name, value)
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУчредит__УчрФЛ__isnull=False).distinct()
return qs_
def check_isFGOS(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУчредит__УчрРФСМО__isnull=False).distinct()
return qs_
def check_isFIn(self, qs, name, value):
if value is False:
qs_ = qs
else:
qs_ = qs.filter(СвЮЛ__СвУчредит__УчрЮЛИн__isnull=False).distinct()
return qs_
def is_active_filter(self, qs, name, value):
if value is False:
qs_ = qs.filter(СвЮЛ__СвПрекрЮЛ__isnull=False).distinct()
else:
qs_ = qs.filter(СвЮЛ__СвПрекрЮЛ__isnull=True).distinct()
return qs_
