netboxlabs-netbox-custom-objects 0.1.0__py3-none-any.whl

netbox_custom_objects/__init__.py

@@ -0,0 +1,42 @@
+from netbox.plugins import PluginConfig
+
+
+# Plugin Configuration
+class CustomObjectsPluginConfig(PluginConfig):
+    name = "netbox_custom_objects"
+    verbose_name = "Custom Objects"
+    description = "A plugin to manage custom objects in NetBox"
+    version = "0.1.0"
+    base_url = "custom-objects"
+    min_version = "4.2.0"
+    default_settings = {}
+    required_settings = []
+    template_extensions = "template_content.template_extensions"
+
+    # def get_model(self, model_name, require_ready=True):
+    #     if require_ready:
+    #         self.apps.check_models_ready()
+    #     else:
+    #         self.apps.check_apps_ready()
+    #
+    #     if model_name.lower() in self.models:
+    #         return self.models[model_name.lower()]
+    #
+    #     from .models import CustomObjectType
+    #     if "table" not in model_name.lower() or "model" not in model_name.lower():
+    #         raise LookupError(
+    #             "App '%s' doesn't have a '%s' model." % (self.label, model_name)
+    #         )
+    #
+    #     custom_object_type_id = int(model_name.replace("table", "").replace("model", ""))
+    #
+    #     try:
+    #         obj = CustomObjectType.objects.get(pk=custom_object_type_id)
+    #     except CustomObjectType.DoesNotExist:
+    #         raise LookupError(
+    #             "App '%s' doesn't have a '%s' model." % (self.label, model_name)
+    #         )
+    #     return obj.get_model()
+
+
+config = CustomObjectsPluginConfig

netbox_custom_objects/api/serializers.py

