nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/wireless/models.py

@@ -0,0 +1,207 @@
+from django.db import models
+
+from nautobot.core.constants import CHARFIELD_MAX_LENGTH
+from nautobot.core.models import BaseModel
+from nautobot.core.models.fields import JSONArrayField
+from nautobot.core.models.generics import PrimaryModel
+from nautobot.extras.utils import extras_features
+from nautobot.wireless.choices import (
+    RadioProfileChannelWidthChoices,
+    RadioProfileFrequencyChoices,
+    RadioProfileRegulatoryDomainChoices,
+    SupportedDataRateStandardChoices,
+    WirelessNetworkAuthenticationChoices,
+    WirelessNetworkModeChoices,
+)
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "webhooks",
+)
+class SupportedDataRate(PrimaryModel):
+    """
+    A SupportedDataRate represents a data rate that can be used by an access point radio.
+    """
+
+    standard = models.CharField(max_length=CHARFIELD_MAX_LENGTH, choices=SupportedDataRateStandardChoices)
+    rate = models.PositiveIntegerField(verbose_name="Rate (Kbps)")
+    mcs_index = models.IntegerField(
+        blank=True,
+        null=True,
+        help_text="The Modulation and Coding Scheme (MCS) index is a value used in wireless communications to define the modulation type, coding rate, and number of spatial streams used in a transmission.",
+    )
+
+    class Meta:
+        ordering = ["standard", "rate"]
+        unique_together = ["standard", "rate"]
+
+    def __str__(self):
+        return f"{self.standard}: {self.rate} Kbps"
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "webhooks",
+)
+class RadioProfile(PrimaryModel):
+    """
+    A RadioProfile is a collection of settings that can be applied to an access point radio.
+    """
+
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
+    frequency = models.CharField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        choices=RadioProfileFrequencyChoices,
+        blank=True,
+    )
+    tx_power_min = models.IntegerField(blank=True, null=True)
+    tx_power_max = models.IntegerField(blank=True, null=True)
+    channel_width = JSONArrayField(
+        base_field=models.IntegerField(choices=RadioProfileChannelWidthChoices),
+        blank=True,
+        null=True,
+    )
+    allowed_channel_list = JSONArrayField(
+        base_field=models.IntegerField(),
+        blank=True,
+        null=True,
+        help_text="Comma-separated list of allowed channel numbers for this radio profile.",
+    )
+    supported_data_rates = models.ManyToManyField(
+        to="wireless.SupportedDataRate",
+        related_name="radio_profiles",
+        blank=True,
+    )
+    regulatory_domain = models.CharField(max_length=CHARFIELD_MAX_LENGTH, choices=RadioProfileRegulatoryDomainChoices)
+    rx_power_min = models.IntegerField(blank=True, null=True)
+
+    class Meta:
+        ordering = ["name"]
+
+    def __str__(self):
+        return self.name
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "webhooks",
+)
+class WirelessNetwork(PrimaryModel):
+    """
+    A WirelessNetwork represents a wireless network that can be broadcast by an access point.
+    """
+
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
+    description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
+    ssid = models.CharField(max_length=CHARFIELD_MAX_LENGTH, verbose_name="SSID")
+    mode = models.CharField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        choices=WirelessNetworkModeChoices,
+    )
+    enabled = models.BooleanField(default=True)
+    authentication = models.CharField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        choices=WirelessNetworkAuthenticationChoices,
+    )
+    secrets_group = models.ForeignKey(
+        to="extras.SecretsGroup",
+        on_delete=models.PROTECT,
+        related_name="wireless_networks",
+        blank=True,
+        null=True,
+    )
+    hidden = models.BooleanField(default=False)
+    tenant = models.ForeignKey(
+        to="tenancy.Tenant",
+        on_delete=models.PROTECT,
+        related_name="wireless_networks",
+        blank=True,
+        null=True,
+    )
+
+    class Meta:
+        ordering = ["name"]
+
+    def __str__(self):
+        return self.name
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+)
+class ControllerManagedDeviceGroupWirelessNetworkAssignment(BaseModel):
+    """
+    A ControllerManagedDeviceGroupWirelessNetworkAssignment represents the assignment of a WirelessNetwork to an ControllerManagedDeviceGroup.
+    """
+
+    controller_managed_device_group = models.ForeignKey(
+        to="dcim.ControllerManagedDeviceGroup",
+        on_delete=models.CASCADE,
+        related_name="wireless_network_assignments",
+    )
+    wireless_network = models.ForeignKey(
+        to="wireless.WirelessNetwork",
+        on_delete=models.CASCADE,
+        related_name="controller_managed_device_group_assignments",
+    )
+    vlan = models.ForeignKey(
+        to="ipam.VLAN",
+        on_delete=models.PROTECT,
+        related_name="controller_managed_device_group_wireless_network_assignments",
+        blank=True,
+        null=True,
+    )
+    is_metadata_associable_model = False
+    documentation_static_path = "docs/user-guide/core-data-model/dcim/controllermanageddevicegroup.html"
+
+    class Meta:
+        unique_together = ["controller_managed_device_group", "wireless_network"]
+        ordering = ["controller_managed_device_group", "wireless_network"]
+
+    def __str__(self):
+        return f"{self.controller_managed_device_group}: {self.wireless_network}"
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+)
+class ControllerManagedDeviceGroupRadioProfileAssignment(BaseModel):
+    """
+    A ControllerManagedDeviceGroupRadioProfile represents the assignment of a RadioProfile to an ControllerManagedDeviceGroup.
+    """
+
+    controller_managed_device_group = models.ForeignKey(
+        to="dcim.ControllerManagedDeviceGroup",
+        on_delete=models.CASCADE,
+        related_name="radio_profile_assignments",
+    )
+    radio_profile = models.ForeignKey(
+        to="wireless.RadioProfile",
+        on_delete=models.CASCADE,
+        related_name="controller_managed_device_group_assignments",
+    )
+    is_metadata_associable_model = False
+    documentation_static_path = "docs/user-guide/core-data-model/dcim/controllermanageddevicegroup.html"
+
+    class Meta:
+        unique_together = ["controller_managed_device_group", "radio_profile"]
+        ordering = ["controller_managed_device_group", "radio_profile"]
+
+    def __str__(self):
+        return f"{self.controller_managed_device_group}: {self.radio_profile}"

