Coverage for vpn/views.py: 97%

1from django.utils.translation import gettext_lazy as _ 

2 

3from extras.ui.panels import CustomFieldsPanel, TagsPanel 

4from ipam.tables import RouteTargetTable 

5from netbox.object_actions import AddObject, BulkDelete, BulkEdit, BulkExport, BulkImport 

6from netbox.ui import actions, layout 

7from netbox.ui.panels import ( 

8 CommentsPanel, 

9 ContextTablePanel, 

10 ObjectsTablePanel, 

11 PluginContentPanel, 

12 RelatedObjectsPanel, 

13) 

14from netbox.views import generic 

15from utilities.query import count_related 

16from utilities.views import GetRelatedModelsMixin, register_model_view 

17 

18from . import filtersets, forms, tables 

19from .models import * 

20from .ui import panels 

21 

22# 

23# Tunnel groups 

24# 

25 

26 

27@register_model_view(TunnelGroup, 'list', path='', detail=False) 

28class TunnelGroupListView(generic.ObjectListView): 

29 queryset = TunnelGroup.objects.annotate( 

30 tunnel_count=count_related(Tunnel, 'group') 

31 ) 

32 filterset = filtersets.TunnelGroupFilterSet 

33 filterset_form = forms.TunnelGroupFilterForm 

34 table = tables.TunnelGroupTable 

35 

36 

37@register_model_view(TunnelGroup) 

38class TunnelGroupView(GetRelatedModelsMixin, generic.ObjectView): 

39 queryset = TunnelGroup.objects.all() 

40 layout = layout.SimpleLayout( 

41 left_panels=[ 

42 panels.TunnelGroupPanel(), 

43 TagsPanel(), 

44 ], 

45 right_panels=[ 

46 RelatedObjectsPanel(), 

47 CommentsPanel(), 

48 CustomFieldsPanel(), 

49 ], 

50 ) 

51 

52 def get_extra_context(self, request, instance): 

53 return { 

54 'related_models': self.get_related_models(request, instance), 

55 } 

56 

57 

58@register_model_view(TunnelGroup, 'add', detail=False) 

59@register_model_view(TunnelGroup, 'edit') 

60class TunnelGroupEditView(generic.ObjectEditView): 

61 queryset = TunnelGroup.objects.all() 

62 form = forms.TunnelGroupForm 

63 

64 

65@register_model_view(TunnelGroup, 'delete') 

66class TunnelGroupDeleteView(generic.ObjectDeleteView): 

67 queryset = TunnelGroup.objects.all() 

68 

69 

70@register_model_view(TunnelGroup, 'bulk_import', path='import', detail=False) 

71class TunnelGroupBulkImportView(generic.BulkImportView): 

72 queryset = TunnelGroup.objects.all() 

73 model_form = forms.TunnelGroupImportForm 

74 

75 

76@register_model_view(TunnelGroup, 'bulk_edit', path='edit', detail=False) 

77class TunnelGroupBulkEditView(generic.BulkEditView): 

78 queryset = TunnelGroup.objects.annotate( 

79 tunnel_count=count_related(Tunnel, 'group') 

80 ) 

81 filterset = filtersets.TunnelGroupFilterSet 

82 table = tables.TunnelGroupTable 

83 form = forms.TunnelGroupBulkEditForm 

84 

85 

86@register_model_view(TunnelGroup, 'bulk_rename', path='rename', detail=False) 

87class TunnelGroupBulkRenameView(generic.BulkRenameView): 

88 queryset = TunnelGroup.objects.all() 

89 filterset = filtersets.TunnelGroupFilterSet 

90 

91 

92@register_model_view(TunnelGroup, 'bulk_delete', path='delete', detail=False) 

93class TunnelGroupBulkDeleteView(generic.BulkDeleteView): 

94 queryset = TunnelGroup.objects.annotate( 

95 tunnel_count=count_related(Tunnel, 'group') 

96 ) 

97 filterset = filtersets.TunnelGroupFilterSet 

98 table = tables.TunnelGroupTable 

