class ProductTypeFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Product type list filter label', 'Name'), lookup_expr='icontains') sort_by = OrderingFilter(label=pgettext_lazy( 'Product type list filter label', 'Sort by'), fields=PRODUCT_TYPE_SORT_BY_FIELDS.keys(), field_labels=PRODUCT_TYPE_SORT_BY_FIELDS) product_attributes = ModelMultipleChoiceFilter( label=pgettext_lazy('Product type list filter label', 'Product attributes'), name='product_attributes', queryset=ProductAttribute.objects.all()) variant_attributes = ModelMultipleChoiceFilter( label=pgettext_lazy('Product type list filter label', 'Variant attributes'), name='variant_attributes', queryset=ProductAttribute.objects.all()) class Meta: model = ProductType fields = ['name', 'product_attributes', 'variant_attributes'] def get_summary_message(self): counter = self.qs.count() return npgettext( 'Number of matching records in the dashboard product types list', 'Found %(counter)d matching product type', 'Found %(counter)d matching product types', number=counter) % { 'counter': counter }
class MonitoringResultTableFilter(FilterSet): q = CharFilter( method='search', label='Search', ) metadata = ModelMultipleChoiceFilter( queryset=Metadata.objects.filter( metadata_type=MetadataEnum.SERVICE.value), widget=autocomplete.ModelSelect2Multiple( url='resource:autocomplete_metadata_service')) monitoring_run = ModelMultipleChoiceFilter( queryset=MonitoringRun.objects.all(), widget=autocomplete.ModelSelect2Multiple( url='monitoring:autocomplete_monitoring_run')) monitoring_result = ModelMultipleChoiceFilter( label=_('Monitoring result'), queryset=MonitoringResult.objects.all(), widget=autocomplete.ModelSelect2Multiple( url='monitoring:autocomplete_monitoring_result')) class Meta: model = MonitoringResult fields = ['q', 'available'] def search(self, queryset, name, value): if not value.strip(): return queryset qs_filter = (Q(error_msg__icontains=value) | Q(monitored_uri__icontains=value)) return queryset.filter(qs_filter)
class ReportAuthedFindingFilter(DojoFilter): title = CharFilter(lookup_type='icontains', label='Name') test__engagement__product = ModelMultipleChoiceFilter( queryset=Product.objects.all(), label="Product") test__engagement__product__prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all(), label="Product Type") severity = MultipleChoiceFilter(choices=SEVERITY_CHOICES) active = ReportBooleanFilter() mitigated = MitigatedDateRangeFilter() verified = ReportBooleanFilter() false_p = ReportBooleanFilter(label="False Positive") test__engagement__risk_acceptance = ReportRiskAcceptanceFilter( label="Risk Accepted") duplicate = ReportBooleanFilter() out_of_scope = ReportBooleanFilter() def __init__(self, *args, **kwargs): self.user = None if 'user' in kwargs: self.user = kwargs.pop('user') super(ReportAuthedFindingFilter, self).__init__(*args, **kwargs) if not self.user.is_staff: self.form.fields[ 'test__engagement__product'].queryset = Product.objects.filter( authorized_users__in=[self.user]) class Meta: model = Finding exclude = [ 'date', 'cwe', 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'thread_id', 'notes', 'endpoints', 'numerical_severity', 'reporter', 'last_reviewed' ]
class ChallengeFilter(TitleDescriptionModalityStructureFilter): task_types = ModelMultipleChoiceFilter( queryset=TaskType.objects.all(), widget=Select2MultipleWidget, label="Task Type", ) series = ModelMultipleChoiceFilter( queryset=ChallengeSeries.objects.all(), widget=Select2MultipleWidget, label="Challenge Series", ) class Meta(TitleDescriptionModalityStructureFilter.Meta): model = Challenge fields = ( *TitleDescriptionModalityStructureFilter.Meta.fields, "series", "task_types", "educational", ) search_fields = ( *TitleDescriptionModalityStructureFilter.Meta.search_fields, "short_name", "event_name", )
class ReportFilter(FilterSet): center_point = MethodFilter(action='center_point') status_choices = ( ('', '---------'), ('fixed', 'Fixed'), ('not-fixed', 'Not fixed'), ('in-progress', 'In progress'), ) status = ChoiceFilter(choices=status_choices) from_date = DateTimeFilter(name='created_at', lookup_type='gte') to_date = DateTimeFilter(name='created_at', lookup_type='lte') from_date_unix = UnixTimeFilter(name='created_at', lookup_type='gte') to_date_unix = UnixTimeFilter(name='created_at', lookup_type='lte') order_by_field = 'order_by' city = ModelMultipleChoiceFilter(name='ward__city', queryset=City.objects.all(), widget=forms.CheckboxSelectMultiple()) ward = ModelMultipleChoiceFilter(queryset=Ward.objects.all(), widget=forms.CheckboxSelectMultiple()) class Meta: model = Report fields = [ 'ward', 'city', 'category', 'from_date', 'to_date', 'from_date_unix', 'to_date_unix' ] order_by = (('-created_at', _('Latest First')), ('created_at', _('Oldest First')))
class ProductTypeFilter(SortedFilterSet): name = CharFilter( label=pgettext_lazy("Product type list filter label", "Name"), lookup_expr="icontains", ) sort_by = OrderingFilter( label=pgettext_lazy("Product type list filter label", "Sort by"), fields=PRODUCT_TYPE_SORT_BY_FIELDS.keys(), field_labels=PRODUCT_TYPE_SORT_BY_FIELDS, ) product_attributes = ModelMultipleChoiceFilter( label=pgettext_lazy("Product type list filter label", "Product attributes"), field_name="product_attributes", queryset=Attribute.objects.all(), ) variant_attributes = ModelMultipleChoiceFilter( label=pgettext_lazy("Product type list filter label", "Variant attributes"), field_name="variant_attributes", queryset=Attribute.objects.all(), ) class Meta: model = ProductType fields = ["name", "product_attributes", "variant_attributes"] def get_summary_message(self): counter = self.qs.count() return npgettext( "Number of matching records in the tradingroom product types list", "Found %(counter)d matching product type", "Found %(counter)d matching product types", number=counter, ) % {"counter": counter}
class AcceptedFindingFilter(DojoFilter): title = CharFilter(lookup_expr='icontains') sourcefile = CharFilter(lookup_expr='icontains') sourcefilepath = CharFilter(lookup_expr='icontains') param = CharFilter(lookup_expr='icontains') payload = CharFilter(lookup_expr='icontains') test__engagement__risk_acceptance__created = \ DateRangeFilter(label="Acceptance Date") date = DateRangeFilter(label="Finding Date") cwe = MultipleChoiceFilter(choices=[]) severity = MultipleChoiceFilter(choices=[]) test__test_type = ModelMultipleChoiceFilter( queryset=Test_Type.objects.all()) test__engagement__product = ModelMultipleChoiceFilter( queryset=Product.objects.all(), label="Product") test__engagement__product__prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all(), label="Product Type") o = OrderingFilter( # tuple-mapping retains order fields=( ('numerical_severity', 'numerical_severity'), ('date', 'date'), ('test__engagement__risk_acceptance__created', 'test__engagement__risk_acceptance__created'), ('title', 'title'), ('test__engagement__product__name', 'test__engagement__product__name'), ), field_labels={ 'numerical_severity': 'Severity', 'date': 'Finding Date', 'test__engagement__risk_acceptance__created': 'Acceptance Date', 'title': 'Finding Name', 'test__engagement__product__name': 'Product Name', }) class Meta: model = Finding fields = ['title', 'test__engagement__risk_acceptance__created'] exclude = [ 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'active', 'verified', 'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'mitigated', 'notes', 'numerical_severity', 'reporter', 'endpoints', 'last_reviewed', 'o', 'jira_creation', 'jira_change' ] def __init__(self, *args, **kwargs): super(AcceptedFindingFilter, self).__init__(*args, **kwargs) cwe = dict() cwe = dict([finding.cwe, finding.cwe] for finding in self.queryset.distinct() if type(finding.cwe) is int and finding.cwe is not None and finding.cwe > 0 and finding.cwe not in cwe) cwe = collections.OrderedDict(sorted(cwe.items())) self.form.fields['cwe'].choices = list(cwe.items()) self.form.fields['severity'].choices = self.queryset.order_by( 'numerical_severity').values_list('severity', 'severity').distinct()
class BlogFilter(FilterSet): search = CharFilter(method="search_filter", label="Title or Content") tags = ModelMultipleChoiceFilter(queryset=Tag.objects.all(), widget=Select2MultipleWidget, label="Tags") authors = ModelMultipleChoiceFilter( queryset=get_user_model().objects.filter( blog_authors__isnull=False, blog_authors__published=True).distinct().order_by("username"), widget=Select2MultipleWidget, label="Authors", ) class Meta: model = Post form = FilterForm fields = ("search", "authors", "tags") search_fields = ("title", "content") def search_filter(self, queryset, name, value): return queryset.filter( reduce( or_, [ Q(**{f"{f}__icontains": value}) for f in self.Meta.search_fields ], Q(), ))
class OpenFindingFilter(DojoFilter): title = CharFilter(lookup_expr='icontains') duplicate = ReportBooleanFilter() sourcefile = CharFilter(lookup_expr='icontains') sourcefilepath = CharFilter(lookup_expr='icontains') param = CharFilter(lookup_expr='icontains') payload = CharFilter(lookup_expr='icontains') date = DateRangeFilter() last_reviewed = DateRangeFilter() cwe = MultipleChoiceFilter(choices=[]) severity = MultipleChoiceFilter(choices=[]) test__test_type = ModelMultipleChoiceFilter( queryset=Test_Type.objects.all()) test__engagement__product = ModelMultipleChoiceFilter( queryset=Product.objects.all(), label="Product") o = OrderingFilter( # tuple-mapping retains order fields=( ('numerical_severity', 'numerical_severity'), ('date', 'date'), ('last_reviewed', 'last_reviewed'), ('title', 'title'), ('test__engagement__product__name', 'test__engagement__product__name'), ), ) class Meta: model = Finding exclude = [ 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'active', 'verified', 'out_of_scope', 'false_p', 'thread_id', 'mitigated', 'notes', 'numerical_severity', 'reporter', 'last_reviewed' ] def __init__(self, *args, **kwargs): self.user = None if 'user' in kwargs: self.user = kwargs.pop('user') super(OpenFindingFilter, self).__init__(*args, **kwargs) cwe = dict() cwe = dict([finding.cwe, finding.cwe] for finding in self.queryset.distinct() if finding.cwe > 0 and finding.cwe not in cwe) cwe = collections.OrderedDict(sorted(cwe.items())) self.form.fields['cwe'].choices = cwe.items() sevs = dict() sevs = dict([finding.severity, finding.severity] for finding in self.queryset.distinct() if finding.severity not in sevs) self.form.fields['severity'].choices = sevs.items() if self.user is not None and not self.user.is_staff: self.form.fields[ 'test__engagement__product'].queryset = Product.objects.filter( authorized_users__in=[self.user]) self.form.fields['endpoints'].queryset = Endpoint.objects.filter( product__authorized_users__in=[self.user]).distinct()
class ImageFilterSet(FilterSet): archive = ModelMultipleChoiceFilter( queryset=Archive.objects.all(), widget=Select2MultipleWidget, label="Archive", help_text="Filter images that belong to an archive", field_name="componentinterfacevalue__archive_items__archive__pk", to_field_name="pk", ) job_input = ModelMultipleChoiceFilter( queryset=Job.objects.all(), widget=Select2MultipleWidget, label="Job Input", help_text="Filter images that are used as input to an algorithm job", field_name="componentinterfacevalue__algorithm_jobs_as_input__pk", to_field_name="pk", ) job_output = ModelMultipleChoiceFilter( queryset=Job.objects.all(), widget=Select2MultipleWidget, label="Job Output", help_text= "Filter images that are produced as output from an algorithm job", field_name="componentinterfacevalue__algorithm_jobs_as_output__pk", to_field_name="pk", ) reader_study = ModelMultipleChoiceFilter( queryset=ReaderStudy.objects.all(), widget=Select2MultipleWidget, label="Reader Study", help_text="Filter images that belong to a reader study", field_name="readerstudies__pk", to_field_name="pk", ) patient_id__isempty = EmptyStringFilter(field_name="patient_id") study_description__isempty = EmptyStringFilter( field_name="study_description") class Meta: model = Image fields = ( "origin", "job_input", "job_output", "archive", "reader_study", "name", "patient_id", "patient_name", "patient_birth_date", "patient_age", "patient_sex", "study_date", "study_instance_uid", "series_instance_uid", "study_description", "series_description", )
class ChallengeFilter(FilterSet): search = CharFilter(method="search_filter", label="Title or Description") modalities = ModelMultipleChoiceFilter( queryset=ImagingModality.objects.all(), widget=Select2MultipleWidget, label="Modality", ) task_types = ModelMultipleChoiceFilter( queryset=TaskType.objects.all(), widget=Select2MultipleWidget, label="Task Type", ) structures = ModelMultipleChoiceFilter( queryset=BodyStructure.objects.select_related("region").all(), widget=Select2MultipleWidget, label="Anatomical Structure", ) structures__region = ModelMultipleChoiceFilter( queryset=BodyRegion.objects.all(), widget=Select2MultipleWidget, label="Anatomical Region", ) series = ModelMultipleChoiceFilter( queryset=ChallengeSeries.objects.all(), widget=Select2MultipleWidget, label="Challenge Series", ) class Meta: model = Challenge fields = ( "search", "series", "task_types", "modalities", "structures", "structures__region", "educational", ) form = ChallengeFilterForm def search_filter(self, queryset, name, value): search_fields = [ "title", "short_name", "description", "event_name", ] return queryset.filter( reduce( or_, [Q(**{f"{f}__icontains": value}) for f in search_fields], Q(), ) )
class ClosedFindingFilter(DojoFilter): title = CharFilter(lookup_expr='icontains') mitigated = DateRangeFilter(label="Mitigated Date") cwe = MultipleChoiceFilter(choices=[]) severity = MultipleChoiceFilter(choices=[]) test__test_type = ModelMultipleChoiceFilter( queryset=Test_Type.objects.all()) test__engagement__product = ModelMultipleChoiceFilter( queryset=Product.objects.all(), label="Product") test__engagement__product__prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all(), label="Product Type") o = OrderingFilter( # tuple-mapping retains order fields=( ('numerical_severity', 'numerical_severity'), ('date', 'date'), ('mitigated', 'mitigated'), ('title', 'title'), ('test__engagement__product__name', 'test__engagement__product__name'), ), field_labels={ 'numerical_severity': 'Severity', 'date': 'Date', 'mitigated': 'Mitigated Date', 'title': 'Finding Name', 'test__engagement__product__name': 'Product Name', }) class Meta: model = Finding exclude = [ 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'active', 'verified', 'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'date', 'notes', 'numerical_severity', 'reporter', 'endpoints', 'last_reviewed' ] def __init__(self, *args, **kwargs): super(ClosedFindingFilter, self).__init__(*args, **kwargs) cwe = dict() cwe = dict([finding.cwe, finding.cwe] for finding in self.queryset.distinct() if finding.cwe > 0 and finding.cwe not in cwe) cwe = collections.OrderedDict(sorted(cwe.items())) self.form.fields['cwe'].choices = cwe.items() sevs = dict() sevs = dict([finding.severity, finding.severity] for finding in self.queryset.distinct() if finding.severity not in sevs) self.form.fields['severity'].choices = sevs.items()
class ProductFilter(FilterSet): price = RangeFilter() brand = ModelMultipleChoiceFilter(queryset=brands, widget=forms.CheckboxSelectMultiple) category = ModelMultipleChoiceFilter(queryset=categories, widget=forms.CheckboxSelectMultiple) class Meta: model = Product fields = [ 'brand', 'price', ]
class AcceptedFindingFilter(DojoFilter): title = CharFilter(lookup_type='icontains') test__engagement__risk_acceptance__created = \ DateRangeFilter(label="Acceptance Date") date = DateRangeFilter(label="Finding Date") cwe = MultipleChoiceFilter(choices=[]) severity = MultipleChoiceFilter(choices=[]) test__test_type = ModelMultipleChoiceFilter( queryset=Test_Type.objects.all()) test__engagement__product = ModelMultipleChoiceFilter( queryset=Product.objects.all(), label="Product") test__engagement__product__prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all(), label="Product Type") class Meta: model = Finding order_by = (('numerical_severity', 'Severity'), ('-numerical_severity', 'Severity Desc'), ('date', 'Finding Date Asc'), ('-date', 'Finding Date Desc'), ('test__engagement__risk_acceptance__created', 'Acceptance Date Asc'), ('-test__engagement__risk_acceptance__created', 'Acceptance Date Desc'), ('title', 'Finding Name'), ('-title', 'Finding Name Desc'), ('test__engagement__product__name', 'Product Name'), ('-test__engagement__product__name', 'Product Name Dec')) fields = ['title', 'test__engagement__risk_acceptance__created'] exclude = [ 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'active', 'verified', 'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'mitigated', 'notes', 'numerical_severity', 'reporter', 'endpoints', 'last_reviewed', 'o' ] def __init__(self, *args, **kwargs): super(AcceptedFindingFilter, self).__init__(*args, **kwargs) cwe = dict() cwe = dict([finding.cwe, finding.cwe] for finding in self.queryset.distinct() if finding.cwe > 0 and finding.cwe not in cwe) cwe = collections.OrderedDict(sorted(cwe.items())) self.form.fields['cwe'].choices = cwe.items() sevs = dict() sevs = dict([finding.severity, finding.severity] for finding in self.queryset.distinct() if finding.severity not in sevs) self.form.fields['severity'].choices = sevs.items()
class ProductFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Product list filter label', 'Name'), lookup_expr='icontains') category = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Product list filter label', 'Category'), name='category', queryset=Category.objects.all()) brand_id = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Product list filter label', 'Brand'), name='brand_id', queryset=Brand.objects.all()), product_type = ModelMultipleChoiceFilter( label=pgettext_lazy('Product list filter label', 'Product type'), name='product_type', queryset=ProductType.objects.all()) price = RangeFilter(label=pgettext_lazy('Product list filter label', 'Price'), name='price', widget=MoneyRangeWidget) is_published = ChoiceFilter( label=pgettext_lazy('Product list filter label', 'Is published'), choices=PUBLISHED_CHOICES, empty_label=pgettext_lazy('Filter empty choice label', 'All'), widget=forms.Select) is_featured = ChoiceFilter( label=pgettext_lazy('Product list is featured filter label', 'Is featured'), choices=FEATURED_CHOICES, empty_label=pgettext_lazy('Filter empty choice label', 'All'), widget=forms.Select) sort_by = OrderingFilter(label=pgettext_lazy('Product list filter label', 'Sort by'), fields=PRODUCT_SORT_BY_FIELDS.keys(), field_labels=PRODUCT_SORT_BY_FIELDS) class Meta: model = Product fields = ['brand_id', 'location_id'] def get_summary_message(self): counter = self.qs.count() return npgettext( 'Number of matching records in the dashboard products list', 'Found %(counter)d matching product', 'Found %(counter)d matching products', number=counter) % { 'counter': counter }
class ReportFilter(DojoFilter): name = CharFilter(lookup_type='icontains') type = MultipleChoiceFilter(choices=[]) format = MultipleChoiceFilter(choices=[]) requester = ModelMultipleChoiceFilter(queryset=Dojo_User.objects.all()) datetime = DateTimeFilter() status = MultipleChoiceFilter(choices=[]) class Meta: model = Report exclude = ['task_id', 'file'] order_by = (('-datetime', 'Date Desc'), ('datetime', 'Date Asc'), ('name', 'Name'), ('-name', 'Name Desc'), ('type', 'Type'), ('-type', 'Type Desc'), ('format', 'Format'), ('-format', 'Format Desc'), ('requester', 'Requester'), ('-requester', 'Requester Desc')) def __init__(self, *args, **kwargs): super(ReportFilter, self).__init__(*args, **kwargs) type = dict() type = dict([report.type, report.type] for report in self.queryset.distinct() if report.type is not None) type = collections.OrderedDict(sorted(type.items())) self.form.fields['type'].choices = type.items() status = dict() status = dict([report.status, report.status] for report in self.queryset.distinct() if report.status is not None) status = collections.OrderedDict(sorted(status.items())) self.form.fields['status'].choices = status.items()
class EngagementFilter(DojoFilter): engagement__lead = ModelChoiceFilter( queryset=User.objects.filter( engagement__lead__isnull=False).distinct(), label="Lead") name = CharFilter(lookup_expr='icontains') prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all().order_by('name'), label="Product Type") o = OrderingFilter( # tuple-mapping retains order fields=( ('name', 'name'), ('prod_type__name', 'prod_type__name'), ), field_labels={ 'name': 'Product Name', 'prod_type__name': 'Product Type', } ) class Meta: model = Product fields = ['name', 'prod_type']
class ImageFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Image list filter label', 'Name'), lookup_expr='icontains') category = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Gallery list filter label', 'Category'), name='category', queryset=Category.objects.all()) sort_by = OrderingFilter(label=pgettext_lazy('Image list filter label', 'Sort by'), fields=IMAGE_SORT_BY_FIELDS.keys(), field_labels=IMAGE_SORT_BY_FIELDS) class Meta: model = ImageData fields = [] def get_summary_message(self): counter = self.qs.count() return npgettext( 'Number of matching records in the dashboard ' 'image list', 'Found %(counter)d matching attribute', 'Found %(counter)d matching attributes', number=counter) % { 'counter': counter }
class SaleFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Sale list filter label', 'Name'), lookup_expr='icontains') categories = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Sale list filter label', 'Categories'), name='categories', queryset=Category.objects.all()) type = ChoiceFilter(label=pgettext_lazy('Sale list filter label', 'Discount type'), choices=DISCOUNT_TYPE_CHOICES, empty_label=pgettext_lazy('Filter empty choice label', 'All'), widget=forms.Select) value = RangeFilter(label=pgettext_lazy('Sale list filter label', 'Value')) sort_by = OrderingFilter(label=pgettext_lazy('Sale list filter label', 'Sort by'), fields=SORT_BY_FIELDS_SALE.keys(), field_labels=SORT_BY_FIELDS_SALE) class Meta: model = Sale fields = [] def get_summary_message(self): counter = self.qs.count() return npgettext( 'Number of matching records in the dashboard sales list', 'Found %(counter)d matching sale', 'Found %(counter)d matching sales', number=counter) % { 'counter': counter }
class EventFilter(FilterSet): # https://django-filter.readthedocs.io/en/latest/guide/usage.html#declaring-filters start = DateTimeFromToRangeFilter(field_name="occurrences__start") category = ModelMultipleChoiceFilter( field_name="categories__name", to_field_name="name", queryset=EventCategory.objects.all(), ) tag = ModelMultipleChoiceFilter(field_name="tags__name", to_field_name="name", queryset=Tag.objects.all()) class Meta: model = Event fields = ["occurrences__start", "category", "tag"]
class ProductFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Product list filter label', 'Name'), lookup_expr='icontains') categories = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Product list filter label', 'Categories'), name='categories', queryset=Category.objects.all()) price = RangeFilter(label=pgettext_lazy('Product list filter label', 'Price'), name='price', widget=PriceRangeWidget) is_published = ChoiceFilter( label=pgettext_lazy('Product list filter label', 'Is published'), choices=PUBLISHED_CHOICES, empty_label=pgettext_lazy('Filter empty choice label', 'All'), widget=forms.Select) is_featured = ChoiceFilter( label=pgettext_lazy('Product list is featured filter label', 'Is featured'), choices=FEATURED_CHOICES, empty_label=pgettext_lazy('Filter empty choice label', 'All'), widget=forms.Select) sort_by = OrderingFilter(label=pgettext_lazy('Product list filter label', 'Sort by'), fields=PRODUCT_SORT_BY_FIELDS.keys(), field_labels=PRODUCT_SORT_BY_FIELDS) class Meta: model = Product fields = []
class StaffFilter(SortedFilterSet): name_or_email = CharFilter(label=pgettext_lazy('Staff list filter label', 'Name or email'), method=filter_by_customer) location = CharFilter(label=pgettext_lazy('Staff list filter label', 'Location'), method=filter_by_location) groups = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Staff list filter label', 'Groups'), name='groups', queryset=Group.objects.all()) is_active = ChoiceFilter(label=pgettext_lazy('Staff list filter label', 'Is active'), choices=IS_ACTIVE_CHOICES, empty_label=pgettext_lazy( 'Filter empty choice label', 'All'), widget=forms.Select) sort_by = OrderingFilter(label=pgettext_lazy('Staff list filter label', 'Sort by'), fields=SORT_BY_FIELDS, field_labels=SORT_BY_FIELDS_LABELS) class Meta: model = User fields = []
class GroupFilter(SortedFilterSet): name = CharFilter(label=pgettext_lazy('Group list filter label', 'Name'), lookup_expr='icontains') permissions = ModelMultipleChoiceFilter(label=pgettext_lazy( 'Group list filter label', 'Permissions'), name='permissions', queryset=get_permissions()) sort_by = OrderingFilter(label=pgettext_lazy('Group list filter label', 'Sort by'), fields=SORT_BY_FIELDS.keys(), field_labels=SORT_BY_FIELDS) class Meta: model = Group fields = [] def get_summary_message(self): counter = self.qs.count() return npgettext( 'Number of matching records in the dashboard groups list', 'Found %(counter)d matching group', 'Found %(counter)d matching groups', number=counter) % { 'counter': counter }
class EndpointFilter(DojoFilter): product = ModelMultipleChoiceFilter( queryset=Product.objects.all().order_by('name'), label="Product") host = CharFilter(lookup_expr='icontains') path = CharFilter(lookup_expr='icontains') query = CharFilter(lookup_expr='icontains') fragment = CharFilter(lookup_expr='icontains') o = OrderingFilter( # tuple-mapping retains order fields=( ('product', 'product'), ('host', 'host'), ), ) def __init__(self, *args, **kwargs): self.user = None if 'user' in kwargs: self.user = kwargs.pop('user') super(EndpointFilter, self).__init__(*args, **kwargs) if self.user and not self.user.is_staff: self.form.fields['product'].queryset = Product.objects.filter( authorized_users__in=[self.user]).distinct().order_by('name') class Meta: model = Endpoint exclude = []
class ProductFilter(DojoFilter): name = CharFilter(lookup_expr='icontains', label="Product Name") prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all().order_by('name'), label="Product Type") o = OrderingFilter( # tuple-mapping retains order fields=( ('name', 'name'), ('prod_type__name', 'prod_type__name'), ), field_labels={ 'name': 'Product Name', 'prod_type__name': 'Product Type', }) # tags = CharFilter(lookup_expr='icontains', label="Tags") def __init__(self, *args, **kwargs): self.user = None if 'user' in kwargs: self.user = kwargs.pop('user') super(ProductFilter, self).__init__(*args, **kwargs) if self.user is not None and not self.user.is_staff: self.form.fields[ 'prod_type'].queryset = Product_Type.objects.filter( prod_type__authorized_users__in=[self.user]) class Meta: model = Product fields = ['name', 'prod_type'] exclude = ['tags']
class ProductFindingFilter(FilterSet): title = CharFilter(lookup_type='icontains') date = DateRangeFilter() cwe = MultipleChoiceFilter(choices=[]) severity = MultipleChoiceFilter(choices=[]) test__test_type = ModelMultipleChoiceFilter( queryset=Test_Type.objects.all()) class Meta: model = Finding order_by = ( ('numerical_severity', 'Severity'), ('test__engagement__risk_acceptance__created', 'Date'), ) exclude = [ 'url', 'description', 'mitigation', 'impact', 'endpoint', 'references', 'test', 'is_template', 'active', 'verified', 'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'mitigated', 'notes', 'numerical_severity', 'reporter' ] def __init__(self, *args, **kwargs): super(ProductFindingFilter, self).__init__(*args, **kwargs) cwe = dict() cwe = dict([finding.cwe, finding.cwe] for finding in self.queryset.distinct() if finding.cwe > 0 and finding.cwe not in cwe) cwe = collections.OrderedDict(sorted(cwe.items())) self.form.fields['cwe'].choices = cwe.items() sevs = dict() sevs = dict([finding.severity, finding.severity] for finding in self.queryset.distinct() if finding.severity not in sevs) self.form.fields['severity'].choices = sevs.items()
class MetricsFindingFilter(FilterSet): date = MetricsDateRangeFilter() test__engagement__product__prod_type = ModelMultipleChoiceFilter( queryset=Product_Type.objects.all().order_by('name'), label="Product Type") severity = MultipleChoiceFilter(choices=[]) status = FindingStatusFilter(label='Status') def __init__(self, *args, **kwargs): super(MetricsFindingFilter, self).__init__(*args, **kwargs) self.form.fields['severity'].choices = self.queryset.order_by('numerical_severity') \ .values_list('severity', 'severity').distinct() class Meta: model = Finding exclude = ['url', 'description', 'mitigation', 'unsaved_endpoints', 'unsaved_request', 'unsaved_response', 'unsaved_tags', 'references', 'review_requested_by', 'reviewers', 'defect_review_requested_by', 'thread_id', 'notes', 'last_reviewed_by', 'images', 'endpoints', 'is_template']
class TitleDescriptionModalityStructureFilter(FilterSet): search = CharFilter(method="search_filter", label="Title or Description") modalities = ModelMultipleChoiceFilter( queryset=ImagingModality.objects.all(), widget=Select2MultipleWidget, label="Modality", ) structures = ModelMultipleChoiceFilter( queryset=BodyStructure.objects.select_related("region").all(), widget=Select2MultipleWidget, label="Anatomical Structure", ) structures__region = ModelMultipleChoiceFilter( queryset=BodyRegion.objects.all(), widget=Select2MultipleWidget, label="Anatomical Region", ) organizations = ModelMultipleChoiceFilter( queryset=Organization.objects.all(), widget=Select2MultipleWidget, label="Organization", field_name="organizations__slug", to_field_name="slug", ) class Meta: fields = ( "search", "modalities", "structures", "structures__region", "organizations", ) form = FilterForm search_fields = ("title", "description") def search_filter(self, queryset, name, value): return queryset.filter( reduce( or_, [ Q(**{f"{f}__icontains": value}) for f in self.Meta.search_fields ], Q(), ) )
class ProductFilter(SortedFilterSet): name = CharFilter( label=pgettext_lazy("Product list filter label", "Name"), lookup_expr="icontains", ) category = ModelMultipleChoiceFilter( label=pgettext_lazy("Product list filter label", "Category"), field_name="category", queryset=Category.objects.all(), null_label="---------", ) product_type = ModelMultipleChoiceFilter( label=pgettext_lazy("Product list filter label", "Product type"), field_name="product_type", queryset=ProductType.objects.all(), ) price = RangeFilter( label=pgettext_lazy("Product list filter label", "Price"), field_name="price_amount", widget=MoneyRangeWidget, ) is_published = ChoiceFilter( label=pgettext_lazy("Product list filter label", "Is published"), choices=PUBLISHED_CHOICES, empty_label=pgettext_lazy("Filter empty choice label", "All"), widget=forms.Select, ) sort_by = OrderingFilter( label=pgettext_lazy("Product list filter label", "Sort by"), fields=PRODUCT_SORT_BY_FIELDS.keys(), field_labels=PRODUCT_SORT_BY_FIELDS, ) class Meta: model = Product fields = [] def get_summary_message(self): counter = self.qs.count() return npgettext( "Number of matching records in the dashboard products list", "Found %(counter)d matching product", "Found %(counter)d matching products", number=counter, ) % { "counter": counter }
class BenthicAttributeFilterSet(BaseAPIFilterSet): parent = NullableUUIDFilter(field_name='parent') life_history = NullableUUIDFilter(field_name='life_history') regions = ModelMultipleChoiceFilter(queryset=Region.objects.all()) class Meta: model = BenthicAttribute fields = ['parent', 'life_history', 'regions', ]