@@ -0,0 +1,244 @@
+from django.contrib.contenttypes.models import ContentType
+from extras.choices import CustomFieldTypeChoices
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from rest_framework.reverse import reverse
+
+from netbox_custom_objects import field_types
+from netbox_custom_objects.models import CustomObject, CustomObjectType, CustomObjectTypeField
+
+__all__ = (
+    "CustomObjectTypeSerializer",
+    "CustomObjectSerializer",
+)
+
+
+class ContentTypeSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = ContentType
+        fields = (
+            "id",
+            "app_label",
+            "model",
+        )
+
+
+class CustomObjectTypeFieldSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_custom_objects-api:customobjecttypefield-detail"
+    )
+    app_label = serializers.CharField(required=False)
+    model = serializers.CharField(required=False)
+
+    class Meta:
+        model = CustomObjectTypeField
+        fields = (
+            # 'id', 'url', 'name', 'label', 'custom_object_type', 'field_type', 'content_type', 'many', 'options',
+            "id",
+            "name",
+            "label",
+            "custom_object_type",
+            "type",
+            "primary",
+            "default",
+            "choice_set",
+            "validation_regex",
+            "validation_minimum",
+            "validation_maximum",
+            "related_object_type",
+            "app_label",
+            "model",
+        )
+
+    def validate(self, attrs):
+        app_label = attrs.pop("app_label", None)
+        model = attrs.pop("model", None)
+        if attrs["type"] in [
+            CustomFieldTypeChoices.TYPE_OBJECT,
+            CustomFieldTypeChoices.TYPE_MULTIOBJECT,
+        ]:
+            try:
+                attrs["related_object_type"] = ContentType.objects.get(
+                    app_label=app_label, model=model
+                )
+            except ContentType.DoesNotExist:
+                raise ValidationError(
+                    "Must provide valid app_label and model for object field type."
+                )
+        if attrs["type"] in [
+            CustomFieldTypeChoices.TYPE_SELECT,
+            CustomFieldTypeChoices.TYPE_MULTISELECT,
+        ]:
+            if not attrs.get("choice_set", None):
+                raise ValidationError(
+                    "Must provide choice_set with valid PK for select field type."
+                )
+        return super().validate(attrs)
+
+    def create(self, validated_data):
+        """
+        Record the user who created the Custom Object as its owner.
+        """
+        return super().create(validated_data)
+
+    def get_related_object_type(self, obj):
+        if obj.related_object_type:
+            return dict(
+                id=obj.related_object_type.id,
+                app_label=obj.related_object_type.app_label,
+                model=obj.related_object_type.model,
+            )
+
+
+class CustomObjectTypeSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_custom_objects-api:customobjecttype-detail"
+    )
+    fields = CustomObjectTypeFieldSerializer(
+        nested=True,
+        read_only=True,
+        many=True,
+    )
+
+    class Meta:
+        model = CustomObjectType
+        fields = [
+            "id",
+            "url",
+            "name",
+            "description",
+            "tags",
+            "created",
+            "last_updated",
+            "fields",
+        ]
+        brief_fields = ("id", "url", "name", "description")
+
+    def create(self, validated_data):
+        return super().create(validated_data)
+
+
+# TODO: Remove or reduce to a stub (not needed as all custom object serializers are generated via get_serializer_class)
+class CustomObjectSerializer(NetBoxModelSerializer):
+    relation_fields = None
+
+    url = serializers.SerializerMethodField()
+    field_data = serializers.SerializerMethodField()
+    custom_object_type = CustomObjectTypeSerializer(nested=True)
+
+    class Meta:
+        model = CustomObject
+        fields = [
+            "id",
+            "url",
+            "name",
+            "display",
+            "custom_object_type",
+            "tags",
+            "created",
+            "last_updated",
+            "data",
+            "field_data",
+        ]
+        brief_fields = (
+            "id",
+            "url",
+            "name",
+            "custom_object_type",
+        )
+
+    def get_display(self, obj):
+        return f"{obj.custom_object_type}: {obj.name}"
+
+    def validate(self, attrs):
+        return super().validate(attrs)
+
+    def update_relation_fields(self, instance):
+        # TODO: Implement this
+        pass
+
+    def create(self, validated_data):
+        model = validated_data["custom_object_type"].get_model()
+        instance = model.objects.create(**validated_data)
+
+        return instance
+
+    def update(self, instance, validated_data):
+        instance = super().update(instance, validated_data)
+        # self.update_relation_fields(instance)
+        return instance
+
+    def get_url(self, obj):
+        """
+        Given an object, return the URL that hyperlinks to the object.
+
+        May raise a `NoReverseMatch` if the `view_name` and `lookup_field`
+        attributes are not configured to correctly match the URL conf.
+        """
+        # Unsaved objects will not yet have a valid URL.
+        if hasattr(obj, "pk") and obj.pk in (None, ""):
+            return None
+
+        view_name = "plugins-api:netbox_custom_objects-api:customobject-detail"
+        lookup_value = getattr(obj, "pk")
+        kwargs = {
+            "pk": lookup_value,
+            "custom_object_type": obj.custom_object_type.name.lower(),
+        }
+        request = self.context["request"]
+        format = self.context.get("format")
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
+
+    def get_field_data(self, obj):
+        result = {}
+        return result
+
+
+def get_serializer_class(model):
+    model_fields = model.custom_object_type.fields.all()
+    meta = type(
+        "Meta",
+        (),
+        {
+            "model": model,
+            "fields": "__all__",
+        },
+    )
+
+    def get_url(self, obj):
+        # Unsaved objects will not yet have a valid URL.
+        if hasattr(obj, "pk") and obj.pk in (None, ""):
+            return None
+
+        view_name = "plugins-api:netbox_custom_objects-api:customobject-detail"
+        lookup_value = getattr(obj, "pk")
+        kwargs = {
+            "pk": lookup_value,
+            "custom_object_type": obj.custom_object_type.name.lower(),
+        }
+        request = self.context["request"]
+        format = self.context.get("format")
+        return reverse(view_name, kwargs=kwargs, request=request, format=format)
+
+    attrs = {
+        "Meta": meta,
+        "__module__": "database.serializers",
+        "url": serializers.SerializerMethodField(),
+        "get_url": get_url,
+    }
+
+    for field in model_fields:
+        field_type = field_types.FIELD_TYPE_CLASS[field.type]()
+        try:
+            attrs[field.name] = field_type.get_serializer_field(field)
+        except NotImplementedError:
+            print(f"serializer: {field.name} field is not implemented; using a default serializer field")
+
+    serializer = type(
+        f"{model._meta.object_name}Serializer",
+        (serializers.ModelSerializer,),
+        attrs,
+    )
+
+    return serializer

netbox_custom_objects/api/urls.py

