netbox-authorized-keys 1.0.0__tar.gz

netbox_authorized_keys-1.0.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.1
+Name: netbox_authorized_keys
+Version: 1.0.0
+Summary: NetBox plugin to store Authorized Keys
+Author: Jan Krupa
+License: MIT

netbox_authorized_keys-1.0.0/README.md

@@ -0,0 +1,42 @@
+# NetBox Authorized Keys Plugin
+
+NetBox Authorized Keys is a plugin for NetBox that allows you to store and manage SSH authorized keys.
+
+## Features
+
+- Store SSH authorized keys
+- Assign keys to devices or virtual machines
+- Manage keys through the NetBox UI
+- API support for managing keys
+
+## Installation
+
+1. Clone the repository:
+    ```sh
+    git clone https://github.com/yourusername/netbox_authorized_keys.git
+    ```
+
+2. Navigate to the project directory:
+    ```sh
+    cd netbox_authorized_keys
+    ```
+
+3. Install the plugin:
+    ```sh
+    pip install .
+    ```
+
+4. Add the plugin to your NetBox configuration:
+    ```python
+    PLUGINS = ["netbox_authorized_keys"]
+    PLUGINS_CONFIG = {
+        "netbox_authorized_keys": {
+            # Add any plugin-specific configuration here
+        }
+    }
+    ```
+
+5. Run the migrations:
+    ```sh
+    python manage.py migrate
+    ```

netbox_authorized_keys-1.0.0/netbox_authorized_keys/__init__.py

@@ -0,0 +1,19 @@
+"""Top-level package for NetBox cesnet_services Plugin."""
+
+__author__ = """Jan Krupa"""
+__email__ = "jan.krupa@cesnet.cz"
+__version__ = "0.0.1"
+
+
+from netbox.plugins import PluginConfig
+
+
+class NetBoxAuthorizeKeysConfig(PluginConfig):
+    name = "netbox_authorized_keys"
+    verbose_name = "NetBox Authorized key Plugin"
+    description = ""
+    version = __version__
+    base_url = "authorized-keys"
+
+
+config = NetBoxAuthorizeKeysConfig

netbox_authorized_keys-1.0.0/netbox_authorized_keys/api/__init__.py

@@ -0,0 +1,2 @@
+
+# This file can be left empty or used to include any necessary initialization code for the API module.

netbox_authorized_keys-1.0.0/netbox_authorized_keys/api/serializers.py

@@ -0,0 +1,59 @@
+from dcim.api.serializers_.devices import DeviceSerializer
+from dcim.models import Device
+from netbox.api.fields import SerializedPKRelatedField
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+from virtualization.api.serializers_.virtualmachines import VirtualMachineSerializer
+from virtualization.models import VirtualMachine
+
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+
+
+class AuthorizedKeySerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:netbox_authorized_keys-api:authorizedkey-detail")
+    devices = SerializedPKRelatedField(
+        queryset=Device.objects.all(), serializer=DeviceSerializer, nested=True, required=False, many=True
+    )
+
+    virtual_machines = SerializedPKRelatedField(
+        queryset=VirtualMachine.objects.all(),
+        serializer=VirtualMachineSerializer,
+        nested=True,
+        required=False,
+        many=True,
+    )
+
+    class Meta:
+        model = AuthorizedKey
+        fields = [
+            "id",
+            "display",
+            "url",
+            "public_key",
+            "username",
+            "full_name",
+            "description",
+            "comments",
+            "devices",
+            "virtual_machines",
+            "tags",
+        ]
+        brief_fields = ("id", "url", "display")
+
+
+class AuthorizedKeyDeviceSerializer(NetBoxModelSerializer):
+    authorized_key = AuthorizedKeySerializer(nested=True)
+    device = DeviceSerializer(nested=True)
+
+    class Meta:
+        model = AuthorizedKeyDevice
+        fields = ["id", "authorized_key", "device"]
+
+
+class AuthorizedKeyVirtualMachineSerializer(NetBoxModelSerializer):
+    authorized_key = AuthorizedKeySerializer(nested=True)
+    virtual_machine = VirtualMachineSerializer(nested=True)
+
+    class Meta:
+        model = AuthorizedKeyVirtualMachine
+        fields = ["id", "authorized_key", "virtual_machine"]

netbox_authorized_keys-1.0.0/netbox_authorized_keys/api/urls.py

