Coverage for vpn/filtersets.py: 74%

1import django_filters 

2from django.db.models import Q 

3from django.utils.translation import gettext as _ 

4 

5from core.models import ObjectType 

6from dcim.models import Device, Interface 

7from ipam.models import VLAN, IPAddress, RouteTarget 

8from netbox.filtersets import NetBoxModelFilterSet, OrganizationalModelFilterSet, PrimaryModelFilterSet 

9from tenancy.filtersets import ContactModelFilterSet, TenancyFilterSet 

10from utilities.filters import MultiValueCharFilter, MultiValueContentTypeFilter, MultiValueNumberFilter 

11from utilities.filtersets import register_filterset 

12from virtualization.models import VirtualMachine, VMInterface 

13 

14from .choices import * 

15from .models import * 

16 

17__all__ = ( 

18 'IKEPolicyFilterSet', 

19 'IKEProposalFilterSet', 

20 'IPSecPolicyFilterSet', 

21 'IPSecProfileFilterSet', 

22 'IPSecProposalFilterSet', 

23 'L2VPNFilterSet', 

24 'L2VPNTerminationFilterSet', 

25 'TunnelFilterSet', 

26 'TunnelGroupFilterSet', 

27 'TunnelTerminationFilterSet', 

28) 

29 

30 

31@register_filterset 

32class TunnelGroupFilterSet(OrganizationalModelFilterSet, ContactModelFilterSet): 

33 

34 class Meta: 

35 model = TunnelGroup 

36 fields = ('id', 'name', 'slug', 'description') 

37 

38 

39@register_filterset 

40class TunnelFilterSet(PrimaryModelFilterSet, TenancyFilterSet, ContactModelFilterSet): 

41 status = django_filters.MultipleChoiceFilter( 

42 choices=TunnelStatusChoices, 

43 distinct=False, 

44 ) 

45 group_id = django_filters.ModelMultipleChoiceFilter( 

46 queryset=TunnelGroup.objects.all(), 

47 distinct=False, 

48 label=_('Tunnel group (ID)'), 

49 ) 

50 group = django_filters.ModelMultipleChoiceFilter( 

51 field_name='group__slug', 

52 queryset=TunnelGroup.objects.all(), 

53 distinct=False, 

54 to_field_name='slug', 

55 label=_('Tunnel group (slug)'), 

56 ) 

57 encapsulation = django_filters.MultipleChoiceFilter( 

58 choices=TunnelEncapsulationChoices, 

59 distinct=False, 

60 ) 

61 ipsec_profile_id = django_filters.ModelMultipleChoiceFilter( 

62 queryset=IPSecProfile.objects.all(), 

63 distinct=False, 

64 label=_('IPSec profile (ID)'), 

65 ) 

66 ipsec_profile = django_filters.ModelMultipleChoiceFilter( 

67 field_name='ipsec_profile__name', 

68 queryset=IPSecProfile.objects.all(), 

69 distinct=False, 

70 to_field_name='name', 

71 label=_('IPSec profile (name)'), 

72 ) 

73 

74 class Meta: 

75 model = Tunnel 

76 fields = ('id', 'name', 'tunnel_id', 'description') 

77 

78 def search(self, queryset, name, value): 

79 if not value.strip(): 

80 return queryset 

81 return queryset.filter( 

82 Q(name__icontains=value) | 

83 Q(description__icontains=value) | 

84 Q(comments__icontains=value) 

85 ) 

86 

87 

88@register_filterset 

89class TunnelTerminationFilterSet(NetBoxModelFilterSet): 

90 tunnel_id = django_filters.ModelMultipleChoiceFilter( 

91 field_name='tunnel', 

92 queryset=Tunnel.objects.all(), 

93 distinct=False, 

94 label=_('Tunnel (ID)'), 

95 ) 

96 tunnel = django_filters.ModelMultipleChoiceFilter( 

97 field_name='tunnel__name', 

98 queryset=Tunnel.objects.all(), 

99 distinct=False, 

100 to_field_name='name', 

101 label=_('Tunnel (name)'), 

102 ) 