99 

100 

101# 

102# Tunnels 

103# 

104 

105@register_model_view(Tunnel, 'list', path='', detail=False) 

106class TunnelListView(generic.ObjectListView): 

107 queryset = Tunnel.objects.annotate( 

108 count_terminations=count_related(TunnelTermination, 'tunnel') 

109 ) 

110 filterset = filtersets.TunnelFilterSet 

111 filterset_form = forms.TunnelFilterForm 

112 table = tables.TunnelTable 

113 

114 

115@register_model_view(Tunnel) 

116class TunnelView(generic.ObjectView): 

117 queryset = Tunnel.objects.all() 

118 layout = layout.SimpleLayout( 

119 left_panels=[ 

120 panels.TunnelPanel(), 

121 ], 

122 right_panels=[ 

123 CustomFieldsPanel(), 

124 TagsPanel(), 

125 CommentsPanel(), 

126 ], 

127 bottom_panels=[ 

128 ObjectsTablePanel( 

129 'vpn.tunneltermination', 

130 filters={'tunnel_id': lambda ctx: ctx['object'].pk}, 

131 exclude_columns=['tunnel'], 

132 actions=[ 

133 actions.AddObject( 

134 'vpn.tunneltermination', 

135 url_params={'tunnel': lambda ctx: ctx['object'].pk}, 

136 label=_('Add a Termination'), 

137 ), 

138 ], 

139 title=_('Terminations'), 

140 ), 

141 ], 

142 ) 

143 

144 

145@register_model_view(Tunnel, 'add', detail=False) 

146@register_model_view(Tunnel, 'edit') 

147class TunnelEditView(generic.ObjectEditView): 

148 queryset = Tunnel.objects.all() 

149 form = forms.TunnelForm 

150 

151 def dispatch(self, request, *args, **kwargs): 

152 

153 # If creating a new Tunnel, use the creation form 

154 if 'pk' not in kwargs: 

155 self.form = forms.TunnelCreateForm 

156 

157 return super().dispatch(request, *args, **kwargs) 

158 

159 

160@register_model_view(Tunnel, 'delete') 

161class TunnelDeleteView(generic.ObjectDeleteView): 

162 queryset = Tunnel.objects.all() 

163 

164 

165@register_model_view(Tunnel, 'bulk_import', path='import', detail=False) 

166class TunnelBulkImportView(generic.BulkImportView): 

167 queryset = Tunnel.objects.all() 

168 model_form = forms.TunnelImportForm 

169 

170 

171@register_model_view(Tunnel, 'bulk_edit', path='edit', detail=False) 

172class TunnelBulkEditView(generic.BulkEditView): 

173 queryset = Tunnel.objects.annotate( 

174 count_terminations=count_related(TunnelTermination, 'tunnel') 

175 ) 

176 filterset = filtersets.TunnelFilterSet 

177 table = tables.TunnelTable 

178 form = forms.TunnelBulkEditForm 

179 

180 

181@register_model_view(Tunnel, 'bulk_rename', path='rename', detail=False) 

182class TunnelBulkRenameView(generic.BulkRenameView): 

183 queryset = Tunnel.objects.all() 

184 filterset = filtersets.TunnelFilterSet 

185 

186 

187@register_model_view(Tunnel, 'bulk_delete', path='delete', detail=False) 

188class TunnelBulkDeleteView(generic.BulkDeleteView): 

189 queryset = Tunnel.objects.annotate( 

190 count_terminations=count_related(TunnelTermination, 'tunnel') 

191 ) 

192 filterset = filtersets.TunnelFilterSet 

193 table = tables.TunnelTable 

194 

195 

196# 

197# Tunnel terminations 

198# 

199 

200@register_model_view(TunnelTermination, 'list', path='', detail=False) 

201class TunnelTerminationListView(generic.ObjectListView): 

202 queryset = TunnelTermination.objects.all() 

203 filterset = filtersets.TunnelTerminationFilterSet 

204 filterset_form = forms.TunnelTerminationFilterForm 