@@ -0,0 +1,14 @@
+from rest_framework.routers import DefaultRouter
+
+from netbox_authorized_keys.api.views import (
+    AuthorizedKeyDeviceViewSet,
+    AuthorizedKeyViewSet,
+    AuthorizedKeyVirtualMachineViewSet,
+)
+
+router = DefaultRouter()
+router.register(r"authorized-keys", AuthorizedKeyViewSet)
+router.register(r"devices", AuthorizedKeyDeviceViewSet)
+router.register(r"virtual-machines", AuthorizedKeyVirtualMachineViewSet)
+
+urlpatterns = router.urls

netbox_authorized_keys-1.0.0/netbox_authorized_keys/api/views.py

@@ -0,0 +1,27 @@
+from netbox.api.viewsets import NetBoxModelViewSet
+
+from netbox_authorized_keys.api.serializers import (
+    AuthorizedKeyDeviceSerializer,
+    AuthorizedKeySerializer,
+    AuthorizedKeyVirtualMachineSerializer,
+)
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+from netbox_authorized_keys.filtersets import AuthorizedKeyFilterSet, AuthorizedKeyDeviceFilterSet, AuthorizedKeyVirtualMachineFilterSet
+
+
+class AuthorizedKeyViewSet(NetBoxModelViewSet):
+    queryset = AuthorizedKey.objects.all()
+    serializer_class = AuthorizedKeySerializer
+    filterset_class = AuthorizedKeyFilterSet
+
+
+class AuthorizedKeyDeviceViewSet(NetBoxModelViewSet):
+    queryset = AuthorizedKeyDevice.objects.all()
+    serializer_class = AuthorizedKeyDeviceSerializer
+    filterset_class = AuthorizedKeyDeviceFilterSet
+
+
+class AuthorizedKeyVirtualMachineViewSet(NetBoxModelViewSet):
+    queryset = AuthorizedKeyVirtualMachine.objects.all()
+    serializer_class = AuthorizedKeyVirtualMachineSerializer
+    filterset_class = AuthorizedKeyVirtualMachineFilterSet

netbox_authorized_keys-1.0.0/netbox_authorized_keys/filtersets/__init__.py

@@ -0,0 +1 @@
+from .authorizedkey import *

netbox_authorized_keys-1.0.0/netbox_authorized_keys/filtersets/authorizedkey.py

@@ -0,0 +1,63 @@
+import django_filters
+from dcim.models import Device
+from django.db.models import Q
+from extras.filters import TagFilter
+from netbox.filtersets import BaseFilterSet, NetBoxModelFilterSet
+from virtualization.models import VirtualMachine
+
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+
+
+class AuthorizedKeyFilterSet(NetBoxModelFilterSet):
+    q = django_filters.CharFilter(method="search", label="Search")
+    public_key = django_filters.CharFilter()
+    username = django_filters.CharFilter()
+    full_name = django_filters.CharFilter()
+    description = django_filters.CharFilter()
+    tag = TagFilter()
+
+    devices = django_filters.ModelMultipleChoiceFilter(
+        field_name="devices", queryset=Device.objects.all(), label="Devices"
+    )
+    virtual_machines = django_filters.ModelMultipleChoiceFilter(
+        field_name="virtual_machines", queryset=VirtualMachine.objects.all(), label="Virtual Machines"
+    )
+
+    class Meta:
+        model = AuthorizedKey
+        fields = ["id", "public_key", "username", "full_name", "description", "comments", "devices", "virtual_machines"]
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+
+        filters = Q(username__icontains=value) | Q(full_name__icontains=value) | Q(description__icontains=value) | Q(comments__icontains=value)
+        return queryset.filter(filters)
+
+
+class AuthorizedKeyDeviceFilterSet(BaseFilterSet):
+    authorized_key = django_filters.ModelMultipleChoiceFilter(
+        field_name="authorized_key", queryset=AuthorizedKey.objects.all(), label="Authorized Key"
+    )
+
+    device = django_filters.ModelMultipleChoiceFilter(
+        field_name="device", queryset=Device.objects.all(), label="Device"
+    )
+
+    class Meta:
+        model = AuthorizedKeyDevice
+        fields = ["id", "authorized_key", "device"]
+
+
+class AuthorizedKeyVirtualMachineFilterSet(BaseFilterSet):
+    authorized_key = django_filters.ModelMultipleChoiceFilter(
+        field_name="authorized_key", queryset=AuthorizedKey.objects.all(), label="Authorized Key"
+    )
+
+    virtual_machine = django_filters.ModelMultipleChoiceFilter(
+        field_name="virtual_machine", queryset=VirtualMachine.objects.all(), label="Virtual Machine"
+    )
+
+    class Meta:
+        model = AuthorizedKeyVirtualMachine
+        fields = ["id", "authorized_key", "virtual_machine"]

