class BerthApplicationFilter(django_filters.FilterSet): switch_applications = django_filters.BooleanFilter( field_name="berth_switch", method="filter_berth_switch") no_customer = django_filters.BooleanFilter(field_name="customer", lookup_expr="isnull") application_code = django_filters.BooleanFilter( field_name="application_code", method="filter_application_code") order_by = django_filters.OrderingFilter( fields=("created_at", ), label="Supports only `createdAt` and `-createdAt`.", ) name = django_filters.CharFilter(method="filter_name") def filter_name(self, qs, name, value): for part in value.split(): qs = qs.filter( Q(first_name__icontains=part) | Q(last_name__icontains=part)) return qs def filter_berth_switch(self, queryset, name, value): lookup = "__".join([name, "isnull"]) return queryset.filter(**{lookup: not value}) def filter_application_code(self, queryset, name, value): lookup = "__".join([name, "exact"]) return (queryset.exclude(**{lookup: ""}) if value else queryset.filter( **{lookup: ""}))
class ItemTypeFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('created_at', 'created_at'), ('category', 'category'), ('text', 'text'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) # def user_filtering(self, queryset, name, value): # return queryset.filter( # Q(user__slug=value) # ) # # user = django_filters.CharFilter(method='user_filtering') class Meta: model = ItemType fields = ['is_archived', 'category', 'slug']
class ProductFilter(django_filters.FilterSet): name = django_filters.CharFilter(method='filter_by_name') min_price = django_filters.CharFilter(method='filter_from_min_price', label='min_price') max_price = django_filters.CharFilter(method='filter_until_max_price', label='max_price') description = django_filters.CharFilter(method='filter_by_description') ordering = django_filters.OrderingFilter( fields={ 'name': 'name', 'price': 'price' } ) class Meta: model = Product fields = ('name', 'description') def filter_by_name(self, queryset, name, value): return queryset.get_products_by_name(value) def filter_by_description(self, queryset, name, value): return queryset.get_products_by_description(value) def filter_from_min_price(self, queryset, name, value): return queryset.get_products_price_more_than(value) def filter_until_max_price(self, queryset, name, value): return queryset.get_products_price_less_than(value)
class InsuranceRequirementFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('id', 'id'), ('text', 'text'), ('description', 'description'), ('is_archived', 'is_archived'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) class Meta: model = InsuranceRequirement fields = [ # 'id', # 'title', # 'is_closed', # 'type_of', 'is_archived', ]
class BadgeAwardsFilter(AMYFilterSet): awarded_after = django_filters.DateFilter(field_name='awarded', lookup_expr='gte') awarded_before = django_filters.DateFilter(field_name='awarded', lookup_expr='lte') event = django_filters.ModelChoiceFilter( queryset=Event.objects.all(), label='Event', widget=ModelSelect2Widget( data_view='event-lookup', attrs=SELECT2_SIDEBAR, ), ) order_by = django_filters.OrderingFilter(fields=( 'awarded', 'person__family', ), field_labels={ 'awarded': 'Awarded date', 'person__family': 'Person', }) class Meta: model = Award fields = ( 'awarded_after', 'awarded_before', 'event', )
class HowHearAboutUsItemFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('sort_number', 'sort_number'), ('text', 'text'), ('is_for_associate', 'is_for_associate'), ('is_for_customer', 'is_for_customer'), ('is_for_staff', 'is_for_staff'), ('is_for_partner', 'is_for_partner'), ('is_archived', 'is_archived'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) class Meta: model = HowHearAboutUsItem fields = [ # 'id', # 'title', # 'is_closed', # 'type_of', 'is_archived', ]
class TeamEventFilterSet(django_filters.FilterSet): year = django_filters.NumberFilter(method='get_year', field_name='year') event = django_filters.CharFilter(method='get_event', field_name='event') team = django_filters.NumberFilter(method='get_team', field_name='team') o = django_filters.OrderingFilter(fields=( ('time', 'time'), ('team', 'team'), ('year', 'year'), ), ) def get_year(self, queryset, field_name, value): if value: return queryset.filter(year=value) return queryset def get_event(self, queryset, field_name, value): if value: return queryset.filter(event=value) return queryset def get_team(self, queryset, field_name, value): if value: return queryset.filter(team=value) return queryset class Meta: model = TeamEvent fields = ['year', 'event', 'team']
class PlaybookFilter(DateFilter): ansible_version = django_filters.CharFilter(field_name="ansible_version", lookup_expr="icontains") controller = django_filters.CharFilter(field_name="controller", lookup_expr="icontains") name = django_filters.CharFilter(field_name="name", lookup_expr="icontains") path = django_filters.CharFilter(field_name="path", lookup_expr="icontains") status = django_filters.MultipleChoiceFilter( field_name="status", choices=ara_models.Playbook.STATUS, lookup_expr="iexact") label = django_filters.CharFilter(field_name="labels", lookup_expr="name__iexact") # fmt: off order = django_filters.OrderingFilter(fields=( ("id", "id"), ("created", "created"), ("updated", "updated"), ("started", "started"), ("ended", "ended"), ("duration", "duration"), ))
class TeamFilterSet(django_filters.FilterSet): team = django_filters.NumberFilter(method=get_team, field_name="team") active = django_filters.NumberFilter(method=get_active, field_name="active") state = django_filters.CharFilter(method=get_state, field_name="state") country = django_filters.CharFilter(method=get_country, field_name="country") district = django_filters.CharFilter(method=get_district, field_name="district") o = django_filters.OrderingFilter(fields=( ("team", "team"), ("elo", "elo"), ("elo_recent", "elo_recent"), ("elo_mean", "elo_mean"), ("elo_max", "elo_max"), ("wins", "wins"), ("losses", "losses"), ("ties", "ties"), ("winrate", "winrate"), )) class Meta: model = Team fields = ["team", "active", "state", "country", "district"]
class TaskFilter(DateFilter): playbook = django_filters.NumberFilter(field_name="playbook__id", lookup_expr="exact") status = django_filters.MultipleChoiceFilter( field_name="status", choices=ara_models.Task.STATUS, lookup_expr="iexact") name = django_filters.CharFilter(field_name="name", lookup_expr="icontains") action = django_filters.CharFilter(field_name="action", lookup_expr="iexact") path = django_filters.CharFilter(field_name="file__path", lookup_expr="icontains") handler = django_filters.BooleanFilter(field_name="handler", lookup_expr="exact") # fmt: off order = django_filters.OrderingFilter(fields=( ("id", "id"), ("created", "created"), ("updated", "updated"), ("started", "started"), ("ended", "ended"), ("duration", "duration"), ))
class ResultFilter(DateFilter): playbook = django_filters.NumberFilter(field_name="playbook__id", lookup_expr="exact") task = django_filters.NumberFilter(field_name="task__id", lookup_expr="exact") play = django_filters.NumberFilter(field_name="play__id", lookup_expr="exact") host = django_filters.NumberFilter(field_name="host__id", lookup_expr="exact") changed = django_filters.BooleanFilter(field_name="changed", lookup_expr="exact") status = django_filters.MultipleChoiceFilter( field_name="status", choices=ara_models.Result.STATUS, lookup_expr="iexact") ignore_errors = django_filters.BooleanFilter(field_name="ignore_errors", lookup_expr="exact") # fmt: off order = django_filters.OrderingFilter(fields=( ("id", "id"), ("created", "created"), ("updated", "updated"), ("started", "started"), ("ended", "ended"), ("duration", "duration"), ))
class AwayLogFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('id', 'id'), ('associate__indexed_text', 'associate_name'), ('created', 'created'), ('last_modified', 'last_modified'), ('was_deleted', 'was_deleted'), ('start_date', 'start_date'), ('until_date', 'until_date'), ('until_further_notice', 'until_further_notice'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) class Meta: model = AwayLog fields = [ 'id', 'associate', 'associate_id', 'associates', 'created', 'created_by', 'created_by_id', 'last_modified', 'last_modified_by', 'last_modified_by_id', 'reason', 'reason_other', 'start_date', 'until_date', 'until_further_notice', 'was_deleted' ]
class WatchCommentFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('id', 'id'), ('comment__text', 'text'), ('watch', 'watch'), ('created_at', 'created_at'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) def watch_filtering(self, queryset, name, value): return queryset.filter(watch__slug=value) # return queryset.filter( # Q(contact__last_name__icontains=value) | # Q(contact__last_name__istartswith=value) | # Q(contact__last_name__iendswith=value) | # Q(contact__last_name__exact=value) | # Q(contact__last_name__icontains=value) # ) watch = django_filters.CharFilter(method='watch_filtering') class Meta: model = WatchComment fields = [ 'watch', 'created_at', ]
class AdvertFilterSet(df.FilterSet): """Filters for Advert object""" user = df.NumberFilter(field_name='user__id') title = df.CharFilter(field_name='title', lookup_expr='icontains') category = df.NumberFilter(field_name='category__id', method='category_filter') price__gte = df.NumberFilter(field_name='price', lookup_expr='gte') price__lte = df.NumberFilter(field_name='price', lookup_expr='lte') location = df.NumberFilter(field_name='location__id') ordering = df.OrderingFilter(fields=(('price', 'price'), ('date_refreshed', 'date'))) def category_filter(self, queryset, name, value): """Category filter to include child categories in results""" criteria = \ Q(category__id=value) | \ Q(category__parent__id=value) | \ Q(category__parent__parent__id=value) | \ Q(category__parent__parent__parent__id=value) # query = queryset.filter(criteria).query return queryset.filter(criteria)
class PartnerFilter(django_filters.FilterSet): text_search = django_filters.CharFilter(method='my_text_search', label="Arama", widget=forms.TextInput(attrs={'placeholder': 'Ara...', 'class': ' form-control custom-shadow custom-radius bg-white'})) sort = django_filters.OrderingFilter( fields=( ('first_name', 'first_name'), ), field_labels={ 'first_name': 'Ada Göre', '-first_name': 'Ada Göre (azalan)', }, ) class Meta: model = Partner fields = ['text_search',"sort"] def __init__(self,data=None, queryset=None, *, request=None, prefix=None): super(PartnerFilter, self).__init__(data=data, queryset=queryset, request=request, prefix=prefix) self.filters['text_search'].field.widget.attrs.update({'class': ' form-control'}) self.filters['sort'].field.widget.attrs.update({'class': ' custom-select custom-select-set form-control bg-white custom-shadow custom-radius'}) self.filters["sort"].field.empty_label = "Sırala" def my_text_search(self, queryset, name, value): return Partner.objects.filter( Q(first_name__icontains=value) | Q(last_name__icontains=value) | Q(email__icontains=value) | Q(phone__icontains=value) | Q(city__name__icontains=value) | Q(district__name__icontains=value) | Q(description__icontains=value) )
class OfferingUserFilter(OfferingFilterMixin, django_filters.FilterSet): user_uuid = django_filters.UUIDFilter(field_name='user__uuid') o = django_filters.OrderingFilter(fields=('created', )) class Meta: model = models.OfferingUser fields = []
class JournalIssueFilter(django_filters.FilterSet): journalissue_title_text = django_filters.CharFilter(label=FieldJournalIssue.TITLE, lookup_expr='icontains', widget=forms.TextInput(attrs={'class': 'list__form--input'})) journalissue_publisher = django_filters.ModelChoiceFilter(label=FieldJournalIssue.PUBLISHERS, queryset=Institution.objects.all(), widget=autocomplete.ModelSelect2(url='institution-autocomplete')) journalissue_category = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.CATEGORY, queryset=PublicationCategory.objects.all(), widget=autocomplete.ModelSelect2Multiple(url='publicationcategory-autocomplete')) journalissue_journal = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.JOURNAL, queryset=Journal.objects.all(), widget=autocomplete.ModelSelect2Multiple(url='journal-autocomplete')) journalissue_publication_date = django_filters.DateFilter(label=FieldJournalIssue.PUBLICATION_DATE, lookup_expr='exact', widget=forms.DateTimeInput(attrs={'class': 'datepicker list__form--input'})) journalissue_keywords = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.KEYWORDS, queryset=Tag.objects.all(), widget=autocomplete.ModelSelect2Multiple(url='tag-autocomplete')) journalissue_is_accepted = django_filters.BooleanFilter(label=FieldJournalIssue.IS_ACCEPTED, widget=NullBooleanSelect(attrs={'class': 'select2'})) o = django_filters.OrderingFilter( fields=( ('journalissue_is_promoted', 'journalissue_is_promoted'), ('journalissue_date_add', 'journalissue_date_add'), ('journalissue_title_text', 'journalissue_title_text'), ), ) strict = True class Meta: model = JournalIssue form = JournalIssueFilterForm fields = ['journalissue_title_text', 'journalissue_publisher', 'journalissue_category', 'journalissue_publication_date', 'journalissue_keywords', 'journalissue_is_accepted']
class HostFilter(BaseFilter): playbook = django_filters.NumberFilter(field_name="playbook__id", lookup_expr="exact") name = django_filters.CharFilter(field_name="name", lookup_expr="icontains") # For example: /api/v1/hosts/failed__gt=0 to return hosts with 1 failure or more changed__gt = django_filters.NumberFilter(field_name="changed", lookup_expr="gt") changed__lt = django_filters.NumberFilter(field_name="changed", lookup_expr="lt") failed__gt = django_filters.NumberFilter(field_name="failed", lookup_expr="gt") failed__lt = django_filters.NumberFilter(field_name="failed", lookup_expr="lt") ok__gt = django_filters.NumberFilter(field_name="ok", lookup_expr="gt") ok__lt = django_filters.NumberFilter(field_name="ok", lookup_expr="lt") skipped__gt = django_filters.NumberFilter(field_name="skipped", lookup_expr="gt") skipped__lt = django_filters.NumberFilter(field_name="skipped", lookup_expr="lt") unreachable__gt = django_filters.NumberFilter(field_name="unreachable", lookup_expr="gt") unreachable__lt = django_filters.NumberFilter(field_name="unreachable", lookup_expr="lt") # fmt: off order = django_filters.OrderingFilter( fields=( ("id", "id"), ("created", "created"), ("updated", "updated"), ("name", "name"), ("changed", "changed"), ("failed", "failed"), ("ok", "ok"), ("skipped", "skipped"), ("unreachable", "unreachable"), ) )
class EventFilterSet(django_filters.FilterSet): event = django_filters.CharFilter(method='get_event', field_name='event') year = django_filters.NumberFilter(method='get_year', field_name='year') o = django_filters.OrderingFilter(fields=( ('year', 'year'), ('elo_max', 'elo_max'), ('elo_top8', 'elo_top8'), ('elo_top24', 'elo_top24'), ('elo_mean', 'elo_mean'), ), ) def get_event(self, queryset, field_name, value): if value: return queryset.filter(event=value) return queryset def get_year(self, queryset, field_name, value): if value: return queryset.filter(year=value) return queryset class Meta: model = Event fields = ['event', 'year']
class DistinctHostFilter(BaseFilter): playbook = django_filters.NumberFilter(field_name="latest__playbook__id", lookup_expr="exact") name = django_filters.CharFilter(field_name="latest__name", lookup_expr="icontains") changed__gt = django_filters.NumberFilter(field_name="latest__changed", lookup_expr="gt") changed__lt = django_filters.NumberFilter(field_name="latest__changed", lookup_expr="lt") failed__gt = django_filters.NumberFilter(field_name="latest__failed", lookup_expr="gt") failed__lt = django_filters.NumberFilter(field_name="latest__failed", lookup_expr="lt") ok__gt = django_filters.NumberFilter(field_name="latest__ok", lookup_expr="gt") ok__lt = django_filters.NumberFilter(field_name="latest__ok", lookup_expr="lt") skipped__gt = django_filters.NumberFilter(field_name="latest__skipped", lookup_expr="gt") skipped__lt = django_filters.NumberFilter(field_name="latest__skipped", lookup_expr="lt") unreachable__gt = django_filters.NumberFilter(field_name="latest__unreachable", lookup_expr="gt") unreachable__lt = django_filters.NumberFilter(field_name="latest__unreachable", lookup_expr="lt") # fmt: off order = django_filters.OrderingFilter( fields=( ("id", "id"), ("created", "created"), ("updated", "updated"), ("name", "name"), ("changed", "changed"), ("failed", "failed"), ("ok", "ok"), ("skipped", "skipped"), ("unreachable", "unreachable"), ) )
class AwardFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('created_at', 'created_at'), ('type_of', 'type_of'), ('user', 'user'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) def user_filtering(self, queryset, name, value): return queryset.filter(Q(user__slug=value)) user = django_filters.CharFilter(method='user_filtering') class Meta: model = Award fields = [ 'user', 'is_archived', 'type_of', ]
class UserFilter(django_filters.FilterSet): full_name = django_filters.CharFilter(lookup_expr='icontains') username = django_filters.CharFilter() native_name = django_filters.CharFilter(lookup_expr='icontains') job_title = django_filters.CharFilter(lookup_expr='icontains') email = django_filters.CharFilter(lookup_expr='icontains') is_active = django_filters.BooleanFilter() o = django_filters.OrderingFilter( fields=('full_name', 'native_name', 'organization', 'organization_approved', 'email', 'phone_number', 'description', 'job_title', 'username', 'is_active', 'registration_method')) class Meta(object): model = User fields = [ 'full_name', 'native_name', 'organization', 'organization_approved', 'email', 'phone_number', 'description', 'job_title', 'username', 'civil_number', 'is_active', 'registration_method', ]
class TaskFilter(AMYFilterSet): event = django_filters.ModelChoiceFilter( queryset=Event.objects.all(), label='Event', widget=ModelSelect2Widget( data_view='event-lookup', attrs=SELECT2_SIDEBAR, ), ) order_by = django_filters.OrderingFilter(fields=( ('event__slug', 'event'), ('person__family', 'person'), ('role', 'role'), ), field_labels={ 'event__slug': 'Event', 'person__family': 'Person', 'role': 'Role', }) class Meta: model = Task fields = [ 'event', # can't filter on person because person's name contains 3 fields: # person.personal, person.middle, person.family # 'person', 'role', ]
class UserPermissionFilter(django_filters.FilterSet): user = django_filters.UUIDFilter(name='user__uuid') user_url = core_filters.URLFilter( view_name='user-detail', name='user__uuid', ) username = django_filters.CharFilter( name='user__username', lookup_expr='exact', ) full_name = django_filters.CharFilter( name='user__full_name', lookup_expr='icontains', ) native_name = django_filters.CharFilter( name='user__native_name', lookup_expr='icontains', ) o = django_filters.OrderingFilter(fields=( ('user__username', 'username'), ('user__full_name', 'full_name'), ('user__native_name', 'native_name'), ('user__email', 'email'), ('expiration_time', 'expiration_time'), ('created', 'created'), ('role', 'role'), ))
class UserCaseFilter(CrispyFilterMixin, CaseFilterMixin, django_filters.FilterSet): def __init__(self, *args, **kwargs): kwargs["queryset"] = kwargs.pop("queryset").order_by( "-%s" % (Case.USER_ORDER_DEFAULT_FIELD) ) super().__init__(*args, **kwargs) name = django_filters.CharFilter(label=_("Subject"), lookup_expr="icontains") created_on = django_filters.DateRangeFilter(label=_("Created on")) last_send = django_filters.DateRangeFilter(label=_("Last send")) o = django_filters.OrderingFilter( fields=["last_send", "pk", "created_on"], help_text=None, initial="last_send", field_labels={ "last_send": _("Last send"), "pk": _("ID"), "created_on": _("Created on"), }, ) class Meta: model = Case fields = ["name", "created_on", "last_send"] order_by_field = "last_send"
class EventRequestFilter(AMYFilterSet): assigned_to = ForeignKeyAllValuesFilter(Person) country = AllCountriesFilter() active = django_filters.ChoiceFilter( choices=(('all', 'All'), ('true', 'Open'), ('false', 'Closed')), label='Status', method=filter_active_eventrequest, widget=widgets.RadioSelect, ) workshop_type = django_filters.ChoiceFilter( choices=(('', 'All'), ('swc', 'Software-Carpentry'), ('dc', 'Data-Carpentry')), label='Workshop type', widget=widgets.RadioSelect, ) order_by = django_filters.OrderingFilter(fields=('created_at', ), ) class Meta: model = EventRequest fields = [ 'assigned_to', 'workshop_type', 'active', 'country', ]
class TaskItemFilter(django_filters.FilterSet): id = django_filters.AllValuesMultipleFilter( name="id", label="ID", ) title = django_filters.AllValuesMultipleFilter( name="title", label="Title", ) o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('due_date', 'due_date'), ('title', 'title'), ('type_of', 'type_of'), ('job__customer__indexed_text', 'customer_name'), ('job__associate__indexed_text', 'associate_name'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) class Meta: model = TaskItem fields = [ 'id', 'title', 'is_closed', 'type_of', ]
class MembershipFilter(AMYFilterSet): organization_name = django_filters.CharFilter( label='Organization name', field_name='organization__fullname', lookup_expr='icontains', ) MEMBERSHIP_CHOICES = (('', 'Any'), ) + Membership.MEMBERSHIP_CHOICES variant = django_filters.ChoiceFilter(choices=MEMBERSHIP_CHOICES) CONTRIBUTION_CHOICES = (('', 'Any'), ) + Membership.CONTRIBUTION_CHOICES contribution_type = django_filters.ChoiceFilter( choices=CONTRIBUTION_CHOICES) order_by = django_filters.OrderingFilter(fields=( 'organization__fullname', 'organization__domain', 'agreement_start', 'agreement_end', ), ) class Meta: model = Membership fields = [ 'organization_name', 'variant', 'contribution_type', ]
class WorkOrderFilter(django_filters.FilterSet): o = django_filters.OrderingFilter( # tuple-mapping retains order fields=( ('id', 'id'), ('customer__indexed_text', 'customer_name'), ('associate__indexed_text', 'associate_name'), ('customer__type_of', 'type_of'), ('assignment_date', 'assignment_date'), ('start_date', 'start_date'), ('completion_date', 'completion_date'), ('state', 'state'), ), # # labels do not need to retain order # field_labels={ # 'username': '******', # } ) class Meta: model = WorkOrder fields = [ 'customer', 'state', ]
class TestFilter(filters.FilterSet): is_passed = filters.BooleanFilter(field_name='results', label='Is passed', method='filter_passed') name = filters.CharFilter(field_name='name', label='Search by name', method='search_by_name') ordering = filters.OrderingFilter(fields=(('created', 'created'), ), field_labels={ 'created': 'Date Created', }) def search_by_name(self, queryset, name, value): lookup = '__'.join([name, 'icontains']) return queryset.filter(**{lookup: value}) def filter_passed(self, queryset, name, value): user = getattr(self.request, 'user', None) if user: if value is not None: lookup = '__'.join([name, 'user', 'exact']) if value: return queryset.filter(**{lookup: user}) else: return queryset.filter(~Q(**{lookup: user})) return queryset class Meta: model = Test fields = ['is_passed', 'name']