9856 filter types

netbox/netbox/graphql/filter_mixins.py

@@ -11,8 +11,11 @@ from utilities.filters import *
 
 def autotype_decorator(filterset):
 
-    def wrapper(cls):
+    def show_field(fieldname, v, cls):
         print(f"cls: {cls}")
+        print(f"{fieldname}: {v}")
+
+    def wrapper(cls):
         cls.filterset = filterset
         fields = filterset.get_fields()
         model = filterset._meta.model
@@ -35,11 +38,9 @@ def autotype_decorator(filterset):
                 create_function = True
                 attr_type = str | None
             elif isinstance(v, MACAddressFilter):
-                print(f"{fieldname}: {v}")
-                print("MACAddressFilter")
+                show_field("MACAddressFilter", v, cls)
             elif isinstance(v, MultiValueArrayFilter):
-                print(f"{fieldname}: {v}")
-                print("MultiValueArrayFilter")
+                show_field("MultiValueArrayFilter", v, cls)
             elif isinstance(v, MultiValueCharFilter):
                 create_function = True
                 attr_type = List[str] | None
@@ -48,8 +49,7 @@ def autotype_decorator(filterset):
             elif isinstance(v, MultiValueDateTimeFilter):
                 attr_type = auto
             elif isinstance(v, MultiValueDecimalFilter):
-                print(f"{fieldname}: {v}")
-                print("MultiValueDecimalFilter")
+                show_field("MultiValueDecimalFilter", v, cls)
             elif isinstance(v, MultiValueMACAddressFilter):
                 create_function = True
                 attr_type = List[str] | None
@@ -57,17 +57,14 @@ def autotype_decorator(filterset):
                 create_function = True
                 attr_type = List[str] | None
             elif isinstance(v, MultiValueTimeFilter):
-                print(f"{fieldname}: {v}")
-                print("MultiValueTimeFilter")
+                show_field("MultiValueTimeFilter", v, cls)
             elif isinstance(v, MultiValueWWNFilter):
                 create_function = True
                 attr_type = List[str] | None
             elif isinstance(v, NullableCharFieldFilter):
-                print(f"{fieldname}: {v}")
-                print("NullableCharFieldFilter")
+                show_field("NullableCharFieldFilter", v, cls)
             elif isinstance(v, NumericArrayFilter):
-                print(f"{fieldname}: {v}")
-                print("NumericArrayFilter")
+                show_field("NumericArrayFilter", v, cls)
             elif isinstance(v, TreeNodeMultipleChoiceFilter):
                 create_function = True
                 attr_type = List[str] | None
@@ -75,26 +72,19 @@ def autotype_decorator(filterset):
             # From django_filters - ordering of these matters as base classes must
             # come after derived classes so the base class doesn't get matched first
             elif issubclass(type(v), django_filters.OrderingFilter):
-                print(f"{fieldname}: {v}")
-                print("OrderingFilter")
+                show_field("OrderingFilter", v, cls)
             elif issubclass(type(v), django_filters.BaseRangeFilter):
-                print(f"{fieldname}: {v}")
-                print("BaseRangeFilter")
+                show_field("BaseRangeFilter", v, cls)
             elif issubclass(type(v), django_filters.BaseInFilter):
-                print(f"{fieldname}: {v}")
-                print("BaseInFilter")
+                show_field("BaseInFilter", v, cls)
             elif issubclass(type(v), django_filters.LookupChoiceFilter):
-                print(f"{fieldname}: {v}")
-                print("LookupChoiceFilter")
+                show_field("LookupChoiceFilter", v, cls)
             elif issubclass(type(v), django_filters.AllValuesMultipleFilter):
-                print(f"{fieldname}: {v}")
-                print("AllValuesMultipleFilter")
+                show_field("AllValuesMultipleFilter", v, cls)
             elif issubclass(type(v), django_filters.AllValuesFilter):
-                print(f"{fieldname}: {v}")
-                print("AllValuesFilter")
+                show_field("AllValuesFilter", v, cls)
             elif issubclass(type(v), django_filters.TimeRangeFilter):
-                print(f"{fieldname}: {v}")
-                print("TimeRangeFilter")
+                show_field("TimeRangeFilter", v, cls)
             elif issubclass(type(v), django_filters.IsoDateTimeFromToRangeFilter):
                 create_function = True
                 attr_type = str | None