netbox_authorized_keys-1.0.0/netbox_authorized_keys/forms/__init__.py

@@ -0,0 +1 @@
+from .authorizedkey import *

netbox_authorized_keys-1.0.0/netbox_authorized_keys/forms/authorizedkey.py

@@ -0,0 +1,79 @@
+from dcim.models import Device
+from django import forms
+from django.utils.translation import gettext_lazy as _
+from netbox.forms import NetBoxModelFilterSetForm, NetBoxModelForm
+from utilities.forms.fields import (
+    CommentField,
+    DynamicModelMultipleChoiceField,
+    TagFilterField,
+)
+from utilities.forms.rendering import FieldSet
+from virtualization.models import VirtualMachine
+
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+
+
+class AuthorizedKeyForm(NetBoxModelForm):
+    public_key = forms.CharField(
+        label=_("Public Key"), widget=forms.Textarea, required=True, help_text=_("Enter the public key (unique)")
+    )
+    username = forms.CharField(label=_("Username"), required=True)
+    full_name = forms.CharField(label=_("Full Name"), required=False, help_text=_("Owner's Full Name"))
+
+    devices = DynamicModelMultipleChoiceField(queryset=Device.objects.all(), label=_("Devices"), required=False)
+    virtual_machines = DynamicModelMultipleChoiceField(
+        queryset=VirtualMachine.objects.all(), label=_("Virtual Machines"), required=False
+    )
+
+    fieldsets = (
+        FieldSet("public_key", "username", "full_name", "description", name=_("Base")),
+        FieldSet("devices", "virtual_machines", name=_("Host Assignment")),
+        FieldSet("tags", name=_("Misc")),
+    )
+
+    class Meta:
+        comments = CommentField()
+        model = AuthorizedKey
+        fields = [
+            "public_key",
+            "username",
+            "full_name",
+            "description",
+            "devices",
+            "virtual_machines",
+            "comments",
+            "tags",
+        ]
+
+
+class AuthorizedKeyFilterForm(NetBoxModelFilterSetForm):
+    model = AuthorizedKey
+    public_key = forms.CharField(required=False, widget=forms.widgets.Textarea(attrs={"placeholder": _("Public Key")}))
+    username = forms.CharField(required=False)
+    full_name = forms.CharField(required=False)
+    description = forms.CharField(required=False)
+
+    devices = DynamicModelMultipleChoiceField(queryset=Device.objects.all(), label=_("Devices"), required=False)
+    virtual_machines = DynamicModelMultipleChoiceField(
+        queryset=VirtualMachine.objects.all(), label=_("Virtual Machines"), required=False
+    )
+
+    tag = TagFilterField(model)
+
+
+class AuthorizedKeyDeviceFilterForm(NetBoxModelFilterSetForm):
+    model = AuthorizedKeyDevice
+    authorized_key = DynamicModelMultipleChoiceField(
+        queryset=AuthorizedKey.objects.all(), label=_("Authorized Key"), required=False
+    )
+    device = DynamicModelMultipleChoiceField(queryset=Device.objects.all(), label=_("Device"), required=False)
+
+
+class AuthorizedKeyVirtualMachineFilterForm(NetBoxModelFilterSetForm):
+    model = AuthorizedKeyVirtualMachine
+    authorized_key = DynamicModelMultipleChoiceField(
+        queryset=AuthorizedKey.objects.all(), label=_("Authorized Key"), required=False
+    )
+    virtual_machine = DynamicModelMultipleChoiceField(
+        queryset=VirtualMachine.objects.all(), label=_("Virtual Machine"), required=False
+    )

netbox_authorized_keys-1.0.0/netbox_authorized_keys/migrations/0001_initial.py

