NeoAnd/netbox
1
0
Fork 0
mirror of https://github.com/netbox-community/netbox.git synced 2025-07-24 17:38:37 -06:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

9856 update strawberry types

Browse Source
This commit is contained in:
Arthur 2024-02-06 13:52:41 -08:00
parent 5e40ebd331
commit 663af64ec1
18 changed files with 544 additions and 442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
netbox/circuits/graphql/types.py
View File

@ -6,7 +6,6 @@ from dcim.graphql.mixins import CabledObjectMixin
from extras.graphql.mixins import CustomFieldsMixin, TagsMixin, ContactsMixin from extras.graphql.mixins import CustomFieldsMixin, TagsMixin, ContactsMixin
from netbox.graphql.types import ObjectType, OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import ObjectType, OrganizationalObjectType, NetBoxObjectType
from .filters import * from .filters import *
from typing import List
__all__ = ( __all__ = (
'CircuitTerminationType', 'CircuitTerminationType',

0
netbox/core/graphql/filters.py Normal file
View File

26
netbox/core/graphql/types.py
View File

@ -1,5 +1,9 @@
from core import filtersets, models import strawberry
import strawberry_django
from core import models
from netbox.graphql.types import BaseObjectType, NetBoxObjectType from netbox.graphql.types import BaseObjectType, NetBoxObjectType
from .filters import *
__all__ = ( __all__ = (
'DataFileType', 'DataFileType',
@ -7,15 +11,19 @@ __all__ = (
) )
@strawberry_django.type(
models.DataFile,
fields='__all__',
filters=DataFileFilter
)
class DataFileType(BaseObjectType): class DataFileType(BaseObjectType):
class Meta: pass
model = models.DataFile
exclude = ('data',)
filterset_class = filtersets.DataFileFilterSet
@strawberry_django.type(
models.DataSource,
fields='__all__',
filters=DataSourceFilter
)
class DataSourceType(NetBoxObjectType): class DataSourceType(NetBoxObjectType):
class Meta: pass
model = models.DataSource
fields = '__all__'
filterset_class = filtersets.DataSourceFilterSet

0
netbox/dcim/graphql/filters.py Normal file
View File

433
netbox/dcim/graphql/types.py
View File

@ -1,12 +1,14 @@
import graphene import strawberry
import strawberry_django
from dcim import filtersets, models from dcim import models
from extras.graphql.mixins import ( from extras.graphql.mixins import (
ChangelogMixin, ConfigContextMixin, ContactsMixin, CustomFieldsMixin, ImageAttachmentsMixin, TagsMixin, ChangelogMixin, ConfigContextMixin, ContactsMixin, CustomFieldsMixin, ImageAttachmentsMixin, TagsMixin,
) )
from ipam.graphql.mixins import IPAddressesMixin, VLANGroupsMixin from ipam.graphql.mixins import IPAddressesMixin, VLANGroupsMixin
from netbox.graphql.scalars import BigInt from netbox.graphql.scalars import BigInt
from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType
from .filters import *
from .mixins import CabledObjectMixin, PathEndpointMixin from .mixins import CabledObjectMixin, PathEndpointMixin
__all__ = ( __all__ = (
@ -86,6 +88,11 @@ class ComponentTemplateObjectType(
# Model types # Model types
# #
@strawberry_django.type(
models.Cable,
fields='__all__',
filters=CableFilter
)
class CableType(NetBoxObjectType): class CableType(NetBoxObjectType):
a_terminations = graphene.List('dcim.graphql.gfk_mixins.CableTerminationTerminationType') a_terminations = graphene.List('dcim.graphql.gfk_mixins.CableTerminationTerminationType')
b_terminations = graphene.List('dcim.graphql.gfk_mixins.CableTerminationTerminationType') b_terminations = graphene.List('dcim.graphql.gfk_mixins.CableTerminationTerminationType')
@ -108,66 +115,66 @@ class CableType(NetBoxObjectType):
return self.b_terminations return self.b_terminations
@strawberry_django.type(
models.CableTermination,
exclude=('termination_type', 'termination_id'),
filters=CableTerminationFilter
)
class CableTerminationType(NetBoxObjectType): class CableTerminationType(NetBoxObjectType):
termination = graphene.Field('dcim.graphql.gfk_mixins.CableTerminationTerminationType') termination = graphene.Field('dcim.graphql.gfk_mixins.CableTerminationTerminationType')
class Meta:
model = models.CableTermination
exclude = ('termination_type', 'termination_id')
filterset_class = filtersets.CableTerminationFilterSet
@strawberry_django.type(
models.ConsolePort,
exclude=('_path',),
filters=ConsolePortFilter
)
class ConsolePortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin): class ConsolePortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin):
class Meta:
model = models.ConsolePort
exclude = ('_path',)
filterset_class = filtersets.ConsolePortFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.ConsolePortTemplate,
fields='__all__',
filters=ConsolePortTemplateFilter
)
class ConsolePortTemplateType(ComponentTemplateObjectType): class ConsolePortTemplateType(ComponentTemplateObjectType):
class Meta:
model = models.ConsolePortTemplate
fields = '__all__'
filterset_class = filtersets.ConsolePortTemplateFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.ConsoleServerPort,
exclude=('_path',),
filters=ConsoleServerPortFilter
)
class ConsoleServerPortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin): class ConsoleServerPortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin):
class Meta:
model = models.ConsoleServerPort
exclude = ('_path',)
filterset_class = filtersets.ConsoleServerPortFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.ConsoleServerPortTemplate,
fields='__all__',
filters=ConsoleServerPortTemplateFilter
)
class ConsoleServerPortTemplateType(ComponentTemplateObjectType): class ConsoleServerPortTemplateType(ComponentTemplateObjectType):
class Meta:
model = models.ConsoleServerPortTemplate
fields = '__all__'
filterset_class = filtersets.ConsoleServerPortTemplateFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.Device,
fields='__all__',
filters=DeviceFilter
)
class DeviceType(ConfigContextMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType): class DeviceType(ConfigContextMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType):
class Meta:
model = models.Device
fields = '__all__'
filterset_class = filtersets.DeviceFilterSet
def resolve_face(self, info): def resolve_face(self, info):
return self.face or None return self.face or None
@ -175,46 +182,49 @@ class DeviceType(ConfigContextMixin, ImageAttachmentsMixin, ContactsMixin, NetBo
return self.airflow or None return self.airflow or None
@strawberry_django.type(
models.DeviceBay,
fields='__all__',
filters=DeviceBayFilter
)
class DeviceBayType(ComponentObjectType): class DeviceBayType(ComponentObjectType):
pass
class Meta:
model = models.DeviceBay
fields = '__all__'
filterset_class = filtersets.DeviceBayFilterSet
@strawberry_django.type(
models.DeviceBayTemplate,
fields='__all__',
filters=DeviceBayTemplateFilter
)
class DeviceBayTemplateType(ComponentTemplateObjectType): class DeviceBayTemplateType(ComponentTemplateObjectType):
pass
class Meta:
model = models.DeviceBayTemplate
fields = '__all__'
filterset_class = filtersets.DeviceBayTemplateFilterSet
@strawberry_django.type(
models.InventoryItemTemplate,
exclude=('component_type', 'component_id'),
filters=InventoryItemTemplateFilter
)
class InventoryItemTemplateType(ComponentTemplateObjectType): class InventoryItemTemplateType(ComponentTemplateObjectType):
component = graphene.Field('dcim.graphql.gfk_mixins.InventoryItemTemplateComponentType') component = graphene.Field('dcim.graphql.gfk_mixins.InventoryItemTemplateComponentType')
class Meta:
model = models.InventoryItemTemplate
exclude = ('component_type', 'component_id')
filterset_class = filtersets.InventoryItemTemplateFilterSet
@strawberry_django.type(
models.DeviceRole,
fields='__all__',
filters=DeviceRoleFilter
)
class DeviceRoleType(OrganizationalObjectType): class DeviceRoleType(OrganizationalObjectType):
pass
class Meta:
model = models.DeviceRole
fields = '__all__'
filterset_class = filtersets.DeviceRoleFilterSet
@strawberry_django.type(
models.DeviceType,
fields='__all__',
filters=DeviceTypeFilter
)
class DeviceTypeType(NetBoxObjectType): class DeviceTypeType(NetBoxObjectType):
class Meta:
model = models.DeviceType
fields = '__all__'
filterset_class = filtersets.DeviceTypeFilterSet
def resolve_subdevice_role(self, info): def resolve_subdevice_role(self, info):
return self.subdevice_role or None return self.subdevice_role or None
@ -225,29 +235,31 @@ class DeviceTypeType(NetBoxObjectType):
return self.weight_unit or None return self.weight_unit or None
@strawberry_django.type(
models.FrontPort,
fields='__all__',
filters=FrontPortFilter
)
class FrontPortType(ComponentObjectType, CabledObjectMixin): class FrontPortType(ComponentObjectType, CabledObjectMixin):
pass
class Meta:
model = models.FrontPort
fields = '__all__'
filterset_class = filtersets.FrontPortFilterSet
@strawberry_django.type(
models.FrontPortTemplate,
fields='__all__',
filters=FrontPortTemplateFilter
)
class FrontPortTemplateType(ComponentTemplateObjectType): class FrontPortTemplateType(ComponentTemplateObjectType):
pass
class Meta:
model = models.FrontPortTemplate
fields = '__all__'
filterset_class = filtersets.FrontPortTemplateFilterSet
@strawberry_django.type(
models.Interface,
exclude=('_path',),
filters=InterfaceFilter
)
class InterfaceType(IPAddressesMixin, ComponentObjectType, CabledObjectMixin, PathEndpointMixin): class InterfaceType(IPAddressesMixin, ComponentObjectType, CabledObjectMixin, PathEndpointMixin):
class Meta:
model = models.Interface
exclude = ('_path',)
filterset_class = filtersets.InterfaceFilterSet
def resolve_poe_mode(self, info): def resolve_poe_mode(self, info):
return self.poe_mode or None return self.poe_mode or None
@ -264,13 +276,13 @@ class InterfaceType(IPAddressesMixin, ComponentObjectType, CabledObjectMixin, Pa
return self.rf_channel or None return self.rf_channel or None
@strawberry_django.type(
models.InterfaceTemplate,
fields='__all__',
filters=InterfaceTemplateFilter
)
class InterfaceTemplateType(ComponentTemplateObjectType): class InterfaceTemplateType(ComponentTemplateObjectType):
class Meta:
model = models.InterfaceTemplate
fields = '__all__'
filterset_class = filtersets.InterfaceTemplateFilterSet
def resolve_poe_mode(self, info): def resolve_poe_mode(self, info):
return self.poe_mode or None return self.poe_mode or None
@ -281,97 +293,105 @@ class InterfaceTemplateType(ComponentTemplateObjectType):
return self.rf_role or None return self.rf_role or None
@strawberry_django.type(
models.InventoryItem,
exclude=('component_type', 'component_id'),
filters=InventoryItemFilter
)
class InventoryItemType(ComponentObjectType): class InventoryItemType(ComponentObjectType):
component = graphene.Field('dcim.graphql.gfk_mixins.InventoryItemComponentType') component = graphene.Field('dcim.graphql.gfk_mixins.InventoryItemComponentType')
class Meta:
model = models.InventoryItem
exclude = ('component_type', 'component_id')
filterset_class = filtersets.InventoryItemFilterSet
@strawberry_django.type(
models.InventoryItemRole,
fields='__all__',
filters=InventoryItemRoleFilter
)
class InventoryItemRoleType(OrganizationalObjectType): class InventoryItemRoleType(OrganizationalObjectType):
pass
class Meta:
model = models.InventoryItemRole
fields = '__all__'
filterset_class = filtersets.InventoryItemRoleFilterSet
@strawberry_django.type(
models.Location,
fields='__all__',
filters=LocationFilter
)
class LocationType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, OrganizationalObjectType): class LocationType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, OrganizationalObjectType):
pass
class Meta:
model = models.Location
fields = '__all__'
filterset_class = filtersets.LocationFilterSet
@strawberry_django.type(
models.Manufacturer,
fields='__all__',
filters=ManufacturerFilter
)
class ManufacturerType(OrganizationalObjectType, ContactsMixin): class ManufacturerType(OrganizationalObjectType, ContactsMixin):
pass
class Meta:
model = models.Manufacturer
fields = '__all__'
filterset_class = filtersets.ManufacturerFilterSet
@strawberry_django.type(
models.Module,
fields='__all__',
filters=ModuleFilter
)
class ModuleType(ComponentObjectType): class ModuleType(ComponentObjectType):
pass
class Meta:
model = models.Module
fields = '__all__'
filterset_class = filtersets.ModuleFilterSet
@strawberry_django.type(
models.ModuleBay,
fields='__all__',
filters=ModuleBayFilter
)
class ModuleBayType(ComponentObjectType): class ModuleBayType(ComponentObjectType):
pass
class Meta:
model = models.ModuleBay
fields = '__all__'
filterset_class = filtersets.ModuleBayFilterSet
@strawberry_django.type(
models.ModuleBayTemplate,
fields='__all__',
filters=ModuleBayTemplateFilter
)
class ModuleBayTemplateType(ComponentTemplateObjectType): class ModuleBayTemplateType(ComponentTemplateObjectType):
pass
class Meta:
model = models.ModuleBayTemplate
fields = '__all__'
filterset_class = filtersets.ModuleBayTemplateFilterSet
@strawberry_django.type(
models.ModuleType,
fields='__all__',
filters=ModuleTypeFilter
)
class ModuleTypeType(NetBoxObjectType): class ModuleTypeType(NetBoxObjectType):
class Meta:
model = models.ModuleType
fields = '__all__'
filterset_class = filtersets.ModuleTypeFilterSet
def resolve_weight_unit(self, info): def resolve_weight_unit(self, info):
return self.weight_unit or None return self.weight_unit or None
@strawberry_django.type(
models.Platform,
fields='__all__',
filters=PlatformFilter
)
class PlatformType(OrganizationalObjectType): class PlatformType(OrganizationalObjectType):
pass
class Meta:
model = models.Platform
fields = '__all__'
filterset_class = filtersets.PlatformFilterSet
@strawberry_django.type(
models.PowerFeed,
exclude=('_path',),
filters=PowerFeedFilter
)
class PowerFeedType(NetBoxObjectType, CabledObjectMixin, PathEndpointMixin): class PowerFeedType(NetBoxObjectType, CabledObjectMixin, PathEndpointMixin):
pass
class Meta:
model = models.PowerFeed
exclude = ('_path',)
filterset_class = filtersets.PowerFeedFilterSet
@strawberry_django.type(
models.PowerOutlet,
exclude=('_path',),
filters=PowerOutletFilter
)
class PowerOutletType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin): class PowerOutletType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin):
class Meta:
model = models.PowerOutlet
exclude = ('_path',)
filterset_class = filtersets.PowerOutletFilterSet
def resolve_feed_leg(self, info): def resolve_feed_leg(self, info):
return self.feed_leg or None return self.feed_leg or None
@ -379,13 +399,13 @@ class PowerOutletType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin)
return self.type or None return self.type or None
@strawberry_django.type(
models.PowerOutletTemplate,
fields='__all__',
filters=PowerOutletTemplateFilter
)
class PowerOutletTemplateType(ComponentTemplateObjectType): class PowerOutletTemplateType(ComponentTemplateObjectType):
class Meta:
model = models.PowerOutletTemplate
fields = '__all__'
filterset_class = filtersets.PowerOutletTemplateFilterSet
def resolve_feed_leg(self, info): def resolve_feed_leg(self, info):
return self.feed_leg or None return self.feed_leg or None
@ -393,43 +413,44 @@ class PowerOutletTemplateType(ComponentTemplateObjectType):
return self.type or None return self.type or None
@strawberry_django.type(
models.PowerPanel,
fields='__all__',
filters=PowerPanelFilter
)
class PowerPanelType(NetBoxObjectType, ContactsMixin): class PowerPanelType(NetBoxObjectType, ContactsMixin):
pass
class Meta:
model = models.PowerPanel
fields = '__all__'
filterset_class = filtersets.PowerPanelFilterSet
@strawberry_django.type(
models.PowerPort,
exclude=('_path',),
filters=PowerPortFilter
)
class PowerPortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin): class PowerPortType(ComponentObjectType, CabledObjectMixin, PathEndpointMixin):
class Meta:
model = models.PowerPort
exclude = ('_path',)
filterset_class = filtersets.PowerPortFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.PowerPortTemplate,
fields='__all__',
filters=PowerPortTemplateFilter
)
class PowerPortTemplateType(ComponentTemplateObjectType): class PowerPortTemplateType(ComponentTemplateObjectType):
class Meta:
model = models.PowerPortTemplate
fields = '__all__'
filterset_class = filtersets.PowerPortTemplateFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@strawberry_django.type(
models.Rack,
fields='__all__',
filters=RackFilter
)
class RackType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType): class RackType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType):
class Meta:
model = models.Rack
fields = '__all__'
filterset_class = filtersets.RackFilterSet
def resolve_type(self, info): def resolve_type(self, info):
return self.type or None return self.type or None
@ -440,74 +461,82 @@ class RackType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObje
return self.weight_unit or None return self.weight_unit or None
@strawberry_django.type(
models.RackReservation,
fields='__all__',
filters=RackReservationFilter
)
class RackReservationType(NetBoxObjectType): class RackReservationType(NetBoxObjectType):
pass
class Meta:
model = models.RackReservation
fields = '__all__'
filterset_class = filtersets.RackReservationFilterSet
@strawberry_django.type(
models.RackRole,
fields='__all__',
filters=RackRoleFilter
)
class RackRoleType(OrganizationalObjectType): class RackRoleType(OrganizationalObjectType):
pass
class Meta:
model = models.RackRole
fields = '__all__'
filterset_class = filtersets.RackRoleFilterSet
@strawberry_django.type(
models.RearPort,
fields='__all__',
filters=RearPortFilter
)
class RearPortType(ComponentObjectType, CabledObjectMixin): class RearPortType(ComponentObjectType, CabledObjectMixin):
pass
class Meta:
model = models.RearPort
fields = '__all__'
filterset_class = filtersets.RearPortFilterSet
@strawberry_django.type(
models.RearPortTemplate,
fields='__all__',
filters=RearPortTemplateFilter
)
class RearPortTemplateType(ComponentTemplateObjectType): class RearPortTemplateType(ComponentTemplateObjectType):
pass
class Meta:
model = models.RearPortTemplate
fields = '__all__'
filterset_class = filtersets.RearPortTemplateFilterSet
@strawberry_django.type(
models.Region,
fields='__all__',
filters=RegionFilter
)
class RegionType(VLANGroupsMixin, ContactsMixin, OrganizationalObjectType): class RegionType(VLANGroupsMixin, ContactsMixin, OrganizationalObjectType):
pass
class Meta:
model = models.Region
fields = '__all__'
filterset_class = filtersets.RegionFilterSet
@strawberry_django.type(
models.Site,
fields='__all__',
filters=SiteFilter
)
class SiteType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType): class SiteType(VLANGroupsMixin, ImageAttachmentsMixin, ContactsMixin, NetBoxObjectType):
asn = graphene.Field(BigInt) asn = graphene.Field(BigInt)
class Meta:
model = models.Site
fields = '__all__'
filterset_class = filtersets.SiteFilterSet
@strawberry_django.type(
models.SiteGroup,
fields='__all__',
filters=SiteGroupFilter
)
class SiteGroupType(VLANGroupsMixin, ContactsMixin, OrganizationalObjectType): class SiteGroupType(VLANGroupsMixin, ContactsMixin, OrganizationalObjectType):
pass
class Meta:
model = models.SiteGroup
fields = '__all__'
filterset_class = filtersets.SiteGroupFilterSet
@strawberry_django.type(
models.VirtualChassis,
fields='__all__',
filters=VirtualChassisFilter
)
class VirtualChassisType(NetBoxObjectType): class VirtualChassisType(NetBoxObjectType):
pass
class Meta:
model = models.VirtualChassis
fields = '__all__'
filterset_class = filtersets.VirtualChassisFilterSet
@strawberry_django.type(
models.VirtualDeviceContext,
fields='__all__',
filters=VirtualDeviceContextFilter
)
class VirtualDeviceContextType(NetBoxObjectType): class VirtualDeviceContextType(NetBoxObjectType):
pass
class Meta:
model = models.VirtualDeviceContext
fields = '__all__'
filterset_class = filtersets.VirtualDeviceContextFilterSet