@@ -108,14 +98,11 @@ def autotype_decorator(filterset):
                 create_function = True
                 attr_type = str | None
             elif issubclass(type(v), django_filters.RangeFilter):
-                print(f"{fieldname}: {v}")
-                print("RangeFilter")
+                show_field("RangeFilter", v, cls)
             elif issubclass(type(v), django_filters.NumericRangeFilter):
-                print(f"{fieldname}: {v}")
-                print("NumericRangeFilter")
+                show_field("NumericRangeFilter", v, cls)
             elif issubclass(type(v), django_filters.NumberFilter):
-                print(f"{fieldname}: {v}")
-                print("NumberFilter")
+                show_field("NumberFilter", v, cls)
             elif issubclass(type(v), django_filters.ModelMultipleChoiceFilter):
                 create_function = True
                 attr_type = List[str] | None
@@ -123,11 +110,9 @@ def autotype_decorator(filterset):
                 create_function = True
                 attr_type = str | None
             elif issubclass(type(v), django_filters.DurationFilter):
-                print(f"{fieldname}: {v}")
-                print("DurationFilter")
+                show_field("DurationFilter", v, cls)
             elif issubclass(type(v), django_filters.IsoDateTimeFilter):
-                print(f"{fieldname}: {v}")
-                print("IsoDateTimeFilter")
+                show_field("IsoDateTimeFilter", v, cls)
             elif issubclass(type(v), django_filters.DateTimeFilter):
                 attr_type = auto
             elif issubclass(type(v), django_filters.TimeFilter):
@@ -135,17 +120,14 @@ def autotype_decorator(filterset):
             elif issubclass(type(v), django_filters.DateFilter):
                 attr_type = auto
             elif issubclass(type(v), django_filters.TypedMultipleChoiceFilter):
-                print(f"{fieldname}: {v}")
-                print("TypedMultipleChoiceFilter")
+                show_field("TypedMultipleChoiceFilter", v, cls)
             elif issubclass(type(v), django_filters.MultipleChoiceFilter):
                 create_function = True
                 attr_type = List[str] | None
             elif issubclass(type(v), django_filters.TypedChoiceFilter):
-                print(f"{fieldname}: {v}")
-                print("TypedChoiceFilter")
+                show_field("TypedChoiceFilter", v, cls)
             elif issubclass(type(v), django_filters.ChoiceFilter):
-                print(f"{fieldname}: {v}")
-                print("ChoiceFilter")
+                show_field("ChoiceFilter", v, cls)
             elif issubclass(type(v), django_filters.BooleanFilter):
                 create_function = True
                 attr_type = bool | None
@@ -157,8 +139,7 @@ def autotype_decorator(filterset):
                 create_function = True
                 attr_type = str | None
             else:
-                print(f"{fieldname}: {v}")
-                print("unknown type!")
+                show_field("unknown type!", v, cls)
 
             if fieldname not in cls.__annotations__ and attr_type:
                 cls.__annotations__[fieldname] = attr_type
@@ -178,36 +159,3 @@ class BaseFilterMixin:
 
     def filter_by_filterset(self, queryset, key):
         return self.filterset(data={key: getattr(self, key)}, queryset=queryset).qs
-
-
-@strawberry.input
-class ChangeLoggedModelFilterMixin(BaseFilterMixin):
-    created: auto
-    last_updated: auto
-    created_by_request: str | None
-    updated_by_request: str | None
-    modified_by_request: str | None
-
-    def filter_created_by_request(self, queryset):
-        return self.filter_by_filterset(queryset, 'created_by_request')
-
-    def filter_updated_by_request(self, queryset):
-        return self.filter_by_filterset(queryset, 'updated_by_request')
-
-    def filter_modified_by_request(self, queryset):
-        return self.filter_by_filterset(queryset, 'modified_by_request')
-
-
-@strawberry.input
-class NetBoxModelFilterMixin(ChangeLoggedModelFilterMixin):
-    q: str | None
-    tag: List[str] | None
-
-    def filter_q(self, queryset):
-        # return self.search(queryset, None, self.q)
-        return self.filter_by_filterset(queryset, 'q')
-
-    def filter_tag(self, queryset, info):
-        # return self.filterset(data={'tag': self.tag}, queryset=queryset).qs
-        # return self.filterset(data={'tag': getattr(self, 'tag')}, queryset=queryset).qs
-        return self.filter_by_filterset(queryset, 'tag')

