Coverage for vpn/graphql/filters.py: 95%

1from typing import TYPE_CHECKING, Annotated 

2 

3import strawberry 

4import strawberry_django 

5from strawberry.scalars import ID 

6from strawberry_django import BaseFilterLookup, StrFilterLookup 

7 

8from extras.graphql.filter_mixins import CustomFieldsFilterMixin, TagsFilterMixin 

9from netbox.graphql.filters import ( 

10 ChangeLoggedModelFilter, 

11 NetBoxModelFilter, 

12 OrganizationalModelFilter, 

13 PrimaryModelFilter, 

14 register_filter, 

15) 

16from tenancy.graphql.filter_mixins import ContactFilterMixin, TenancyFilterMixin 

17from vpn import models 

18 

19if TYPE_CHECKING: 19 ↛ 20line 19 didn't jump to line 20 because the condition on line 19 was never true

20 from core.graphql.filters import ContentTypeFilter 

21 from ipam.graphql.filters import IPAddressFilter, RouteTargetFilter 

22 from netbox.graphql.filter_lookups import BigIntegerLookup, IntegerLookup 

23 

24 from .enums import * 

25 

26__all__ = ( 

27 'IKEPolicyFilter', 

28 'IKEProposalFilter', 

29 'IPSecPolicyFilter', 

30 'IPSecProfileFilter', 

31 'IPSecProposalFilter', 

32 'L2VPNFilter', 

33 'L2VPNTerminationFilter', 

34 'TunnelFilter', 

35 'TunnelGroupFilter', 

36 'TunnelTerminationFilter', 

37) 

38 

39 

40@register_filter(models.TunnelGroup, lookups=True) 

41class TunnelGroupFilter(OrganizationalModelFilter): 

42 pass 

43 

44 

45@register_filter(models.TunnelTermination, lookups=True) 

46class TunnelTerminationFilter(CustomFieldsFilterMixin, TagsFilterMixin, ChangeLoggedModelFilter): 

47 tunnel: Annotated['TunnelFilter', strawberry.lazy('vpn.graphql.filters')] | None = strawberry_django.filter_field() 

48 tunnel_id: ID | None = strawberry_django.filter_field() 