103 role = django_filters.MultipleChoiceFilter( 

104 choices=TunnelTerminationRoleChoices, 

105 distinct=False, 

106 ) 

107 termination_type = MultiValueContentTypeFilter() 

108 interface = django_filters.ModelMultipleChoiceFilter( 

109 field_name='interface__name', 

110 queryset=Interface.objects.all(), 

111 to_field_name='name', 

112 label=_('Interface (name)'), 

113 ) 

114 interface_id = django_filters.ModelMultipleChoiceFilter( 

115 field_name='interface', 

116 queryset=Interface.objects.all(), 

117 label=_('Interface (ID)'), 

118 ) 

119 vminterface = django_filters.ModelMultipleChoiceFilter( 

120 field_name='vminterface__name', 

121 queryset=VMInterface.objects.all(), 

122 to_field_name='name', 

123 label=_('VM interface (name)'), 

124 ) 

125 vminterface_id = django_filters.ModelMultipleChoiceFilter( 

126 field_name='vminterface', 

127 queryset=VMInterface.objects.all(), 

128 label=_('VM interface (ID)'), 

129 ) 

130 outside_ip_id = django_filters.ModelMultipleChoiceFilter( 

131 field_name='outside_ip', 

132 queryset=IPAddress.objects.all(), 

133 distinct=False, 

134 label=_('Outside IP (ID)'), 

135 ) 

136 

137 class Meta: 

138 model = TunnelTermination 

139 fields = ('id', 'termination_id') 

140 

141 

142@register_filterset 

143class IKEProposalFilterSet(PrimaryModelFilterSet): 

144 ike_policy_id = django_filters.ModelMultipleChoiceFilter( 

145 field_name='ike_policies', 

146 queryset=IKEPolicy.objects.all(), 

147 label=_('IKE policy (ID)'), 

148 ) 

149 ike_policy = django_filters.ModelMultipleChoiceFilter( 

150 field_name='ike_policies__name', 

151 queryset=IKEPolicy.objects.all(), 

152 to_field_name='name', 

153 label=_('IKE policy (name)'), 

154 ) 

155 authentication_method = django_filters.MultipleChoiceFilter( 

156 choices=AuthenticationMethodChoices, 

157 distinct=False, 

158 ) 

159 encryption_algorithm = django_filters.MultipleChoiceFilter( 

160 choices=EncryptionAlgorithmChoices, 

161 distinct=False, 

162 ) 

163 authentication_algorithm = django_filters.MultipleChoiceFilter( 

164 choices=AuthenticationAlgorithmChoices, 

165 distinct=False, 

166 ) 

167 group = django_filters.MultipleChoiceFilter( 

168 choices=DHGroupChoices, 

169 distinct=False, 

170 ) 

171 

172 class Meta: 

173 model = IKEProposal 

174 fields = ('id', 'name', 'sa_lifetime', 'description') 

175 

176 def search(self, queryset, name, value): 

177 if not value.strip(): 

178 return queryset 

179 return queryset.filter( 

180 Q(name__icontains=value) | 

181 Q(description__icontains=value) | 

182 Q(comments__icontains=value) 

183 ) 

184 

185 

186@register_filterset 

187class IKEPolicyFilterSet(PrimaryModelFilterSet): 

188 version = django_filters.MultipleChoiceFilter( 

189 choices=IKEVersionChoices, 

190 distinct=False, 

191 ) 

192 mode = django_filters.MultipleChoiceFilter( 

193 choices=IKEModeChoices, 

194 distinct=False, 

195 ) 

196 ike_proposal_id = django_filters.ModelMultipleChoiceFilter( 

197 field_name='proposals', 

198 queryset=IKEProposal.objects.all() 

199 ) 

200 ike_proposal = django_filters.ModelMultipleChoiceFilter( 

201 field_name='proposals__name', 

202 queryset=IKEProposal.objects.all(), 

203 to_field_name='name' 

204 ) 