@@ -0,0 +1,160 @@
+# Generated by Django 5.0.9 on 2024-11-25 13:28
+
+import django.db.models.deletion
+import taggit.managers
+import utilities.json
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("dcim", "0191_module_bay_rebuild"),
+        ("extras", "0121_customfield_related_object_filter"),
+        ("virtualization", "0040_convert_disk_size"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="AuthorizedKey",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                ("public_key", models.TextField()),
+                ("username", models.CharField(blank=True, default="", max_length=200)),
+                (
+                    "description",
+                    models.CharField(blank=True, default="", max_length=200),
+                ),
+                ("comments", models.TextField(blank=True, default="")),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="AuthorizedKeyDevice",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                (
+                    "authorized_key",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="netbox_authorized_keys.authorizedkey",
+                    ),
+                ),
+                (
+                    "device",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, to="dcim.device"
+                    ),
+                ),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+            ],
+            options={
+                "unique_together": {("authorized_key", "device")},
+            },
+        ),
+        migrations.AddField(
+            model_name="authorizedkey",
+            name="devices",
+            field=models.ManyToManyField(
+                blank=True,
+                related_name="authorized_keys",
+                through="netbox_authorized_keys.AuthorizedKeyDevice",
+                to="dcim.device",
+            ),
+        ),
+        migrations.CreateModel(
+            name="AuthorizedKeyVirtualMachine",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "custom_field_data",
+                    models.JSONField(
+                        blank=True,
+                        default=dict,
+                        encoder=utilities.json.CustomFieldJSONEncoder,
+                    ),
+                ),
+                (
+                    "authorized_key",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="netbox_authorized_keys.authorizedkey",
+                    ),
+                ),
+                (
+                    "tags",
+                    taggit.managers.TaggableManager(
+                        through="extras.TaggedItem", to="extras.Tag"
+                    ),
+                ),
+                (
+                    "virtual_machine",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="virtualization.virtualmachine",
+                    ),
+                ),
+            ],
+            options={
+                "unique_together": {("authorized_key", "virtual_machine")},
+            },
+        ),
+        migrations.AddField(
+            model_name="authorizedkey",
+            name="virtual_machines",
+            field=models.ManyToManyField(
+                blank=True,
+                related_name="authorized_keys",
+                through="netbox_authorized_keys.AuthorizedKeyVirtualMachine",
+                to="virtualization.virtualmachine",
+            ),
+        ),
+    ]

netbox_authorized_keys-1.0.0/netbox_authorized_keys/migrations/0002_authorizedkey_full_name_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 5.0.9 on 2024-11-26 08:06
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("netbox_authorized_keys", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="authorizedkey",
+            name="full_name",
+            field=models.CharField(blank=True, max_length=200),
+        ),
+        migrations.AlterField(
+            model_name="authorizedkey",
+            name="description",
+            field=models.CharField(blank=True, default="", max_length=255),
+        ),
+        migrations.AlterField(
+            model_name="authorizedkey",
+            name="public_key",
+            field=models.TextField(unique=True),
+        ),
+        migrations.AlterField(
+            model_name="authorizedkey",
+            name="username",
+            field=models.CharField(max_length=200),
+        ),
+    ]

netbox_authorized_keys-1.0.0/netbox_authorized_keys/models/__init__.py

@@ -0,0 +1 @@
+from .authorizedkey import *

netbox_authorized_keys-1.0.0/netbox_authorized_keys/models/authorizedkey.py