49 role: BaseFilterLookup[Annotated['TunnelTerminationRoleEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

50 strawberry_django.filter_field() 

51 ) 

52 termination_type: ( 

53 BaseFilterLookup[Annotated['TunnelTerminationTypeEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

54 ) = ( 

55 strawberry_django.filter_field() 

56 ) 

57 termination_type_id: ID | None = strawberry_django.filter_field() 

58 termination_id: ID | None = strawberry_django.filter_field() 

59 outside_ip: Annotated['IPAddressFilter', strawberry.lazy('ipam.graphql.filters')] | None = ( 

60 strawberry_django.filter_field() 

61 ) 

62 outside_ip_id: ID | None = strawberry_django.filter_field() 

63 

64 

65@register_filter(models.Tunnel, lookups=True) 

66class TunnelFilter(TenancyFilterMixin, PrimaryModelFilter): 

67 name: StrFilterLookup | None = strawberry_django.filter_field() 

68 status: BaseFilterLookup[Annotated['TunnelStatusEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

69 strawberry_django.filter_field() 

70 ) 

71 group: Annotated['TunnelGroupFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

72 strawberry_django.filter_field() 

73 ) 

74 group_id: ID | None = strawberry_django.filter_field() 

75 encapsulation: ( 

76 BaseFilterLookup[Annotated['TunnelEncapsulationEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

77 ) = ( 

78 strawberry_django.filter_field() 

79 ) 

80 ipsec_profile: Annotated['IPSecProfileFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

81 strawberry_django.filter_field() 

82 ) 

83 tunnel_id: Annotated['BigIntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

84 strawberry_django.filter_field() 

85 ) 

86 terminations: Annotated['TunnelTerminationFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

87 strawberry_django.filter_field() 

88 ) 

89 

90 

91@register_filter(models.IKEProposal, lookups=True) 

92class IKEProposalFilter(PrimaryModelFilter): 

93 name: StrFilterLookup | None = strawberry_django.filter_field() 

94 authentication_method: ( 

95 BaseFilterLookup[Annotated['AuthenticationMethodEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

96 ) = ( 

97 strawberry_django.filter_field() 

98 ) 

99 encryption_algorithm: ( 

100 BaseFilterLookup[Annotated['EncryptionAlgorithmEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

101 ) = ( 

102 strawberry_django.filter_field() 

103 ) 

104 authentication_algorithm: ( 

105 BaseFilterLookup[Annotated['AuthenticationAlgorithmEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

106 ) = ( 

107 strawberry_django.filter_field() 

108 ) 

109 group: BaseFilterLookup[Annotated['DHGroupEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

110 strawberry_django.filter_field() 

111 ) 

112 sa_lifetime: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

113 strawberry_django.filter_field() 

114 ) 

115 ike_policies: Annotated['IKEPolicyFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

116 strawberry_django.filter_field() 

117 ) 

118 

119 

120@register_filter(models.IKEPolicy, lookups=True) 

121class IKEPolicyFilter(PrimaryModelFilter): 

122 name: StrFilterLookup | None = strawberry_django.filter_field() 

123 version: BaseFilterLookup[Annotated['IKEVersionEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

124 strawberry_django.filter_field() 

125 ) 

126 mode: BaseFilterLookup[Annotated['IKEModeEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

127 strawberry_django.filter_field() 

128 ) 

129 proposals: Annotated['IKEProposalFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

130 strawberry_django.filter_field() 

131 ) 

132 preshared_key: StrFilterLookup | None = strawberry_django.filter_field() 

133 

134 

135@register_filter(models.IPSecProposal, lookups=True) 

136class IPSecProposalFilter(PrimaryModelFilter): 

137 name: StrFilterLookup | None = strawberry_django.filter_field() 

138 encryption_algorithm: ( 

139 BaseFilterLookup[Annotated['EncryptionAlgorithmEnum', strawberry.lazy('vpn.graphql.enums')]] | None 

140 ) = ( 

141 strawberry_django.filter_field() 

142 ) 

143 authentication_algorithm: ( 

144 BaseFilterLookup[ 

145 BaseFilterLookup[Annotated['AuthenticationAlgorithmEnum', strawberry.lazy('vpn.graphql.enums')]] 

146 ] | None 

147 ) = ( 

148 strawberry_django.filter_field() 

149 ) 

150 sa_lifetime_seconds: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

151 strawberry_django.filter_field() 

152 ) 

153 sa_lifetime_data: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

154 strawberry_django.filter_field() 

155 ) 

156 ipsec_policies: Annotated['IPSecPolicyFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

157 strawberry_django.filter_field() 

158 ) 

159 

160 

161@register_filter(models.IPSecPolicy, lookups=True) 

162class IPSecPolicyFilter(PrimaryModelFilter): 

163 name: StrFilterLookup | None = strawberry_django.filter_field() 

164 proposals: Annotated['IPSecProposalFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

165 strawberry_django.filter_field() 

166 ) 

167 pfs_group: BaseFilterLookup[Annotated['DHGroupEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

168 strawberry_django.filter_field() 

169 ) 

170 

171 

172@register_filter(models.IPSecProfile, lookups=True) 

173class IPSecProfileFilter(PrimaryModelFilter): 

174 name: StrFilterLookup | None = strawberry_django.filter_field() 

175 mode: BaseFilterLookup[Annotated['IPSecModeEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

176 strawberry_django.filter_field() 

177 ) 

178 ike_policy: Annotated['IKEPolicyFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

179 strawberry_django.filter_field() 

180 ) 

181 ike_policy_id: ID | None = strawberry_django.filter_field() 

182 ipsec_policy: Annotated['IPSecPolicyFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

183 strawberry_django.filter_field() 

184 ) 

185 ipsec_policy_id: ID | None = strawberry_django.filter_field() 

186 

187 

188@register_filter(models.L2VPN, lookups=True) 

189class L2VPNFilter(ContactFilterMixin, TenancyFilterMixin, PrimaryModelFilter): 

190 name: StrFilterLookup | None = strawberry_django.filter_field() 

191 slug: StrFilterLookup | None = strawberry_django.filter_field() 

192 type: BaseFilterLookup[Annotated['L2VPNTypeEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

193 strawberry_django.filter_field() 

194 ) 

195 identifier: Annotated['BigIntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

196 strawberry_django.filter_field() 

197 ) 

198 import_targets: Annotated['RouteTargetFilter', strawberry.lazy('ipam.graphql.filters')] | None = ( 

199 strawberry_django.filter_field() 

200 ) 

201 export_targets: Annotated['RouteTargetFilter', strawberry.lazy('ipam.graphql.filters')] | None = ( 

202 strawberry_django.filter_field() 

203 ) 

204 terminations: Annotated['L2VPNTerminationFilter', strawberry.lazy('vpn.graphql.filters')] | None = ( 

205 strawberry_django.filter_field() 

206 ) 

207 status: BaseFilterLookup[Annotated['L2VPNStatusEnum', strawberry.lazy('vpn.graphql.enums')]] | None = ( 

208 strawberry_django.filter_field() 

209 ) 

210 

211 

212@register_filter(models.L2VPNTermination, lookups=True) 

213class L2VPNTerminationFilter(NetBoxModelFilter): 

214 l2vpn: Annotated['L2VPNFilter', strawberry.lazy('vpn.graphql.filters')] | None = strawberry_django.filter_field() 

215 l2vpn_id: ID | None = strawberry_django.filter_field() 

216 assigned_object_type: Annotated['ContentTypeFilter', strawberry.lazy('core.graphql.filters')] | None = ( 

217 strawberry_django.filter_field() 

218 ) 

219 assigned_object_id: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = ( 

220 strawberry_django.filter_field() 

221 )