205 table = tables.TunnelTerminationTable 

206 

207 

208@register_model_view(TunnelTermination) 

209class TunnelTerminationView(generic.ObjectView): 

210 queryset = TunnelTermination.objects.all() 

211 template_name = 'generic/object.html' 

212 layout = layout.SimpleLayout( 

213 left_panels=[ 

214 panels.TunnelTerminationPanel(), 

215 ], 

216 right_panels=[ 

217 CustomFieldsPanel(), 

218 TagsPanel(), 

219 ], 

220 bottom_panels=[ 

221 ObjectsTablePanel( 

222 'vpn.tunneltermination', 

223 filters={ 

224 'tunnel_id': lambda ctx: ctx['object'].tunnel.pk, 

225 'id__n': lambda ctx: ctx['object'].pk, 

226 }, 

227 exclude_columns=['tunnel'], 

228 title=_('Peer Terminations'), 

229 ), 

230 ], 

231 ) 

232 

233 

234@register_model_view(TunnelTermination, 'add', detail=False) 

235@register_model_view(TunnelTermination, 'edit') 

236class TunnelTerminationEditView(generic.ObjectEditView): 

237 queryset = TunnelTermination.objects.all() 

238 form = forms.TunnelTerminationForm 

239 

240 

241@register_model_view(TunnelTermination, 'delete') 

242class TunnelTerminationDeleteView(generic.ObjectDeleteView): 

243 queryset = TunnelTermination.objects.all() 

244 

245 

246@register_model_view(TunnelTermination, 'bulk_import', path='import', detail=False) 

247class TunnelTerminationBulkImportView(generic.BulkImportView): 

248 queryset = TunnelTermination.objects.all() 

249 model_form = forms.TunnelTerminationImportForm 

250 

251 

252@register_model_view(TunnelTermination, 'bulk_edit', path='edit', detail=False) 

253class TunnelTerminationBulkEditView(generic.BulkEditView): 

254 queryset = TunnelTermination.objects.all() 

255 filterset = filtersets.TunnelTerminationFilterSet 

256 table = tables.TunnelTerminationTable 

257 form = forms.TunnelTerminationBulkEditForm 

258 

259 

260@register_model_view(TunnelTermination, 'bulk_delete', path='delete', detail=False) 

261class TunnelTerminationBulkDeleteView(generic.BulkDeleteView): 

262 queryset = TunnelTermination.objects.all() 

263 filterset = filtersets.TunnelTerminationFilterSet 

264 table = tables.TunnelTerminationTable 

265 

266 

267# 

268# IKE proposals 

269# 

270 

271@register_model_view(IKEProposal, 'list', path='', detail=False) 

272class IKEProposalListView(generic.ObjectListView): 

273 queryset = IKEProposal.objects.all() 

274 filterset = filtersets.IKEProposalFilterSet 

275 filterset_form = forms.IKEProposalFilterForm 

276 table = tables.IKEProposalTable 

277 

278 

279@register_model_view(IKEProposal) 

280class IKEProposalView(generic.ObjectView): 

281 queryset = IKEProposal.objects.all() 

282 template_name = 'generic/object.html' 

283 layout = layout.SimpleLayout( 

284 left_panels=[ 

285 panels.IKEProposalPanel(), 

286 ], 

287 right_panels=[ 

288 CustomFieldsPanel(), 

289 CommentsPanel(), 

290 TagsPanel(), 

291 ], 

292 bottom_panels=[ 

293 ObjectsTablePanel( 

294 'vpn.ikepolicy', 

295 filters={'ike_proposal_id': lambda ctx: ctx['object'].pk}, 

296 title=_('IKE Policies'), 

297 ), 

298 ], 

299 ) 

300 

301 

302@register_model_view(IKEProposal, 'add', detail=False) 

303@register_model_view(IKEProposal, 'edit') 

304class IKEProposalEditView(generic.ObjectEditView): 

305 queryset = IKEProposal.objects.all() 

306 form = forms.IKEProposalForm 

307 

308 