@@ -0,0 +1,116 @@
+from django.db import models
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from netbox.models import NetBoxModel
+from netbox.models.features import (
+    BookmarksMixin,
+    # ChangeLoggingMixin,
+    CloningMixin,
+    CustomFieldsMixin,
+    CustomLinksMixin,
+    CustomValidationMixin,
+    EventRulesMixin,
+    ExportTemplatesMixin,
+    JournalingMixin,
+    NotificationsMixin,
+    TagsMixin,
+)
+from utilities.querysets import RestrictedQuerySet
+
+
+class AuthorizedKey(NetBoxModel):
+    public_key = models.TextField(verbose_name=_("Public Key"), null=False, blank=False, unique=True)
+    username = models.CharField(max_length=200, blank=False, null=False, verbose_name=_("Username"))
+    full_name = models.CharField(max_length=200, blank=True, null=False, verbose_name=_("Full Name"))
+
+    description = models.CharField(max_length=255, verbose_name=_("description"), blank=True, default="", null=False)
+    comments = models.TextField(blank=True, default="", null=False, verbose_name=_("Comments"))
+
+    devices = models.ManyToManyField(
+        to="dcim.device",
+        related_name="authorized_keys",
+        blank=True,
+        through="netbox_authorized_keys.AuthorizedKeyDevice",
+        verbose_name=_("Devices"),
+    )
+
+    virtual_machines = models.ManyToManyField(
+        to="virtualization.virtualmachine",
+        related_name="authorized_keys",
+        blank=True,
+        through="netbox_authorized_keys.AuthorizedKeyVirtualMachine",
+        verbose_name=_("Virtual Machines"),
+    )
+
+    objects = RestrictedQuerySet.as_manager()
+
+    def __str__(self):
+        if self.username and self.full_name and self.description:
+            return f"{self.username} - {self.full_name} - {self.description}"
+        elif self.username and self.full_name:
+            return f"{self.username} - {self.full_name}"
+        elif self.username and self.description:
+            return f"{self.username} - {self.description}"
+
+        return self.username
+
+    def get_absolute_url(self):
+        return reverse("plugins:netbox_authorized_keys:authorizedkey", args=[self.pk])
+
+    def serialize_object(self, *, exclude=None):
+        data = super().serialize_object(exclude=exclude or [])
+        data["devices"] = list(self.devices.values_list("pk", flat=True))
+        data["virtual_machines"] = list(self.virtual_machines.values_list("pk", flat=True))
+        return data
+
+
+class AuthorizedKeyDevice(
+    BookmarksMixin,
+    # ChangeLoggingMixin,
+    CloningMixin,
+    CustomFieldsMixin,
+    CustomLinksMixin,
+    CustomValidationMixin,
+    ExportTemplatesMixin,
+    JournalingMixin,
+    NotificationsMixin,
+    TagsMixin,
+    EventRulesMixin,
+    models.Model,
+):
+    authorized_key = models.ForeignKey(to="netbox_authorized_keys.AuthorizedKey", on_delete=models.CASCADE)
+    device = models.ForeignKey(to="dcim.Device", on_delete=models.CASCADE)
+
+    objects = RestrictedQuerySet.as_manager()
+
+    class Meta:
+        unique_together = ("authorized_key", "device")
+
+    def __str__(self):
+        return f"{self.authorized_key} - {self.device}"
+
+
+class AuthorizedKeyVirtualMachine(
+    BookmarksMixin,
+    # ChangeLoggingMixin,
+    CloningMixin,
+    CustomFieldsMixin,
+    CustomLinksMixin,
+    CustomValidationMixin,
+    ExportTemplatesMixin,
+    JournalingMixin,
+    NotificationsMixin,
+    TagsMixin,
+    EventRulesMixin,
+    models.Model,
+):
+    authorized_key = models.ForeignKey(to="netbox_authorized_keys.AuthorizedKey", on_delete=models.CASCADE)
+    virtual_machine = models.ForeignKey(to="virtualization.VirtualMachine", on_delete=models.CASCADE)
+
+    objects = RestrictedQuerySet.as_manager()
+
+    class Meta:
+        unique_together = ("authorized_key", "virtual_machine")
+
+    def __str__(self):
+        return f"{self.authorized_key} - {self.virtual_machine}"

netbox_authorized_keys-1.0.0/netbox_authorized_keys/navigation.py

@@ -0,0 +1,28 @@
+from netbox.plugins import PluginMenu, PluginMenuItem
+
+menu = PluginMenu(
+    label="Authorized Keys",
+    icon_class="mdi mdi-key",
+    groups=(
+        (
+            "SSH Public Keys",
+            (
+                PluginMenuItem(
+                    link="plugins:netbox_authorized_keys:authorizedkey_list",
+                    link_text="Authorized Keys",
+                    permissions=["netbox_authorized_keys.view_authorizedkey"],
+                ),
+                PluginMenuItem(
+                    link="plugins:netbox_authorized_keys:authorizedkeydevice_list",
+                    link_text="Devices",
+                    permissions=["netbox_authorized_keys.view_authorizedkey"],
+                ),
+                PluginMenuItem(
+                    link="plugins:netbox_authorized_keys:authorizedkeyvirtualmachine_list",
+                    link_text="Virtual Machines",
+                    permissions=["netbox_authorized_keys.view_authorizedkey"],
+                ),
+            ),
+        ),
+    ),
+)

