def get_extra_context(self, request, instance): vlans = ( VLAN.objects.restrict(request.user, "view") .filter(group=instance) .prefetch_related(Prefetch("prefixes", queryset=Prefix.objects.restrict(request.user))) ) vlans_count = vlans.count() vlans = add_available_vlans(instance, vlans) vlan_table = tables.VLANDetailTable(vlans) if request.user.has_perm("ipam.change_vlan") or request.user.has_perm("ipam.delete_vlan"): vlan_table.columns.show("pk") vlan_table.columns.hide("site") vlan_table.columns.hide("group") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(vlan_table) # Compile permissions list for rendering the object table permissions = { "add": request.user.has_perm("ipam.add_vlan"), "change": request.user.has_perm("ipam.change_vlan"), "delete": request.user.has_perm("ipam.delete_vlan"), } return { "first_available_vlan": instance.get_next_available_vid(), "bulk_querystring": f"group_id={instance.pk}", "vlan_table": vlan_table, "permissions": permissions, "vlans_count": vlans_count, }
def get(self, request, *args, **kwargs): """Render the home page for Nautobot.""" registry = dict(get_commands_registry()) logs = CommandLog.objects.all().order_by("-start_time") # Summarize the number of times each command/subcommand has been called for command_name, command_data in registry.items(): registry[command_name]["count"] = logs.filter( command=command_name).count() for subcommand_name in command_data["subcommands"]: registry[command_name]["subcommands"][subcommand_name][ "count"] = logs.filter(command=command_name, subcommand=subcommand_name).count() # Support sorting, filtering, customization, and pagination of the table queryset = CommandLogFilter(request.GET, logs).qs table = self.table(queryset, user=request.user) RequestConfig(request, paginate={ "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request) }).configure(table) return render( request, "nautobot/home.html", { "commands": registry, "table": table, "table_config_form": TableConfigForm(table) }, )
def get(self, request): plugins = [apps.get_app_config(plugin) for plugin in settings.PLUGINS] data = [] for plugin in plugins: data.append({ "name": plugin.verbose_name, "package_name": plugin.name, "author": plugin.author, "author_email": plugin.author_email, "description": plugin.description, "version": plugin.version, "actions": { "home": plugin.home_view_name, "configure": plugin.config_view_name, }, }) table = self.table(data, user=request.user) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(table) return render( request, "extras/plugins_list.html", { "table": table, "table_config_form": TableConfigForm(table=table), "filter_form": None, }, )
def test_get_paginate_count_request_params(self): """Get the paginate count from the request's GET params, overriding user and global default values.""" self.user.set_config("pagination.per_page", 200, commit=True) request = self.request_factory.get("some_paginated_view", {"per_page": 400}) request.user = self.user self.assertEqual(get_paginate_count(request), 400)
def get_extra_context(self, request, instance): interfaces = instance.get_vminterfaces().prefetch_related("virtual_machine") members_table = tables.VLANVirtualMachinesTable(interfaces) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(members_table) return { "members_table": members_table, "active_tab": "vminterfaces", }
def get_extra_context(self, request, instance): tagged_items = TaggedItem.objects.filter(tag=instance).prefetch_related("content_type", "content_object") # Generate a table of all items tagged with this Tag items_table = tables.TaggedItemTable(tagged_items) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(items_table) return { "items_count": tagged_items.count(), "items_table": items_table, }
def get_extra_context(self, request, instance): # Aggregates aggregates = Aggregate.objects.restrict(request.user, "view").filter(rir=instance).prefetch_related("tenant") aggregate_table = tables.AggregateTable(aggregates) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(aggregate_table) return { "aggregate_table": aggregate_table, }
def get(self, request, model, **kwargs): # Handle QuerySet restriction of parent object if needed if hasattr(model.objects, "restrict"): obj = get_object_or_404(model.objects.restrict(request.user, "view"), **kwargs) else: obj = get_object_or_404(model, **kwargs) # Gather all changes for this object (and its related objects) content_type = ContentType.objects.get_for_model(model) objectchanges = ( ObjectChange.objects.restrict(request.user, "view") .prefetch_related("user", "changed_object_type") .filter( Q(changed_object_type=content_type, changed_object_id=obj.pk) | Q(related_object_type=content_type, related_object_id=obj.pk) ) ) objectchanges_table = tables.ObjectChangeTable(data=objectchanges, orderable=False) # Apply the request context paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(objectchanges_table) # Default to using "<app>/<model>.html" as the template, if it exists. Otherwise, # fall back to using base.html. if self.base_template is None: self.base_template = f"{model._meta.app_label}/{model._meta.model_name}.html" # TODO: This can be removed once an object view has been established for every model. try: template.loader.get_template(self.base_template) except template.TemplateDoesNotExist: self.base_template = "base.html" return render( request, "extras/object_changelog.html", { "object": obj, "table": objectchanges_table, "base_template": self.base_template, "active_tab": "changelog", }, )
def get_extra_context(self, request, instance): # Parent prefixes table parent_prefixes = (Prefix.objects.restrict( request.user, "view").filter(vrf=instance.vrf, prefix__net_contains=str( instance.address.ip)).prefetch_related( "site", "status", "role")) parent_prefixes_table = tables.PrefixTable(list(parent_prefixes), orderable=False) parent_prefixes_table.exclude = ("vrf", ) # Duplicate IPs table duplicate_ips = (IPAddress.objects.restrict( request.user, "view").filter(vrf=instance.vrf, address=str(instance.address)).exclude( pk=instance.pk).prefetch_related("nat_inside")) # Exclude anycast IPs if this IP is anycast if instance.role == IPAddressRoleChoices.ROLE_ANYCAST: duplicate_ips = duplicate_ips.exclude( role=IPAddressRoleChoices.ROLE_ANYCAST) # Limit to a maximum of 10 duplicates displayed here duplicate_ips_table = tables.IPAddressTable(duplicate_ips[:10], orderable=False) # Related IP table related_ips = (IPAddress.objects.restrict( request.user, "view").exclude(address=str(instance.address)).filter( vrf=instance.vrf, address__net_contained_or_equal=str(instance.address))) related_ips_table = tables.IPAddressTable(related_ips, orderable=False) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(related_ips_table) return { "parent_prefixes_table": parent_prefixes_table, "duplicate_ips_table": duplicate_ips_table, "more_duplicate_ips": duplicate_ips.count() > 10, "related_ips_table": related_ips_table, }
def get_extra_context(self, request, instance): circuits = (Circuit.objects.restrict( request.user, "view").filter(provider=instance).prefetch_related( "type", "tenant", "terminations__site").annotate_sites()) circuits_table = tables.CircuitTable(circuits) circuits_table.columns.hide("provider") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(circuits_table) return { "circuits_table": circuits_table, }
def get_extra_context(self, request, instance): # Prefixes prefixes = ( Prefix.objects.restrict(request.user, "view") .filter(role=instance) .prefetch_related( "site", "status", "tenant", "vlan", "vrf", ) ) prefix_table = tables.PrefixTable(prefixes) prefix_table.columns.hide("role") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(prefix_table) # VLANs vlans = ( VLAN.objects.restrict(request.user, "view") .filter(role=instance) .prefetch_related( "group", "site", "status", "tenant", ) ) vlan_table = tables.VLANTable(vlans) vlan_table.columns.hide("role") RequestConfig(request, paginate).configure(vlan_table) return { "prefix_table": prefix_table, "vlan_table": vlan_table, }
def get_extra_context(self, request, instance): # Clusters clusters = (Cluster.objects.restrict(request.user, "view").filter( group=instance).prefetch_related("type", "site", "tenant")) cluster_table = tables.ClusterTable(clusters) cluster_table.columns.hide("group") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(cluster_table) return { "cluster_table": cluster_table, }
def get_extra_context(self, request, instance): # Tenants tenants = Tenant.objects.restrict(request.user, "view").filter( group__in=instance.get_descendants(include_self=True)) tenant_table = tables.TenantTable(tenants) tenant_table.columns.hide("group") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(tenant_table) return { "tenant_table": tenant_table, }
def get_extra_context(self, request, instance): # Find all IPAddresses belonging to this Prefix ipaddresses = (instance.get_child_ips().restrict( request.user, "view").prefetch_related("vrf", "primary_ip4_for", "primary_ip6_for", "status")) # Add available IP addresses to the table if requested if request.GET.get("show_available", "true") == "true": ipaddresses = add_available_ipaddresses(instance.prefix, ipaddresses, instance.is_pool) ip_table = tables.IPAddressTable(ipaddresses) if request.user.has_perm( "ipam.change_ipaddress") or request.user.has_perm( "ipam.delete_ipaddress"): ip_table.columns.show("pk") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(ip_table) # Compile permissions list for rendering the object table permissions = { "add": request.user.has_perm("ipam.add_ipaddress"), "change": request.user.has_perm("ipam.change_ipaddress"), "delete": request.user.has_perm("ipam.delete_ipaddress"), } bulk_querystring = "vrf_id={}&parent={}".format( instance.vrf.pk if instance.vrf else "0", instance.prefix) return { "first_available_ip": instance.get_first_available_ip(), "ip_table": ip_table, "permissions": permissions, "bulk_querystring": bulk_querystring, "active_tab": "ip-addresses", "show_available": request.GET.get("show_available", "true") == "true", }
def get_extra_context(self, request, instance): # Child prefixes table child_prefixes = (instance.get_child_prefixes().restrict( request.user, "view").prefetch_related("site", "status", "role", "vlan").annotate_tree()) # Add available prefixes to the table if requested if child_prefixes and request.GET.get("show_available", "true") == "true": child_prefixes = add_available_prefixes(instance.prefix, child_prefixes) prefix_table = tables.PrefixDetailTable(child_prefixes) if request.user.has_perm( "ipam.change_prefix") or request.user.has_perm( "ipam.delete_prefix"): prefix_table.columns.show("pk") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(prefix_table) # Compile permissions list for rendering the object table permissions = { "add": request.user.has_perm("ipam.add_prefix"), "change": request.user.has_perm("ipam.change_prefix"), "delete": request.user.has_perm("ipam.delete_prefix"), } bulk_querystring = "vrf_id={}&within={}".format( instance.vrf.pk if instance.vrf else "0", instance.prefix) return { "first_available_prefix": instance.get_first_available_prefix(), "prefix_table": prefix_table, "permissions": permissions, "bulk_querystring": bulk_querystring, "active_tab": "prefixes", "show_available": request.GET.get("show_available", "true") == "true", }
def get_extra_context(self, request, instance): # Find all child prefixes contained by this aggregate child_prefixes = (Prefix.objects.restrict( request.user, "view").net_contained_or_equal(instance.prefix).prefetch_related( "site", "role").order_by("network").annotate_tree()) # Add available prefixes to the table if requested if request.GET.get("show_available", "true") == "true": child_prefixes = add_available_prefixes(instance.prefix, child_prefixes) prefix_table = tables.PrefixDetailTable(child_prefixes) if request.user.has_perm( "ipam.change_prefix") or request.user.has_perm( "ipam.delete_prefix"): prefix_table.columns.show("pk") paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(prefix_table) # Compile permissions list for rendering the object table permissions = { "add": request.user.has_perm("ipam.add_prefix"), "change": request.user.has_perm("ipam.change_prefix"), "delete": request.user.has_perm("ipam.delete_prefix"), } return { "prefix_table": prefix_table, "permissions": permissions, "show_available": request.GET.get("show_available", "true") == "true", }
def test_get_paginate_count_user_config(self): """Get the user's configured paginate count, overriding global defaults.""" self.user.set_config("pagination.per_page", 200, commit=True) self.assertEqual(get_paginate_count(self.request), 200)
def test_get_paginate_count_settings(self): """Get the default paginate count from Django settings, overriding Constance config.""" self.assertEqual(get_paginate_count(self.request), 50)
def test_get_paginate_count_config(self): """Get the default paginate count from Constance config.""" self.assertEqual(get_paginate_count(self.request), 100)
def get_extra_context(self, request, instance): """ Reuse the model tables for config context, device, and virtual machine but inject the `ConfigContextSchemaValidationStateColumn` and an object edit action button. """ # Prep the validator with the schema so it can be reused for all records validator = Draft7Validator(instance.data_schema) # Config context table config_context_table = tables.ConfigContextTable( data=instance.configcontext_set.all(), orderable=False, extra_columns=[ ( "validation_state", tables.ConfigContextSchemaValidationStateColumn(validator, "data", empty_values=()), ), ("actions", ButtonsColumn(model=ConfigContext, buttons=["edit"])), ], ) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(config_context_table) # Device table device_table = DeviceTable( data=instance.device_set.prefetch_related( "tenant", "site", "rack", "device_type", "device_role", "primary_ip" ), orderable=False, extra_columns=[ ( "validation_state", tables.ConfigContextSchemaValidationStateColumn(validator, "local_context_data", empty_values=()), ), ("actions", ButtonsColumn(model=Device, buttons=["edit"])), ], ) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(device_table) # Virtual machine table virtual_machine_table = VirtualMachineTable( data=instance.virtualmachine_set.prefetch_related("cluster", "role", "tenant", "primary_ip"), orderable=False, extra_columns=[ ( "validation_state", tables.ConfigContextSchemaValidationStateColumn(validator, "local_context_data", empty_values=()), ), ("actions", ButtonsColumn(model=VirtualMachine, buttons=["edit"])), ], ) paginate = { "paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request), } RequestConfig(request, paginate).configure(virtual_machine_table) return { "config_context_table": config_context_table, "device_table": device_table, "virtual_machine_table": virtual_machine_table, "active_tab": "validation", }