309@register_model_view(IKEProposal, 'delete') 

310class IKEProposalDeleteView(generic.ObjectDeleteView): 

311 queryset = IKEProposal.objects.all() 

312 

313 

314@register_model_view(IKEProposal, 'bulk_import', path='import', detail=False) 

315class IKEProposalBulkImportView(generic.BulkImportView): 

316 queryset = IKEProposal.objects.all() 

317 model_form = forms.IKEProposalImportForm 

318 

319 

320@register_model_view(IKEProposal, 'bulk_edit', path='edit', detail=False) 

321class IKEProposalBulkEditView(generic.BulkEditView): 

322 queryset = IKEProposal.objects.all() 

323 filterset = filtersets.IKEProposalFilterSet 

324 table = tables.IKEProposalTable 

325 form = forms.IKEProposalBulkEditForm 

326 

327 

328@register_model_view(IKEProposal, 'bulk_rename', path='rename', detail=False) 

329class IKEProposalBulkRenameView(generic.BulkRenameView): 

330 queryset = IKEProposal.objects.all() 

331 filterset = filtersets.IKEProposalFilterSet 

332 

333 

334@register_model_view(IKEProposal, 'bulk_delete', path='delete', detail=False) 

335class IKEProposalBulkDeleteView(generic.BulkDeleteView): 

336 queryset = IKEProposal.objects.all() 

337 filterset = filtersets.IKEProposalFilterSet 

338 table = tables.IKEProposalTable 

339 

340 

341# 

342# IKE policies 

343# 

344 

345@register_model_view(IKEPolicy, 'list', path='', detail=False) 

346class IKEPolicyListView(generic.ObjectListView): 

347 queryset = IKEPolicy.objects.all() 

348 filterset = filtersets.IKEPolicyFilterSet 

349 filterset_form = forms.IKEPolicyFilterForm 

350 table = tables.IKEPolicyTable 

351 

352 

353@register_model_view(IKEPolicy) 

354class IKEPolicyView(GetRelatedModelsMixin, generic.ObjectView): 

355 queryset = IKEPolicy.objects.all() 

356 template_name = 'generic/object.html' 

357 layout = layout.SimpleLayout( 

358 left_panels=[ 

359 panels.IKEPolicyPanel(), 

360 ], 

361 right_panels=[ 

362 CustomFieldsPanel(), 

363 CommentsPanel(), 

364 TagsPanel(), 

365 RelatedObjectsPanel(), 

366 ], 

367 bottom_panels=[ 

368 ObjectsTablePanel( 

369 'vpn.ikeproposal', 

370 filters={'ike_policy_id': lambda ctx: ctx['object'].pk}, 

371 title=_('Proposals'), 

372 ), 

373 ], 

374 ) 

375 

376 def get_extra_context(self, request, instance): 

377 return { 

378 'related_models': self.get_related_models(request, instance), 

379 } 

380 

381 

382@register_model_view(IKEPolicy, 'add', detail=False) 

383@register_model_view(IKEPolicy, 'edit') 

384class IKEPolicyEditView(generic.ObjectEditView): 

385 queryset = IKEPolicy.objects.all() 

386 form = forms.IKEPolicyForm 

387 

388 

389@register_model_view(IKEPolicy, 'delete') 

390class IKEPolicyDeleteView(generic.ObjectDeleteView): 

391 queryset = IKEPolicy.objects.all() 

392 

393 

394@register_model_view(IKEPolicy, 'bulk_import', path='import', detail=False) 

395class IKEPolicyBulkImportView(generic.BulkImportView): 

396 queryset = IKEPolicy.objects.all() 

397 model_form = forms.IKEPolicyImportForm 

398 

399 

400@register_model_view(IKEPolicy, 'bulk_edit', path='edit', detail=False) 

401class IKEPolicyBulkEditView(generic.BulkEditView): 

402 queryset = IKEPolicy.objects.all() 

403 filterset = filtersets.IKEPolicyFilterSet 

404 table = tables.IKEPolicyTable 

405 form = forms.IKEPolicyBulkEditForm 

