class StoryboardFilter(filters.FilterSet): storyboarder = filters.ModelMultipleChoiceFilter( name='storyboarder__username', to_field_name='username', queryset=Storyboarder.objects.all(), conjoined=True, ) tags = filters.ModelMultipleChoiceFilter( name='tags__internal_id', to_field_name='internal_id', queryset=Tag.objects.all(), conjoined=True, ) class Meta: model = Storyboard fields = [ 'song', 'artist', 'set_id', 'storyboarder', 'mapper', 'date_added', 'date_created', 'medium', 'tags' ] filter_overrides = { models.CharField: { 'filter_class': filters.CharFilter, 'extra': lambda f: { 'lookup_expr': 'icontains', } } }
class CategoryColumnFilterSet(rest_framework.FilterSet): categories = rest_framework.ModelMultipleChoiceFilter( queryset=create_category_filter(), name='field__category', label='Categories') purposes = rest_framework.ModelMultipleChoiceFilter( queryset=CategoryColumnPurpose.objects.all(), name='purpose', label='Purposes') @property def qs(self): qs = super(CategoryColumnFilterSet, self).qs qs = qs.prefetch_related( 'field__category', 'country', 'purpose', ) if self.request: categories_with_permission = create_category_filter()(self.request) qs = qs.filter(field__category__in=categories_with_permission, ) return qs class Meta: model = CategoryColumn fields = ('purpose', )
class EntityFilter(django_filters.FilterSet): id = django_filters.ModelMultipleChoiceFilter( help_text="Filter by Entity ID", queryset=Entity.objects.all().only("id"), method="filter_entities", ) contractor_id = django_filters.ModelMultipleChoiceFilter( help_text="Filter by Contractor ID", queryset=Contractor.objects.all(), method="filter_contractors_by_id", ) class Meta: model = Entity fields = ["id", "contractor_id"] def filter_entities(self, queryset, name, value): if not value: return queryset entity_ids = [entity.id for entity in value] return queryset.filter(pk__in=entity_ids) def filter_contractors_by_id(self, queryset, name, value): if not value: return queryset return queryset.filter(contract__contractors__in=value).distinct()
class EventFilter(filters.FilterSet): """ Provides useful filtering options for the :class:`~research.models.event.Event` model. """ title = filters.LookupChoiceFilter(lookup_choices=LOOKUP_CHOICES) description = filters.LookupChoiceFilter(lookup_choices=LOOKUP_CHOICES) procedure = filters.ModelMultipleChoiceFilter( queryset=Procedure.objects.all(), label="Procedures:") exclude_procedure = filters.ModelMultipleChoiceFilter( queryset=Procedure.objects.all(), exclude=True, field_name="procedure", label="Exclude procedures:", ) study = filters.ModelMultipleChoiceFilter( queryset=Study.objects.all(), label="Studies:", field_name="procedure__study", ) class Meta: model = Event fields = ("id", )
class RunFilter(filters.FilterSet): """ Provides useful filtering options for the :class:`~django_analyses.models.run.Run` model. """ analysis = filters.ModelMultipleChoiceFilter( "analysis_version__analysis", queryset=ANALYSES_WITH_RUNS, ) analysis_version = filters.ModelMultipleChoiceFilter( "analysis_version", queryset=ANALYSIS_VERSIONS_WITH_RUNS) status = filters.MultipleChoiceFilter(choices=RunStatus.choices()) start_time = filters.DateTimeFromToRangeFilter() end_time = filters.DateTimeFromToRangeFilter() if Subject: subject = filters.NumberFilter(method="get_subject_runs", label="By subject ID:", required=False) class Meta: model = Run fields = ("id", ) def get_subject_runs(self, queryset: QuerySet, name: str, pk: int) -> QuerySet: try: subject = Subject.objects.get(id=pk) except Subject.DoesNotExist: pass else: return subject.query_run_set()
class SkillFilter(filters.FilterSet): name = filters.CharFilter(method='filter_name') description = filters.CharFilter(method='filter_description') scaling_stats__pk = filters.ModelMultipleChoiceFilter(queryset=ScalingStat.objects.all(), to_field_name='pk', conjoined=True) effects_logic = filters.BooleanFilter(method='filter_effects_logic') effect__pk = filters.ModelMultipleChoiceFilter(queryset=SkillEffect.objects.all(), method='filter_skill_effects') used_on = filters.NumberFilter(method='filter_used_on') class Meta: model = Skill fields = { 'id': ['in'], 'name': ['exact'], 'com2us_id': ['exact'], 'slot': ['exact'], 'cooltime': ['exact', 'isnull', 'gte', 'lte', 'gt', 'lt'], 'hits': ['exact', 'isnull', 'gte', 'lte', 'gt', 'lt'], 'aoe': ['exact'], 'passive': ['exact'], 'max_level': ['exact', 'gte', 'lte', 'gt', 'lt'], } def filter_name(self, queryset, name, value): return queryset.filter(name__istartswith=value) def filter_description(self, queryset, name, value): return queryset.filter(description__icontains=value) def filter_skill_effects(self, queryset, name, value): old_filtering = self.form.cleaned_data.get('effects_logic', False) stat_scaling = self.form.cleaned_data.get('scaling_stats__pk', []) if old_filtering: # Filter if any skill on the monster has the designated fields for effect in value: queryset = queryset.filter(skill_effect=effect) for pk in stat_scaling: queryset = queryset.filter(scaling_stats=pk) return queryset.distinct() else: # Filter effects based on effects of each individual skill. This ensures a monster will not show up unless it has # the desired effects on the same skill rather than across any skills. skills = Skill.objects.all() for effect in value: skills = skills.filter(skill_effect=effect) for pk in stat_scaling: skills = skills.filter(scaling_stats=pk) return queryset.filter(pk__in=skills).distinct() def filter_used_on(self, queryset, name, value): return queryset.filter(monster__pk=value) def filter_effects_logic(self, queryset, name, value): # This field is just used to alter the logic of skill effect filter return queryset
class VisitFilterSet(rest_framework.FilterSet): timestamp = IsoDateTimeFromToRangeFilter( name='timestamp' ) products = rest_framework.ModelMultipleChoiceFilter( queryset=create_product_filter(), name='product', label='Products' ) websites = rest_framework.ModelMultipleChoiceFilter( queryset=create_website_filter('view_website_visits'), name='website', label='Websites' ) categories = rest_framework.ModelMultipleChoiceFilter( queryset=create_category_filter('view_category_visits'), name='product__instance_model__model__category', label='Categories' ) @property def qs(self): qs = super(VisitFilterSet, self).qs.select_related( 'product__instance_model__model__category', 'user' ) if self.request: qs = qs.filter_by_user_perms(self.request.user, 'view_visit') return qs class Meta: model = Visit fields = []
class InformationPackageFilter(filters.FilterSet): archivist_organization = filters.ModelMultipleChoiceFilter( label=_("Archivist Organization"), queryset=Agent.objects.filter(role__iexact="archivist", type__iexact="organization"), ) responsible = filters.ModelMultipleChoiceFilter( field_name="responsible__username", to_field_name="username", queryset=users ) state = MultipleCharFilter() object_size = filters.RangeFilter() start_date = filters.IsoDateTimeFromToRangeFilter() end_date = filters.IsoDateTimeFromToRangeFilter() create_date = filters.IsoDateTimeFromToRangeFilter() entry_date = filters.IsoDateTimeFromToRangeFilter() package_type = MultipleCharFilter() package_type_name_exclude = filters.CharFilter( label=_("Excluded Package Type"), method='exclude_package_type_name' ) def exclude_package_type_name(self, queryset, name, value): for package_type_id, package_type_name in InformationPackage.PACKAGE_TYPE_CHOICES: if package_type_name.lower() == value.lower(): return queryset.exclude(package_type=package_type_id) return queryset.none() class Meta: model = InformationPackage fields = ['archivist_organization', 'state', 'responsible', 'create_date', 'entry_date', 'object_size', 'start_date', 'end_date', 'archived', 'cached', 'package_type', 'package_type_name_exclude']
class SeekingFilter(django_rest_filters.FilterSet): """Custom filter for seekings""" class Meta: model = Seeking fields = ['tags', 'category', 'location_id', 'author_id'] # tricky part - how to filter by related field? # but not by its foreign key (default) # `to_field_name` is crucial here # `conjoined=True` makes that, the more tags, the more narrow the search tags = django_rest_filters.ModelMultipleChoiceFilter(queryset=Tag.objects, to_field_name='name', conjoined=True, method='filter_tags') category = django_rest_filters.ModelMultipleChoiceFilter( queryset=Category.objects, to_field_name='name', conjoined=True, method='filter_category') def filter_tags(self, queryset, name, tags): if tags: q = queryset.filter(tags__in=tags).distinct() return q else: return queryset def filter_category(self, queryset, name, categories): if categories and len(categories) > 0: return queryset.filter(category=categories[0]) else: return queryset
class RestaurantFilter(filters.FilterSet): cuisine_type = filters.ModelMultipleChoiceFilter(queryset=CuisineType.objects.all()) outlet_type = filters.ModelMultipleChoiceFilter(queryset=OutletType.objects.all()) affordability = filters.ModelMultipleChoiceFilter(queryset=Affordability.objects.all()) class Meta: model = Restaurant fields = ['cuisine_type', 'outlet_type', 'affordability', 'halal', 'vegan_friendly']
class ReviewFilter(filters.FilterSet): user = filters.ModelMultipleChoiceFilter(field_name="user_id", to_field_name="user_id", queryset=Review.objects.all()) product = filters.ModelMultipleChoiceFilter(field_name="product_id", to_field_name="product_id", queryset=Review.objects.all()) created_at = filters.DateFromToRangeFilter(lookup_expr='exact') updated_at = filters.DateFromToRangeFilter(lookup_expr='exact')
class BookFilter(filters.FilterSet): title = filters.CharFilter(lookup_expr='icontains') authors = filters.ModelMultipleChoiceFilter(queryset=Author.objects.all()) language = filters.ModelMultipleChoiceFilter( queryset=Language.objects.all()) pub_date__gte = filters.NumberFilter(field_name='pub_date', lookup_expr='gte') pub_date__lte = filters.NumberFilter(field_name='pub_date', lookup_expr='lte')
class AgendaFilter(filters.FilterSet): medico = filters.ModelMultipleChoiceFilter(queryset=Medico.objects.all()) especialidade = filters.ModelMultipleChoiceFilter( queryset=Especialidade.objects.all(), field_name="medico__especialidade", ) data_inicio = filters.DateFilter(field_name='horario', lookup_expr='gte') data_final = filters.DateFilter(field_name='horario', lookup_expr='lte') class Meta: model = Agenda fields = ['medico', 'especialidade', 'data_inicio', 'data_final']
class AgendaFilter(filters.FilterSet): doctor = filters.ModelMultipleChoiceFilter(queryset=Doctor.objects.all()) specialty = filters.ModelMultipleChoiceFilter( field_name='doctor__specialty', lookup_expr='exact', queryset=Specialty.objects.all()) start_date = filters.CharFilter(field_name="day", lookup_expr='gte') end_date = filters.CharFilter(field_name="day", lookup_expr='lte') class Meta: model = Agenda fields = ['doctor', 'specialty', 'start_date', 'end_date']
class KeyWordListFilter(django_filters.FilterSet): rvn_stelle_key_word_keyword__text__autor = django_filters.ModelMultipleChoiceFilter( queryset=Autor.objects.all(), label="Autor", help_text="Stichworte wurde von diesen Autoren verwendet", widget=autocomplete.Select2Multiple( url="archiv-ac:autor-autocomplete", )) legacy_id = django_filters.CharFilter( lookup_expr='icontains', help_text=KeyWord._meta.get_field('legacy_id').help_text, label=KeyWord._meta.get_field('legacy_id').verbose_name) stichwort = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=KeyWord._meta.get_field('stichwort').help_text, label=KeyWord._meta.get_field('stichwort').verbose_name) wurzel = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=KeyWord._meta.get_field('wurzel').help_text, label=KeyWord._meta.get_field('wurzel').verbose_name) kommentar = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=KeyWord._meta.get_field('kommentar').help_text, label=KeyWord._meta.get_field('kommentar').verbose_name) varianten = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=KeyWord._meta.get_field('varianten').help_text, label=KeyWord._meta.get_field('varianten').verbose_name) rvn_stelle_key_word_keyword = django_filters.ModelMultipleChoiceFilter( queryset=Stelle.objects.all(), label="Stelle", help_text="Stichworte stehen mit diesen Stellen in Verbindung", widget=autocomplete.Select2Multiple( url="archiv-ac:stelle-autocomplete", )) rvn_stelle_key_word_keyword__text = django_filters.ModelMultipleChoiceFilter( queryset=Text.objects.all(), label="Text", help_text="Stichworte stehen mit diesen Texten in Verbindung", widget=autocomplete.Select2Multiple( url="archiv-ac:text-autocomplete", )) rvn_stelle_key_word_keyword__text__autor__ort = django_filters.ModelMultipleChoiceFilter( queryset=Ort.objects.all(), label="Ort", help_text="Stichworte stehen mit diesen Orten in Verbindung", widget=autocomplete.Select2Multiple( url="archiv-ac:ort-autocomplete", )) class Meta: model = KeyWord fields = [ 'rvn_stelle_key_word_keyword__text__autor', 'id', 'legacy_id', 'legacy_pk', 'stichwort', 'art', 'wurzel', 'kommentar', 'varianten' ]
class FacilityStaffFilter(filters.FilterSet): facility = filters.ModelMultipleChoiceFilter( queryset=facility_models.Facility.objects.all()) name = filters.CharFilter(lookup_expr='istartswith') phone_number = filters.CharFilter() email = filters.CharFilter() designation = filters.ModelMultipleChoiceFilter( field_name="designation__name", queryset=facility_models.StaffDesignation.objects.all()) class Meta: model = facility_models.FacilityStaff fields = ("facility", "name", "phone_number", "email", "designation")
class RecordFilter(filters.FilterSet): class Meta: model = Record fields = [ 'assets_from', 'assets_to', 'dt_from', 'dt_to', 'tags_and', 'tags_or', 'mode', ] dt_from = filters.DateTimeFilter(name='created_dt', lookup_expr='gte') dt_to = filters.DateTimeFilter(name='created_dt', lookup_expr='lte') tags_or = filters.ModelMultipleChoiceFilter( name='tags__pk', to_field_name='pk', queryset=user_tags, conjoined=False, ) tags_and = filters.ModelMultipleChoiceFilter( name='tags__pk', to_field_name='pk', queryset=user_tags, conjoined=True, ) assets_from = filters.ModelMultipleChoiceFilter( name='asset_from', queryset=user_assets, conjoined=False, ) assets_to = filters.ModelMultipleChoiceFilter( name='asset_to', queryset=user_assets, conjoined=False, ) mode_or = filters.MultipleChoiceFilter( name='mode', choices=Record.MODES, conjoined=False, ) sort_by = filters.OrderingFilter( # tuple-mapping retains order fields=(('created_dt', 'created_ts'), ), )
class InformationPackageFilter(filters.FilterSet): archivist_organization = filters.ModelMultipleChoiceFilter( label=_("Archivist Organization"), queryset=Agent.objects.filter(role__iexact="archivist", type__iexact="organization"), ) responsible = filters.ModelMultipleChoiceFilter( field_name="responsible__username", to_field_name="username", queryset=lambda request: users_in_organization(request.user), ) state = MultipleCharFilter() object_size = filters.RangeFilter() start_date = filters.IsoDateTimeFromToRangeFilter() end_date = filters.IsoDateTimeFromToRangeFilter() create_date = filters.IsoDateTimeFromToRangeFilter() entry_date = filters.IsoDateTimeFromToRangeFilter() package_type = MultipleCharFilter() package_type_name_exclude = filters.CharFilter( label=_("Excluded Package Type"), method='exclude_package_type_name' ) migratable = filters.BooleanFilter(label='migratable', method='filter_migratable') workarea = filters.ChoiceFilter(label=_("Workarea"), field_name='workareas__type', choices=Workarea.TYPE_CHOICES) medium = filters.ModelChoiceFilter( label='Storage Medium', queryset=StorageMedium.objects.all(), field_name='storage__storage_medium', distinct=True ) policy = filters.ModelChoiceFilter( label='Storage Policy', queryset=StoragePolicy.objects.all(), field_name='submission_agreement__policy', distinct=True ) def exclude_package_type_name(self, queryset, name, value): for package_type_id, package_type_name in InformationPackage.PACKAGE_TYPE_CHOICES: if package_type_name.lower() == value.lower(): return queryset.exclude(package_type=package_type_id) return queryset.none() def filter_migratable(self, queryset, name, value): return queryset.migratable() class Meta: model = InformationPackage fields = ['archivist_organization', 'state', 'responsible', 'active', 'label', 'create_date', 'entry_date', 'object_size', 'start_date', 'end_date', 'policy', 'archived', 'cached', 'package_type', 'package_type_name_exclude', 'workarea']
class CoursePageFilter(filters.FilterSet): lang_code = filters.MultipleChoiceFilter(name='lang_code', \ lookup_expr='exact', choices=settings.LANGUAGES, \ widget=forms.CheckboxSelectMultiple, initial='en', \ label=_('Language')) keywords = filters.ModelMultipleChoiceFilter( name='multilang_keywords', queryset=MultilangKeyword.objects.all(), widget=forms.CheckboxSelectMultiple, label=_('Keywords')) level = filters.MultipleChoiceFilter(name='level', \ lookup_expr='exact', choices=LEVELS, \ widget=forms.CheckboxSelectMultiple, \ label=_('Level')) delivery_method = filters.MultipleChoiceFilter(name='delivery_format', \ lookup_expr='exact', choices=CoursePage.DELIVERY_FORMAT, \ widget=forms.CheckboxSelectMultiple, \ label=_('Delivery Method')) o = filters.OrderingFilter(choices=(('title', _('Title')), ), fields={ 'title': 'title', }, initial='title', help_text='') class Meta: model = CoursePage fields = {}
class SubmissionsFilter(filters.FilterSet): round = RoundLabFilter(queryset=RoundsAndLabs.objects.all()) status = filters.MultipleChoiceFilter(choices=PHASES) active = filters.BooleanFilter(method='filter_active', label='Active') submit_date = filters.DateFromToRangeFilter(field_name='submit_time', label='Submit date') fund = filters.ModelMultipleChoiceFilter( field_name='page', label='fund', queryset=Page.objects.type(FundType) | Page.objects.type(LabType)) class Meta: model = ApplicationSubmission fields = ( 'status', 'round', 'active', 'submit_date', 'fund', ) def filter_active(self, qs, name, value): if value is None: return qs if value: return qs.active() else: return qs.inactive()
class MedicoFilter(filters.FilterSet): especialidade = filters.ModelMultipleChoiceFilter( queryset=Especialidade.objects.all()) class Meta: model = Medico fields = ['especialidade']
class EventFilter(filters.FilterSet): start_after = filters.DateFilter(field_name='start', lookup_expr='gte') start_before = filters.DateFilter(field_name='start', lookup_expr='lte') end_after = filters.DateFilter(field_name='end', lookup_expr='gte') end_before = filters.DateFilter(field_name='end', lookup_expr='lte') tags = filters.ModelMultipleChoiceFilter( field_name='tags__name', to_field_name='name', queryset=Tag.objects.all(), conjoined=True, ) order_by = filters.OrderingFilter(fields=( 'slug', 'start', 'end', ), ) class Meta: model = Event fields = ( 'completed', 'tags', 'administrator', 'host', 'start', 'start_before', 'start_after', 'end', 'end_before', 'end_after', 'country', )
class ProcedureFilter(filters.FilterSet): """ Provides useful filtering options for the :class:`~research.models.procedure.Procedure` model. """ title = filters.LookupChoiceFilter(lookup_choices=LOOKUP_CHOICES) description = filters.LookupChoiceFilter(lookup_choices=LOOKUP_CHOICES) study = filters.ModelMultipleChoiceFilter(queryset=Study.objects.all()) exclude_study = filters.ModelMultipleChoiceFilter( field_name="study", exclude=True, queryset=Study.objects.all() ) class Meta: model = Procedure fields = ("id",)
class VideoFilter(djfilters.FilterSet): categories__name__icontains = djfilters.ModelMultipleChoiceFilter( field_name='categories__name', to_field_name='name', lookup_expr='icontains', queryset=Category.objects.all(), ) created_time = djfilters.DateTimeFromToRangeFilter() updated_time = djfilters.DateTimeFromToRangeFilter() uploaded_time = djfilters.DateTimeFromToRangeFilter() class Meta: model = Video fields = { 'duration': ['exact', 'gt', 'gte', 'lt', 'lte'], 'creator__email': ['exact'], 'framerate': ['exact'], 'has_tono_records': ['exact'], 'is_filler': ['exact'], 'name': ['exact', 'icontains'], 'organization': ['exact'], 'played_count_web': ['exact', 'gt', 'gte', 'lt', 'lte'], 'publish_on_web': ['exact'], 'ref_url': ['exact', 'startswith', 'icontains'], }
class DietaEspecialFilter(filters.FilterSet): aluno = filters.CharFilter(field_name='aluno__uuid', lookup_expr='iexact') nome_aluno = filters.CharFilter(field_name='aluno__nome', lookup_expr='icontains') nome_completo_aluno = filters.CharFilter(field_name='aluno__nome', lookup_expr='iexact') codigo_eol_aluno = filters.CharFilter(field_name='aluno__codigo_eol', lookup_expr='iexact') escola = filters.CharFilter(field_name='rastro_escola__uuid', lookup_expr='iexact') dre = filters.CharFilter( field_name='rastro_escola__diretoria_regional__uuid', lookup_expr='iexact') cpf_responsavel = filters.CharFilter(field_name='aluno__responsaveis__cpf', lookup_expr='iexact') ativo = filters.BooleanFilter(field_name='ativo') tipo_solicitacao = filters.CharFilter(field_name='tipo_solicitacao', lookup_expr='iexact') data_inicial = filters.DateFilter(field_name='criado_em', lookup_expr='date__gte') data_final = filters.DateFilter(field_name='criado_em', lookup_expr='date__lte') classificacao = filters.ModelMultipleChoiceFilter( field_name='classificacao__id', to_field_name='id', queryset=ClassificacaoDieta.objects.all()) status = filters.MultipleChoiceFilter( choices=[(str(state), state) for state in DietaEspecialWorkflow.states])
class AssociateFilter(filters.FilterSet): associate_name = filters.ModelMultipleChoiceFilter( queryset=Associate.objects.all(), field_name="associate__name", to_field_name="name", ) associate_id = filters.ModelMultipleChoiceFilter( queryset=Associate.objects.all(), field_name="associate__id", to_field_name="id", ) associate_slug = filters.ModelMultipleChoiceFilter( queryset=Associate.objects.all(), field_name="associate__slug", to_field_name="slug", )
class EventFilter(filters.FilterSet): start_after = filters.DateFilter(field_name="start", lookup_expr="gte") start_before = filters.DateFilter(field_name="start", lookup_expr="lte") end_after = filters.DateFilter(field_name="end", lookup_expr="gte") end_before = filters.DateFilter(field_name="end", lookup_expr="lte") tags = filters.ModelMultipleChoiceFilter( field_name="tags__name", to_field_name="name", queryset=Tag.objects.all(), conjoined=True, ) order_by = filters.OrderingFilter(fields=( "slug", "start", "end", ), ) class Meta: model = Event fields = ( "completed", "tags", "administrator", "host", "start", "start_before", "start_after", "end", "end_before", "end_after", "country", )
class ProductionFilter(filters.FilterSet): title = filters.CharFilter(lookup_expr='iexact') platform = filters.ModelMultipleChoiceFilter( field_name='platforms', queryset=Platform.objects.all()) released_before = filters.DateFilter(field_name='release_date_date', lookup_expr='lt', label="Released before") released_since = filters.DateFilter(field_name='release_date_date', lookup_expr='gte', label="Released since") added_before = filters.DateTimeFilter(field_name='created_at', lookup_expr='lt', label="Added before") added_since = filters.DateTimeFilter(field_name='created_at', lookup_expr='gte', label="Added since") updated_before = filters.DateTimeFilter(field_name='updated_at', lookup_expr='lt', label="Updated before") updated_since = filters.DateTimeFilter(field_name='updated_at', lookup_expr='gte', label="Updated since") author = filters.NumberFilter(method='filter_author', label="Author ID") def filter_author(self, queryset, name, value): return queryset.filter( Q(author_nicks__releaser_id=value) | Q(author_affiliation_nicks__releaser_id=value)) class Meta: model = Production fields = ['supertype']
class StelleListFilter(django_filters.FilterSet): legacy_id = django_filters.CharFilter( lookup_expr='icontains', help_text=Stelle._meta.get_field('legacy_id').help_text, label=Stelle._meta.get_field('legacy_id').verbose_name) text = django_filters.ModelMultipleChoiceFilter( queryset=Text.objects.all(), help_text=Stelle._meta.get_field('text').help_text, label=Stelle._meta.get_field('text').verbose_name, widget=autocomplete.Select2Multiple( url="archiv-ac:text-autocomplete", )) summary = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=Stelle._meta.get_field('summary').help_text, label=Stelle._meta.get_field('summary').verbose_name) zitat = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=Stelle._meta.get_field('zitat').help_text, label=Stelle._meta.get_field('zitat').verbose_name) translation = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=Stelle._meta.get_field('translation').help_text, label=Stelle._meta.get_field('translation').verbose_name) key_word = django_filters.ModelMultipleChoiceFilter( queryset=KeyWord.objects.all(), help_text=Stelle._meta.get_field('key_word').help_text, label=Stelle._meta.get_field('key_word').verbose_name, widget=autocomplete.Select2Multiple( url="archiv-ac:keyword-autocomplete", )) use_case = django_filters.ModelMultipleChoiceFilter( queryset=UseCase.objects.all(), help_text="Related UseCase", label="UseCase", widget=autocomplete.Select2Multiple( url="archiv-ac:usecase-autocomplete", )) kommentar = django_filters.LookupChoiceFilter( lookup_choices=CHAR_LOOKUP_CHOICES, help_text=Stelle._meta.get_field('kommentar').help_text, label=Stelle._meta.get_field('kommentar').verbose_name) class Meta: model = Stelle fields = [ 'id', 'legacy_id', 'legacy_pk', 'text', 'summary', 'zitat', 'translation', 'key_word', 'kommentar', 'use_case' ]
class DoctorFilter(filters.FilterSet): search = filters.CharFilter(field_name="name", lookup_expr='icontains') specialty = filters.ModelMultipleChoiceFilter( queryset=Specialty.objects.all()) class Meta: model = Doctor fields = ['search', 'specialty']