205 

206 class Meta: 

207 model = IKEPolicy 

208 fields = ('id', 'name', 'preshared_key', 'description') 

209 

210 def search(self, queryset, name, value): 

211 if not value.strip(): 

212 return queryset 

213 return queryset.filter( 

214 Q(name__icontains=value) | 

215 Q(description__icontains=value) | 

216 Q(comments__icontains=value) 

217 ) 

218 

219 

220@register_filterset 

221class IPSecProposalFilterSet(PrimaryModelFilterSet): 

222 ipsec_policy_id = django_filters.ModelMultipleChoiceFilter( 

223 field_name='ipsec_policies', 

224 queryset=IPSecPolicy.objects.all(), 

225 label=_('IPSec policy (ID)'), 

226 ) 

227 ipsec_policy = django_filters.ModelMultipleChoiceFilter( 

228 field_name='ipsec_policies__name', 

229 queryset=IPSecPolicy.objects.all(), 

230 to_field_name='name', 

231 label=_('IPSec policy (name)'), 

232 ) 

233 encryption_algorithm = django_filters.MultipleChoiceFilter( 

234 choices=EncryptionAlgorithmChoices, 

235 distinct=False, 

236 ) 

237 authentication_algorithm = django_filters.MultipleChoiceFilter( 

238 choices=AuthenticationAlgorithmChoices, 

239 distinct=False, 

240 ) 

241 

242 class Meta: 

243 model = IPSecProposal 

244 fields = ('id', 'name', 'sa_lifetime_seconds', 'sa_lifetime_data', 'description') 

245 

246 def search(self, queryset, name, value): 

247 if not value.strip(): 

248 return queryset 

249 return queryset.filter( 

250 Q(name__icontains=value) | 

251 Q(description__icontains=value) | 

252 Q(comments__icontains=value) 

253 ) 

254 

255 

256@register_filterset 

257class IPSecPolicyFilterSet(PrimaryModelFilterSet): 

258 pfs_group = django_filters.MultipleChoiceFilter( 

259 choices=DHGroupChoices, 

260 distinct=False, 

261 ) 

262 ipsec_proposal_id = django_filters.ModelMultipleChoiceFilter( 

263 field_name='proposals', 

264 queryset=IPSecProposal.objects.all() 

265 ) 

266 ipsec_proposal = django_filters.ModelMultipleChoiceFilter( 

267 field_name='proposals__name', 

268 queryset=IPSecProposal.objects.all(), 

269 to_field_name='name' 

270 ) 

271 

272 class Meta: 

273 model = IPSecPolicy 

274 fields = ('id', 'name', 'description') 

275 

276 def search(self, queryset, name, value): 

277 if not value.strip(): 

278 return queryset 

279 return queryset.filter( 

280 Q(name__icontains=value) | 

281 Q(description__icontains=value) | 

282 Q(comments__icontains=value) 

283 ) 

284 

285 

286@register_filterset 

287class IPSecProfileFilterSet(PrimaryModelFilterSet): 

288 mode = django_filters.MultipleChoiceFilter( 

289 choices=IPSecModeChoices, 

290 distinct=False, 

291 ) 

292 ike_policy_id = django_filters.ModelMultipleChoiceFilter( 

293 queryset=IKEPolicy.objects.all(), 

294 distinct=False, 

295 label=_('IKE policy (ID)'), 

296 ) 

297 ike_policy = django_filters.ModelMultipleChoiceFilter( 

298 field_name='ike_policy__name', 

299 queryset=IKEPolicy.objects.all(), 

300 distinct=False, 

301 to_field_name='name', 

302 label=_('IKE policy (name)'), 

303 ) 

304 ipsec_policy_id = django_filters.ModelMultipleChoiceFilter( 

305 queryset=IPSecPolicy.objects.all(), 

306 distinct=False, 

307 label=_('IPSec policy (ID)'), 

308 ) 