406 

407 

408@register_model_view(IKEPolicy, 'bulk_rename', path='rename', detail=False) 

409class IKEPolicyBulkRenameView(generic.BulkRenameView): 

410 queryset = IKEPolicy.objects.all() 

411 filterset = filtersets.IKEPolicyFilterSet 

412 

413 

414@register_model_view(IKEPolicy, 'bulk_delete', path='delete', detail=False) 

415class IKEPolicyBulkDeleteView(generic.BulkDeleteView): 

416 queryset = IKEPolicy.objects.all() 

417 filterset = filtersets.IKEPolicyFilterSet 

418 table = tables.IKEPolicyTable 

419 

420 

421# 

422# IPSec proposals 

423# 

424 

425@register_model_view(IPSecProposal, 'list', path='', detail=False) 

426class IPSecProposalListView(generic.ObjectListView): 

427 queryset = IPSecProposal.objects.all() 

428 filterset = filtersets.IPSecProposalFilterSet 

429 filterset_form = forms.IPSecProposalFilterForm 

430 table = tables.IPSecProposalTable 

431 

432 

433@register_model_view(IPSecProposal) 

434class IPSecProposalView(generic.ObjectView): 

435 queryset = IPSecProposal.objects.all() 

436 template_name = 'generic/object.html' 

437 layout = layout.SimpleLayout( 

438 left_panels=[ 

439 panels.IPSecProposalPanel(), 

440 ], 

441 right_panels=[ 

442 CustomFieldsPanel(), 

443 CommentsPanel(), 

444 TagsPanel(), 

445 ], 

446 bottom_panels=[ 

447 ObjectsTablePanel( 

448 'vpn.ipsecpolicy', 

449 filters={'ipsec_proposal_id': lambda ctx: ctx['object'].pk}, 

450 title=_('IPSec Policies'), 

451 ), 

452 ], 

453 ) 

454 

455 

456@register_model_view(IPSecProposal, 'add', detail=False) 

457@register_model_view(IPSecProposal, 'edit') 

458class IPSecProposalEditView(generic.ObjectEditView): 

459 queryset = IPSecProposal.objects.all() 

460 form = forms.IPSecProposalForm 

461 

462 

463@register_model_view(IPSecProposal, 'delete') 

464class IPSecProposalDeleteView(generic.ObjectDeleteView): 

465 queryset = IPSecProposal.objects.all() 

466 

467 

468@register_model_view(IPSecProposal, 'bulk_import', path='import', detail=False) 

469class IPSecProposalBulkImportView(generic.BulkImportView): 

470 queryset = IPSecProposal.objects.all() 

471 model_form = forms.IPSecProposalImportForm 

472 

473 

474@register_model_view(IPSecProposal, 'bulk_edit', path='edit', detail=False) 

475class IPSecProposalBulkEditView(generic.BulkEditView): 

476 queryset = IPSecProposal.objects.all() 

477 filterset = filtersets.IPSecProposalFilterSet 

478 table = tables.IPSecProposalTable 

479 form = forms.IPSecProposalBulkEditForm 

480 

481 

482@register_model_view(IPSecProposal, 'bulk_rename', path='rename', detail=False) 

483class IPSecProposalBulkRenameView(generic.BulkRenameView): 

484 queryset = IPSecProposal.objects.all() 

485 filterset = filtersets.IPSecProposalFilterSet 

486 

487 

488@register_model_view(IPSecProposal, 'bulk_delete', path='delete', detail=False) 

489class IPSecProposalBulkDeleteView(generic.BulkDeleteView): 

490 queryset = IPSecProposal.objects.all() 

491 filterset = filtersets.IPSecProposalFilterSet 

492 table = tables.IPSecProposalTable 

493 

494 

495# 

496# IPSec policies 

497# 

498 

499@register_model_view(IPSecPolicy, 'list', path='', detail=False) 

500class IPSecPolicyListView(generic.ObjectListView): 

501 queryset = IPSecPolicy.objects.all() 

