Coverage for circuits/views.py: 98%

1from django.utils.translation import gettext_lazy as _ 

2 

3from dcim.views import PathTraceView 

4from extras.ui.panels import CustomFieldsPanel, ImageAttachmentsPanel, TagsPanel 

5from ipam.models import ASN 

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

7from netbox.ui import actions, layout 

8from netbox.ui.breadcrumbs import Breadcrumb, filtered_list_url 

9from netbox.ui.panels import ( 

10 CommentsPanel, 

11 ObjectsTablePanel, 

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# Providers 

24# 

25 

26 

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

28class ProviderListView(generic.ObjectListView): 

29 queryset = Provider.objects.annotate( 

30 count_circuits=count_related(Circuit, 'provider'), 

31 asn_count=count_related(ASN, 'providers'), 

32 account_count=count_related(ProviderAccount, 'provider'), 

33 ) 

34 filterset = filtersets.ProviderFilterSet 

35 filterset_form = forms.ProviderFilterForm 

36 table = tables.ProviderTable 

37 

38 

39@register_model_view(Provider) 

40class ProviderView(GetRelatedModelsMixin, generic.ObjectView): 

41 queryset = Provider.objects.all() 

42 layout = layout.SimpleLayout( 

43 left_panels=[ 

44 panels.ProviderPanel(), 

45 TagsPanel(), 

46 CommentsPanel(), 

47 ], 

48 right_panels=[ 

49 RelatedObjectsPanel(), 

50 CustomFieldsPanel(), 

51 ], 

52 bottom_panels=[ 

53 ObjectsTablePanel( 

54 model='circuits.ProviderAccount', 

55 filters={'provider_id': lambda ctx: ctx['object'].pk}, 

56 exclude_columns=['provider'], 

57 actions=[ 

58 actions.AddObject( 

59 'circuits.ProviderAccount', url_params={'provider': lambda ctx: ctx['object'].pk} 

60 ), 

61 ], 

62 ), 

63 ObjectsTablePanel( 

64 model='circuits.Circuit', 

65 filters={'provider_id': lambda ctx: ctx['object'].pk}, 

66 exclude_columns=['provider'], 

67 actions=[ 

68 actions.AddObject('circuits.Circuit', url_params={'provider': lambda ctx: ctx['object'].pk}), 

69 ], 

70 ), 

71 ], 

72 ) 

73 

74 def get_extra_context(self, request, instance): 

75 return { 

76 'related_models': self.get_related_models( 

77 request, 

78 instance, 

79 omit=(), 

80 extra=( 

81 ( 

82 VirtualCircuit.objects.restrict(request.user, 'view').filter( 

83 provider_network__provider=instance 

84 ), 

85 'provider_id', 

86 ), 

87 ), 

88 ), 

89 } 

90 

91 

92@register_model_view(Provider, 'add', detail=False) 

93@register_model_view(Provider, 'edit') 

94class ProviderEditView(generic.ObjectEditView): 

95 queryset = Provider.objects.all() 

96 form = forms.ProviderForm 

97 

98 

99@register_model_view(Provider, 'delete') 

100class ProviderDeleteView(generic.ObjectDeleteView): 

101 queryset = Provider.objects.all() 

102 

103 

104@register_model_view(Provider, 'bulk_import', path='import', detail=False) 

105class ProviderBulkImportView(generic.BulkImportView): 

106 queryset = Provider.objects.all() 

107 model_form = forms.ProviderImportForm 

108 

109 

110@register_model_view(Provider, 'bulk_edit', path='edit', detail=False) 

111class ProviderBulkEditView(generic.BulkEditView): 

112 queryset = Provider.objects.annotate( 

113 count_circuits=count_related(Circuit, 'provider') 

114 ) 

115 filterset = filtersets.ProviderFilterSet 

116 table = tables.ProviderTable 

117 form = forms.ProviderBulkEditForm 

118 

119 

120@register_model_view(Provider, 'bulk_rename', path='rename', detail=False) 

121class ProviderBulkRenameView(generic.BulkRenameView): 

122 queryset = Provider.objects.all() 

123 filterset = filtersets.ProviderFilterSet 

124 

125 

126@register_model_view(Provider, 'bulk_delete', path='delete', detail=False) 

127class ProviderBulkDeleteView(generic.BulkDeleteView): 

128 queryset = Provider.objects.annotate( 

129 count_circuits=count_related(Circuit, 'provider') 

130 ) 

131 filterset = filtersets.ProviderFilterSet 

132 table = tables.ProviderTable 

133 

134 

135# 

136# ProviderAccounts 

137# 

138 

139@register_model_view(ProviderAccount, 'list', path='', detail=False) 

140class ProviderAccountListView(generic.ObjectListView): 

141 queryset = ProviderAccount.objects.annotate( 

142 count_circuits=count_related(Circuit, 'provider_account') 

143 ) 

144 filterset = filtersets.ProviderAccountFilterSet 

145 filterset_form = forms.ProviderAccountFilterForm 

146 table = tables.ProviderAccountTable 

147 

148 

149@register_model_view(ProviderAccount) 

150class ProviderAccountView(GetRelatedModelsMixin, generic.ObjectView): 

151 template_name = 'generic/object.html' 

152 queryset = ProviderAccount.objects.all() 

153 layout = layout.SimpleLayout( 

154 breadcrumbs=[ 

155 Breadcrumb('provider', url=filtered_list_url('circuits:provideraccount_list', 'provider_id')), 

156 ], 

157 left_panels=[ 

158 panels.ProviderAccountPanel(), 

159 TagsPanel(), 

160 ], 

161 right_panels=[ 

162 RelatedObjectsPanel(), 

163 CommentsPanel(), 

164 CustomFieldsPanel(), 

165 ], 

166 bottom_panels=[ 

167 ObjectsTablePanel( 

168 model='circuits.Circuit', 

169 filters={'provider_account_id': lambda ctx: ctx['object'].pk}, 

170 exclude_columns=['provider_account'], 

171 actions=[ 

172 actions.AddObject( 

173 'circuits.Circuit', 

174 url_params={ 

175 'provider': lambda ctx: ctx['object'].provider.pk, 

176 'provider_account': lambda ctx: ctx['object'].pk, 

177 }, 

178 ), 

179 ], 

180 ), 

181 ], 

182 ) 

183 

184 def get_extra_context(self, request, instance): 

185 return { 

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

187 } 

188 

189 

190@register_model_view(ProviderAccount, 'add', detail=False) 

191@register_model_view(ProviderAccount, 'edit') 

192class ProviderAccountEditView(generic.ObjectEditView): 

193 queryset = ProviderAccount.objects.all() 

194 form = forms.ProviderAccountForm 

195 

196 

197@register_model_view(ProviderAccount, 'delete') 

198class ProviderAccountDeleteView(generic.ObjectDeleteView): 

199 queryset = ProviderAccount.objects.all() 

200 

201 

202@register_model_view(ProviderAccount, 'bulk_import', path='import', detail=False) 

203class ProviderAccountBulkImportView(generic.BulkImportView): 

204 queryset = ProviderAccount.objects.all() 

205 model_form = forms.ProviderAccountImportForm 

206 table = tables.ProviderAccountTable 

207 

208 

209@register_model_view(ProviderAccount, 'bulk_edit', path='edit', detail=False) 

210class ProviderAccountBulkEditView(generic.BulkEditView): 

211 queryset = ProviderAccount.objects.annotate( 

212 count_circuits=count_related(Circuit, 'provider_account') 

213 ) 

214 filterset = filtersets.ProviderAccountFilterSet 

215 table = tables.ProviderAccountTable 

216 form = forms.ProviderAccountBulkEditForm 

217 

218 

219@register_model_view(ProviderAccount, 'bulk_rename', path='rename', detail=False) 

220class ProviderAccountBulkRenameView(generic.BulkRenameView): 

221 queryset = ProviderAccount.objects.all() 

222 filterset = filtersets.ProviderAccountFilterSet 

223 

224 

225@register_model_view(ProviderAccount, 'bulk_delete', path='delete', detail=False) 

226class ProviderAccountBulkDeleteView(generic.BulkDeleteView): 

227 queryset = ProviderAccount.objects.annotate( 

228 count_circuits=count_related(Circuit, 'provider_account') 

229 ) 

230 filterset = filtersets.ProviderAccountFilterSet 

231 table = tables.ProviderAccountTable 

232 

233 

234# 

235# Provider networks 

236# 

237 

238@register_model_view(ProviderNetwork, 'list', path='', detail=False) 

239class ProviderNetworkListView(generic.ObjectListView): 

240 queryset = ProviderNetwork.objects.all() 

241 filterset = filtersets.ProviderNetworkFilterSet 

242 filterset_form = forms.ProviderNetworkFilterForm 

243 table = tables.ProviderNetworkTable 

244 

245 

246@register_model_view(ProviderNetwork) 

247class ProviderNetworkView(GetRelatedModelsMixin, generic.ObjectView): 

248 template_name = 'generic/object.html' 

249 queryset = ProviderNetwork.objects.all() 

250 layout = layout.SimpleLayout( 

251 breadcrumbs=[ 

252 Breadcrumb('provider', url=filtered_list_url('circuits:providernetwork_list', 'provider_id')), 

253 ], 

254 left_panels=[ 

255 panels.ProviderNetworkPanel(), 

256 TagsPanel(), 

257 ], 

258 right_panels=[ 

259 RelatedObjectsPanel(), 

260 CommentsPanel(), 

261 CustomFieldsPanel(), 

262 ], 

263 bottom_panels=[ 

264 ObjectsTablePanel( 

265 model='circuits.Circuit', 

266 filters={'provider_network_id': lambda ctx: ctx['object'].pk}, 

267 ), 

268 ObjectsTablePanel( 

269 model='circuits.VirtualCircuit', 

270 filters={'provider_network_id': lambda ctx: ctx['object'].pk}, 

271 exclude_columns=['provider_network'], 

272 actions=[ 

273 actions.AddObject( 

274 'circuits.VirtualCircuit', url_params={'provider_network': lambda ctx: ctx['object'].pk} 

275 ), 

276 ], 

277 ), 

278 ], 

279 ) 

280 

281 def get_extra_context(self, request, instance): 

282 return { 

283 'related_models': self.get_related_models( 

284 request, 

285 instance, 

286 omit=(CircuitTermination,), 

287 extra=( 

288 ( 

289 Circuit.objects.restrict(request.user, 'view').filter(terminations___provider_network=instance), 

290 'provider_network_id', 

291 ), 

292 ( 

293 CircuitTermination.objects.restrict(request.user, 'view').filter(_provider_network=instance), 

294 'provider_network_id', 

295 ), 

296 ), 

297 ), 

298 } 

299 

300 

301@register_model_view(ProviderNetwork, 'add', detail=False) 

302@register_model_view(ProviderNetwork, 'edit') 

303class ProviderNetworkEditView(generic.ObjectEditView): 

304 queryset = ProviderNetwork.objects.all() 

305 form = forms.ProviderNetworkForm 

306 

307 

308@register_model_view(ProviderNetwork, 'delete') 

309class ProviderNetworkDeleteView(generic.ObjectDeleteView): 

310 queryset = ProviderNetwork.objects.all() 

311 

312 

313@register_model_view(ProviderNetwork, 'bulk_import', path='import', detail=False) 

314class ProviderNetworkBulkImportView(generic.BulkImportView): 

315 queryset = ProviderNetwork.objects.all() 

316 model_form = forms.ProviderNetworkImportForm 

317 

318 

319@register_model_view(ProviderNetwork, 'bulk_edit', path='edit', detail=False) 

320class ProviderNetworkBulkEditView(generic.BulkEditView): 

321 queryset = ProviderNetwork.objects.all() 

322 filterset = filtersets.ProviderNetworkFilterSet 

323 table = tables.ProviderNetworkTable 

324 form = forms.ProviderNetworkBulkEditForm 

325 

326 

327@register_model_view(ProviderNetwork, 'bulk_rename', path='rename', detail=False) 

328class ProviderNetworkBulkRenameView(generic.BulkRenameView): 

329 queryset = ProviderNetwork.objects.all() 

330 filterset = filtersets.ProviderNetworkFilterSet 

331 

332 

333@register_model_view(ProviderNetwork, 'bulk_delete', path='delete', detail=False) 

334class ProviderNetworkBulkDeleteView(generic.BulkDeleteView): 

335 queryset = ProviderNetwork.objects.all() 

336 filterset = filtersets.ProviderNetworkFilterSet 

337 table = tables.ProviderNetworkTable 

338 

339 

340# 

341# Circuit Types 

342# 

343 

344@register_model_view(CircuitType, 'list', path='', detail=False) 

345class CircuitTypeListView(generic.ObjectListView): 

346 queryset = CircuitType.objects.annotate( 

347 circuit_count=count_related(Circuit, 'type') 

348 ) 

349 filterset = filtersets.CircuitTypeFilterSet 

350 filterset_form = forms.CircuitTypeFilterForm 

351 table = tables.CircuitTypeTable 

352 

353 

354@register_model_view(CircuitType) 

355class CircuitTypeView(GetRelatedModelsMixin, generic.ObjectView): 

356 queryset = CircuitType.objects.all() 

357 layout = layout.SimpleLayout( 

358 left_panels=[ 

359 panels.CircuitTypePanel(), 

360 TagsPanel(), 

361 ], 

362 right_panels=[ 

363 RelatedObjectsPanel(), 

364 CommentsPanel(), 

365 CustomFieldsPanel(), 

366 ], 

367 ) 

368 

369 def get_extra_context(self, request, instance): 

370 return { 

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

372 } 

373 

374 

375@register_model_view(CircuitType, 'add', detail=False) 

376@register_model_view(CircuitType, 'edit') 

377class CircuitTypeEditView(generic.ObjectEditView): 

378 queryset = CircuitType.objects.all() 

379 form = forms.CircuitTypeForm 

380 

381 

382@register_model_view(CircuitType, 'delete') 

383class CircuitTypeDeleteView(generic.ObjectDeleteView): 

384 queryset = CircuitType.objects.all() 

385 

386 

387@register_model_view(CircuitType, 'bulk_import', path='import', detail=False) 

388class CircuitTypeBulkImportView(generic.BulkImportView): 

389 queryset = CircuitType.objects.all() 

390 model_form = forms.CircuitTypeImportForm 

391 

392 

393@register_model_view(CircuitType, 'bulk_edit', path='edit', detail=False) 

394class CircuitTypeBulkEditView(generic.BulkEditView): 

395 queryset = CircuitType.objects.annotate( 

396 circuit_count=count_related(Circuit, 'type') 

397 ) 

398 filterset = filtersets.CircuitTypeFilterSet 

399 table = tables.CircuitTypeTable 

400 form = forms.CircuitTypeBulkEditForm 

401 

402 

403@register_model_view(CircuitType, 'bulk_rename', path='rename', detail=False) 

404class CircuitTypeBulkRenameView(generic.BulkRenameView): 

405 queryset = CircuitType.objects.all() 

406 filterset = filtersets.CircuitTypeFilterSet 

407 

408 

409@register_model_view(CircuitType, 'bulk_delete', path='delete', detail=False) 

410class CircuitTypeBulkDeleteView(generic.BulkDeleteView): 

411 queryset = CircuitType.objects.annotate( 

412 circuit_count=count_related(Circuit, 'type') 

413 ) 

414 filterset = filtersets.CircuitTypeFilterSet 

415 table = tables.CircuitTypeTable 

416 

417 

418# 

419# Circuits 

420# 

421 

422@register_model_view(Circuit, 'list', path='', detail=False) 

423class CircuitListView(generic.ObjectListView): 

424 queryset = Circuit.objects.prefetch_related( 

425 'tenant__group', 'termination_a__termination', 'termination_z__termination', 

426 ) 

427 filterset = filtersets.CircuitFilterSet 

428 filterset_form = forms.CircuitFilterForm 

429 table = tables.CircuitTable 

430 

431 

432@register_model_view(Circuit) 

433class CircuitView(generic.ObjectView): 

434 template_name = 'generic/object.html' 

435 queryset = Circuit.objects.all() 

436 layout = layout.SimpleLayout( 

437 breadcrumbs=[ 

438 Breadcrumb('provider', url=filtered_list_url('circuits:circuit_list', 'provider_id')), 

439 ], 

440 left_panels=[ 

441 panels.CircuitPanel(), 

442 panels.CircuitGroupAssignmentsPanel(), 

443 CustomFieldsPanel(), 

444 TagsPanel(), 

445 CommentsPanel(), 

446 ], 

447 right_panels=[ 

448 panels.CircuitCircuitTerminationPanel(side='A'), 

449 panels.CircuitCircuitTerminationPanel(side='Z'), 

450 ImageAttachmentsPanel(), 

451 ], 

452 ) 

453 

454 

455@register_model_view(Circuit, 'add', detail=False) 

456@register_model_view(Circuit, 'edit') 

457class CircuitEditView(generic.ObjectEditView): 

458 queryset = Circuit.objects.all() 

459 form = forms.CircuitForm 

460 

461 

462@register_model_view(Circuit, 'delete') 

463class CircuitDeleteView(generic.ObjectDeleteView): 

464 queryset = Circuit.objects.all() 

465 

466 

467@register_model_view(Circuit, 'bulk_import', path='import', detail=False) 

468class CircuitBulkImportView(generic.BulkImportView): 

469 queryset = Circuit.objects.all() 

470 model_form = forms.CircuitImportForm 

471 additional_permissions = [ 

472 'circuits.add_circuittermination', 

473 ] 

474 related_object_forms = { 

475 'terminations': forms.CircuitTerminationImportRelatedForm, 

476 } 

477 

478 def prep_related_object_data(self, parent, data): 

479 data.update({'circuit': parent}) 

480 return data 

481 

482 

483@register_model_view(Circuit, 'bulk_edit', path='edit', detail=False) 

484class CircuitBulkEditView(generic.BulkEditView): 

485 queryset = Circuit.objects.prefetch_related( 

486 'tenant__group', 'termination_a__termination', 'termination_z__termination', 

487 ) 

488 filterset = filtersets.CircuitFilterSet 

489 table = tables.CircuitTable 

490 form = forms.CircuitBulkEditForm 

491 

492 

493@register_model_view(Circuit, 'bulk_rename', path='rename', detail=False) 

494class CircuitBulkRenameView(generic.BulkRenameView): 

495 queryset = Circuit.objects.all() 

496 field_name = 'cid' 

497 filterset = filtersets.CircuitFilterSet 

498 

499 

500@register_model_view(Circuit, 'bulk_delete', path='delete', detail=False) 

501class CircuitBulkDeleteView(generic.BulkDeleteView): 

502 queryset = Circuit.objects.prefetch_related( 

503 'tenant__group', 'termination_a__termination', 'termination_z__termination', 

504 ) 

505 filterset = filtersets.CircuitFilterSet 

506 table = tables.CircuitTable 

507 

508 

509# 

510# Circuit terminations 

511# 

512 

513@register_model_view(CircuitTermination, 'list', path='', detail=False) 

514class CircuitTerminationListView(generic.ObjectListView): 

515 queryset = CircuitTermination.objects.all() 

516 filterset = filtersets.CircuitTerminationFilterSet 

517 filterset_form = forms.CircuitTerminationFilterForm 

518 table = tables.CircuitTerminationTable 

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

520 

521 

522@register_model_view(CircuitTermination) 

523class CircuitTerminationView(generic.ObjectView): 

524 template_name = 'generic/object.html' 

525 queryset = CircuitTermination.objects.all() 

526 layout = layout.SimpleLayout( 

527 breadcrumbs=[ 

528 Breadcrumb('circuit.provider', url=filtered_list_url('circuits:circuit_list', 'provider_id')), 

529 ], 

530 left_panels=[ 

531 panels.CircuitTerminationPanel(), 

532 ], 

533 right_panels=[ 

534 CustomFieldsPanel(), 

535 TagsPanel(), 

536 ], 

537 ) 

538 

539 

540@register_model_view(CircuitTermination, 'add', detail=False) 

541@register_model_view(CircuitTermination, 'edit') 

542class CircuitTerminationEditView(generic.ObjectEditView): 

543 queryset = CircuitTermination.objects.all() 

544 form = forms.CircuitTerminationForm 

545 

546 

547@register_model_view(CircuitTermination, 'delete') 

548class CircuitTerminationDeleteView(generic.ObjectDeleteView): 

549 queryset = CircuitTermination.objects.all() 

550 

551 

552@register_model_view(CircuitTermination, 'bulk_import', path='import', detail=False) 

553class CircuitTerminationBulkImportView(generic.BulkImportView): 

554 queryset = CircuitTermination.objects.all() 

555 model_form = forms.CircuitTerminationImportForm 

556 

557 

558@register_model_view(CircuitTermination, 'bulk_edit', path='edit', detail=False) 

559class CircuitTerminationBulkEditView(generic.BulkEditView): 

560 queryset = CircuitTermination.objects.all() 

561 filterset = filtersets.CircuitTerminationFilterSet 

562 table = tables.CircuitTerminationTable 

563 form = forms.CircuitTerminationBulkEditForm 

564 

565 

566@register_model_view(CircuitTermination, 'bulk_delete', path='delete', detail=False) 

567class CircuitTerminationBulkDeleteView(generic.BulkDeleteView): 

568 queryset = CircuitTermination.objects.all() 

569 filterset = filtersets.CircuitTerminationFilterSet 

570 table = tables.CircuitTerminationTable 

571 

572 

573# Trace view 

574register_model_view(CircuitTermination, 'trace', kwargs={'model': CircuitTermination})(PathTraceView) 

575 

576 

577# 

578# Circuit Groups 

579# 

580 

581@register_model_view(CircuitGroup, 'list', path='', detail=False) 

582class CircuitGroupListView(generic.ObjectListView): 

583 queryset = CircuitGroup.objects.annotate( 

584 circuit_group_assignment_count=count_related(CircuitGroupAssignment, 'group') 

585 ) 

586 filterset = filtersets.CircuitGroupFilterSet 

587 filterset_form = forms.CircuitGroupFilterForm 

588 table = tables.CircuitGroupTable 

589 

590 

591@register_model_view(CircuitGroup) 

592class CircuitGroupView(GetRelatedModelsMixin, generic.ObjectView): 

593 queryset = CircuitGroup.objects.all() 

594 layout = layout.SimpleLayout( 

595 left_panels=[ 

596 panels.CircuitGroupPanel(), 

597 TagsPanel(), 

598 ], 

599 right_panels=[ 

600 RelatedObjectsPanel(), 

601 CommentsPanel(), 

602 CustomFieldsPanel(), 

603 ], 

604 ) 

605 

606 def get_extra_context(self, request, instance): 

607 return { 

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

609 } 

610 

611 

612@register_model_view(CircuitGroup, 'add', detail=False) 

613@register_model_view(CircuitGroup, 'edit') 

614class CircuitGroupEditView(generic.ObjectEditView): 

615 queryset = CircuitGroup.objects.all() 

616 form = forms.CircuitGroupForm 

617 

618 

619@register_model_view(CircuitGroup, 'delete') 

620class CircuitGroupDeleteView(generic.ObjectDeleteView): 

621 queryset = CircuitGroup.objects.all() 

622 

623 

624@register_model_view(CircuitGroup, 'bulk_import', path='import', detail=False) 

625class CircuitGroupBulkImportView(generic.BulkImportView): 

626 queryset = CircuitGroup.objects.all() 

627 model_form = forms.CircuitGroupImportForm 

628 

629 

630@register_model_view(CircuitGroup, 'bulk_edit', path='edit', detail=False) 

631class CircuitGroupBulkEditView(generic.BulkEditView): 

632 queryset = CircuitGroup.objects.all() 

633 filterset = filtersets.CircuitGroupFilterSet 

634 table = tables.CircuitGroupTable 

635 form = forms.CircuitGroupBulkEditForm 

636 

637 

638@register_model_view(CircuitGroup, 'bulk_rename', path='rename', detail=False) 

639class CircuitGroupBulkRenameView(generic.BulkRenameView): 

640 queryset = CircuitGroup.objects.all() 

641 filterset = filtersets.CircuitGroupFilterSet 

642 

643 

644@register_model_view(CircuitGroup, 'bulk_delete', path='delete', detail=False) 

645class CircuitGroupBulkDeleteView(generic.BulkDeleteView): 

646 queryset = CircuitGroup.objects.all() 

647 filterset = filtersets.CircuitGroupFilterSet 

648 table = tables.CircuitGroupTable 

649 

650 

651# 

652# Circuit Groups 

653# 

654 

655@register_model_view(CircuitGroupAssignment, 'list', path='', detail=False) 

656class CircuitGroupAssignmentListView(generic.ObjectListView): 

657 queryset = CircuitGroupAssignment.objects.all() 

658 filterset = filtersets.CircuitGroupAssignmentFilterSet 

659 filterset_form = forms.CircuitGroupAssignmentFilterForm 

660 table = tables.CircuitGroupAssignmentTable 

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

662 

663 

664@register_model_view(CircuitGroupAssignment) 

665class CircuitGroupAssignmentView(generic.ObjectView): 

666 template_name = 'generic/object.html' 

667 queryset = CircuitGroupAssignment.objects.all() 

668 layout = layout.SimpleLayout( 

669 breadcrumbs=[ 

670 Breadcrumb('group', url=filtered_list_url('circuits:circuitgroupassignment_list', 'group_id')), 

671 ], 

672 left_panels=[ 

673 panels.CircuitGroupAssignmentPanel(), 

674 TagsPanel(), 

675 ], 

676 right_panels=[ 

677 CustomFieldsPanel(), 

678 ], 

679 ) 

680 

681 

682@register_model_view(CircuitGroupAssignment, 'add', detail=False) 

683@register_model_view(CircuitGroupAssignment, 'edit') 

684class CircuitGroupAssignmentEditView(generic.ObjectEditView): 

685 queryset = CircuitGroupAssignment.objects.all() 

686 form = forms.CircuitGroupAssignmentForm 

687 

688 

689@register_model_view(CircuitGroupAssignment, 'delete') 

690class CircuitGroupAssignmentDeleteView(generic.ObjectDeleteView): 

691 queryset = CircuitGroupAssignment.objects.all() 

692 

693 

694@register_model_view(CircuitGroupAssignment, 'bulk_import', path='import', detail=False) 

695class CircuitGroupAssignmentBulkImportView(generic.BulkImportView): 

696 queryset = CircuitGroupAssignment.objects.all() 

697 model_form = forms.CircuitGroupAssignmentImportForm 

698 

699 

700@register_model_view(CircuitGroupAssignment, 'bulk_edit', path='edit', detail=False) 

701class CircuitGroupAssignmentBulkEditView(generic.BulkEditView): 

702 queryset = CircuitGroupAssignment.objects.all() 

703 filterset = filtersets.CircuitGroupAssignmentFilterSet 

704 table = tables.CircuitGroupAssignmentTable 

705 form = forms.CircuitGroupAssignmentBulkEditForm 

706 

707 

708@register_model_view(CircuitGroupAssignment, 'bulk_delete', path='delete', detail=False) 

709class CircuitGroupAssignmentBulkDeleteView(generic.BulkDeleteView): 

710 queryset = CircuitGroupAssignment.objects.all() 

711 filterset = filtersets.CircuitGroupAssignmentFilterSet 

712 table = tables.CircuitGroupAssignmentTable 

713 

714 

715# 

716# Virtual circuit Types 

717# 

718 

719@register_model_view(VirtualCircuitType, 'list', path='', detail=False) 

720class VirtualCircuitTypeListView(generic.ObjectListView): 

721 queryset = VirtualCircuitType.objects.annotate( 

722 virtual_circuit_count=count_related(VirtualCircuit, 'type') 

723 ) 

724 filterset = filtersets.VirtualCircuitTypeFilterSet 

725 filterset_form = forms.VirtualCircuitTypeFilterForm 

726 table = tables.VirtualCircuitTypeTable 

727 

728 

729@register_model_view(VirtualCircuitType) 

730class VirtualCircuitTypeView(GetRelatedModelsMixin, generic.ObjectView): 

731 queryset = VirtualCircuitType.objects.all() 

732 layout = layout.SimpleLayout( 

733 left_panels=[ 

734 panels.VirtualCircuitTypePanel(), 

735 TagsPanel(), 

736 ], 

737 right_panels=[ 

738 RelatedObjectsPanel(), 

739 CommentsPanel(), 

740 CustomFieldsPanel(), 

741 ], 

742 ) 

743 

744 def get_extra_context(self, request, instance): 

745 return { 

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

747 } 

748 

749 

750@register_model_view(VirtualCircuitType, 'add', detail=False) 

751@register_model_view(VirtualCircuitType, 'edit') 

752class VirtualCircuitTypeEditView(generic.ObjectEditView): 

753 queryset = VirtualCircuitType.objects.all() 

754 form = forms.VirtualCircuitTypeForm 

755 

756 

757@register_model_view(VirtualCircuitType, 'delete') 

758class VirtualCircuitTypeDeleteView(generic.ObjectDeleteView): 

759 queryset = VirtualCircuitType.objects.all() 

760 

761 

762@register_model_view(VirtualCircuitType, 'bulk_import', path='import', detail=False) 

763class VirtualCircuitTypeBulkImportView(generic.BulkImportView): 

764 queryset = VirtualCircuitType.objects.all() 

765 model_form = forms.VirtualCircuitTypeImportForm 

766 

767 

768@register_model_view(VirtualCircuitType, 'bulk_edit', path='edit', detail=False) 

769class VirtualCircuitTypeBulkEditView(generic.BulkEditView): 

770 queryset = VirtualCircuitType.objects.annotate( 

771 circuit_count=count_related(Circuit, 'type') 

772 ) 

773 filterset = filtersets.VirtualCircuitTypeFilterSet 

774 table = tables.VirtualCircuitTypeTable 

775 form = forms.VirtualCircuitTypeBulkEditForm 

776 

777 

778@register_model_view(VirtualCircuitType, 'bulk_rename', path='rename', detail=False) 

779class VirtualCircuitTypeBulkRenameView(generic.BulkRenameView): 

780 queryset = VirtualCircuitType.objects.all() 

781 filterset = filtersets.VirtualCircuitTypeFilterSet 

782 

783 

784@register_model_view(VirtualCircuitType, 'bulk_delete', path='delete', detail=False) 

785class VirtualCircuitTypeBulkDeleteView(generic.BulkDeleteView): 

786 queryset = VirtualCircuitType.objects.annotate( 

787 circuit_count=count_related(Circuit, 'type') 

788 ) 

789 filterset = filtersets.VirtualCircuitTypeFilterSet 

790 table = tables.VirtualCircuitTypeTable 

791 

792 

793# 

794# Virtual circuits 

795# 

796 

797@register_model_view(VirtualCircuit, 'list', path='', detail=False) 

798class VirtualCircuitListView(generic.ObjectListView): 

799 queryset = VirtualCircuit.objects.annotate(