class FaultFilter(filters.FilterSet):
fault_type = filters.RelatedFilter(
FaultTypeFilter,
field_name="fault_type",
queryset=models.FaultType.objects.all(),
)
unit = filters.RelatedFilter(UnitFilter,
field_name='unit',
queryset=Unit.objects.all())
modality = filters.RelatedFilter(
ModalityFilter,
field_name='modality',
queryset=Modality.objects.all(),
)
occurred_min = MinDateFilter(field_name="occurred")
occurred_max = MaxDateFilter(field_name="occurred")
class Meta:
model = models.Fault
fields = {
"occurred": ['exact', "in"],
"created": ['exact', "in"],
"modified": ['exact', "in"],
}
class OrdenadorFilter(filters.FilterSet):
equipo = filters.RelatedFilter(EquipoFilter,
field_name="idordenador",
queryset=models.Equipo.objects.all())
Oss = filters.RelatedFilter(OsFilter,
field_name="os_idos",
queryset=models.Os.objects.all())
class Meta:
model = models.Ordenador
fields = {
'idequipo': ['exact', 'in', 'startswith', 'contains'],
'marca': ['exact', 'in', 'startswith', 'contains'],
'modelo': ['exact', 'in', 'startswith', 'contains'],
'nro_serie': ['exact', 'in', 'startswith', 'contains'],
'nro_activo_fijo': ['exact', 'in', 'startswith', 'contains'],
'ip': ['exact', 'in', 'startswith', 'contains'],
'tipo': ['exact', 'in', 'startswith', 'contains'],
'mac': ['exact', 'in', 'startswith', 'contains'],
'hostname': ['exact', 'in', 'startswith', 'contains'],
'procesador': ['exact', 'in', 'startswith', 'contains'],
'ram': ['exact', 'in', 'startswith', 'contains'],
'almacenamiento': ['exact', 'in', 'startswith', 'contains'],
'tipo_almacenamiento': ['exact', 'in', 'startswith', 'contains'],
}
class RECAPDocumentFilter(FilterSet):
docket_entry = filters.RelatedFilter(
DocketEntryFilter,
queryset=DocketEntry.objects.all(),
)
tags = filters.RelatedFilter(
TagFilter,
queryset=Tag.objects.all(),
)
class Meta:
model = RECAPDocument
fields = {
"id": ["exact"],
"date_created": DATETIME_LOOKUPS,
"date_modified": DATETIME_LOOKUPS,
"date_upload": DATETIME_LOOKUPS,
"document_type": ["exact"],
"document_number": ["exact", "gte", "gt", "lte", "lt"],
# Parameter required in view.
"pacer_doc_id": ["exact", "in"],
"is_available": ["exact"],
"sha1": ["exact"],
"ocr_status": INTEGER_LOOKUPS,
"is_free_on_pacer": ["exact"],
}
class CatalogEntryFilter(filters.FilterSet):
op_status = filters.RelatedFilter(OperationalStatusFilter,
name='operational_status',
queryset=OperationalStatus.objects.all())
orbital_status = filters.RelatedFilter(
OrbitalStatusFilter,
name='orbital_status',
queryset=OrbitalStatus.objects.all())
launch_site = filters.RelatedFilter(LaunchSiteFilter,
name='launch_site',
queryset=LaunchSite.objects.all())
owner = filters.RelatedFilter(SourceFilter,
name='owner',
queryset=Source.objects.all())
class Meta:
model = CatalogEntry
fields = {
'international_designator': ['exact', 'in', 'startswith'],
'norad_catalog_number': ['exact', 'in', 'startswith'],
'names': ['exact', 'in', 'startswith'],
}
class PartFilter(filters.FilterSet):
part_category = filters.RelatedFilter(
PartCategoryFilter,
field_name="part_category",
queryset=models.PartCategory.objects.all(),
)
suppliers = filters.RelatedFilter(SupplierFilter,
field_name="suppliers",
queryset=models.Supplier.objects.all())
storage = filters.RelatedFilter(StorageFilter,
field_name="storage",
queryset=models.Storage.objects.all())
class Meta:
model = models.Part
fields = {
"part_number": "__all__",
"alt_part_number": "__all__",
"name": "__all__",
"quantity_min": "__all__",
"quantity_current": "__all__",
"cost": "__all__",
"notes": "__all__",
"is_obsolete": "__all__",
}
class OrganizationFilter(filters.FilterSet):
bureau_organization = filters.RelatedFilter(
'talentmap_api.organization.filters.OrganizationFilter',
name='bureau_organization',
queryset=Organization.objects.all())
parent_organization = filters.RelatedFilter(
'talentmap_api.organization.filters.OrganizationFilter',
name='parent_organization',
queryset=Organization.objects.all())
location = filters.RelatedFilter(
'talentmap_api.organization.filters.LocationFilter',
name='location',
queryset=Location.objects.all())
# Name here must be a valid field, but it is ignored when overriden by the method parameter
is_available = filters.BooleanFilter(
name="bureau_positions",
method=multi_field_filter(
fields=["bureau_positions", "organization_positions"],
lookup_expr="isnull",
exclude=True))
class Meta:
model = Organization
fields = {
"code": ALL_TEXT_LOOKUPS,
"long_description": ALL_TEXT_LOOKUPS,
"short_description": ALL_TEXT_LOOKUPS,
"is_bureau": ['exact'],
"is_regional": ['exact'],
"bureau_organization": FOREIGN_KEY_LOOKUPS,
"parent_organization": FOREIGN_KEY_LOOKUPS,
"location": FOREIGN_KEY_LOOKUPS
}
class DelayedReportFilter(filters.FilterSet):
build = filters.RelatedFilter(BuildFilter,
name="build",
queryset=Build.objects.all(),
widget=forms.TextInput)
baseline = filters.RelatedFilter(BuildFilter,
name="baseline",
queryset=Build.objects.all(),
widget=forms.TextInput)
class Meta:
model = DelayedReport
fields = {
"output_format":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"template": ['exact', 'in'],
"email_recipient":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"email_recipient_notified": ['exact'],
"callback": ['exact', 'in', 'startswith', 'contains', 'icontains'],
"callback_notified": ['exact'],
"data_retention_days": ['exact', 'in'],
"output_text":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"output_html":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"error_message":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"status_code": ['exact', 'in'],
"created_at": ['exact', 'gt', 'lt'],
}
class StoreFilterSet(drf_filters.FilterSet):
vendor = drf_filters.RelatedFilter(VendorFilterSet)
purchasebill = drf_filters.RelatedFilter(PurchaseBillFilterSet)
sellbill = drf_filters.RelatedFilter(SellBillFilterSet)
class Meta:
model = Store
class OpinionClusterFilter(FilterSet):
docket = filters.RelatedFilter(DocketFilter, queryset=Docket.objects.all())
panel = filters.RelatedFilter(
"cl.people_db.filters.PersonFilter", queryset=Person.objects.all()
)
non_participating_judges = filters.RelatedFilter(
"cl.people_db.filters.PersonFilter", queryset=Person.objects.all()
)
sub_opinions = filters.RelatedFilter(
OpinionFilter, queryset=Opinion.objects.all()
)
source = filters.MultipleChoiceFilter(choices=SOURCES)
citations = filters.RelatedFilter(
CitationFilter, queryset=Citation.objects.all()
)
class Meta:
model = OpinionCluster
fields = {
"id": ["exact"],
"date_created": DATETIME_LOOKUPS,
"date_modified": DATETIME_LOOKUPS,
"date_filed": DATE_LOOKUPS,
"scdb_id": ["exact"],
"scdb_decision_direction": ["exact"],
"scdb_votes_majority": INTEGER_LOOKUPS,
"scdb_votes_minority": INTEGER_LOOKUPS,
"citation_count": INTEGER_LOOKUPS,
"precedential_status": ["exact"],
"date_blocked": DATE_LOOKUPS,
"blocked": ["exact"],
}
class TestListCycleFilter(filters.FilterSet):
created_by = filters.RelatedFilter(UserFilter,
field_name="created_by",
queryset=User.objects.all())
modified_by = filters.RelatedFilter(UserFilter,
field_name="modified_by",
queryset=User.objects.all())
test_lists = filters.RelatedFilter(TestListFilter,
field_name="test_lists",
queryset=models.TestList.objects.all())
utcs = filters.RelatedFilter(
"qatrack.api.qa.filters.UnitTestCollectionFilter",
field_name="utcs",
queryset=models.UnitTestCollection.objects.all(),
)
created_min = MinDateFilter(field_name="created")
created_max = MaxDateFilter(field_name="created")
modified_min = MinDateFilter(field_name="modified")
modified_max = MaxDateFilter(field_name="modified")
class Meta:
model = models.TestListCycle
fields = {
"name": ['exact', 'icontains', 'contains', 'in'],
"slug": ['exact', 'icontains', 'contains', 'in'],
"description": ['icontains'],
"drop_down_label": ['icontains', 'in'],
"day_option_text": ['icontains', 'in'],
"created": ['exact'],
"modified": ['exact'],
}
class ReferenceFilter(filters.FilterSet):
created_by = filters.RelatedFilter(UserFilter,
field_name="created_by",
queryset=User.objects.all())
modified_by = filters.RelatedFilter(UserFilter,
field_name="modified_by",
queryset=User.objects.all())
type = filters.Filter(
field_name="type",
widget=widgets.Select(choices=[('', 'Any')] +
list(models.REF_TYPE_CHOICES)),
)
created_min = MinDateFilter(field_name="created")
created_max = MaxDateFilter(field_name="created")
modified_min = MinDateFilter(field_name="modified")
modified_max = MaxDateFilter(field_name="modified")
class Meta:
model = models.Reference
fields = {
"name": ['exact', 'icontains', 'contains', 'in'],
"value": ['exact', 'in', 'gte', 'lte'],
"created": ['exact'],
"modified": ['exact'],
}
class PositionFilter(filters.FilterSet):
court = filters.RelatedFilter(CourtFilter, name='court')
retention_events = filters.RelatedFilter(RetentionEventFilter,
name='retention_events')
appointer = filters.RelatedFilter('cl.people_db.filters.PersonFilter',
name='appointer')
class Meta:
model = Position
fields = {
'id': ['exact'],
'position_type': ['exact'],
'person': ['exact'],
'predecessor': ['exact'],
'job_title': ALL_TEXT_LOOKUPS,
'date_created': DATETIME_LOOKUPS,
'date_modified': DATETIME_LOOKUPS,
'date_nominated': DATE_LOOKUPS,
'date_elected': DATE_LOOKUPS,
'date_recess_appointment': DATE_LOOKUPS,
'date_referred_to_judicial_committee': DATE_LOOKUPS,
'date_judicial_committee_action': DATE_LOOKUPS,
'date_hearing': DATE_LOOKUPS,
'date_confirmation': DATE_LOOKUPS,
'date_start': DATE_LOOKUPS,
'date_retirement': DATE_LOOKUPS,
'date_termination': DATE_LOOKUPS,
'judicial_committee_action': ['exact'],
'nomination_process': ['exact'],
'voice_vote': ['exact'],
'votes_yes': INTEGER_LOOKUPS,
'votes_no': INTEGER_LOOKUPS,
'how_selected': ['exact'],
'termination_reason': ['exact'],
}
class ContractFilterSet(filters.FilterSet):
customer = filters.RelatedFilter(CustomerFilterSet,
queryset=Customer.objects.all())
serviceinfo = filters.RelatedFilter(ServiceInfoFilterSet,
queryset=ServiceInfo.objects.all())
last_counselor__username__in = CharCSVFilter(
method="filter_last_counselor_usernames")
class Meta:
model = Contract
fields = {
"id": (
"exact",
"in",
), # fore delete...
"contract_num": ("exact", "in", "icontains"),
"signing_date": ("gte", "lte", "range"),
"probation_until": ("gte", "lte", "range"),
}
def filter_last_counselor_usernames(self, qs, field_name, value):
qs = qs.annotate(
max_transfer_date=Max("takeover__transfer_date")).filter(
takeover__transfer_date=F("max_transfer_date"),
takeover__counselor__username__in=value,
)
return qs
class OpinionFilter(FilterSet):
# Cannot to reference to opinions_cited here, due to it being a self join,
# which is not supported (possibly for good reasons?)
cluster = filters.RelatedFilter('cl.search.filters.OpinionClusterFilter',
queryset=OpinionCluster.objects.all())
author = filters.RelatedFilter(
'cl.people_db.filters.PersonFilter',
queryset=Person.objects.all(),
)
joined_by = filters.RelatedFilter(
'cl.people_db.filters.PersonFilter',
queryset=Person.objects.all(),
)
type = filters.MultipleChoiceFilter(choices=Opinion.OPINION_TYPES)
class Meta:
model = Opinion
fields = {
'id': INTEGER_LOOKUPS,
'date_modified': DATETIME_LOOKUPS,
'date_created': DATETIME_LOOKUPS,
'sha1': ['exact'],
'extracted_by_ocr': ['exact'],
'per_curiam': ['exact'],
}
class RECAPDocumentFilter(FilterSet):
docket_entry = filters.RelatedFilter(
DocketEntryFilter,
queryset=DocketEntry.objects.all(),
)
tags = filters.RelatedFilter(
TagFilter,
queryset=Tag.objects.all(),
)
class Meta:
model = RECAPDocument
fields = {
'id': ['exact'],
'date_created': DATETIME_LOOKUPS,
'date_modified': DATETIME_LOOKUPS,
'date_upload': DATETIME_LOOKUPS,
'document_type': ['exact'],
'document_number': ['exact', 'gte', 'gt', 'lte', 'lt'],
'pacer_doc_id': ['exact', 'in'],
'is_available': ['exact'],
'sha1': ['exact'],
'ocr_status': INTEGER_LOOKUPS,
'is_free_on_pacer': ['exact'],
}
class ReturnToServiceQAFilter(filters.FilterSet):
unit_test_collection = filters.RelatedFilter(
UnitTestCollectionFilter,
field_name='unit_test_collection',
queryset=UnitTestCollection.objects.all())
test_list_instance = filters.RelatedFilter(
TestListInstanceFilter,
field_name='test_list_instance',
queryset=TestListInstance.objects.all())
user_assigned_by = filters.RelatedFilter(UserFilter,
field_name='user_assigned_by',
queryset=User.objects.all())
service_event = filters.RelatedFilter(
ServiceEventFilter,
field_name='service_event',
queryset=models.ServiceEvent.objects.all())
datetime_assigned_min = MinDateFilter(field_name="datetime_assigned")
datetime_assigned_max = MaxDateFilter(field_name="datetime_assigned")
class Meta:
model = models.ReturnToServiceQA
fields = {
'datetime_assigned': ['exact'],
}
class TestJobFilter(filters.FilterSet):
testrun = filters.RelatedFilter(TestRunFilter,
name="testrun",
queryset=TestRun.objects.all(),
widget=forms.TextInput)
target_build = filters.RelatedFilter(BuildFilter,
name="target_build",
queryset=Build.objects.all(),
widget=forms.TextInput)
target = filters.RelatedFilter(ProjectFilter,
name="target",
queryset=Project.objects.all(),
widget=forms.TextInput)
class Meta:
model = TestJob
fields = {
'name': ['exact', 'in', 'startswith', 'contains', 'icontains'],
"environment":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"submitted": ['exact', 'in'],
"fetched": ['exact', 'in'],
"fetch_attempts": ['exact', 'in'],
"last_fetch_attempt": ['exact', 'in', 'lt', 'gt', 'lte', 'gte'],
"failure": ['exact', 'in', 'startswith', 'contains', 'icontains'],
"can_resubmit": ['exact', 'in'],
"resubmitted_count": ['exact', 'in'],
"job_status":
['exact', 'in', 'startswith', 'contains', 'icontains'],
"job_id": ['exact', 'in', 'startswith', 'contains', 'icontains']
}
class WaiverFilter(filters.FilterSet):
bid = filters.RelatedFilter(BidFilter,
name='bid',
queryset=Bid.objects.all())
position = filters.RelatedFilter(
'talentmap_api.position.filters.PositionFilter',
name='position',
queryset=Position.objects.all())
user = filters.RelatedFilter(
'talentmap_api.user_profile.filters.UserProfileFilter',
name='user',
queryset=UserProfile.objects.all())
class Meta:
model = Waiver
fields = {
"user": FOREIGN_KEY_LOOKUPS,
"position": FOREIGN_KEY_LOOKUPS,
"bid": FOREIGN_KEY_LOOKUPS,
"status": ALL_TEXT_LOOKUPS,
"category": ALL_TEXT_LOOKUPS,
"type": ALL_TEXT_LOOKUPS,
"description": ALL_TEXT_LOOKUPS,
"create_date": DATE_LOOKUPS,
"update_date": DATE_LOOKUPS
}
class BuildFilter(filters.FilterSet):
project = filters.RelatedFilter(ProjectFilter, name="project", queryset=Project.objects.all(), widget=forms.TextInput)
status = filters.RelatedFilter(ProjectStatusFilter, name="status", queryset=ProjectStatus.objects.all(), widget=forms.TextInput)
class Meta:
model = Build
fields = {'version': ['exact', 'in', 'startswith'],
'id': ['exact']}
class OpinionsCitedFilter(FilterSet):
citing_opinion = filters.RelatedFilter(OpinionFilter)
cited_opinion = filters.RelatedFilter(OpinionFilter)
class Meta:
model = OpinionsCited
fields = {
'id': ['exact'],
}
class DatasetRelationshipFilter(rest_framework_filters.FilterSet):
"""Filter for DatasetRelationships"""
child = rest_framework_filters.RelatedFilter(
DatasetFilter,
field_name='child',
queryset=geospaas.catalog.models.Dataset.objects.all())
parent = rest_framework_filters.RelatedFilter(
DatasetFilter,
field_name='parent',
queryset=geospaas.catalog.models.Dataset.objects.all())
class TrackPlayFilter(filters.FilterSet):
label = filters.RelatedFilter('LabelFilter', field_name='label', queryset=Label.objects.all())
track = filters.RelatedFilter('TrackFilter', field_name='track', queryset=Track.objects.all())
setlist = filters.RelatedFilter('SetlistFilter', field_name='setlist', queryset=Setlist.objects.all())
class Meta:
model = TrackPlay
fields = {
'set_order': ['exact', 'in']
}
class SourceFilter(rest_framework_filters.FilterSet):
"""Filter for Sources"""
instrument = rest_framework_filters.RelatedFilter(
InstrumentFilter,
field_name='instrument',
queryset=geospaas.vocabularies.models.Instrument.objects.all())
platform = rest_framework_filters.RelatedFilter(
PlatformFilter,
field_name='platform',
queryset=geospaas.vocabularies.models.Platform.objects.all())
class TestRunFilter(filters.FilterSet):
build = filters.RelatedFilter(BuildFilter, name="build", queryset=Build.objects.all(), widget=forms.TextInput)
environment = filters.RelatedFilter(EnvironmentFilter, name="environment", queryset=Environment.objects.all(), widget=forms.TextInput)
class Meta:
model = TestRun
fields = {'job_id': ['exact', 'in', 'startswith'],
'job_status': ['exact', 'in', 'startswith'],
'data_processed': ['exact', 'in'],
'status_recorded': ['exact', 'in']}
class TestFilter(filters.FilterSet):
test_run = filters.RelatedFilter(TestRunFilter, field_name="test_run", queryset=TestRun.objects.all(), widget=forms.TextInput)
suite = filters.RelatedFilter(SuiteFilter, field_name="suite", queryset=Suite.objects.all(), widget=forms.TextInput)
known_issues = filters.RelatedFilter(KnownIssueFilter, field_name='known_issues', queryset=KnownIssue.objects.all(), widget=forms.TextInput)
class Meta:
model = Test
fields = {'name': ['exact', 'in', 'startswith', 'contains', 'icontains'],
'result': ['exact', 'in'],
'has_known_issues': ['exact', 'in']}
class TrackFilter(filters.FilterSet):
title = CharFilter(field_name='title', lookup_expr='iexact')
artist = filters.RelatedFilter('ArtistFilter', field_name='artist', queryset=Artist.objects.all())
setlists = filters.RelatedFilter('SetlistFilter', field_name='setlists', queryset=Setlist.objects.all())
plays = filters.RelatedFilter('TrackPlayFilter', field_name='plays', queryset=TrackPlay.objects.all())
class Meta:
model = Track
fields = {
'title': ['iexact', 'in', 'startswith', 'icontains'],
}
class PlanRepositoryRelatedFilter(filters.FilterSet):
plan = filters.RelatedFilter(PlanRelatedFilter,
name="plan",
queryset=Plan.objects.all())
repo = filters.RelatedFilter(RepositoryRelatedFilter,
name="repo",
queryset=Repository.objects.all())
class Meta:
model = PlanRepository
fields = ["id"]
class ClaimFilter(rf_filters.FilterSet):
tricycle = rf_filters.RelatedFilter(ClaimTricycleFilter,
field_name="tricycle",
queryset=Tricycle.objects.all())
garage = rf_filters.RelatedFilter(ClaimGarageFilter,
field_name="garage",
queryset=Garage.objects.all())
class Meta:
model = Claim
fields = ("status", )
class MetricFilter(filters.FilterSet):
test_run = filters.RelatedFilter(TestRunFilter, field_name="test_run", queryset=TestRun.objects.all(), widget=forms.TextInput)
suite = filters.RelatedFilter(SuiteFilter, field_name="suite", queryset=Suite.objects.all(), widget=forms.TextInput)
class Meta:
model = Metric
fields = {'name': ['exact', 'in', 'startswith', 'contains', 'icontains'],
'result': ['exact', 'in'],
'test_run': ['exact', 'in'],
'is_outlier': ['exact', 'in'],
'suite': ['exact', 'in']}
class OpinionsCitedFilter(FilterSet):
citing_opinion = filters.RelatedFilter(
OpinionFilter, queryset=Opinion.objects.all()
)
cited_opinion = filters.RelatedFilter(
OpinionFilter, queryset=Opinion.objects.all()
)
class Meta:
model = OpinionsCited
fields = {
"id": ["exact"],
}