502 filterset = filtersets.IPSecPolicyFilterSet 

503 filterset_form = forms.IPSecPolicyFilterForm 

504 table = tables.IPSecPolicyTable 

505 

506 

507@register_model_view(IPSecPolicy) 

508class IPSecPolicyView(GetRelatedModelsMixin, generic.ObjectView): 

509 queryset = IPSecPolicy.objects.all() 

510 template_name = 'generic/object.html' 

511 layout = layout.SimpleLayout( 

512 left_panels=[ 

513 panels.IPSecPolicyPanel(), 

514 ], 

515 right_panels=[ 

516 CustomFieldsPanel(), 

517 CommentsPanel(), 

518 TagsPanel(), 

519 RelatedObjectsPanel(), 

520 ], 

521 bottom_panels=[ 

522 ObjectsTablePanel( 

523 'vpn.ipsecproposal', 

524 filters={'ipsec_policy_id': lambda ctx: ctx['object'].pk}, 

525 title=_('Proposals'), 

526 ), 

527 ], 

528 ) 

529 

530 def get_extra_context(self, request, instance): 

531 return { 

532 'related_models': self.get_related_models(request, instance), 

533 } 

534 

535 

536@register_model_view(IPSecPolicy, 'add', detail=False) 

537@register_model_view(IPSecPolicy, 'edit') 

538class IPSecPolicyEditView(generic.ObjectEditView): 

539 queryset = IPSecPolicy.objects.all() 

540 form = forms.IPSecPolicyForm 

541 

542 

543@register_model_view(IPSecPolicy, 'delete') 

544class IPSecPolicyDeleteView(generic.ObjectDeleteView): 

545 queryset = IPSecPolicy.objects.all() 

546 

547 

548@register_model_view(IPSecPolicy, 'bulk_import', path='import', detail=False) 

549class IPSecPolicyBulkImportView(generic.BulkImportView): 

550 queryset = IPSecPolicy.objects.all() 

551 model_form = forms.IPSecPolicyImportForm 

552 

553 

554@register_model_view(IPSecPolicy, 'bulk_edit', path='edit', detail=False) 

555class IPSecPolicyBulkEditView(generic.BulkEditView): 

556 queryset = IPSecPolicy.objects.all() 

557 filterset = filtersets.IPSecPolicyFilterSet 

558 table = tables.IPSecPolicyTable 

559 form = forms.IPSecPolicyBulkEditForm 

560 

561 

562@register_model_view(IPSecPolicy, 'bulk_rename', path='rename', detail=False) 

563class IPSecPolicyBulkRenameView(generic.BulkRenameView): 

564 queryset = IPSecPolicy.objects.all() 

565 filterset = filtersets.IPSecPolicyFilterSet 

566 

567 

568@register_model_view(IPSecPolicy, 'bulk_delete', path='delete', detail=False) 

569class IPSecPolicyBulkDeleteView(generic.BulkDeleteView): 

570 queryset = IPSecPolicy.objects.all() 

571 filterset = filtersets.IPSecPolicyFilterSet 

572 table = tables.IPSecPolicyTable 

573 

574 

575# 

576# IPSec profiles 

577# 

578 

579@register_model_view(IPSecProfile, 'list', path='', detail=False) 

580class IPSecProfileListView(generic.ObjectListView): 

581 queryset = IPSecProfile.objects.all() 

582 filterset = filtersets.IPSecProfileFilterSet 

583 filterset_form = forms.IPSecProfileFilterForm 

584 table = tables.IPSecProfileTable 

585 

586 

587@register_model_view(IPSecProfile) 

588class IPSecProfileView(generic.ObjectView): 

589 queryset = IPSecProfile.objects.all() 

590 template_name = 'generic/object.html' 

591 layout = layout.SimpleLayout( 

592 left_panels=[ 

593 panels.IPSecProfilePanel(), 

594 TagsPanel(), 

595 CustomFieldsPanel(), 

596 CommentsPanel(), 

597 ], 

598 right_panels=[ 

599 panels.IPSecProfileIKEPolicyPanel(), 

600 panels.IPSecProfileIPSecPolicyPanel(), 

601 ], 

602 ) 