netbox_authorized_keys-1.0.0/netbox_authorized_keys/tables/__init__.py

@@ -0,0 +1 @@
+from .authorizedkey import *

netbox_authorized_keys-1.0.0/netbox_authorized_keys/tables/authorizedkey.py

@@ -0,0 +1,50 @@
+import django_tables2 as tables
+from django.utils.html import format_html
+from netbox.tables import NetBoxTable, columns
+
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+
+
+class AuthorizedKeyTable(NetBoxTable):
+    id = tables.Column(linkify=True, verbose_name="ID")
+    public_key = tables.Column(verbose_name="Public Key")
+
+    class Meta(NetBoxTable.Meta):
+        model = AuthorizedKey
+        fields = ("id", "public_key", "username", "full_name", "description", "comments", "tags")
+        default_columns = ("id", "username", "full_name", "description")
+
+    def render_public_key(self, value):
+        if len(value) > 23:
+            truncated_value = f"{value[:10]}...{value[-10:]}"
+        else:
+            truncated_value = value
+        return format_html('<span title="{}">{}</span>', value, truncated_value)
+
+
+class AuthorizedKeyDeviceTable(NetBoxTable):
+    id = tables.Column(linkify=False, verbose_name="ID")
+
+    authorized_key = tables.Column(linkify=True)
+    device = tables.Column(linkify=True)
+    actions = columns.ActionsColumn(
+        actions=(),
+    )
+
+    class Meta(NetBoxTable.Meta):
+        model = AuthorizedKeyDevice
+        fields = ("authorized_key", "device")
+
+
+class AuthorizedKeyVirtualMachineTable(NetBoxTable):
+    id = tables.Column(linkify=False, verbose_name="ID")
+
+    authorized_key = tables.Column(linkify=True)
+    virtual_machine = tables.Column(linkify=True)
+    actions = columns.ActionsColumn(
+        actions=(),
+    )
+
+    class Meta(NetBoxTable.Meta):
+        model = AuthorizedKeyVirtualMachine
+        fields = ("authorized_key", "virtual_machine")

netbox_authorized_keys-1.0.0/netbox_authorized_keys/template_content.py

@@ -0,0 +1,58 @@
+from dcim.models import Device
+from netbox.views import generic
+from utilities.views import ViewTab, register_model_view
+from virtualization.models import VirtualMachine
+
+from netbox_authorized_keys.filtersets import AuthorizedKeyFilterSet
+from netbox_authorized_keys.models import AuthorizedKey
+from netbox_authorized_keys.tables import AuthorizedKeyTable
+
+
+def create_authorized_key_tab_view(model):
+    view_name = f"{model._meta.model_name}-authorized-keys"
+    view_path = f"{model._meta.model_name}-authorized-keys"
+
+    class AuthorizedKeyTabView(generic.ObjectChildrenView):
+        child_model = AuthorizedKey
+        filterset = AuthorizedKeyFilterSet
+        template_name = "generic/object_children.html"
+        table = AuthorizedKeyTable
+        queryset = model.objects.all()
+
+        if model == Device:
+            tab = ViewTab(
+                label="Authorized Keys",
+                badge=lambda obj: AuthorizedKey.objects.filter(devices=obj.id).count(),
+                permission="netbox_authorized_keys.view_authorizedkey",
+            )
+
+            def get_children(self, request, parent):
+                children = self.child_model.objects.filter(devices=parent.id).restrict(request.user, "view")
+                return children
+
+            def get_table(self, data, request, bulk_actions=True):
+                table = super().get_table(data, request, bulk_actions)
+                table.exclude = "actions"
+                return table
+
+        elif model == VirtualMachine:
+            tab = ViewTab(
+                label="Authorized Keys",
+                badge=lambda obj: AuthorizedKey.objects.filter(virtual_machines=obj.id).count(),
+                permission="netbox_authorized_keys.view_authorizedkey",
+            )
+
+            def get_children(self, request, parent):
+                children = self.child_model.objects.filter(virtual_machines=parent.id).restrict(request.user, "view")
+                return children
+
+            def get_table(self, data, request, bulk_actions=True):
+                table = super().get_table(data, request, bulk_actions)
+                table.exclude = "actions"
+                return table
+
+    register_model_view(model, name=view_name, path=view_path)(AuthorizedKeyTabView)
+
+
+for model in [Device, VirtualMachine]:
+    create_authorized_key_tab_view(model)

