class IssueFilter(filters.FilterSet):
status = filters.CharFilter(field_name='kanbancol__name',
lookup_expr='exact')
assignee = filters.CharFilter(field_name="assignee__username",
lookup_expr='contains')
participant = filters.CharFilter(field_name="participant__username",
lookup_expr='contains')
dependsOn = filters.NumberFilter(field_name="dependsOn__number",
lookup_expr='exact')
sprint = filters.NumberFilter(field_name="sprint__seqnum",
lookup_expr='exact')
project = filters.CharFilter(field_name="project__name_short",
lookup_expr='exact')
logged_total__gt = DurationFilter(field_name='logged_total',
lookup_expr='gt')
logged_total__lt = DurationFilter(field_name='logged_total',
lookup_expr='lt')
logged_total = DurationFilter(field_name='logged_total',
lookup_expr='exact')
class Meta:
model = Issue
fields = {
'priority': ['exact', 'lt', 'gt'],
'type': ['exact'],
'description': ['contains'],
'due_date': ['exact', 'lt', 'gt'],
'created': ['exact', 'lt', 'gt'],
'storypoints': ['exact', 'lt', 'gt'],
'archived': ['exact'],
'sprint': ['isnull']
}
class LogDateFilter(filters.FilterSet):
timestamp = filters.DateTimeFilter(name="timestamp", lookup_type="gte")
coordinate_X = filters.NumberFilter(name="coordinate_X")
coordinate_Y = filters.NumberFilter(name="coordinate_Y")
class Meta:
model = Logs
fields = ['timestamp', 'coordinate_X', 'coordinate_Y']
class EntityImageFilter(filters.FilterSet):
"""
EntityImageFilter
"""
entity = filters.NumberFilter()
key = filters.NumberFilter()
class Meta:
model = EntityImage
fields = ['entity', 'key']
class SplitFilter(filters.FilterSet):
reader = filters.CharFilter(name='reader__id_str')
tag = filters.CharFilter(name='tag__id_str')
time_gte = filters.NumberFilter(name='time', lookup_type='gte')
time_lte = filters.NumberFilter(name='time', lookup_type='lte')
session = filters.NumberFilter(name='timingsession')
checkpoint = filters.NumberFilter(name='reader__checkpoint', distinct=True)
class Meta:
model = Split
fields = ('athlete', 'tag', 'session', 'reader', 'time_lte',
'time_gte', 'checkpoint')
class ServiceBaseFilter(filters.FilterSet):
id = filters.AllLookupsFilter(name="id")
serve_name = filters.AllLookupsFilter(name="serve_name")
serve_type = filters.RelatedFilter(ServiceTypeFilter, name='serve_type')
type_id = filters.NumberFilter(name="serve_type__id")
category_id = filters.NumberFilter(name="serve_type__category")
class Meta:
model = Service_base
fields = [
'id', 'serve_name', 'serve_abbreviation', 'serve_type',
'category_id', 'type_id'
]
class VerbatimFilter(filters.FilterSet):
queryset = models.Verbatim.objects.all().prefetch_related(
'question', 'variable', 'parent', 'job')
csp_quota = filters.NumberFilter(name='variable__csp_quota')
age_bands = filters.NumberFilter(name='variable__age_bands')
reg_quota = filters.NumberFilter(name='variable__reg_quota')
sex = filters.NumberFilter(name='variable__sex')
variable = filters.RelatedFilter(VariableFilter)
class Meta:
model = models.Verbatim
fields = ('parent', 'question', 'variable', 'csp_quota', 'age_bands',
'reg_quota', 'sex')
class ServiceErrorCodeFilter(filters.FilterSet):
error_type_id = filters.NumberFilter(name='error_type__id')
error_type_name = filters.NumberFilter(name='error_type__error_type_name')
class Meta:
model = Service_errorCode
fields = [
'id',
'service',
'error_type_id',
'error_type_name',
'error_code',
'error_name',
'create_time',
]
class LocationGeometryFilterBase(GeoFilterSet):
label = filters.CharFilter(name='label', lookup_expr='iexact')
label__contains = filters.CharFilter(name='label', lookup_expr='icontains')
name = filters.CharFilter(name='attributes__name', lookup_expr='exact')
layer = filters.CharFilter(name='attributes__layer', lookup_expr='exact')
region = filters.NumberFilter(name='attributes__region', action=filter_region_json)
class ScaleFilter(filters.FilterSet):
scale = filters.NumberFilter(name='scale')
class Meta:
model = Scale
fields = ('scale',)
class TimingSessionFilter(filters.FilterSet):
start_date = filters.DateFilter(name='start_time', lookup_type='gte')
stop_date = filters.DateFilter(name='start_time', lookup_type='lte')
athlete = filters.NumberFilter(name='splits__athlete', distinct=True)
class Meta:
model = TimingSession
fields = ('start_date', 'stop_date', 'private', 'coach', 'athlete')
class ComponentVersionFilter(filters.FilterSet):
component = filters.RelatedFilter(
ComponentFilter,
field_name='component',
queryset=models.ComponentModel.objects.all(),
lookups='__all__')
owner_maintainer = filters.RelatedFilter(
UserFilter,
lookups='__all__',
queryset=models.User.objects.all(),
)
deployments = filters.RelatedFilter(
DeploymentFilter,
field_name='deployments',
queryset=models.ComponentDeploymentModel.objects.all())
statuses = filters.RelatedFilter(
RequirementStatusEntryFilter,
field_name='statuses',
queryset=models.RequirementStatusEntry.objects.all())
exclude_statuses = filters.BaseInFilter(field_name='statuses',
method='filter_exclude_statuses')
unknown_status_count = filters.NumberFilter()
negative_status_count = filters.NumberFilter()
total_statuses = filters.NumberFilter()
version = filters.AutoFilter(lookups='__all__')
class Meta:
model = models.ComponentVersionModel
fields = '__all__'
def filter_exclude_statuses(self, qs, name, value):
""" handle query params for excluding component version with some requirement statuses.
that useful for filtering component version that have not requirement statuses by some
requirement. It's equal to select "unknown" status at frontend filters. We exclude all
statuses except unknown: Ready, not ready, n/a. That case cover situation when component
version have not requirement status. If requirement status is not exist it equal "unknown" status"""
requirement = self.request.query_params.get('exclude_requirement')
req_type = self.request.query_params.get('exclude_type')
args = {}
if requirement:
args.update({'requirement__in': requirement.split(',')})
if req_type:
args.update({'type__in': req_type.split(',')})
return qs.exclude(statuses__in=models.RequirementStatusEntry.objects.
filter(status__in=value, **args))
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 ServiceActivePackFilter(filters.FilterSet):
pack_name = filters.AllLookupsFilter(name="pack_name")
pack_price = filters.NumberFilter(name="pack_price", lookup_type='lte')
class Meta:
model = Service_activePack
fields = [
'id', 'service', 'pack_name', 'pack_price', 'status', 'create_time'
]
class DataMartImageFilter(filters.FilterSet):
"""
DataMartImageFilter
"""
data_mart = filters.NumberFilter()
class Meta:
model = BaseDataMartImage
fields = ['data_mart']
class BaseResolweFilter(filters.FilterSet):
"""Base filter for Resolwe's endpoints."""
id = filters.AllLookupsFilter() # pylint: disable=invalid-name
slug = filters.AllLookupsFilter()
name = filters.AllLookupsFilter()
contributor = filters.NumberFilter()
created = filters.AllLookupsFilter()
modified = filters.AllLookupsFilter()
class EntityFileFilter(filters.FilterSet):
"""
EntityImageFilter
"""
entity = filters.NumberFilter()
class Meta:
model = BaseEntityFile
fields = ['entity']
class WorkFilter(filters.FilterSet):
id = filters.NumberFilter(field_name='id_from_source')
class Meta:
model = Work
fields = {
'iswc': ['exact', 'in'],
'source': ['exact'],
}
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 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 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 AllowedForStepsFilter(filters.FilterSet):
"""Filter sections on allowed effort steps."""
allowed_for_steps = filters.NumberFilter(field_name="allowed_for_steps",
method="filter_allowed_for_steps")
class Meta:
model = Section
fields = "__all__"
def filter_allowed_for_steps(self, qs, name, value):
"""Filter on "allowed_for_steps" relation."""
return qs.filter(allowed_for_steps__number=value)
class PlanoTrabalhoFilter(filters.FilterSet):
situacao_conselho_descricao = filters.CharFilter(
name='conselho_cultural__situacao_ata__descricao',
lookup_expr='istartswith')
situacao_conselho_id = filters.NumberFilter(
name='conselho_cultural__situacao_ata__id')
situacao_orgao_descricao = filters.CharFilter(
name='orgao_gestor__situacao_relatorio_secretaria__descricao',
lookup_expr='istartswith')
situacao_orgao_id = filters.NumberFilter(
name='orgao_gestor__situacao_relatorio_secretaria__id')
situacao_lei_descricao = filters.CharFilter(
name='criacao_sistema__situacao_lei_sistema__descricao',
lookup_expr='istartswith')
situacao_lei_id = filters.CharFilter(
name='criacao_sistema__situacao_lei_sistema__id')
situacao_fundo_descricao = filters.CharFilter(
name='fundo_cultura__situacao_lei_plano__descricao',
lookup_expr='istartswith')
situacao_fundo_id = filters.NumberFilter(
name='fundo_cultura__situacao_lei_plano__descricao__id')
situacao_plano_descricao = filters.CharFilter(
name='plano_cultura__situacao_lei_plano__descricao',
lookup_expr='istartswith')
situacao_plano_id = filters.NumberFilter(
name='plano_cultura__situacao_lei_plano__descricao__id')
sistema_cultura = filters.RelatedFilter(MunicipioFilter,
name='usuario__municipio',
queryset=Municipio.objects.all())
class Meta:
model = PlanoTrabalho
fields = {'id'}
class BaseResolweFilter(filters.FilterSet):
"""Base filter for Resolwe's endpoints."""
id = filters.AllLookupsFilter() # pylint: disable=invalid-name
slug = filters.AllLookupsFilter()
name = filters.AllLookupsFilter()
contributor = filters.NumberFilter()
created = filters.AllLookupsFilter()
modified = filters.AllLookupsFilter()
class Meta:
"""Filter configuration."""
fields = ['id', 'slug', 'name', 'contributor', 'created', 'modified']
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 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 AppropriationFilter(filters.FilterSet):
"""Filter appropriation."""
main_activity__details__id = filters.NumberFilter(
label=gettext("Aktivitetsdetalje for hovedaktivitet"))
case = filters.RelatedFilter(
CaseForAppropriationFilter,
field_name="case",
label=Case._meta.verbose_name.title(),
queryset=Case.objects.all(),
)
class Meta:
model = Appropriation
fields = "__all__"
class ProductVariantFilter(filters.FilterSet):
product = filters.NumberFilter(field_name='product__id')
class Meta:
model = ProductVariant
fields = ['product']
class AdvancePublicJobsFilters(BasicPublicJobsFilters):
"""Filters for advance search"""
filter_search = filters.InSetCharFilter(
name="title",
method="search_all")
filter_company = filters.RelatedFilter(
EmployerFilter,
name="owner",
queryset=Employer.objects.filter(
user__is_active=True,
user__status=User.S_ENABLED))
filter_title_role = filters.NumberFilter(
name="role")
filter_position = filters.NumberFilter(
name="position")
filter_hierarchy = filters.NumberFilter(
name="hierarchy")
filter_branch_activity = filters.NumberFilter(
name="branch_activity")
filter_handicapped = filters.BooleanFilter(
name="handicapped_postulant")
filter_job_type = filters.NumberFilter(
name="job_type")
filter_is_new = filters.BooleanFilter(
method="is_new")
filter_country = filters.NumberFilter(
name="country")
def search_all(self, qs, name, value):
"""Search on title and description"""
mq = Q()
if len(value) > 0:
values = value[0].split(' ')
for i in range(len(values)):
if values[i] != '':
mq |= Q(title__icontains=values[i]) | Q(description__icontains=values[i])
res = qs.filter(mq)
return res
def is_new(self, qs, name, value):
"""Check if is new"""
# @TODO
return qs
class Meta:
model = Job
fields = (
"filter_subareas",
"filter_roles",
"filter_search",
"filter_title_role",
"filter_position",
"filter_hierarchy",
"filter_branch_activity",
"filter_handicapped",
"filter_job_type",
"filter_is_new",
"filter_country",
)
class PositionFilter(filters.FilterSet):
languages = filters.RelatedFilter(QualificationFilter,
name='languages',
queryset=Qualification.objects.all())
description = filters.RelatedFilter(
CapsuleDescriptionFilter,
name='description',
queryset=CapsuleDescription.objects.all())
grade = filters.RelatedFilter(GradeFilter,
name='grade',
queryset=Grade.objects.all())
skill = filters.RelatedFilter(SkillFilter,
name='skill',
queryset=Skill.objects.all())
organization = filters.RelatedFilter(OrganizationFilter,
name='organization',
queryset=Organization.objects.all())
bureau = filters.RelatedFilter(OrganizationFilter,
name='bureau',
queryset=Organization.objects.all())
post = filters.RelatedFilter(PostFilter,
name='post',
queryset=Post.objects.all())
current_assignment = filters.RelatedFilter(
'talentmap_api.position.filters.AssignmentFilter',
name='current_assignment',
queryset=Assignment.objects.all())
bid_statistics = filters.RelatedFilter(
PositionBidStatisticsFilter,
name='bid_statistics',
queryset=PositionBidStatistics.objects.all())
is_domestic = filters.BooleanFilter(name="is_overseas",
lookup_expr="exact",
exclude=True)
is_highlighted = filters.BooleanFilter(name="highlighted_by_org",
lookup_expr="isnull",
exclude=True)
# Full text search across multiple fields
q = filters.CharFilter(
name="position_number",
method=full_text_search(fields=[
"title", "organization__long_description",
"bureau__long_description", "skill__description", "skill__code",
"languages__language__long_description", "post__location__code",
"post__location__country__name", "post__location__country__code",
"post__location__city", "post__location__state",
"description__content", "position_number"
]))
is_available_in_current_bidcycle = filters.BooleanFilter(
name="bid_cycles", method="filter_available_in_current_bidcycle")
vacancy_in_years = filters.NumberFilter(
name="current_assignment__estimated_end_date",
method="filter_vacancy_in_years")
def filter_available_in_current_bidcycle(self, queryset, name, value):
'''
Returns a queryset of all positions who are in the latest active bidcycle and do not have any
bids with handshake or above status
'''
# Get latest active bidcycle
bidcycle = BidCycle.objects.filter(
active=True).latest('cycle_start_date')
accepting_bids_query = Subquery(
bidcycle.annotated_positions.filter(
accepting_bids=value).values_list('id', flat=True))
return queryset.filter(id__in=accepting_bids_query)
def filter_vacancy_in_years(self, queryset, name, value):
'''
Returns a queryset of all positions with a vacancy in the specified number of years
'''
start = timezone.now()
end = start + relativedelta(years=value)
q_obj = {}
q_obj[LOOKUP_SEP.join([name, "gt"])] = start
q_obj[LOOKUP_SEP.join([name, "lte"])] = end
return queryset.filter(Q(**q_obj))
class Meta:
model = Position
fields = {
"position_number": ALL_TEXT_LOOKUPS,
"title": ALL_TEXT_LOOKUPS,
"is_overseas": ["exact"],
"create_date": DATE_LOOKUPS,
"update_date": DATE_LOOKUPS,
"post": FOREIGN_KEY_LOOKUPS,
"organization": FOREIGN_KEY_LOOKUPS,
"bureau": FOREIGN_KEY_LOOKUPS,
"skill": FOREIGN_KEY_LOOKUPS,
"grade": FOREIGN_KEY_LOOKUPS,
"description": FOREIGN_KEY_LOOKUPS,
"languages": FOREIGN_KEY_LOOKUPS,
"current_assignment": FOREIGN_KEY_LOOKUPS
}
class ServicePriceFilter(filters.FilterSet):
cost = filters.NumberFilter(name="cost", lookup_type='lte')
class Meta:
model = Service_price
fields = ['id', 'service', 'is_free', 'cost', 'create_time']