603 

604 

605@register_model_view(IPSecProfile, 'add', detail=False) 

606@register_model_view(IPSecProfile, 'edit') 

607class IPSecProfileEditView(generic.ObjectEditView): 

608 queryset = IPSecProfile.objects.all() 

609 form = forms.IPSecProfileForm 

610 

611 

612@register_model_view(IPSecProfile, 'delete') 

613class IPSecProfileDeleteView(generic.ObjectDeleteView): 

614 queryset = IPSecProfile.objects.all() 

615 

616 

617@register_model_view(IPSecProfile, 'bulk_import', path='import', detail=False) 

618class IPSecProfileBulkImportView(generic.BulkImportView): 

619 queryset = IPSecProfile.objects.all() 

620 model_form = forms.IPSecProfileImportForm 

621 

622 

623@register_model_view(IPSecProfile, 'bulk_edit', path='edit', detail=False) 

624class IPSecProfileBulkEditView(generic.BulkEditView): 

625 queryset = IPSecProfile.objects.all() 

626 filterset = filtersets.IPSecProfileFilterSet 

627 table = tables.IPSecProfileTable 

628 form = forms.IPSecProfileBulkEditForm 

629 

630 

631@register_model_view(IPSecProfile, 'bulk_rename', path='rename', detail=False) 

632class IPSecProfileBulkRenameView(generic.BulkRenameView): 

633 queryset = IPSecProfile.objects.all() 

634 filterset = filtersets.IPSecProfileFilterSet 

635 

636 

637@register_model_view(IPSecProfile, 'bulk_delete', path='delete', detail=False) 

638class IPSecProfileBulkDeleteView(generic.BulkDeleteView): 

639 queryset = IPSecProfile.objects.all() 

640 filterset = filtersets.IPSecProfileFilterSet 

641 table = tables.IPSecProfileTable 

642 

643 

644# 

645# L2VPN 

646# 

647 

648@register_model_view(L2VPN, 'list', path='', detail=False) 

649class L2VPNListView(generic.ObjectListView): 

650 queryset = L2VPN.objects.all() 

651 table = tables.L2VPNTable 

652 filterset = filtersets.L2VPNFilterSet 

653 filterset_form = forms.L2VPNFilterForm 

654 

655 

656@register_model_view(L2VPN) 

657class L2VPNView(generic.ObjectView): 

658 queryset = L2VPN.objects.all() 

659 template_name = 'generic/object.html' 

660 layout = layout.Layout( 

661 layout.Row( 

662 layout.Column( 

663 panels.L2VPNPanel(), 

664 TagsPanel(), 

665 PluginContentPanel('left_page'), 

666 ), 

667 layout.Column( 

668 CustomFieldsPanel(), 

669 CommentsPanel(), 

670 PluginContentPanel('right_page'), 

671 ), 

672 ), 

673 layout.Row( 

674 layout.Column( 

675 ContextTablePanel('import_targets_table', title=_('Import Route Targets')), 

676 ), 

677 layout.Column( 

678 ContextTablePanel('export_targets_table', title=_('Export Route Targets')), 

679 ), 

680 ), 

681 layout.Row( 

682 layout.Column( 

683 ObjectsTablePanel( 

684 'vpn.l2vpntermination', 

685 filters={'l2vpn_id': lambda ctx: ctx['object'].pk}, 

686 exclude_columns=['l2vpn'], 

687 actions=[ 

688 actions.AddObject( 

689 'vpn.l2vpntermination', 

690 url_params={'l2vpn': lambda ctx: ctx['object'].pk}, 

691 label=_('Add a Termination'), 

692 ), 

693 ], 

694 title=_('Terminations'), 

695 ), 

696 PluginContentPanel('full_width_page'), 

697 ), 

698 ), 

699 ) 

700 

701 def get_extra_context(self, request, instance): 

702 import_targets_table = RouteTargetTable( 

703 instance.import_targets.prefetch_related('tenant'), 

704 orderable=False 

705 ) 