netbox_authorized_keys-1.0.0/netbox_authorized_keys/urls.py

@@ -0,0 +1,27 @@
+from django.urls import path
+from netbox.views.generic import ObjectChangeLogView
+
+from netbox_authorized_keys import models, views
+
+urlpatterns = [
+    # Authorized Keys
+    path("authorized-keys/", views.AuthorizedKeyListView.as_view(), name="authorizedkey_list"),
+    path("authorized-keys/add/", views.AuthorizedKeyEditView.as_view(), name="authorizedkey_add"),
+    path("authorized-keys/<int:pk>/", views.AuthorizedKeyView.as_view(), name="authorizedkey"),
+    path("authorized-keys/<int:pk>/edit/", views.AuthorizedKeyEditView.as_view(), name="authorizedkey_edit"),
+    path("authorized-keys/<int:pk>/delete/", views.AuthorizedKeyDeleteView.as_view(), name="authorizedkey_delete"),
+    path(
+        "authorized-keys/<int:pk>/changelog/",
+        ObjectChangeLogView.as_view(),
+        name="authorizedkey_changelog",
+        kwargs={"model": models.AuthorizedKey},
+    ),
+    # Authorized Key Devices
+    path("authorized-keys/devices/", views.AuthorizedKeyDeviceListView.as_view(), name="authorizedkeydevice_list"),
+    # Authorized Key Virtual Machines
+    path(
+        "authorized-keys/virtual-machines/",
+        views.AuthorizedKeyVirtualMachineListView.as_view(),
+        name="authorizedkeyvirtualmachine_list",
+    ),
+]

netbox_authorized_keys-1.0.0/netbox_authorized_keys/version.py

@@ -0,0 +1,5 @@
+__author__ = "Jan Krupa"
+__email__ = "jan.krupa@cesnet.cz"
+__version__ = "1.0.0"
+__description__ = "NetBox plugin to store Authorized Keys"
+__name__ = "netbox_authorized_keys"

netbox_authorized_keys-1.0.0/netbox_authorized_keys/views/__init__.py

@@ -0,0 +1 @@
+from .authorizedkey import *

netbox_authorized_keys-1.0.0/netbox_authorized_keys/views/authorizedkey.py

@@ -0,0 +1,62 @@
+from dcim.models import Device
+from netbox.views import generic
+from virtualization.models import VirtualMachine
+
+from netbox_authorized_keys.filtersets import (
+    AuthorizedKeyDeviceFilterSet,
+    AuthorizedKeyFilterSet,
+    AuthorizedKeyVirtualMachineFilterSet,
+)
+from netbox_authorized_keys.forms import (
+    AuthorizedKeyDeviceFilterForm,
+    AuthorizedKeyFilterForm,
+    AuthorizedKeyForm,
+    AuthorizedKeyVirtualMachineFilterForm,
+)
+from netbox_authorized_keys.models import AuthorizedKey, AuthorizedKeyDevice, AuthorizedKeyVirtualMachine
+from netbox_authorized_keys.tables import AuthorizedKeyDeviceTable, AuthorizedKeyTable, AuthorizedKeyVirtualMachineTable
+
+
+class AuthorizedKeyListView(generic.ObjectListView):
+    queryset = AuthorizedKey.objects.all()
+    table = AuthorizedKeyTable
+    filterset = AuthorizedKeyFilterSet
+    filterset_form = AuthorizedKeyFilterForm
+
+
+class AuthorizedKeyView(generic.ObjectView):
+    queryset = AuthorizedKey.objects.all()
+
+    def get_extra_context(self, request, instance):
+        device_ids = list(Device.objects.filter(authorized_keys=instance).values_list("id", flat=True))
+        virtual_machine_ids = list(VirtualMachine.objects.filter(authorized_keys=instance).values_list("id", flat=True))
+
+        return {
+            "device_ids": device_ids,
+            "virtual_machine_ids": virtual_machine_ids,
+        }
+
+
+class AuthorizedKeyEditView(generic.ObjectEditView):
+    queryset = AuthorizedKey.objects.all()
+    form = AuthorizedKeyForm
+
+
+class AuthorizedKeyDeleteView(generic.ObjectDeleteView):
+    queryset = AuthorizedKey.objects.all()
+
+
+# Authorized Key Devices
+class AuthorizedKeyDeviceListView(generic.ObjectListView):
+    queryset = AuthorizedKeyDevice.objects.all()
+    table = AuthorizedKeyDeviceTable
+    filterset = AuthorizedKeyDeviceFilterSet
+    filterset_form = AuthorizedKeyDeviceFilterForm
+
+
+# Authorized Key Virtual Machines
+class AuthorizedKeyVirtualMachineListView(generic.ObjectListView):
+    queryset = AuthorizedKeyVirtualMachine.objects.all()
+    table = AuthorizedKeyVirtualMachineTable
+    filterset = AuthorizedKeyVirtualMachineFilterSet
+    filterset_form = AuthorizedKeyVirtualMachineFilterForm

