netboxlabs-netbox-custom-objects 0.1.0__tar.gz

netboxlabs_netbox_custom_objects-0.1.0/LICENSE.md

@@ -0,0 +1,85 @@
+# NetBox Limited Use License 1.0
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as
+both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+NetBox Labs grants you a copyright license to use and modify the software
+only as part of a NetBox installation obtained from NetBox Labs or a NetBox
+distributor authorized by NetBox Labs, and only for your own internal use.
+
+For clarity, this license grants no rights to distribute the software or
+make it available to others as part of a commercial offering.
+
+## Patent License
+
+NetBox Labs grants you a patent license for the software that covers patent
+claims the licensor can license, or becomes able to license, that you would
+infringe by using the software, as allowed in the copyright license above.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to
+infringement of any patent, your patent license for the software granted
+under these terms ends immediately. If your company makes such a claim,
+your patent license ends immediately for work on behalf of your company.
+Competitive Restrictions
+
+This license does not grant you the right to use the software:
+
+- To provide a managed service or software products that includes, integrates
+  with, or extends NetBox in a way that competes with any product or service
+  of NetBox Labs.
+
+- To assist or enable a third party in offering a service or product that
+  competes with any product or service of NetBox Labs.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses
+to anyone else, or prevent NetBox Labs from granting licenses to anyone else.
+These terms do not imply any other licenses.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of
+these terms, or done anything with the software not covered by your licenses,
+your licenses can nonetheless continue if you come into full compliance with
+these terms, and take practical steps to correct past violations, within 30
+days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and NetBox Labs will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+If this disclaimer is unenforceable under applicable law, this license is void.
+
+## Definitions
+
+**NetBox Labs** is NetBox Labs, Inc.
+
+**NetBox** is the community edition of NetBox found at
+<https://github.com/netbox-community/netbox> or any derivative thereof.
+
+The **software** is the software NetBox Labs makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+
+**Control** means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

netboxlabs_netbox_custom_objects-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: netboxlabs-netbox-custom-objects
+Version: 0.1.0
+Summary: A plugin to manage custom objects in NetBox
+Author-email: NetBox Labs <support@netboxlabs.com>
+Maintainer-email: NetBox Labs <support@netboxlabs.com>
+License: PolyForm Shield License 1.0.0
+Project-URL: Homepage, https://netboxlabs.com/
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: Django
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: pycodestyle; extra == "dev"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# NetBox Custom Objects
+
+This [NetBox](https://netboxlabs.com/products/netbox/) plugin introduces the ability to create new object types in NetBox so that users can add models to suit their own needs. NetBox users have been able to extend the NetBox data model for some time using both Tags & Custom Fields and Plugins. Tags and Custom Fields are easy to use, but they have limitations when used at scale, and Plugins are very powerful but require Python/Django knowledge, and ongoing maintenance. Custom Objects provides users with a no-code "sweet spot" for data model extensibility, providing a lot of the power of NetBox plugins, but with the ease of use of Tags and Custom Fields.
+
+You can find further documentation [here](docs/index.md).
+
+## Requirements
+
+* NetBox v4.2 or later
+
+## Installation
+
+1. Add `netboxlabs_netbox_custom_objects` to `PLUGINS` in `configuration.py`.
+
+```python
+PLUGINS = [
+    # ...
+    'netboxlabs_netbox_custom_objects',
+]
+```
+
+2. Run NetBox migrations:
+
+```
+$ ./manage.py migrate
+```
+
+## Known Limitations
+
+The Public Preview of NetBox Custom Objects is under active development as we proceed towards the General Availability release around NetBox 4.4. The best place to look for the latest list of known limitations is the [issues](https://github.com/netboxlabs/netbox-custom-objects/issues) list on the GitHub repository. These include features like Tags, Import/Export, Bulk Edit, Text Search and Branching.

netboxlabs_netbox_custom_objects-0.1.0/README.md

@@ -0,0 +1,30 @@
+# NetBox Custom Objects
+
+This [NetBox](https://netboxlabs.com/products/netbox/) plugin introduces the ability to create new object types in NetBox so that users can add models to suit their own needs. NetBox users have been able to extend the NetBox data model for some time using both Tags & Custom Fields and Plugins. Tags and Custom Fields are easy to use, but they have limitations when used at scale, and Plugins are very powerful but require Python/Django knowledge, and ongoing maintenance. Custom Objects provides users with a no-code "sweet spot" for data model extensibility, providing a lot of the power of NetBox plugins, but with the ease of use of Tags and Custom Fields.
+
+You can find further documentation [here](docs/index.md).
+
+## Requirements
+
+* NetBox v4.2 or later
+
+## Installation
+
+1. Add `netboxlabs_netbox_custom_objects` to `PLUGINS` in `configuration.py`.
+
+```python
+PLUGINS = [
+    # ...
+    'netboxlabs_netbox_custom_objects',
+]
+```
+
+2. Run NetBox migrations:
+
+```
+$ ./manage.py migrate
+```
+
+## Known Limitations
+
+The Public Preview of NetBox Custom Objects is under active development as we proceed towards the General Availability release around NetBox 4.4. The best place to look for the latest list of known limitations is the [issues](https://github.com/netboxlabs/netbox-custom-objects/issues) list on the GitHub repository. These include features like Tags, Import/Export, Bulk Edit, Text Search and Branching.

netboxlabs_netbox_custom_objects-0.1.0/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

netboxlabs_netbox_custom_objects-0.1.0/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

netboxlabs_netbox_custom_objects-0.1.0/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",
+    ),
+]

netboxlabs_netbox_custom_objects-0.1.0/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

netboxlabs_netbox_custom_objects-0.1.0/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"),
+    )

netboxlabs_netbox_custom_objects-0.1.0/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"