netbox-cable-patcher 0.4.1__tar.gz

netbox_cable_patcher-0.4.1/LICENSE

@@ -0,0 +1 @@
+

netbox_cable_patcher-0.4.1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: netbox-cable-patcher
+Version: 0.4.1
+Summary: NetBox plugin providing a visual patch bay interface for managing cable connections.
+Author: NetBox Cable Patcher Contributors
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://github.com/netbox-community/netbox-cable-patcher/blob/main/README.md
+Project-URL: Source, https://github.com/netbox-community/netbox-cable-patcher
+Project-URL: Tracker, https://github.com/netbox-community/netbox-cable-patcher/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+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.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: black==24.3.0; extra == "test"
+Requires-Dist: check-manifest==0.49; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: flake8-pyproject; extra == "test"
+Requires-Dist: pre-commit==3.7.0; extra == "test"
+Requires-Dist: pytest==8.1.1; extra == "test"
+Dynamic: license-file
+
+# NetBox Cable Patcher
+
+NetBox plugin for netbox_cable_patcher.
+
+
+* Free software: Apache-2.0
+* Documentation: https://.github.io/netbox-cable-patcher/
+
+
+## Features
+
+The features the plugin provides should be listed here.
+
+## Compatibility
+
+| NetBox Version | Plugin Version |
+|----------------|----------------|
+|     4.0        |      0.1.0     |
+
+## Installing
+
+For adding to a NetBox Docker setup see
+[the general instructions for using netbox-docker with plugins](https://github.com/netbox-community/netbox-docker/wiki/Using-Netbox-Plugins).
+
+While this is still in development and not yet on pypi you can install with pip:
+
+```bash
+pip install git+https://github.com//netbox-cable-patcher
+```
+
+or by adding to your `local_requirements.txt` or `plugin_requirements.txt` (netbox-docker):
+
+```bash
+git+https://github.com//netbox-cable-patcher
+```
+
+Enable the plugin in `/opt/netbox/netbox/netbox/configuration.py`,
+ or if you use netbox-docker, your `/configuration/plugins.py` file :
+
+```python
+PLUGINS = [
+    'netbox-cable-patcher'
+]
+
+PLUGINS_CONFIG = {
+    "netbox-cable-patcher": {},
+}
+```
+
+## Credits
+
+Based on the NetBox plugin tutorial:
+
+- [demo repository](https://github.com/netbox-community/netbox-plugin-demo)
+- [tutorial](https://github.com/netbox-community/netbox-plugin-tutorial)
+
+This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [`netbox-community/cookiecutter-netbox-plugin`](https://github.com/netbox-community/cookiecutter-netbox-plugin) project template.

netbox_cable_patcher-0.4.1/README.md

@@ -0,0 +1,57 @@
+# NetBox Cable Patcher
+
+NetBox plugin for netbox_cable_patcher.
+
+
+* Free software: Apache-2.0
+* Documentation: https://.github.io/netbox-cable-patcher/
+
+
+## Features
+
+The features the plugin provides should be listed here.
+
+## Compatibility
+
+| NetBox Version | Plugin Version |
+|----------------|----------------|
+|     4.0        |      0.1.0     |
+
+## Installing
+
+For adding to a NetBox Docker setup see
+[the general instructions for using netbox-docker with plugins](https://github.com/netbox-community/netbox-docker/wiki/Using-Netbox-Plugins).
+
+While this is still in development and not yet on pypi you can install with pip:
+
+```bash
+pip install git+https://github.com//netbox-cable-patcher
+```
+
+or by adding to your `local_requirements.txt` or `plugin_requirements.txt` (netbox-docker):
+
+```bash
+git+https://github.com//netbox-cable-patcher
+```
+
+Enable the plugin in `/opt/netbox/netbox/netbox/configuration.py`,
+ or if you use netbox-docker, your `/configuration/plugins.py` file :
+
+```python
+PLUGINS = [
+    'netbox-cable-patcher'
+]
+
+PLUGINS_CONFIG = {
+    "netbox-cable-patcher": {},
+}
+```
+
+## Credits
+
+Based on the NetBox plugin tutorial:
+
+- [demo repository](https://github.com/netbox-community/netbox-plugin-demo)
+- [tutorial](https://github.com/netbox-community/netbox-plugin-tutorial)
+
+This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [`netbox-community/cookiecutter-netbox-plugin`](https://github.com/netbox-community/cookiecutter-netbox-plugin) project template.

netbox_cable_patcher-0.4.1/netbox_cable_patcher/__init__.py

@@ -0,0 +1,20 @@
+"""Top-level package for NetBox Cable Patcher."""
+
+__author__ = """John Doe"""
+__email__ = ""
+__version__ = "0.4.1"
+
+
+from netbox.plugins import PluginConfig
+
+
+class NetBoxCablePatcherConfig(PluginConfig):
+    name = "netbox_cable_patcher"
+    verbose_name = "Cable Patcher"
+    description = "Visual patch bay interface for NetBox with interactive cable connections."
+    version = __version__
+    base_url = "cable-patcher"
+    min_version = "4.0.0"
+
+
+config = NetBoxCablePatcherConfig

netbox_cable_patcher-0.4.1/netbox_cable_patcher/api/__init__.py

@@ -0,0 +1 @@
+# API module for NetBox Cable Patcher

netbox_cable_patcher-0.4.1/netbox_cable_patcher/api/serializers.py

@@ -0,0 +1,239 @@
+from rest_framework import serializers
+from dcim.models import (
+    Site, Location, Rack, Device, Interface,
+    FrontPort, RearPort, PowerPort, PowerOutlet,
+    ConsolePort, ConsoleServerPort, Cable,
+    ModuleBay, Module, ModuleType
+)
+
+
+class SiteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Site
+        fields = ['id', 'name', 'slug']
+
+
+class LocationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Location
+        fields = ['id', 'name', 'slug', 'site']
+
+
+class RackSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Rack
+        fields = ['id', 'name', 'site', 'location']
+
+
+class PortSerializer(serializers.Serializer):
+    """Generic serializer for any port type."""
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    type = serializers.CharField(source='get_type_display', required=False, allow_null=True)
+    cable_id = serializers.SerializerMethodField()
+    connected_endpoint = serializers.SerializerMethodField()
+    port_type = serializers.SerializerMethodField()
+    module_bay_id = serializers.SerializerMethodField()
+
+    def get_cable_id(self, obj):
+        if hasattr(obj, 'cable') and obj.cable:
+            return obj.cable.id
+        return None
+
+    def get_connected_endpoint(self, obj):
+        if hasattr(obj, 'connected_endpoints') and obj.connected_endpoints:
+            endpoints = obj.connected_endpoints
+            if endpoints:
+                endpoint = endpoints[0]
+                return {
+                    'id': endpoint.id,
+                    'name': endpoint.name if hasattr(endpoint, 'name') else str(endpoint),
+                    'device_id': endpoint.device.id if hasattr(endpoint, 'device') else None,
+                    'device_name': endpoint.device.name if hasattr(endpoint, 'device') else None,
+                    'type': endpoint.__class__.__name__
+                }
+        return None
+
+    def get_port_type(self, obj):
+        return obj.__class__.__name__
+
+    untagged_vlan_vid = serializers.SerializerMethodField()
+
+    def get_untagged_vlan_vid(self, obj):
+        if hasattr(obj, 'untagged_vlan') and obj.untagged_vlan:
+            return obj.untagged_vlan.vid
+        return None
+
+    def get_module_bay_id(self, obj):
+        if hasattr(obj, 'module') and obj.module:
+            return obj.module.module_bay_id
+        return None
+
+
+class ModuleBaySerializer(serializers.Serializer):
+    """Serializer for module bay data within a device."""
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    position = serializers.CharField(allow_null=True, required=False)
+    label = serializers.CharField(allow_blank=True, required=False)
+    installed_module = serializers.SerializerMethodField()
+
+    def get_installed_module(self, obj):
+        if not hasattr(obj, 'installed_module') or not obj.installed_module:
+            return None
+        mod = obj.installed_module
+        return {
+            'id': mod.id,
+            'module_type': {
+                'id': mod.module_type_id,
+                'model': mod.module_type.model,
+                'manufacturer': mod.module_type.manufacturer.name,
+            },
+            'status': mod.status,
+        }
+
+
+class ModuleTypeSearchSerializer(serializers.ModelSerializer):
+    """Serializer for module type search results."""
+    manufacturer_name = serializers.CharField(source='manufacturer.name', read_only=True)
+
+    class Meta:
+        model = ModuleType
+        fields = ['id', 'model', 'manufacturer_name', 'description', 'part_number']
+
+
+class ModuleInstallSerializer(serializers.Serializer):
+    """Serializer for validating module installation requests."""
+    module_type_id = serializers.IntegerField()
+    serial = serializers.CharField(required=False, allow_blank=True, default='')
+    asset_tag = serializers.CharField(required=False, allow_blank=True, allow_null=True, default=None)
+
+
+class DeviceWithPortsSerializer(serializers.ModelSerializer):
+    interfaces = serializers.SerializerMethodField()
+    power_ports = serializers.SerializerMethodField()
+    power_outlets = serializers.SerializerMethodField()
+    front_ports = serializers.SerializerMethodField()
+    rear_ports = serializers.SerializerMethodField()
+    console_ports = serializers.SerializerMethodField()
+    console_server_ports = serializers.SerializerMethodField()
+    module_bays = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Device
+        fields = [
+            'id', 'name', 'device_type', 'rack', 'position',
+            'interfaces', 'power_ports', 'power_outlets',
+            'front_ports', 'rear_ports', 'console_ports', 'console_server_ports',
+            'module_bays'
+        ]
+
+    def get_interfaces(self, obj):
+        # Exclude non-physical interface types (virtual, lag, bridge)
+        qs = obj.interfaces.exclude(type__in=['virtual', 'lag', 'bridge'])
+        return PortSerializer(qs, many=True).data
+
+    def get_power_ports(self, obj):
+        return PortSerializer(obj.powerports.all(), many=True).data
+
+    def get_power_outlets(self, obj):
+        return PortSerializer(obj.poweroutlets.all(), many=True).data
+
+    def get_front_ports(self, obj):
+        return PortSerializer(obj.frontports.all(), many=True).data
+
+    def get_rear_ports(self, obj):
+        return PortSerializer(obj.rearports.all(), many=True).data
+
+    def get_console_ports(self, obj):
+        return PortSerializer(obj.consoleports.all(), many=True).data
+
+    def get_console_server_ports(self, obj):
+        return PortSerializer(obj.consoleserverports.all(), many=True).data
+
+    def get_module_bays(self, obj):
+        return ModuleBaySerializer(obj.modulebays.all(), many=True).data
+
+
+class CableSerializer(serializers.ModelSerializer):
+    a_terminations = serializers.SerializerMethodField()
+    b_terminations = serializers.SerializerMethodField()
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    type_display = serializers.CharField(source='get_type_display', read_only=True)
+
+    class Meta:
+        model = Cable
+        fields = [
+            'id', 'type', 'type_display', 'status', 'status_display',
+            'color', 'label', 'length', 'length_unit',
+            'a_terminations', 'b_terminations'
+        ]
+
+    def get_a_terminations(self, obj):
+        return self._serialize_terminations(obj.a_terminations)
+
+    def get_b_terminations(self, obj):
+        return self._serialize_terminations(obj.b_terminations)
+
+    def _serialize_terminations(self, terminations):
+        result = []
+        for term in terminations:
+            data = {
+                'id': term.id,
+                'name': term.name if hasattr(term, 'name') else str(term),
+                'type': term.__class__.__name__,
+            }
+            if hasattr(term, 'device'):
+                data['device_id'] = term.device.id
+                data['device_name'] = term.device.name
+            result.append(data)
+        return result
+
+
+# Defines which port types may be connected to which other port types.
+# This mirrors NetBox's own cable termination compatibility rules.
+COMPATIBLE_TERMINATION_TYPES = {
+    'Interface':         {'Interface', 'FrontPort', 'RearPort'},
+    'FrontPort':         {'Interface', 'FrontPort', 'RearPort', 'ConsolePort', 'ConsoleServerPort'},
+    'RearPort':          {'Interface', 'FrontPort', 'RearPort', 'ConsolePort', 'ConsoleServerPort'},
+    'ConsolePort':       {'ConsoleServerPort', 'FrontPort', 'RearPort'},
+    'ConsoleServerPort': {'ConsolePort', 'FrontPort', 'RearPort'},
+    'PowerPort':         {'PowerOutlet'},
+    'PowerOutlet':       {'PowerPort'},
+}
+
+
+class CableCreateSerializer(serializers.Serializer):
+    """Serializer for creating cables via the patcher interface."""
+    a_termination_type = serializers.CharField()
+    a_termination_id = serializers.IntegerField()
+    b_termination_type = serializers.CharField()
+    b_termination_id = serializers.IntegerField()
+    type = serializers.CharField(required=False, allow_blank=True)
+    status = serializers.CharField(default='connected')
+    color = serializers.CharField(required=False, allow_blank=True)
+    label = serializers.CharField(required=False, allow_blank=True)
+
+    def validate(self, data):
+        a_type = data.get('a_termination_type')
+        b_type = data.get('b_termination_type')
+
+        valid_types = set(COMPATIBLE_TERMINATION_TYPES.keys())
+
+        if a_type not in valid_types:
+            raise serializers.ValidationError(
+                {'a_termination_type': f'Invalid termination type: {a_type}'}
+            )
+        if b_type not in valid_types:
+            raise serializers.ValidationError(
+                {'b_termination_type': f'Invalid termination type: {b_type}'}
+            )
+
+        allowed_b_types = COMPATIBLE_TERMINATION_TYPES.get(a_type, set())
+        if b_type not in allowed_b_types:
+            raise serializers.ValidationError(
+                f'Cannot connect a {a_type} to a {b_type}. '
+                f'A {a_type} may only connect to: {", ".join(sorted(allowed_b_types))}.'
+            )
+
+        return data

netbox_cable_patcher-0.4.1/netbox_cable_patcher/api/urls.py

@@ -0,0 +1,12 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from . import views
+
+router = DefaultRouter()
+router.register('locations', views.LocationsViewSet, basename='locations')
+router.register('devices', views.DevicesViewSet, basename='devices')
+router.register('cables', views.CablesViewSet, basename='cables')
+router.register('module-types', views.ModuleTypesViewSet, basename='module-types')
+router.register('module-bays', views.ModuleBaysViewSet, basename='module-bays')
+
+urlpatterns = router.urls