nautobot/wireless/navigation.py

@@ -0,0 +1,105 @@
+from nautobot.core.apps import (
+    NavMenuAddButton,
+    NavMenuGroup,
+    NavMenuItem,
+    NavMenuTab,
+)
+
+menu_items = (
+    NavMenuTab(
+        name="Wireless",
+        weight=200,
+        groups=(
+            NavMenuGroup(
+                name="Wireless",
+                weight=100,
+                items=(
+                    NavMenuItem(
+                        link="wireless:wirelessnetwork_list",
+                        name="Wireless Networks",
+                        weight=100,
+                        permissions=[
+                            "wireless.view_wirelessnetwork",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="wireless:wirelessnetwork_add",
+                                permissions=[
+                                    "wireless.add_wirelessnetwork",
+                                ],
+                            ),
+                        ),
+                    ),
+                    NavMenuItem(
+                        link="dcim:controller_list",
+                        name="Wireless Controllers",
+                        query_params={"capabilities": "wireless"},
+                        weight=200,
+                        permissions=[
+                            "dcim.view_controller",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="dcim:controller_add",
+                                query_params={"capabilities": "wireless"},
+                                permissions=[
+                                    "dcim.add_controller",
+                                ],
+                            ),
+                        ),
+                    ),
+                    NavMenuItem(
+                        link="dcim:controllermanageddevicegroup_list",
+                        name="Device Groups",
+                        query_params={"capabilities": "wireless"},
+                        weight=300,
+                        permissions=[
+                            "dcim.view_controllermanageddevicegroup",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="dcim:controllermanageddevicegroup_add",
+                                query_params={"capabilities": "wireless"},
+                                permissions=[
+                                    "dcim.add_controllermanageddevicegroup",
+                                ],
+                            ),
+                        ),
+                    ),
+                    NavMenuItem(
+                        link="wireless:radioprofile_list",
+                        name="Radio Profiles",
+                        weight=500,
+                        permissions=[
+                            "wireless.view_radioprofile",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="wireless:radioprofile_add",
+                                permissions=[
+                                    "wireless.add_radioprofile",
+                                ],
+                            ),
+                        ),
+                    ),
+                    NavMenuItem(
+                        link="wireless:supporteddatarate_list",
+                        name="Supported Data Rates",
+                        weight=600,
+                        permissions=[
+                            "wireless.view_supporteddatarate",
+                        ],
+                        buttons=(
+                            NavMenuAddButton(
+                                link="wireless:supporteddatarate_add",
+                                permissions=[
+                                    "wireless.add_supporteddatarate",
+                                ],
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ),
+)

nautobot/wireless/tables.py

@@ -0,0 +1,244 @@
+import django_tables2 as tables
+
+from nautobot.core.tables import (
+    BaseTable,
+    BooleanColumn,
+    ButtonsColumn,
+    LinkedCountColumn,
+    TagColumn,
+    ToggleColumn,
+)
+from nautobot.dcim.models import ControllerManagedDeviceGroup
+
+from .models import RadioProfile, SupportedDataRate, WirelessNetwork
+
+
+class RadioProfileTable(BaseTable):
+    pk = ToggleColumn()
+    name = tables.Column(linkify=True)
+    tags = TagColumn(url_name="wireless:radioprofile_list")
+    actions = ButtonsColumn(RadioProfile)
+    supported_data_rates_count = LinkedCountColumn(
+        viewname="wireless:supporteddatarate_list",
+        url_params={"radio_profiles": "pk"},
+        verbose_name="Supported Data Rates",
+        reverse_lookup="radio_profiles",
+    )
+
+    class Meta(BaseTable.Meta):
+        model = RadioProfile
+        fields = (
+            "pk",
+            "name",
+            "frequency",
+            "channel_width",
+            "allowed_channel_list",
+            "supported_data_rates_count",
+            "tx_power_min",
+            "tx_power_max",
+            "rx_power_min",
+            "regulatory_domain",
+            "tags",
+            "actions",
+        )
+        default_columns = (
+            "pk",
+            "name",
+            "frequency",
+            "channel_width",
+            "regulatory_domain",
+            "allowed_channel_list",
+            "supported_data_rates_count",
+            "actions",
+        )
+
+    def render_channel_width(self, value):
+        return ", ".join(f"{v}MHz" for v in value)
+
+    def render_allowed_channel_list(self, value):
+        return ", ".join(f"{v}" for v in value)
+
+    def render_tx_power_min(self, value):
+        return f"{value} dBm"
+
+    def render_tx_power_max(self, value):
+        return f"{value} dBm"
+
+    def render_rx_power_min(self, value):
+        return f"{value} dBm"
+
+
+class SupportedDataRateTable(BaseTable):
+    pk = ToggleColumn()
+    rate = tables.Column(linkify=True)
+    standard = tables.Column()
+    mcs_index = tables.Column(verbose_name="MCS Index")
+    tags = TagColumn(url_name="wireless:supporteddatarate_list")
+    actions = ButtonsColumn(SupportedDataRate)
+
+    class Meta(BaseTable.Meta):
+        model = SupportedDataRate
+        fields = (
+            "pk",
+            "rate",
+            "standard",
+            "mcs_index",
+            "tags",
+            "actions",
+        )
+        default_columns = (
+            "pk",
+            "rate",
+            "standard",
+            "mcs_index",
+            "actions",
+        )
+
+
+class WirelessNetworkTable(BaseTable):
+    pk = ToggleColumn()
+    name = tables.Column(linkify=True)
+    description = tables.Column()
+    tags = TagColumn(url_name="wireless:wirelessnetwork_list")
+    actions = ButtonsColumn(WirelessNetwork)
+    enabled = BooleanColumn()
+    hidden = BooleanColumn()
+
+    class Meta(BaseTable.Meta):
+        model = WirelessNetwork
+        fields = (
+            "pk",
+            "name",
+            "ssid",
+            "mode",
+            "authentication",
+            "enabled",
+            "hidden",
+            "secret",
+            "description",
+            "tags",
+            "actions",
+        )
+        default_columns = (
+            "pk",
+            "name",
+            "ssid",
+            "mode",
+            "authentication",
+            "enabled",
+            "hidden",
+            "description",
+            "actions",
+        )
+
+
+class ControllerManagedDeviceGroupWirelessNetworkAssignmentTable(BaseTable):
+    controller_managed_device_group = tables.Column(linkify=True, verbose_name="Device Group")
+    wireless_network = tables.Column(linkify=True, verbose_name="Wireless Network")
+    vlan = tables.Column(linkify=True)
+    ssid = tables.Column(accessor="wireless_network.ssid")
+    mode = tables.Column(accessor="wireless_network.mode")
+    authentication = tables.Column(accessor="wireless_network.authentication")
+    enabled = BooleanColumn(accessor="wireless_network.enabled")
+    hidden = BooleanColumn(accessor="wireless_network.hidden")
+    secrets_group = tables.Column(accessor="wireless_network.secrets_group", linkify=True, verbose_name="Secrets Group")
+    controller = tables.Column(accessor="controller_managed_device_group.controller", linkify=True)
+    prefix_count = LinkedCountColumn(
+        viewname="ipam:prefix_list",
+        url_params={"vlan_id": "vlan_id"},
+        verbose_name="Prefixes",
+        reverse_lookup="vlan__controller_managed_device_group_wireless_network_assignments",
+    )
+
+    class Meta(BaseTable.Meta):
+        model = ControllerManagedDeviceGroup
+        fields = (
+            "wireless_network",
+            "controller_managed_device_group",
+            "ssid",
+            "mode",
+            "authentication",
+            "vlan",
+            "prefix_count",
+            "enabled",
+            "hidden",
+            "secrets_group",
+            "controller",
+        )
+        default_columns = (
+            "wireless_network",
+            "controller_managed_device_group",
+            "vlan",
+            "ssid",
+            "prefix_count",
+            "mode",
+            "authentication",
+            "controller",
+        )
+
+
+class ControllerControllerManagedDeviceGroupWirelessNetworkAssignmentTable(
+    ControllerManagedDeviceGroupWirelessNetworkAssignmentTable
+):
+    class Meta(ControllerManagedDeviceGroupWirelessNetworkAssignmentTable.Meta):
+        default_columns = (
+            "wireless_network",
+            "controller_managed_device_group",
+            "vlan",
+            "ssid",
+            "prefix_count",
+            "mode",
+            "authentication",
+        )
+
+
+class ControllerManagedDeviceGroupRadioProfileAssignmentTable(BaseTable):
+    controller_managed_device_group = tables.Column(linkify=True, verbose_name="Device Group")
+    radio_profile = tables.Column(linkify=True, verbose_name="Radio Profile")
+    frequency = tables.Column(accessor="radio_profile.frequency")
+    channel_width = tables.Column(accessor="radio_profile.channel_width", verbose_name="Channel Width")
+    allowed_channel_list = tables.Column(accessor="radio_profile.allowed_channel_list", verbose_name="Allowed Channels")
+    tx_power_min = tables.Column(accessor="radio_profile.tx_power_min")
+    tx_power_max = tables.Column(accessor="radio_profile.tx_power_max")
+    rx_power_min = tables.Column(accessor="radio_profile.rx_power_min")
+    regulatory_domain = tables.Column(accessor="radio_profile.regulatory_domain", verbose_name="Regulatory Domain")
+
+    class Meta(BaseTable.Meta):
+        model = ControllerManagedDeviceGroup
+        fields = (
+            "radio_profile",
+            "controller_managed_device_group",
+            "frequency",
+            "channel_width",
+            "allowed_channel_list",
+            "tx_power_min",
+            "tx_power_max",
+            "rx_power_min",
+            "regulatory_domain",
+        )
+        default_columns = (
+            "radio_profile",
+            "controller_managed_device_group",
+            "frequency",
+            "channel_width",
+            "allowed_channel_list",
+            "tx_power_min",
+            "tx_power_max",
+            "rx_power_min",
+            "regulatory_domain",
+        )
+
+    def render_channel_width(self, value):
+        return ", ".join(f"{v}MHz" for v in value)
+
+    def render_allowed_channel_list(self, value):
+        return ", ".join(f"{v}" for v in value)
+
+    def render_tx_power_min(self, value):
+        return f"{value} dBm"
+
+    def render_tx_power_max(self, value):
+        return f"{value} dBm"
+
+    def render_rx_power_min(self, value):
+        return f"{value} dBm"

nautobot/wireless/templates/wireless/radioprofile_retrieve.html

@@ -0,0 +1,81 @@
+{% extends 'generic/object_retrieve.html' %}
+{% load helpers %}
+
+{% block content_left_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Radio Profile</strong>
+        </div>
+        <table class="table table-hover panel-body attr-table">
+            <tr>
+                <td>Name</td>
+                <td>
+                    {{ object.name }}
+                </td>
+            </tr>
+            <tr>
+                <td>Description</td>
+                <td>{{ object.description|placeholder }}</td>
+            </tr>
+            <tr>
+                <td>Frequency</td>
+                <td>{{ object.frequency }}</td>
+            </tr>
+            <tr>
+                <td>Channel Width</td>
+                <td>
+                    {% if object.channel_width %}
+                        {% for width in object.channel_width %}
+                            <span class="label label-default">{{ width }}MHz</span>
+                        {% endfor %}
+                    {% else %}
+                        {{ None|placeholder }}
+                    {% endif %}
+                </td>
+            </tr>
+            <tr>
+                <td>Allowed Channel List</td>
+                <td>
+                    {% if object.allowed_channel_list %}
+                        {% for channel in object.allowed_channel_list %}
+                            <span class="label label-default">{{ channel }}</span>
+                        {% endfor %}
+                    {% else %}
+                        {{ None|placeholder }}
+                    {% endif %}
+                </td>
+            </tr>
+            <tr>
+                <td>Transmit Power Minimum</td>
+                <td>
+                    {{ object.tx_power_min|dbm}}
+                </td>
+            </tr>
+            <tr>
+                <td>Transmit Power Maximum</td>
+                <td>
+                    {{ object.tx_power_max|dbm}}
+                </td>
+            </tr>
+            <tr>
+                <td>Recieve Power Minimum</td>
+                <td>
+                    {{ object.rx_power_min|dbm}}
+                </td>
+            </tr>
+            <tr>
+                <td>Regulatory Domain</td>
+                <td>{{ object.get_regulatory_domain_display }}</td>
+            </tr>
+        </table>
+    </div>
+{% endblock content_left_page %}
+
+{% block content_full_width_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Supported Data Rates</strong>
+        </div>
+        {% include 'inc/table.html' with table=supported_data_rates_table %}
+    </div>
+{% endblock content_full_width_page %}

nautobot/wireless/templates/wireless/supporteddatarate_retrieve.html

@@ -0,0 +1,26 @@
+{% extends 'generic/object_retrieve.html' %}
+{% load helpers %}
+
+{% block content_left_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Supported Data Rate</strong>
+        </div>
+        <table class="table table-hover panel-body attr-table">
+            <tr>
+                <td>Rate</td>
+                <td>
+                    {{ object.rate|humanize_speed }}
+                </td>
+            </tr>
+            <tr>
+                <td>Standard</td>
+                <td>{{ object.standard }}</td>
+            </tr>
+            <tr>
+                <td>Modulation and Coding Scheme (MCS) Index</td>
+                <td>{{ object.mcs_index }}</td>
+            </tr>
+        </table>
+    </div>
+{% endblock content_left_page %}