@@ -0,0 +1,83 @@
+from copy import deepcopy
+from django.urls import include, path, NoReverseMatch
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+from netbox.api.routers import NetBoxRouter
+from netbox_custom_objects.models import CustomObjectType
+
+from . import views
+
+custom_object_list = views.CustomObjectViewSet.as_view(
+    {"get": "list", "post": "create"}
+)
+custom_object_detail = views.CustomObjectViewSet.as_view(
+    {"get": "retrieve", "put": "update", "patch": "partial_update", "delete": "destroy"}
+)
+
+
+class CustomObjectsAPIRootView(APIView):
+    """
+    This is the root of the NetBox Custom Objects plugin API. Custom Object Types defined at application startup
+    are listed by lowercased name; e.g. `/api/plugins/custom-objects/cat/`.
+    """
+    def get_view_name(self):
+        return "Custom Objects API Root"
+
+    _ignore_model_permissions = True
+    schema = None  # exclude from schema
+    api_root_dict = None
+
+    # This logic is copied from stock DRF APIRootView
+    def get(self, request, *args, **kwargs):
+        # Return a plain {"name": "hyperlink"} response.
+        ret = {}
+        namespace = request.resolver_match.namespace
+        for key, url_name in self.api_root_dict.items():
+            if namespace:
+                url_name = namespace + ':' + url_name
+            try:
+                ret[key] = reverse(
+                    url_name,
+                    args=args,
+                    kwargs=kwargs,
+                    request=request,
+                    format=kwargs.get('format')
+                )
+            except NoReverseMatch:
+                # Don't bail out if eg. no list routes exist, only detail routes.
+                continue
+
+        # Extra logic to populate roots for custom object type lists
+        for custom_object_type in CustomObjectType.objects.all():
+            local_kwargs = deepcopy(kwargs)
+            cot_name = custom_object_type.name.lower()
+            url_name = 'customobject-list'
+            local_kwargs['custom_object_type'] = cot_name
+            if namespace:
+                url_name = namespace + ':' + url_name
+            ret[cot_name] = reverse(
+                url_name,
+                args=args,
+                kwargs=local_kwargs,
+                request=request,
+                format=local_kwargs.get('format')
+            )
+
+        return Response(ret)
+
+
+router = NetBoxRouter()
+router.APIRootView = CustomObjectsAPIRootView
+router.register("custom-object-types", views.CustomObjectTypeViewSet)
+router.register("custom-object-type-fields", views.CustomObjectTypeFieldViewSet)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("<str:custom_object_type>/", custom_object_list, name="customobject-list"),
+    path(
+        "<str:custom_object_type>/<int:pk>/",
+        custom_object_detail,
+        name="customobject-detail",
+    ),
+]

netbox_custom_objects/api/views.py

@@ -0,0 +1,49 @@
+from django.http import Http404
+from rest_framework.routers import APIRootView
+from rest_framework.viewsets import ModelViewSet
+
+from netbox_custom_objects.models import CustomObject, CustomObjectType, CustomObjectTypeField
+
+from . import serializers
+
+
+class RootView(APIRootView):
+    def get_view_name(self):
+        return "CustomObjects"
+
+
+class CustomObjectTypeViewSet(ModelViewSet):
+    queryset = CustomObjectType.objects.all()
+    serializer_class = serializers.CustomObjectTypeSerializer
+
+
+class CustomObjectViewSet(ModelViewSet):
+    queryset = CustomObject.objects.all()
+    serializer_class = serializers.CustomObjectSerializer
+    model = None
+
+    def get_view_name(self):
+        if self.model:
+            return self.model.custom_object_type.name
+        return super().get_view_name()
+
+    def get_serializer_class(self):
+        return serializers.get_serializer_class(self.model)
+
+    def get_queryset(self):
+        try:
+            custom_object_type = CustomObjectType.objects.get(
+                name__iexact=self.kwargs["custom_object_type"]
+            )
+        except CustomObjectType.DoesNotExist:
+            raise Http404
+        self.model = custom_object_type.get_model()
+        return self.model.objects.all()
+
+    def list(self, request, *args, **kwargs):
+        return super().list(request, *args, **kwargs)
+
+
+class CustomObjectTypeFieldViewSet(ModelViewSet):
+    queryset = CustomObjectTypeField.objects.all()
+    serializer_class = serializers.CustomObjectTypeFieldSerializer

netbox_custom_objects/choices.py

@@ -0,0 +1,20 @@
+from django.utils.translation import gettext_lazy as _
+from utilities.choices import ChoiceSet
+
+
+class MappingFieldTypeChoices(ChoiceSet):
+    CHAR = "char"
+    INTEGER = "integer"
+    BOOLEAN = "boolean"
+    DATE = "date"
+    DATETIME = "datetime"
+    OBJECT = "object"
+
+    CHOICES = (
+        (CHAR, _("String"), "cyan"),
+        (INTEGER, _("Integer"), "orange"),
+        (BOOLEAN, _("Boolean"), "green"),
+        (DATE, _("Date"), "red"),
+        (DATETIME, _("DateTime"), "blue"),
+        (OBJECT, _("Object"), "orange"),
+    )

netbox_custom_objects/constants.py

@@ -0,0 +1,8 @@
+# Models which do not support change logging, but whose database tables
+# must be replicated for each branch to ensure proper functionality
+INCLUDE_MODELS = (
+    "dcim.cablepath",
+    "extras.cachedvalue",
+)
+
+APP_LABEL = "netbox_custom_objects"