309 ipsec_policy = django_filters.ModelMultipleChoiceFilter( 

310 field_name='ipsec_policy__name', 

311 queryset=IPSecPolicy.objects.all(), 

312 distinct=False, 

313 to_field_name='name', 

314 label=_('IPSec policy (name)'), 

315 ) 

316 

317 class Meta: 

318 model = IPSecProfile 

319 fields = ('id', 'name', 'description') 

320 

321 def search(self, queryset, name, value): 

322 if not value.strip(): 

323 return queryset 

324 return queryset.filter( 

325 Q(name__icontains=value) | 

326 Q(description__icontains=value) | 

327 Q(comments__icontains=value) 

328 ) 

329 

330 

331@register_filterset 

332class L2VPNFilterSet(PrimaryModelFilterSet, TenancyFilterSet, ContactModelFilterSet): 

333 type = django_filters.MultipleChoiceFilter( 

334 choices=L2VPNTypeChoices, 

335 distinct=False, 

336 null_value=None 

337 ) 

338 status = django_filters.MultipleChoiceFilter( 

339 choices=L2VPNStatusChoices, 

340 distinct=False, 

341 ) 

342 import_target_id = django_filters.ModelMultipleChoiceFilter( 

343 field_name='import_targets', 

344 queryset=RouteTarget.objects.all(), 

345 label=_('Import target'), 

346 ) 

347 import_target = django_filters.ModelMultipleChoiceFilter( 

348 field_name='import_targets__name', 

349 queryset=RouteTarget.objects.all(), 

350 to_field_name='name', 

351 label=_('Import target (name)'), 

352 ) 

353 export_target_id = django_filters.ModelMultipleChoiceFilter( 

354 field_name='export_targets', 

355 queryset=RouteTarget.objects.all(), 

356 label=_('Export target'), 

357 ) 

358 export_target = django_filters.ModelMultipleChoiceFilter( 

359 field_name='export_targets__name', 

360 queryset=RouteTarget.objects.all(), 

361 to_field_name='name', 

362 label=_('Export target (name)'), 

363 ) 

364 

365 class Meta: 

366 model = L2VPN 

367 fields = ('id', 'identifier', 'name', 'slug', 'status', 'type', 'description') 

368 

369 def search(self, queryset, name, value): 

370 if not value.strip(): 

371 return queryset 

372 qs_filter = Q(name__icontains=value) | Q(description__icontains=value) 

373 try: 

374 qs_filter |= Q(identifier=int(value)) 

375 except ValueError: 

376 pass 

377 return queryset.filter(qs_filter) 

378 

379 

380@register_filterset 

381class L2VPNTerminationFilterSet(NetBoxModelFilterSet): 

382 l2vpn_id = django_filters.ModelMultipleChoiceFilter( 

383 queryset=L2VPN.objects.all(), 

384 distinct=False, 

385 label=_('L2VPN (ID)'), 

386 ) 

387 l2vpn = django_filters.ModelMultipleChoiceFilter( 

388 field_name='l2vpn__slug', 

389 queryset=L2VPN.objects.all(), 

390 distinct=False, 

391 to_field_name='slug', 

392 label=_('L2VPN (slug)'), 

393 ) 

394 region = MultiValueCharFilter( 

395 method='filter_region', 

396 field_name='slug', 

397 label=_('Region (slug)'), 

398 ) 

399 region_id = MultiValueNumberFilter( 

400 method='filter_region', 

401 field_name='pk', 

402 label=_('Region (ID)'), 

403 ) 

404 site = MultiValueCharFilter( 

405 method='filter_site', 

406 field_name='slug', 

407 label=_('Site (slug)'), 

408 ) 

409 site_id = MultiValueNumberFilter( 

410 method='filter_site', 

411 field_name='pk', 

412 label=_('Site (ID)'), 

413 ) 

414 device = django_filters.ModelMultipleChoiceFilter( 

415 field_name='interface__device__name', 

416 queryset=Device.objects.all(), 

417 to_field_name='name', 

418 label=_('Device (name)'), 

419 ) 