netbox/tenancy/graphql/filters.py

@@ -1,9 +1,8 @@
 import strawberry
 import strawberry_django
-from strawberry import auto
 from tenancy import filtersets, models
 
-from netbox.graphql import filter_mixins
+from netbox.graphql.filter_mixins import autotype_decorator, BaseFilterMixin
 
 __all__ = (
     'TenantFilter',
@@ -16,30 +15,35 @@ __all__ = (
 
 
 @strawberry_django.filter(models.Tenant, lookups=True)
-class TenantFilter(filtersets.TenantFilterSet):
-    id: auto
+@autotype_decorator(filtersets.TenantFilterSet)
+class TenantFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.TenantGroup, lookups=True)
-class TenantGroupFilter(filtersets.TenantGroupFilterSet):
-    id: auto
+@autotype_decorator(filtersets.TenantGroupFilterSet)
+class TenantGroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.Contact, lookups=True)
-class ContactFilter(filtersets.ContactFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ContactFilterSet)
+class ContactFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.ContactRole, lookups=True)
-class ContactRoleFilter(filtersets.ContactRoleFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ContactRoleFilterSet)
+class ContactRoleFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.ContactGroup, lookups=True)
-class ContactGroupFilter(filtersets.ContactGroupFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ContactGroupFilterSet)
+class ContactGroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.ContactAssignment, lookups=True)
-class ContactAssignmentFilter(filtersets.ContactAssignmentFilterSet):
-    id: auto
+class ContactAssignmentFilter(BaseFilterMixin):
+    pass

netbox/users/graphql/filters.py

@@ -1,9 +1,9 @@
 import strawberry
 import strawberry_django
 from django.contrib.auth import get_user_model
-from django.contrib.auth.models import Group
-from strawberry import auto
-from users import filtersets
+from users import filtersets, models
+
+from netbox.graphql.filter_mixins import autotype_decorator, BaseFilterMixin
 
 __all__ = (
     'GroupFilter',
@@ -11,19 +11,13 @@ __all__ = (
 )
 
 
-@strawberry_django.filter(Group, lookups=True)
-class GroupFilter(filtersets.GroupFilterSet):
-    id: auto
-    name: auto
+@strawberry_django.filter(models.Group, lookups=True)
+@autotype_decorator(filtersets.GroupFilterSet)
+class GroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(get_user_model(), lookups=True)
-class UserFilter(filtersets.UserFilterSet):
-    id: auto
-    username: auto
-    first_name: auto
-    last_name: auto
-    email: auto
-    is_staff: auto
-    is_active: auto
-    is_superuser: auto
+@autotype_decorator(filtersets.UserFilterSet)
+class UserFilter(BaseFilterMixin):
+    pass

netbox/virtualization/graphql/filters.py

@@ -1,7 +1,8 @@
 import strawberry
 import strawberry_django
-from strawberry import auto
-from virtualization import models, filtersets
+from virtualization import filtersets, models
+
+from netbox.graphql.filter_mixins import autotype_decorator, BaseFilterMixin
 
 
 __all__ = (
@@ -15,30 +16,36 @@ __all__ = (
 
 
 @strawberry_django.filter(models.Cluster, lookups=True)
-class ClusterFilter(filtersets.ClusterFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ClusterFilterSet)
+class ClusterFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.ClusterGroup, lookups=True)
-class ClusterGroupFilter(filtersets.ClusterGroupFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ClusterGroupFilterSet)
+class ClusterGroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.ClusterType, lookups=True)
-class ClusterTypeFilter(filtersets.ClusterTypeFilterSet):
-    id: auto
+@autotype_decorator(filtersets.ClusterTypeFilterSet)
+class ClusterTypeFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.VirtualMachine, lookups=True)
-class VirtualMachineFilter(filtersets.VirtualMachineFilterSet):
-    id: auto
+@autotype_decorator(filtersets.VirtualMachineFilterSet)
+class VirtualMachineFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.VMInterface, lookups=True)
-class VMInterfaceFilter(filtersets.VMInterfaceFilterSet):
-    id: auto
+@autotype_decorator(filtersets.VMInterfaceFilterSet)
+class VMInterfaceFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.VirtualDisk, lookups=True)
-class VirtualDiskFilter(filtersets.VirtualDiskFilterSet):
-    id: auto
+@autotype_decorator(filtersets.VirtualDiskFilterSet)
+class VirtualDiskFilter(BaseFilterMixin):
+    pass

