class ResultFilter(filters.FilterSet):
item_uuid = filters.UUIDFilter(field_name="item__uuid")
preset_uuid = filters.UUIDFilter(field_name="preset__uuid")
class Meta:
model = models.Result
fields = ['item_uuid', 'preset_uuid']
class UploadFilter(audio_filters.IncludeChannelsFilterSet):
library = filters.CharFilter("library__uuid")
channel = filters.CharFilter("library__channel__uuid")
track = filters.UUIDFilter("track__uuid")
track_artist = filters.UUIDFilter("track__artist__uuid")
album_artist = filters.UUIDFilter("track__album__artist__uuid")
library = filters.UUIDFilter("library__uuid")
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
scope = common_filters.ActorScopeFilter(
actor_field="library__actor",
distinct=True,
library_field="library",
)
import_status = common_filters.MultipleQueryFilter(coerce=str)
q = fields.SmartSearchFilter(config=search.SearchConfig(
search_fields={
"track_artist": {
"to": "track__artist__name"
},
"album_artist": {
"to": "track__album__artist__name"
},
"album": {
"to": "track__album__title"
},
"title": {
"to": "track__title"
},
},
filter_fields={
"artist": {
"to": "track__artist__name__iexact"
},
"mimetype": {
"to": "mimetype"
},
"album": {
"to": "track__album__title__iexact"
},
"title": {
"to": "track__title__iexact"
},
"status": {
"to": "import_status"
},
},
))
class Meta:
model = models.Upload
fields = [
"import_status",
"mimetype",
"import_reference",
]
include_channels_field = "track__artist__channel"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value)
class ShiftingFilterSet(filters.FilterSet):
def get_status(
self,
queryset,
field_name,
value,
):
if value:
if value in inverse_shifting_status:
return queryset.filter(status=inverse_shifting_status[value])
return queryset
status = filters.CharFilter(method="get_status", field_name="status")
facility = filters.UUIDFilter(field_name="facility__external_id")
patient = filters.UUIDFilter(field_name="patient__external_id")
patient_name = filters.CharFilter(field_name="patient__name",
lookup_expr="icontains")
patient_phone_number = filters.CharFilter(
field_name="patient__phone_number", lookup_expr="icontains")
orgin_facility = filters.UUIDFilter(
field_name="orgin_facility__external_id")
shifting_approving_facility = filters.UUIDFilter(
field_name="shifting_approving_facility__external_id")
assigned_facility = filters.UUIDFilter(
field_name="assigned_facility__external_id")
emergency = filters.BooleanFilter(field_name="emergency")
is_up_shift = filters.BooleanFilter(field_name="is_up_shift")
is_kasp = filters.BooleanFilter(field_name="is_kasp")
created_date = filters.DateFromToRangeFilter(field_name="created_date")
modified_date = filters.DateFromToRangeFilter(field_name="modified_date")
assigned_to = filters.NumberFilter(field_name="assigned_to__id")
class ShiftingFilterSet(filters.FilterSet):
status = CareChoiceFilter(choice_dict=inverse_shifting_status)
breathlessness_level = CareChoiceFilter(
choice_dict=inverse_breathlessness_level)
disease_status = CareChoiceFilter(choice_dict=DISEASE_STATUS_DICT,
field_name="patient__disease_status")
facility = filters.UUIDFilter(field_name="facility__external_id")
patient = filters.UUIDFilter(field_name="patient__external_id")
patient_name = filters.CharFilter(field_name="patient__name",
lookup_expr="icontains")
patient_phone_number = filters.CharFilter(
field_name="patient__phone_number", lookup_expr="icontains")
orgin_facility = filters.UUIDFilter(
field_name="orgin_facility__external_id")
shifting_approving_facility = filters.UUIDFilter(
field_name="shifting_approving_facility__external_id")
assigned_facility = filters.UUIDFilter(
field_name="assigned_facility__external_id")
emergency = filters.BooleanFilter(field_name="emergency")
is_up_shift = filters.BooleanFilter(field_name="is_up_shift")
is_kasp = filters.BooleanFilter(field_name="is_kasp")
created_date = filters.DateFromToRangeFilter(field_name="created_date")
modified_date = filters.DateFromToRangeFilter(field_name="modified_date")
assigned_to = filters.NumberFilter(field_name="assigned_to__id")
created_by = filters.NumberFilter(field_name="created_by__id")
last_edited_by = filters.NumberFilter(field_name="last_edited_by__id")
class SlotFilterSet(filters.FilterSet):
computer = filters.UUIDFilter(field_name="computer__external_id")
program = filters.UUIDFilter(field_name="computer__program__external_id")
max_students = filters.NumberFilter(field_name="max_students",
lookup_expr="lte")
language = filters.CharFilter(field_name="language")
is_mentor_assigned = filters.BooleanFilter(field_name="is_mentor_assigned")
is_student_assigned = filters.BooleanFilter(
field_name="is_student_assigned")
class UploadFilter(filters.FilterSet):
library = filters.CharFilter("library__uuid")
track = filters.UUIDFilter("track__uuid")
track_artist = filters.UUIDFilter("track__artist__uuid")
album_artist = filters.UUIDFilter("track__album__artist__uuid")
library = filters.UUIDFilter("library__uuid")
playable = filters.BooleanFilter(name="_", method="filter_playable")
q = fields.SmartSearchFilter(config=search.SearchConfig(
search_fields={
"track_artist": {
"to": "track__artist__name"
},
"album_artist": {
"to": "track__album__artist__name"
},
"album": {
"to": "track__album__title"
},
"title": {
"to": "track__title"
},
},
filter_fields={
"artist": {
"to": "track__artist__name__iexact"
},
"mimetype": {
"to": "mimetype"
},
"album": {
"to": "track__album__title__iexact"
},
"title": {
"to": "track__title__iexact"
},
"status": {
"to": "import_status"
},
},
))
class Meta:
model = models.Upload
fields = [
"playable",
"import_status",
"mimetype",
"track",
"track_artist",
"album_artist",
"library",
"import_reference",
]
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value)
class ResponsesFilter(filters.FilterSet):
"""A Response filter that actually works."""
child = filters.UUIDFilter(field_name="child__uuid")
study = filters.UUIDFilter(field_name="study__uuid")
class Meta:
model = Response
fields = []
class MasterDetailConcFilter(filter.TsFilterSet):
concurrent_uuid = filters.UUIDFilter(name="concurrent_id__concurrent_uuid")
conc_detail_lookup_type_desc = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_type_id__description')
conc_detail_lookup_type_meaning = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_type_id__meaning')
concurrent_lookup_detail_value_set_desc = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_value_set_id__description')
concurrent_lookup_detail_value_set_meaning = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_value_set_id__meaning')
concurrent_lookup_detail_type_code = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_type_id__lookup_code')
concurrent_lookup_detail_value_set_code = filters.CharFilter(
lookup_expr='icontains',
name='concurrent_lookup_param_value_set_id__lookup_code')
class Meta(filter.TsFilterSet.Meta):
model = MasterConcurrentDetail
fields = '__all__'
order_by = True
class RepositoryEntitiesFilter(filters.FilterSet):
class Meta:
model = RepositoryEntity
fields = ["repository_uuid", "repository_version", "value"]
repository_uuid = filters.UUIDFilter(
field_name="repository_uuid",
required=True,
method="filter_repository_uuid",
help_text=_("Repository's UUID"),
)
repository_version = filters.CharFilter(
field_name="repository_version",
required=True,
method="filter_repository_version",
help_text=_("Repository Version ID"),
)
def filter_repository_uuid(self, queryset, name, value):
request = self.request
try:
repository = Repository.objects.get(uuid=value)
authorization = repository.get_user_authorization(request.user)
if not authorization.can_translate:
raise PermissionDenied()
return queryset.filter(repository_version__repository=repository)
except Repository.DoesNotExist:
raise NotFound(_("Repository {} does not exist").format(value))
except DjangoValidationError:
raise NotFound(_("Invalid repository UUID"))
def filter_repository_version(self, queryset, name, value):
return queryset.filter(repository_version=value)
class PatientFilterSet(filters.FilterSet):
source = filters.ChoiceFilter(choices=PatientRegistration.SourceChoices)
disease_status = CareChoiceFilter(choice_dict=DISEASE_STATUS_DICT)
facility = filters.UUIDFilter(field_name="facility__external_id")
phone_number = filters.CharFilter(field_name="phone_number")
allow_transfer = filters.BooleanFilter(field_name="allow_transfer")
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
ip_no = filters.CharFilter(field_name="last_consultation__ip_no", lookup_expr="icontains")
gender = filters.NumberFilter(field_name="gender")
age = filters.NumberFilter(field_name="age")
age_min = filters.NumberFilter(field_name="age", lookup_expr="gt")
age_max = filters.NumberFilter(field_name="age", lookup_expr="lt")
category = filters.ChoiceFilter(field_name="last_consultation__category", choices=CATEGORY_CHOICES)
created_date = filters.DateFromToRangeFilter(field_name="created_date")
modified_date = filters.DateFromToRangeFilter(field_name="modified_date")
srf_id = filters.CharFilter(field_name="srf_id")
is_declared_positive = filters.BooleanFilter(field_name="is_declared_positive")
# Location Based Filtering
district = filters.NumberFilter(field_name="district__id")
district_name = filters.CharFilter(field_name="district__name", lookup_expr="icontains")
local_body = filters.NumberFilter(field_name="local_body__id")
local_body_name = filters.CharFilter(field_name="local_body__name", lookup_expr="icontains")
state = filters.NumberFilter(field_name="state__id")
state_name = filters.CharFilter(field_name="state__name", lookup_expr="icontains")
# Consultation Fields
last_consultation_admission_date = filters.DateFromToRangeFilter(field_name="last_consultation__admission_date")
last_consultation_discharge_date = filters.DateFromToRangeFilter(field_name="last_consultation__discharge_date")
last_consultation_admitted_to = filters.NumberFilter(field_name="last_consultation__admitted_to")
last_consultation_assigned_to = filters.NumberFilter(field_name="last_consultation__assigned_to")
class LoginAclFilter(BaseFilterSet):
user = filters.UUIDFilter(field_name='user_id')
user_display = filters.CharFilter(field_name='user__name')
class Meta:
model = LoginACL
fields = ('name', 'user', 'user_display', 'action')
class NewsItemFilter(filters.FilterSet):
id = filters.UUIDFilter(field_name="id")
title = filters.CharFilter(field_name="title")
# To add Category Filter
class Meta:
model = NewsItem
fields = ["id", "title"]
class FacilitySummaryFilter(filters.FilterSet):
start_date = filters.DateFilter(field_name="created_date",
lookup_expr="gte")
end_date = filters.DateFilter(field_name="created_date", lookup_expr="lte")
facility = filters.UUIDFilter(field_name="facility__external_id")
district = filters.NumberFilter(field_name="facility__district__id")
local_body = filters.NumberFilter(field_name="facility__local_body__id")
state = filters.NumberFilter(field_name="facility__state__id")
class AHJFilter(filters.FilterSet, rf_filters.SearchFilter):
AHJID__in = df_filters.UUIDFilter(field_name='AHJID')
AHJCode__in = df_filters.UUIDFilter(field_name='AHJCode', lookup_expr='in')
BuildingCode__in = CharInFilter(field_name='BuildingCode',
lookup_expr='in')
ElectricCode__in = CharInFilter(field_name='ElectricCode',
lookup_expr='in')
FireCode__in = CharInFilter(field_name='FireCode', lookup_expr='in')
ResidentialCode__in = CharInFilter(field_name='ResidentialCode',
lookup_expr='in')
WindCode__in = CharInFilter(field_name='WindCode', lookup_expr='in')
Location__in = LocationFilter()
Address__in = AddressFilter()
class Meta:
model = AHJ
fields = '__all__'
class DeviceFilter(filters.FilterSet):
project_id = filters.UUIDFilter(method='filter_project_id')
device_id = filters.UUIDFilter(method='filter_device_id')
class Meta:
model = Device
fields = ('project_id', 'device_id', 'name')
def filter_project_id(self, queryset, name, value):
if value:
queryset = queryset.filter(project__id=value)
return queryset
def filter_device_id(self, queryset, name, value):
if value:
queryset = queryset.filter(id=value)
return queryset
class ShipmentFilter(filters.filterset.FilterSet):
has_ship_from_location = filters.BooleanFilter(
field_name='ship_from_location', lookup_expr='isnull', exclude=True)
has_ship_to_location = filters.BooleanFilter(field_name='ship_to_location',
lookup_expr='isnull',
exclude=True)
has_final_destination_location = filters.BooleanFilter(
field_name='final_destination_location',
lookup_expr='isnull',
exclude=True)
has_quickadd_tracking = filters.BooleanFilter(
field_name='quickadd_tracking', lookup_expr='isnull', exclude=True)
state = CustomMultipleChoiceFilter(method=filter_state,
choices=SHIPMENT_STATE_CHOICES)
exception = filters.CharFilter(method=filter_enum)
gtx_validation = filters.CharFilter(method=filter_enum)
assignee_id = filters.UUIDFilter(field_name='assignee_id')
# Tag filter fields
tag_type = filters.CharFilter(field_name='shipment_tags__tag_type',
lookup_expr='icontains',
distinct=True)
tag_value = filters.CharFilter(field_name='shipment_tags__tag_value',
lookup_expr='icontains',
distinct=True)
class Meta:
model = Shipment
fields = (
'mode_of_transport_code',
'ship_from_location__name',
'ship_from_location__city',
'ship_from_location__address_1',
'ship_from_location__postal_code',
'ship_from_location__country',
'ship_to_location__name',
'ship_to_location__city',
'ship_to_location__state',
'ship_to_location__address_1',
'ship_to_location__postal_code',
'ship_to_location__country',
'final_destination_location__name',
'final_destination_location__city',
'ship_from_location',
'final_destination_location__state',
'final_destination_location__address_1',
'ship_to_location',
'final_destination_location__postal_code',
'final_destination_location__country',
'final_destination_location',
'ship_from_location__state',
'state',
'delayed',
'asset_physical_id',
'asset_custodian_id',
'quickadd_tracking',
'carrier_abbv',
)
class AnnouncementFilter(filters.FilterSet):
id = filters.UUIDFilter(field_name="id")
publication_date = filters.DateFilter(field_name="publication_date",
lookup_expr="gte")
# To add Category Filter
class Meta:
model = Announcement
fields = ["id", "publication_date"]
class CommandFilter(filters.FilterSet):
date_from = filters.DateTimeFilter(method='do_nothing')
date_to = filters.DateTimeFilter(method='do_nothing')
session_id = filters.CharFilter(field_name='session')
command_storage_id = filters.UUIDFilter(method='do_nothing')
user = filters.CharFilter(lookup_expr='startswith')
input = filters.CharFilter(lookup_expr='icontains')
class Meta:
model = Command
fields = [
'asset',
'system_user',
'user',
'session',
'risk_level',
'input',
'date_from',
'date_to',
'session_id',
'risk_level',
'command_storage_id',
]
def do_nothing(self, queryset, name, value):
return queryset
@property
def qs(self):
qs = super().qs
qs = qs.filter(org_id=self.get_org_id())
qs = self.filter_by_timestamp(qs)
return qs
def filter_by_timestamp(self, qs: QuerySet):
date_from = self.form.cleaned_data.get('date_from')
date_to = self.form.cleaned_data.get('date_to')
filters = {}
if date_from:
date_from = date_from.timestamp()
filters['timestamp__gte'] = date_from
if date_to:
date_to = date_to.timestamp()
filters['timestamp__lte'] = date_to
qs = qs.filter(**filters)
return qs
@staticmethod
def get_org_id():
if current_org.is_default():
org_id = ''
else:
org_id = current_org.id
return org_id
class RepositoryQueueTaskFilter(filters.FilterSet):
class Meta:
model = RepositoryQueueTask
fields = ["repository_uuid", "repository_version"]
repository_uuid = filters.UUIDFilter(
field_name="repository_uuid",
required=True,
method="filter_repository_uuid",
help_text=_("Repository's UUID"),
)
repository_version = filters.CharFilter(
field_name="repository_version",
required=True,
method="filter_repository_version",
help_text=_("Repository Version ID"),
)
type_processing = filters.ChoiceFilter(
field_name="type_processing",
method="filter_type_processing",
choices=RepositoryQueueTask.TYPE_PROCESSING_CHOICES,
help_text=_("Choose the type of processing"),
)
id_queue = filters.CharFilter(
field_name="id_queue",
method="filter_id_queue",
help_text=_("Filter by Queue ID"),
)
def filter_repository_uuid(self, queryset, name, value):
request = self.request
try:
repository = Repository.objects.get(uuid=value)
authorization = repository.get_user_authorization(request.user)
if not authorization.can_translate:
raise PermissionDenied()
return queryset.filter(
repositoryversionlanguage__repository_version__repository=repository
)
except Repository.DoesNotExist:
raise NotFound(_("Repository {} does not exist").format(value))
except DjangoValidationError:
raise NotFound(_("Invalid repository UUID"))
def filter_repository_version(self, queryset, name, value):
return queryset.filter(
repositoryversionlanguage__repository_version=value
).order_by("-pk")
def filter_type_processing(self, queryset, name, value):
return queryset.filter(type_processing=value)
def filter_id_queue(self, queryset, name, value):
return queryset.filter(id_queue=value)
class AlgorithmFilter(filters.FilterSet):
has_admin = filters.NumberFilter(method='has_admin_filter', label="Has admin")
submissions_benchmark = filters.UUIDFilter(method='benchmark_submissions_filter', label="Has submissions for benchmark")
submissions_benchmark_or_empty = filters.UUIDFilter(method='benchmark_submissions_or_empty_filter', label="Has submissions for benchmark or no submissions")
class Meta:
model = Algorithm
fields = ['creator', 'has_admin']
def has_admin_filter(self, queryset, name, value):
return queryset.filter(admin_group__user__id__contains=value)
def benchmark_submissions_filter(self, queryset, name, value):
submission_qs = Submission.objects.filter(benchmark__id=value)
return queryset.filter(submissions__in=submission_qs)
def benchmark_submissions_or_empty_filter(self, queryset, name, value):
submissions_for_benchmark_qs = Submission.objects.filter(benchmark__id=value)
return queryset.filter(submissions__isnull=True).union(queryset.filter(submissions__in=submissions_for_benchmark_qs))
class EventFilter(PlaceFilter, AddressFilter, DateFilter):
organizer = filters.UUIDFilter(field_name='organizer_id')
is_top = filters.BooleanFilter(field_name='is_top')
is_hot = filters.BooleanFilter(field_name='is_hot')
class Meta:
model = Event
fields = [
'place', 'address', 'organizer', 'date__lte', 'date__gte',
'is_top', 'is_hot'
]
class ResourceFilterSet(filters.FilterSet):
status = CareChoiceFilter(choice_dict=inverse_resource_status)
category = CareChoiceFilter(choice_dict=inverse_category)
sub_category = CareChoiceFilter(choice_dict=inverse_sub_category)
facility = filters.UUIDFilter(field_name="facility__external_id")
orgin_facility = filters.UUIDFilter(
field_name="orgin_facility__external_id")
approving_facility = filters.UUIDFilter(
field_name="approving_facility__external_id")
assigned_facility = filters.UUIDFilter(
field_name="assigned_facility__external_id")
created_date = filters.DateFromToRangeFilter(field_name="created_date")
modified_date = filters.DateFromToRangeFilter(field_name="modified_date")
assigned_to = filters.NumberFilter(field_name="assigned_to__id")
created_by = filters.NumberFilter(field_name="created_by__id")
last_edited_by = filters.NumberFilter(field_name="last_edited_by__id")
priority = filters.NumberFilter(field_name="priority")
emergency = filters.BooleanFilter(field_name="emergency")
class ResponsesFilter(filters.FilterSet):
"""A Response filter that actually works."""
# Temporarily leave this out so that response requests on TEST_CHILD_DISREGARD
# work
# child = filters.UUIDFilter(field_name="child__uuid")
study = filters.UUIDFilter(field_name="study__uuid")
class Meta:
model = Response
fields = []
class PatientFilterSet(filters.FilterSet):
source = filters.ChoiceFilter(choices=PatientRegistration.SourceChoices)
disease_status = CareChoiceFilter(choice_dict=DISEASE_STATUS_DICT)
facility = filters.UUIDFilter(field_name="facility__external_id")
phone_number = filters.CharFilter(field_name="phone_number")
allow_transfer = filters.BooleanFilter(field_name="allow_transfer")
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
ip_no = filters.CharFilter(field_name="last_consultation__ip_no", lookup_expr="icontains")
gender = filters.BooleanFilter(field_name="gender")
age = filters.NumericRangeFilter(field_name="age")
category = filters.ChoiceFilter(field_name="last_consultation__category", choices=CATEGORY_CHOICES)
class PolicyFilter(filters.FilterSet):
"""Filter for policy."""
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
group_name = filters.CharFilter(field_name="group",
lookup_expr="name__icontains")
group_uuid = filters.UUIDFilter(field_name="group",
lookup_expr="uuid__exact")
class Meta:
model = Policy
fields = ["name", "group_name", "group_uuid"]
class PolicyFilter(filters.FilterSet):
"""Filter for policy."""
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
group_name = filters.CharFilter(field_name='group',
lookup_expr='name__icontains')
group_uuid = filters.UUIDFilter(field_name='group',
lookup_expr='uuid__exact')
class Meta:
model = Policy
fields = ['name', 'group_name', 'group_uuid']
class BlogPostListFilter(filters.FilterSet):
date_created = filters.DateFromToRangeFilter(field_name='date_created')
title = filters.CharFilter(field_name='title', lookup_expr='icontains')
author = filters.UUIDFilter(field_name='author__user__id')
category = filters.CharFilter(field_name='category__name')
tag = filters.CharFilter(field_name='tags', method='filter_tag')
def filter_tag(self, queryset, name, value):
tag = BlogPostTag.objects.get(name=value)
return queryset.filter(tags__in=[tag])
class Meta:
model = BlogPost
fields = ['author', 'title', 'category', 'tag', 'date_created']
class ShiftingFilterSet(filters.FilterSet):
def get_status(
self,
queryset,
field_name,
value,
):
if value:
if value in inverse_shifting_status:
return queryset.filter(status=inverse_shifting_status[value])
return queryset
status = filters.CharFilter(method="get_status", field_name="status")
facility = filters.UUIDFilter(field_name="facility__external_id")
patient = filters.UUIDFilter(field_name="patient__external_id")
orgin_facility = filters.UUIDFilter(
field_name="orgin_facility__external_id")
shifting_approving_facility = filters.UUIDFilter(
field_name="shifting_approving_facility__external_id")
assigned_facility = filters.UUIDFilter(
field_name="assigned_facility__external_id")
emergency = filters.BooleanFilter(field_name="emergency")
is_up_shift = filters.BooleanFilter(field_name="is_up_shift")
class AHJFilter(filters.FilterSet, rf_filters.SearchFilter):
AHJName = df_filters.CharFilter(field_name='AHJName', lookup_expr='icontains')
AHJID = df_filters.UUIDFilter(field_name='AHJID')
AHJCode = df_filters.CharFilter(field_name='AHJCode', lookup_expr='icontains')
AHJLevelCode = df_filters.CharFilter(field_name='AHJLevelCode', lookup_expr='in')
BuildingCode = CharInFilter(field_name='BuildingCode', lookup_expr='in')
ElectricCode = CharInFilter(field_name='ElectricCode', lookup_expr='in')
FireCode = CharInFilter(field_name='FireCode', lookup_expr='in')
ResidentialCode = CharInFilter(field_name='ResidentialCode', lookup_expr='in')
WindCode = CharInFilter(field_name='WindCode', lookup_expr='in')
StateProvince = df_filters.CharFilter(field_name='address__StateProvince', lookup_expr='iexact')
Location = LocationFilter()
class Meta:
model = AHJ
fields = '__all__'
class TicketFilter(BaseFilterSet):
assignees__id = filters.UUIDFilter(method='filter_assignees_id')
class Meta:
model = Ticket
fields = (
'id',
'title',
'type',
'status',
'applicant',
'assignees__id',
'applicant_display',
)
def filter_assignees_id(self, queryset, name, value):
return queryset.filter(
ticket_steps__ticket_assignees__assignee__id=value)