5
netbox/extras/graphql/types.py
View File

@ -1,8 +1,11 @@
import strawberry
import strawberry_django
import strawberry import strawberry
from strawberry import auto from strawberry import auto
import strawberry_django import strawberry_django
from extras import filtersets, models from extras import models
from extras.graphql.mixins import CustomFieldsMixin, TagsMixin from extras.graphql.mixins import CustomFieldsMixin, TagsMixin
from netbox.graphql.types import BaseObjectType, ObjectType, OrganizationalObjectType from netbox.graphql.types import BaseObjectType, ObjectType, OrganizationalObjectType
from .filters import * from .filters import *

0
netbox/ipam/graphql/filters.py Normal file
View File

176
netbox/ipam/graphql/types.py
View File

@ -1,8 +1,10 @@
import graphene import strawberry
import strawberry_django
from ipam import filtersets, models from ipam import models
from netbox.graphql.scalars import BigInt from netbox.graphql.scalars import BigInt
from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType
from .filters import *
__all__ = ( __all__ = (
'ASNType', 'ASNType',
@ -46,142 +48,152 @@ class BaseIPAddressFamilyType:
return IPAddressFamilyType(self.family) return IPAddressFamilyType(self.family)
@strawberry_django.type(
models.ASN,
fields='__all__',
filters=ProviderFilter
)
class ASNType(NetBoxObjectType): class ASNType(NetBoxObjectType):
asn = graphene.Field(BigInt) asn = graphene.Field(BigInt)
class Meta:
model = models.ASN
fields = '__all__'
filterset_class = filtersets.ASNFilterSet
@strawberry_django.type(
models.ASNRange,
fields='__all__',
filters=ASNRangeFilter
)
class ASNRangeType(NetBoxObjectType): class ASNRangeType(NetBoxObjectType):
pass
class Meta:
model = models.ASNRange
fields = '__all__'
filterset_class = filtersets.ASNRangeFilterSet
@strawberry_django.type(
models.Aggregate,
fields='__all__',
filters=AggregateFilter
)
class AggregateType(NetBoxObjectType, BaseIPAddressFamilyType): class AggregateType(NetBoxObjectType, BaseIPAddressFamilyType):
pass
class Meta:
model = models.Aggregate
fields = '__all__'
filterset_class = filtersets.AggregateFilterSet
@strawberry_django.type(
models.FHRPGroup,
fields='__all__',
filters=FHRPGroupFilter
)
class FHRPGroupType(NetBoxObjectType): class FHRPGroupType(NetBoxObjectType):
class Meta:
model = models.FHRPGroup
fields = '__all__'
filterset_class = filtersets.FHRPGroupFilterSet
def resolve_auth_type(self, info): def resolve_auth_type(self, info):
return self.auth_type or None return self.auth_type or None
@strawberry_django.type(
models.FHRPGroupAssignment,
exclude=('interface_type', 'interface_id'),
filters=FHRPGroupAssignmentFilter
)
class FHRPGroupAssignmentType(BaseObjectType): class FHRPGroupAssignmentType(BaseObjectType):
interface = graphene.Field('ipam.graphql.gfk_mixins.FHRPGroupInterfaceType') interface = graphene.Field('ipam.graphql.gfk_mixins.FHRPGroupInterfaceType')
class Meta:
model = models.FHRPGroupAssignment
exclude = ('interface_type', 'interface_id')
filterset_class = filtersets.FHRPGroupAssignmentFilterSet
@strawberry_django.type(
models.IPAddress,
exclude=('assigned_object_type', 'assigned_object_id'),
filters=IPAddressFilter
)
class IPAddressType(NetBoxObjectType, BaseIPAddressFamilyType): class IPAddressType(NetBoxObjectType, BaseIPAddressFamilyType):
assigned_object = graphene.Field('ipam.graphql.gfk_mixins.IPAddressAssignmentType') assigned_object = graphene.Field('ipam.graphql.gfk_mixins.IPAddressAssignmentType')
class Meta:
model = models.IPAddress
exclude = ('assigned_object_type', 'assigned_object_id')
filterset_class = filtersets.IPAddressFilterSet
def resolve_role(self, info): def resolve_role(self, info):
return self.role or None return self.role or None
@strawberry_django.type(
models.IPRange,
fields='__all__',
filters=IPRangeFilter
)
class IPRangeType(NetBoxObjectType): class IPRangeType(NetBoxObjectType):
class Meta:
model = models.IPRange
fields = '__all__'
filterset_class = filtersets.IPRangeFilterSet
def resolve_role(self, info): def resolve_role(self, info):
return self.role or None return self.role or None
@strawberry_django.type(
models.Prefix,
fields='__all__',
filters=PrefixFilter
)
class PrefixType(NetBoxObjectType, BaseIPAddressFamilyType): class PrefixType(NetBoxObjectType, BaseIPAddressFamilyType):
pass
class Meta:
model = models.Prefix
fields = '__all__'
filterset_class = filtersets.PrefixFilterSet
@strawberry_django.type(
models.RIR,
fields='__all__',
filters=RIRFilter
)
class RIRType(OrganizationalObjectType): class RIRType(OrganizationalObjectType):
pass
class Meta:
model = models.RIR
fields = '__all__'
filterset_class = filtersets.RIRFilterSet
@strawberry_django.type(
models.Role,
fields='__all__',
filters=RoleFilter
)
class RoleType(OrganizationalObjectType): class RoleType(OrganizationalObjectType):
pass
class Meta:
model = models.Role
fields = '__all__'
filterset_class = filtersets.RoleFilterSet
@strawberry_django.type(
models.RouteTarget,
fields='__all__',
filters=RouteTargetFilter
)
class RouteTargetType(NetBoxObjectType): class RouteTargetType(NetBoxObjectType):
pass
class Meta:
model = models.RouteTarget
fields = '__all__'
filterset_class = filtersets.RouteTargetFilterSet
@strawberry_django.type(
models.Service,
fields='__all__',
filters=ServiceFilter
)
class ServiceType(NetBoxObjectType): class ServiceType(NetBoxObjectType):
pass
class Meta:
model = models.Service
fields = '__all__'
filterset_class = filtersets.ServiceFilterSet
@strawberry_django.type(
models.ServiceTemplate,
fields='__all__',
filters=ServiceTemplateFilter
)
class ServiceTemplateType(NetBoxObjectType): class ServiceTemplateType(NetBoxObjectType):
pass
class Meta:
model = models.ServiceTemplate
fields = '__all__'
filterset_class = filtersets.ServiceTemplateFilterSet
@strawberry_django.type(
models.VLAN,
fields='__all__',
filters=VLANFilter
)
class VLANType(NetBoxObjectType): class VLANType(NetBoxObjectType):
pass
class Meta:
model = models.VLAN
fields = '__all__'
filterset_class = filtersets.VLANFilterSet
@strawberry_django.type(
models.VLANGroup,
exclude=('scope_type', 'scope_id'),
filters=VLANGroupFilter
)
class VLANGroupType(OrganizationalObjectType): class VLANGroupType(OrganizationalObjectType):
scope = graphene.Field('ipam.graphql.gfk_mixins.VLANGroupScopeType') scope = graphene.Field('ipam.graphql.gfk_mixins.VLANGroupScopeType')
class Meta:
model = models.VLANGroup
exclude = ('scope_type', 'scope_id')
filterset_class = filtersets.VLANGroupFilterSet
@strawberry_django.type(
models.VRF,
fields='__all__',
filters=VRFFilter
)
class VRFType(NetBoxObjectType): class VRFType(NetBoxObjectType):
pass
class Meta:
model = models.VRF
fields = '__all__'
filterset_class = filtersets.VRFFilterSet

21
netbox/netbox/graphql/filters.py Normal file
View File

@ -0,0 +1,21 @@
import strawberry
import strawberry_django
from strawberry import auto
class ChangeLoggedModelFilter:
def created_by_request(self, queryset):
return self.filter_by_request(queryset, "created_by_request", self.created_by_request)
def updated_by_request(self, queryset):
return self.filter_by_request(queryset, "updated_by_request", self.updated_by_request)
def modified_by_request(self, queryset):
return self.filter_by_request(queryset, "modified_by_request", self.modified_by_request)
class NetBoxModelFilter(ChangeLoggedModelFilter):
def filter_q(self, queryset):
return self.search(queryset, None, self.q)

31
netbox/netbox/graphql/schema.py
View File

@ -9,25 +9,22 @@ from users.graphql.schema import UsersQuery
@strawberry.type @strawberry.type
class Query(CircuitsQuery, UsersQuery): class Query(
UsersQuery,
# CircuitsQuery,
# CoreQuery,
# DCIMQuery,
# ExtrasQuery,
# IPAMQuery,
# TenancyQuery,
# VirtualizationQuery,
# VPNQuery,
# WirelessQuery,
# *registry['plugins']['graphql_schemas'], # Append plugin schemas
# graphene.ObjectType
):
pass pass
# class Query(
# UsersQuery,
# CircuitsQuery,
# CoreQuery,
# DCIMQuery,
# ExtrasQuery,
# IPAMQuery,
# TenancyQuery,
# VirtualizationQuery,
# VPNQuery,
# WirelessQuery,
# *registry['plugins']['graphql_schemas'], # Append plugin schemas
# graphene.ObjectType
# ):
# pass
schema = strawberry.Schema( schema = strawberry.Schema(
query=Query, query=Query,

0
netbox/tenancy/graphql/filters.py Normal file
View File

72
netbox/tenancy/graphql/types.py
View File

@ -1,8 +1,10 @@
import graphene import strawberry
import strawberry_django
from extras.graphql.mixins import CustomFieldsMixin, TagsMixin from extras.graphql.mixins import CustomFieldsMixin, TagsMixin
from tenancy import filtersets, models from tenancy import models
from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import BaseObjectType, OrganizationalObjectType, NetBoxObjectType
from .filters import *
__all__ = ( __all__ = (
'ContactAssignmentType', 'ContactAssignmentType',
@ -25,53 +27,59 @@ class ContactAssignmentsMixin:
# Tenants # Tenants
# #
@strawberry_django.type(
models.Tenant,
fields='__all__',
filters=TenantFilter
)
class TenantType(NetBoxObjectType): class TenantType(NetBoxObjectType):
pass
class Meta:
model = models.Tenant
fields = '__all__'
filterset_class = filtersets.TenantFilterSet
@strawberry_django.type(
models.TenantGroup,
fields='__all__',
filters=TenantGroupFilter
)
class TenantGroupType(OrganizationalObjectType): class TenantGroupType(OrganizationalObjectType):
pass
class Meta:
model = models.TenantGroup
fields = '__all__'
filterset_class = filtersets.TenantGroupFilterSet
# #
# Contacts # Contacts
# #
@strawberry_django.type(
models.Contact,
fields='__all__',
filters=ContactFilter
)
class ContactType(ContactAssignmentsMixin, NetBoxObjectType): class ContactType(ContactAssignmentsMixin, NetBoxObjectType):
pass
class Meta:
model = models.Contact
fields = '__all__'
filterset_class = filtersets.ContactFilterSet
@strawberry_django.type(
models.ContactRole,
fields='__all__',
filters=ContactRoleFilter
)
class ContactRoleType(ContactAssignmentsMixin, OrganizationalObjectType): class ContactRoleType(ContactAssignmentsMixin, OrganizationalObjectType):
pass
class Meta:
model = models.ContactRole
fields = '__all__'
filterset_class = filtersets.ContactRoleFilterSet
@strawberry_django.type(
models.ContactGroup,
fields='__all__',
filters=ContactGroupFilter
)
class ContactGroupType(OrganizationalObjectType): class ContactGroupType(OrganizationalObjectType):
pass
class Meta:
model = models.ContactGroup
fields = '__all__'
filterset_class = filtersets.ContactGroupFilterSet
@strawberry_django.type(
models.ContactAssignment,
fields='__all__',
filters=ContactAssignmentFilter
)
class ContactAssignmentType(CustomFieldsMixin, TagsMixin, BaseObjectType): class ContactAssignmentType(CustomFieldsMixin, TagsMixin, BaseObjectType):
pass
class Meta:
model = models.ContactAssignment
fields = '__all__'
filterset_class = filtersets.ContactAssignmentFilterSet

0
netbox/virtualization/graphql/filters.py Normal file
View File

70
netbox/virtualization/graphql/types.py
View File

@ -1,8 +1,12 @@
import strawberry
import strawberry_django
from dcim.graphql.types import ComponentObjectType from dcim.graphql.types import ComponentObjectType
from extras.graphql.mixins import ConfigContextMixin from extras.graphql.mixins import ConfigContextMixin
from ipam.graphql.mixins import IPAddressesMixin, VLANGroupsMixin from ipam.graphql.mixins import IPAddressesMixin, VLANGroupsMixin
from netbox.graphql.types import OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import OrganizationalObjectType, NetBoxObjectType
from virtualization import filtersets, models from virtualization import models
from .filters import *
__all__ = ( __all__ = (
'ClusterType', 'ClusterType',
@ -14,55 +18,59 @@ __all__ = (
) )
@strawberry_django.type(
models.Cluster,
fields='__all__',
filters=ClusterFilter
)
class ClusterType(VLANGroupsMixin, NetBoxObjectType): class ClusterType(VLANGroupsMixin, NetBoxObjectType):
pass
class Meta:
model = models.Cluster
fields = '__all__'
filterset_class = filtersets.ClusterFilterSet
@strawberry_django.type(
models.ClusterGroup,
fields='__all__',
filters=ClusterGroupFilter
)
class ClusterGroupType(VLANGroupsMixin, OrganizationalObjectType): class ClusterGroupType(VLANGroupsMixin, OrganizationalObjectType):
pass
class Meta:
model = models.ClusterGroup
fields = '__all__'
filterset_class = filtersets.ClusterGroupFilterSet
@strawberry_django.type(
models.ClusterType,
fields='__all__',
filters=ClusterTypeFilter
)
class ClusterTypeType(OrganizationalObjectType): class ClusterTypeType(OrganizationalObjectType):
pass
class Meta:
model = models.ClusterType
fields = '__all__'
filterset_class = filtersets.ClusterTypeFilterSet
@strawberry_django.type(
models.VirtualMachine,
fields='__all__',
filters=VirtualMachineFilter
)
class VirtualMachineType(ConfigContextMixin, NetBoxObjectType): class VirtualMachineType(ConfigContextMixin, NetBoxObjectType):
pass
class Meta:
model = models.VirtualMachine
fields = '__all__'
filterset_class = filtersets.VirtualMachineFilterSet
@strawberry_django.type(
models.VMInterface,
fields='__all__',
filters=VMInterfaceFilter
)
class VMInterfaceType(IPAddressesMixin, ComponentObjectType): class VMInterfaceType(IPAddressesMixin, ComponentObjectType):
class Meta:
model = models.VMInterface
fields = '__all__'
filterset_class = filtersets.VMInterfaceFilterSet
def resolve_mode(self, info): def resolve_mode(self, info):
return self.mode or None return self.mode or None
@strawberry_django.type(
models.VirtualDisk,
fields='__all__',
filters=VirtualDiskFilter
)
class VirtualDiskType(ComponentObjectType): class VirtualDiskType(ComponentObjectType):
class Meta:
model = models.VirtualDisk
fields = '__all__'
filterset_class = filtersets.VirtualDiskFilterSet
def resolve_mode(self, info): def resolve_mode(self, info):
return self.mode or None return self.mode or None

0
netbox/vpn/graphql/filters.py Normal file
View File

114
netbox/vpn/graphql/types.py
View File

@ -1,8 +1,10 @@
import graphene import strawberry
import strawberry_django
from extras.graphql.mixins import ContactsMixin, CustomFieldsMixin, TagsMixin from extras.graphql.mixins import ContactsMixin, CustomFieldsMixin, TagsMixin
from netbox.graphql.types import ObjectType, OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import ObjectType, OrganizationalObjectType, NetBoxObjectType
from vpn import filtersets, models from vpn import models
from .filters import *
__all__ = ( __all__ = (
'IKEPolicyType', 'IKEPolicyType',
@ -18,81 +20,91 @@ __all__ = (
) )
@strawberry_django.type(
models.TunnelGroup,
fields='__all__',
filters=TunnelGroupFilter
)
class TunnelGroupType(OrganizationalObjectType): class TunnelGroupType(OrganizationalObjectType):
pass
class Meta:
model = models.TunnelGroup
fields = '__all__'
filterset_class = filtersets.TunnelGroupFilterSet
@strawberry_django.type(
models.TunnelTermination,
fields='__all__',
filters=TunnelTerminationFilter
)
class TunnelTerminationType(CustomFieldsMixin, TagsMixin, ObjectType): class TunnelTerminationType(CustomFieldsMixin, TagsMixin, ObjectType):
pass
class Meta:
model = models.TunnelTermination
fields = '__all__'
filterset_class = filtersets.TunnelTerminationFilterSet
@strawberry_django.type(
models.Tunnel,
fields='__all__',
filters=TunnelFilter
)
class TunnelType(NetBoxObjectType): class TunnelType(NetBoxObjectType):
pass
class Meta:
model = models.Tunnel
fields = '__all__'
filterset_class = filtersets.TunnelFilterSet
@strawberry_django.type(
models.IKEProposal,
fields='__all__',
filters=IKEProposalFilter
)
class IKEProposalType(OrganizationalObjectType): class IKEProposalType(OrganizationalObjectType):
pass
class Meta:
model = models.IKEProposal
fields = '__all__'
filterset_class = filtersets.IKEProposalFilterSet
@strawberry_django.type(
models.IKEPolicy,
fields='__all__',
filters=IKEPolicyFilter
)
class IKEPolicyType(OrganizationalObjectType): class IKEPolicyType(OrganizationalObjectType):
pass
class Meta:
model = models.IKEPolicy
fields = '__all__'
filterset_class = filtersets.IKEPolicyFilterSet
@strawberry_django.type(
models.IPSecProposal,
fields='__all__',
filters=IPSecProposalFilter
)
class IPSecProposalType(OrganizationalObjectType): class IPSecProposalType(OrganizationalObjectType):
pass
class Meta:
model = models.IPSecProposal
fields = '__all__'
filterset_class = filtersets.IPSecProposalFilterSet
@strawberry_django.type(
models.IPSecPolicy,
fields='__all__',
filters=IPSecPolicyFilter
)
class IPSecPolicyType(OrganizationalObjectType): class IPSecPolicyType(OrganizationalObjectType):
pass
class Meta:
model = models.IPSecPolicy
fields = '__all__'
filterset_class = filtersets.IPSecPolicyFilterSet
@strawberry_django.type(
models.IPSecProfile,
fields='__all__',
filters=IPSecProfileFilter
)
class IPSecProfileType(OrganizationalObjectType): class IPSecProfileType(OrganizationalObjectType):
pass
class Meta:
model = models.IPSecProfile
fields = '__all__'
filterset_class = filtersets.IPSecProfileFilterSet
@strawberry_django.type(
models.L2VPN,
fields='__all__',
filters=L2VPNFilter
)
class L2VPNType(ContactsMixin, NetBoxObjectType): class L2VPNType(ContactsMixin, NetBoxObjectType):
class Meta: pass
model = models.L2VPN
fields = '__all__'
filtersets_class = filtersets.L2VPNFilterSet
@strawberry_django.type(
models.L2VPNTermination,
exclude=('assigned_object_type', 'assigned_object_id'),
filters=L2VPNTerminationFilter
)
class L2VPNTerminationType(NetBoxObjectType): class L2VPNTerminationType(NetBoxObjectType):
assigned_object = graphene.Field('vpn.graphql.gfk_mixins.L2VPNAssignmentType') assigned_object = graphene.Field('vpn.graphql.gfk_mixins.L2VPNAssignmentType')
class Meta:
model = models.L2VPNTermination
exclude = ('assigned_object_type', 'assigned_object_id')
filtersets_class = filtersets.L2VPNTerminationFilterSet

0
netbox/wireless/graphql/filters.py Normal file
View File

37
netbox/wireless/graphql/types.py
View File

@ -1,5 +1,9 @@
from wireless import filtersets, models import strawberry
import strawberry_django
from wireless import models
from netbox.graphql.types import OrganizationalObjectType, NetBoxObjectType from netbox.graphql.types import OrganizationalObjectType, NetBoxObjectType
from .filters import *
__all__ = ( __all__ = (
'WirelessLANType', 'WirelessLANType',
@ -8,21 +12,22 @@ __all__ = (
) )
@strawberry_django.type(
models.WirelessLANGroup,
fields='__all__',
filters=WirelessLANGroupFilter
)
class WirelessLANGroupType(OrganizationalObjectType): class WirelessLANGroupType(OrganizationalObjectType):
pass
class Meta:
model = models.WirelessLANGroup
fields = '__all__'
filterset_class = filtersets.WirelessLANGroupFilterSet
@strawberry_django.type(
models.WirelessLAN,
fields='__all__',
filters=WirelessLANFilter
)
class WirelessLANType(NetBoxObjectType): class WirelessLANType(NetBoxObjectType):
class Meta:
model = models.WirelessLAN
fields = '__all__'
filterset_class = filtersets.WirelessLANFilterSet
def resolve_auth_type(self, info): def resolve_auth_type(self, info):
return self.auth_type or None return self.auth_type or None
@ -30,13 +35,13 @@ class WirelessLANType(NetBoxObjectType):
return self.auth_cipher or None return self.auth_cipher or None
@strawberry_django.type(
models.WirelessLink,
fields='__all__',
filters=WirelessLinkFilter
)
class WirelessLinkType(NetBoxObjectType): class WirelessLinkType(NetBoxObjectType):
class Meta:
model = models.WirelessLink
fields = '__all__'
filterset_class = filtersets.WirelessLinkFilterSet
def resolve_auth_type(self, info): def resolve_auth_type(self, info):
return self.auth_type or None return self.auth_type or None