netbox_authorized_keys-1.0.0/netbox_authorized_keys.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.1
+Name: netbox_authorized_keys
+Version: 1.0.0
+Summary: NetBox plugin to store Authorized Keys
+Author: Jan Krupa
+License: MIT

netbox_authorized_keys-1.0.0/netbox_authorized_keys.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+README.md
+setup.py
+netbox_authorized_keys/__init__.py
+netbox_authorized_keys/navigation.py
+netbox_authorized_keys/template_content.py
+netbox_authorized_keys/urls.py
+netbox_authorized_keys/version.py
+netbox_authorized_keys.egg-info/PKG-INFO
+netbox_authorized_keys.egg-info/SOURCES.txt
+netbox_authorized_keys.egg-info/dependency_links.txt
+netbox_authorized_keys.egg-info/not-zip-safe
+netbox_authorized_keys.egg-info/top_level.txt
+netbox_authorized_keys/api/__init__.py
+netbox_authorized_keys/api/serializers.py
+netbox_authorized_keys/api/urls.py
+netbox_authorized_keys/api/views.py
+netbox_authorized_keys/filtersets/__init__.py
+netbox_authorized_keys/filtersets/authorizedkey.py
+netbox_authorized_keys/forms/__init__.py
+netbox_authorized_keys/forms/authorizedkey.py
+netbox_authorized_keys/migrations/0001_initial.py
+netbox_authorized_keys/migrations/0002_authorizedkey_full_name_and_more.py
+netbox_authorized_keys/migrations/__init__.py
+netbox_authorized_keys/models/__init__.py
+netbox_authorized_keys/models/authorizedkey.py
+netbox_authorized_keys/tables/__init__.py
+netbox_authorized_keys/tables/authorizedkey.py
+netbox_authorized_keys/views/__init__.py
+netbox_authorized_keys/views/authorizedkey.py

netbox_authorized_keys-1.0.0/netbox_authorized_keys.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netbox_authorized_keys-1.0.0/netbox_authorized_keys.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

netbox_authorized_keys-1.0.0/netbox_authorized_keys.egg-info/top_level.txt

@@ -0,0 +1 @@
+netbox_authorized_keys

netbox_authorized_keys-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

netbox_authorized_keys-1.0.0/setup.py

@@ -0,0 +1,44 @@
+import codecs
+import os.path
+
+from setuptools import find_packages, setup
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+
+def read(rel_path):
+    here = os.path.abspath(os.path.dirname(__file__))
+    with codecs.open(os.path.join(here, rel_path), "r") as fp:
+        return fp.read()
+
+
+def get_config_param(rel_path, variable_name):
+    for line in read(rel_path).splitlines():
+        if line.startswith(variable_name):
+            delim = '"' if '"' in line else "'"
+            return line.split(delim)[1]
+    else:
+        raise RuntimeError(f"Unable to find {variable_name} string.")
+
+
+def get_version(rel_path):
+    for line in read(rel_path).splitlines():
+        if line.startswith("__version__"):
+            delim = '"' if '"' in line else "'"
+            return line.split(delim)[1]
+    else:
+        raise RuntimeError("Unable to find version string.")
+
+
+setup(
+    name=get_config_param("netbox_authorized_keys/version.py", "__name__"),
+    version=get_version("netbox_authorized_keys/version.py"),
+    description=get_config_param("netbox_authorized_keys/version.py", "__description__"),
+    author=get_config_param("netbox_authorized_keys/version.py", "__author__"),
+    license="MIT",
+    install_requires=[],
+    packages=find_packages(),
+    include_package_data=True,
+    zip_safe=False,
+)