420 device_id = django_filters.ModelMultipleChoiceFilter( 

421 field_name='interface__device', 

422 queryset=Device.objects.all(), 

423 label=_('Device (ID)'), 

424 ) 

425 virtual_machine = django_filters.ModelMultipleChoiceFilter( 

426 field_name='vminterface__virtual_machine__name', 

427 queryset=VirtualMachine.objects.all(), 

428 to_field_name='name', 

429 label=_('Virtual machine (name)'), 

430 ) 

431 virtual_machine_id = django_filters.ModelMultipleChoiceFilter( 

432 field_name='vminterface__virtual_machine', 

433 queryset=VirtualMachine.objects.all(), 

434 label=_('Virtual machine (ID)'), 

435 ) 

436 interface = django_filters.ModelMultipleChoiceFilter( 

437 field_name='interface__name', 

438 queryset=Interface.objects.all(), 

439 to_field_name='name', 

440 label=_('Interface (name)'), 

441 ) 

442 interface_id = django_filters.ModelMultipleChoiceFilter( 

443 field_name='interface', 

444 queryset=Interface.objects.all(), 

445 label=_('Interface (ID)'), 

446 ) 

447 vminterface = django_filters.ModelMultipleChoiceFilter( 

448 field_name='vminterface__name', 

449 queryset=VMInterface.objects.all(), 

450 to_field_name='name', 

451 label=_('VM interface (name)'), 

452 ) 

453 vminterface_id = django_filters.ModelMultipleChoiceFilter( 

454 field_name='vminterface', 

455 queryset=VMInterface.objects.all(), 

456 label=_('VM Interface (ID)'), 

457 ) 

458 vlan = django_filters.ModelMultipleChoiceFilter( 

459 field_name='vlan__name', 

460 queryset=VLAN.objects.all(), 

461 to_field_name='name', 

462 label=_('VLAN (name)'), 

463 ) 

464 vlan_vid = django_filters.NumberFilter( 

465 field_name='vlan__vid', 

466 label=_('VLAN number (1-4094)'), 

467 ) 

468 vlan_id = django_filters.ModelMultipleChoiceFilter( 

469 field_name='vlan', 

470 queryset=VLAN.objects.all(), 

471 label=_('VLAN (ID)'), 

472 ) 

473 assigned_object_type_id = django_filters.ModelMultipleChoiceFilter( 

474 queryset=ObjectType.objects.all(), 

475 distinct=False, 

476 field_name='assigned_object_type' 

477 ) 

478 assigned_object_type = MultiValueContentTypeFilter() 

479 

480 class Meta: 

481 model = L2VPNTermination 

482 fields = ('id', 'assigned_object_id') 

483 

484 def search(self, queryset, name, value): 

485 if not value.strip(): 

486 return queryset 

487 qs_filter = Q(l2vpn__name__icontains=value) 

488 return queryset.filter(qs_filter) 

489 

490 def filter_assigned_object(self, queryset, name, value): 

491 qs = queryset.filter( 

492 Q(**{'{}__in'.format(name): value}) 

493 ) 

494 return qs 

495 

496 def filter_site(self, queryset, name, value): 

497 qs = queryset.filter( 

498 Q( 

499 Q(**{'vlan__site__{}__in'.format(name): value}) | 

500 Q(**{'interface__device__site__{}__in'.format(name): value}) | 

501 Q(**{'vminterface__virtual_machine__site__{}__in'.format(name): value}) 

502 ) 

503 ) 

504 return qs 

505 

506 def filter_region(self, queryset, name, value): 

507 qs = queryset.filter( 

508 Q( 

509 Q(**{'vlan__site__region__{}__in'.format(name): value}) | 

510 Q(**{'interface__device__site__region__{}__in'.format(name): value}) | 

511 Q(**{'vminterface__virtual_machine__site__region__{}__in'.format(name): value}) 

512 ) 

513 ) 

514 return qs