netbox/vpn/graphql/filters.py

@@ -1,8 +1,9 @@
 import strawberry
 import strawberry_django
-from strawberry import auto
 from vpn import filtersets, models
 
+from netbox.graphql.filter_mixins import autotype_decorator, BaseFilterMixin
+
 __all__ = (
     'TunnelGroupFilter',
     'TunnelTerminationFilter',
@@ -18,50 +19,60 @@ __all__ = (
 
 
 @strawberry_django.filter(models.TunnelGroup, lookups=True)
-class TunnelGroupFilter(filtersets.TunnelGroupFilterSet):
-    id: auto
+@autotype_decorator(filtersets.TunnelGroupFilterSet)
+class TunnelGroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.TunnelTermination, lookups=True)
-class TunnelTerminationFilter(filtersets.TunnelTerminationFilterSet):
-    id: auto
+@autotype_decorator(filtersets.TunnelTerminationFilterSet)
+class TunnelTerminationFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.Tunnel, lookups=True)
-class TunnelFilter(filtersets.TunnelFilterSet):
-    id: auto
+@autotype_decorator(filtersets.TunnelFilterSet)
+class TunnelFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.IKEProposal, lookups=True)
-class IKEProposalFilter(filtersets.IKEProposalFilterSet):
-    id: auto
+@autotype_decorator(filtersets.IKEProposalFilterSet)
+class IKEProposalFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.IKEPolicy, lookups=True)
-class IKEPolicyFilter(filtersets.IKEPolicyFilterSet):
-    id: auto
+@autotype_decorator(filtersets.IKEPolicyFilterSet)
+class IKEPolicyFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.IPSecProposal, lookups=True)
-class IPSecProposalFilter(filtersets.IPSecProposalFilterSet):
-    id: auto
+@autotype_decorator(filtersets.IPSecProposalFilterSet)
+class IPSecProposalFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.IPSecPolicy, lookups=True)
-class IPSecPolicyFilter(filtersets.IPSecPolicyFilterSet):
-    id: auto
+@autotype_decorator(filtersets.IPSecPolicyFilterSet)
+class IPSecPolicyFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.IPSecProfile, lookups=True)
-class IPSecProfileFilter(filtersets.IPSecProfileFilterSet):
-    id: auto
+@autotype_decorator(filtersets.IPSecProfileFilterSet)
+class IPSecProfileFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.L2VPN, lookups=True)
-class L2VPNFilter(filtersets.L2VPNFilterSet):
-    id: auto
+@autotype_decorator(filtersets.L2VPNFilterSet)
+class L2VPNFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.L2VPNTermination, lookups=True)
-class L2VPNTerminationFilter(filtersets.L2VPNTerminationFilterSet):
-    id: auto
+@autotype_decorator(filtersets.L2VPNTerminationFilterSet)
+class L2VPNTerminationFilter(BaseFilterMixin):
+    pass

netbox/wireless/graphql/filters.py

@@ -1,8 +1,9 @@
 import strawberry
 import strawberry_django
-from strawberry import auto
 from wireless import filtersets, models
 
+from netbox.graphql.filter_mixins import autotype_decorator, BaseFilterMixin
+
 __all__ = (
     'WirelessLANGroupFilter',
     'WirelessLANFilter',
@@ -11,15 +12,18 @@ __all__ = (
 
 
 @strawberry_django.filter(models.WirelessLANGroup, lookups=True)
-class WirelessLANGroupFilter(filtersets.WirelessLANGroupFilterSet):
-    id: auto
+@autotype_decorator(filtersets.WirelessLANGroupFilterSet)
+class WirelessLANGroupFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.WirelessLAN, lookups=True)
-class WirelessLANFilter(filtersets.WirelessLANFilterSet):
-    id: auto
+@autotype_decorator(filtersets.WirelessLANFilterSet)
+class WirelessLANFilter(BaseFilterMixin):
+    pass
 
 
 @strawberry_django.filter(models.WirelessLink, lookups=True)
-class WirelessLinkFilter(filtersets.WirelessLinkFilterSet):
-    id: auto
+@autotype_decorator(filtersets.WirelessLinkFilterSet)
+class WirelessLinkFilter(BaseFilterMixin):
+    pass