706 import_targets_table.configure(request) 

707 export_targets_table = RouteTargetTable( 

708 instance.export_targets.prefetch_related('tenant'), 

709 orderable=False 

710 ) 

711 export_targets_table.configure(request) 

712 

713 return { 

714 'import_targets_table': import_targets_table, 

715 'export_targets_table': export_targets_table, 

716 } 

717 

718 

719@register_model_view(L2VPN, 'add', detail=False) 

720@register_model_view(L2VPN, 'edit') 

721class L2VPNEditView(generic.ObjectEditView): 

722 queryset = L2VPN.objects.all() 

723 form = forms.L2VPNForm 

724 

725 

726@register_model_view(L2VPN, 'delete') 

727class L2VPNDeleteView(generic.ObjectDeleteView): 

728 queryset = L2VPN.objects.all() 

729 

730 

731@register_model_view(L2VPN, 'bulk_import', path='import', detail=False) 

732class L2VPNBulkImportView(generic.BulkImportView): 

733 queryset = L2VPN.objects.all() 

734 model_form = forms.L2VPNImportForm 

735 

736 

737@register_model_view(L2VPN, 'bulk_edit', path='edit', detail=False) 

738class L2VPNBulkEditView(generic.BulkEditView): 

739 queryset = L2VPN.objects.all() 

740 filterset = filtersets.L2VPNFilterSet 

741 table = tables.L2VPNTable 

742 form = forms.L2VPNBulkEditForm 

743 

744 

745@register_model_view(L2VPN, 'bulk_rename', path='rename', detail=False) 

746class L2VPNBulkRenameView(generic.BulkRenameView): 

747 queryset = L2VPN.objects.all() 

748 filterset = filtersets.L2VPNFilterSet 

749 

750 

751@register_model_view(L2VPN, 'bulk_delete', path='delete', detail=False) 

752class L2VPNBulkDeleteView(generic.BulkDeleteView): 

753 queryset = L2VPN.objects.all() 

754 filterset = filtersets.L2VPNFilterSet 

755 table = tables.L2VPNTable 

756 

757 

758# 

759# L2VPN terminations 

760# 

761 

762@register_model_view(L2VPNTermination, 'list', path='', detail=False) 

763class L2VPNTerminationListView(generic.ObjectListView): 

764 queryset = L2VPNTermination.objects.all() 

765 table = tables.L2VPNTerminationTable 

766 filterset = filtersets.L2VPNTerminationFilterSet 

767 filterset_form = forms.L2VPNTerminationFilterForm 

768 actions = (AddObject, BulkImport, BulkExport, BulkEdit, BulkDelete) 

769 

770 

771@register_model_view(L2VPNTermination) 

772class L2VPNTerminationView(generic.ObjectView): 

773 queryset = L2VPNTermination.objects.all() 

774 template_name = 'generic/object.html' 

775 layout = layout.SimpleLayout( 

776 left_panels=[ 

777 panels.L2VPNTerminationPanel(), 

778 ], 

779 right_panels=[ 

780 CustomFieldsPanel(), 

781 TagsPanel(), 

782 ], 

783 ) 

784 

785 

786@register_model_view(L2VPNTermination, 'add', detail=False) 

787@register_model_view(L2VPNTermination, 'edit') 

788class L2VPNTerminationEditView(generic.ObjectEditView): 

789 queryset = L2VPNTermination.objects.all() 

790 form = forms.L2VPNTerminationForm 

791 

792 

793@register_model_view(L2VPNTermination, 'delete') 

794class L2VPNTerminationDeleteView(generic.ObjectDeleteView): 

795 queryset = L2VPNTermination.objects.all() 

796 

797 

798@register_model_view(L2VPNTermination, 'bulk_import', path='import', detail=False) 

799class L2VPNTerminationBulkImportView(generic.BulkImportView): 

800 queryset = L2VPNTermination.objects.all() 

801 model_form = forms.L2VPNTerminationImportForm 

802 

803