netbox-inventree-sync 0.1.0__py3-none-any.whl

netbox_inventree_sync/__init__.py

@@ -0,0 +1,42 @@
+"""NetBox plugin: synchronize NetBox inventory data to InvenTree."""
+
+import logging
+
+from netbox.plugins import PluginConfig
+
+__version__ = '0.1.0'
+
+logger = logging.getLogger('netbox_inventree_sync')
+
+
+class NetBoxInvenTreeSyncConfig(PluginConfig):
+    name = 'netbox_inventree_sync'
+    verbose_name = 'InvenTree Sync'
+    description = 'Synchronize NetBox inventory data to InvenTree'
+    version = __version__
+    min_version = '4.7'
+    menu = 'navigation.menu'
+
+    def ready(self):
+        # Connect the sync signal wiring. This only connects signal hooks
+        # (and may run one guarded binding build when apps are already
+        # populated — during a plain web/worker boot they are, so a
+        # single exception-guarded query happens here). At first boot (or
+        # while `manage.py test` builds the test database) the plugin's
+        # tables may not even exist, hence the guard. Whatever bindings
+        # are missed here converge later, on post_migrate, on the first
+        # request in the process (TTL re-check), or on the next mapping
+        # save — see signals.register_receivers(). Anything unexpected at
+        # boot must not take NetBox down.
+        super().ready()
+        try:
+            from netbox_inventree_sync import signals
+            signals.register_receivers()
+        except Exception:
+            logger.exception(
+                'netbox_inventree_sync: signal receiver hooks not connected; '
+                'they will be connected on the next migrate or first request'
+            )
+
+
+config = NetBoxInvenTreeSyncConfig

netbox_inventree_sync/api/__init__.py

@@ -0,0 +1,8 @@
+"""REST API components for the InvenTree sync plugin.
+
+NetBox discovers a plugin's REST API by convention: it imports
+``netbox_inventree_sync.api.urls`` and mounts its ``urlpatterns`` under
+``/api/plugins/netbox_inventree_sync/`` (see
+``netbox/plugins/urls.py``). The submodules here follow NetBox's
+recommended plugin API layout (``docs/plugins/development/rest-api.md``).
+"""

netbox_inventree_sync/api/exceptions.py

@@ -0,0 +1,19 @@
+"""API-layer exceptions shared by the plugin's serializers and views.
+
+Kept in its own module so both the view layer (fields endpoint) and the
+serializer layer (mapping writes) translate an unreachable InvenTree
+into the same 502 semantics without importing each other.
+"""
+
+from rest_framework import status
+from rest_framework.exceptions import APIException
+
+__all__ = ('InvenTreeUnavailable',)
+
+
+class InvenTreeUnavailable(APIException):
+    """The InvenTree server could not be queried for endpoint metadata."""
+
+    status_code = status.HTTP_502_BAD_GATEWAY
+    default_detail = 'The InvenTree server could not be reached.'
+    default_code = 'inventree_unavailable'

netbox_inventree_sync/api/serializers.py

@@ -0,0 +1,253 @@
+"""API serializers for the InvenTree sync plugin models.
+
+Highlights:
+
+* ``InvenTreeInstanceSerializer`` exposes the model's ``url`` column as
+  ``server_url`` — the inherited ``url`` field is the object's API
+  identity (NetBox convention) and would otherwise shadow it — and keeps
+  ``api_token`` strictly write-only.
+* ``SyncMappingSerializer`` carries a nested, writable ``field_pairs``
+  list. Its ``validate()`` runs :func:`~netbox_inventree_sync.sync.validation.validate_mapping`
+  on unsaved :class:`~netbox_inventree_sync.models.SyncFieldPair`
+  instances built from the posted data, so an incompatible mapping is
+  rejected with HTTP 400 (carrying the validator's error codes) instead
+  of ever reaching the sync engine; it then runs
+  :func:`~netbox_inventree_sync.sync.validation.validate_mapping_graph_for_write`
+  so a pair set closing a pairing cycle is rejected the same way. An
+  InvenTree unreachable during either check surfaces as the shared 502
+  :class:`~netbox_inventree_sync.api.exceptions.InvenTreeUnavailable`
+  (the failure is upstream, not in the request). On success each pair's
+  ``transform`` is auto-set by the validator. When ``field_pairs`` is
+  present on a write it replaces the mapping's full pair set; when
+  absent (e.g. a PATCH) the existing pairs are left untouched.
+"""
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError as DjangoValidationError
+from django.db import transaction
+from rest_framework import serializers
+from rest_framework.exceptions import ErrorDetail, ValidationError
+from rest_framework.settings import api_settings
+
+from netbox.api.fields import ContentTypeField
+from netbox.api.serializers import NetBoxModelSerializer
+from netbox_inventree_sync.api.exceptions import InvenTreeUnavailable
+from netbox_inventree_sync.models import (
+    InvenTreeInstance, SyncFieldPair, SyncLogEntry, SyncMapping, SyncedObject,
+)
+from netbox_inventree_sync.sync.client import InvenTreeClientError
+from netbox_inventree_sync.sync.validation import (
+    validate_mapping,
+    validate_mapping_graph_for_write,
+)
+
+__all__ = (
+    'InvenTreeInstanceSerializer',
+    'SyncFieldPairSerializer',
+    'SyncLogEntrySerializer',
+    'SyncMappingSerializer',
+    'SyncedObjectSerializer',
+)
+
+
+class InvenTreeInstanceSerializer(NetBoxModelSerializer):
+    server_url = serializers.URLField(
+        source='url',
+        label='Server URL',
+        help_text="Base URL of the InvenTree server, e.g. https://inventree.example.com",
+    )
+    api_token = serializers.CharField(
+        write_only=True,
+        max_length=255,
+        help_text='InvenTree API token; accepted on write, never returned on read',
+    )
+
+    class Meta:
+        model = InvenTreeInstance
+        fields = ('id', 'url', 'display', 'name', 'server_url', 'api_token', 'enabled')
+        brief_fields = ('id', 'url', 'display', 'name', 'enabled')
+
+
+class SyncFieldPairSerializer(serializers.ModelSerializer):
+    """One NetBox → InvenTree field assignment of a mapping.
+
+    Deliberately a plain DRF ``ModelSerializer``: NetBox's
+    ``ValidatedModelSerializer`` would ``full_clean()`` a freshly built
+    (unsaved, mapping-less) pair instance and reject it long before the
+    mapping serializer's ``validate()`` can run ``validate_mapping``.
+    Pairs are persisted by the mapping serializer, which is also why
+    ``transform`` is read-only — it is computed by ``validate_mapping``.
+    """
+
+    class Meta:
+        model = SyncFieldPair
+        fields = ('id', 'netbox_field', 'netbox_subfield', 'inventree_field', 'transform')
+        read_only_fields = ('id', 'transform')
+
+
+class SyncMappingSerializer(NetBoxModelSerializer):
+    connection = InvenTreeInstanceSerializer(nested=True)
+    netbox_content_type = ContentTypeField(
+        queryset=ContentType.objects.all(),
+    )
+    field_pairs = SyncFieldPairSerializer(
+        many=True,
+        required=False,
+        help_text='Full pair set of the mapping; replaces all existing pairs when present',
+    )
+
+    class Meta:
+        model = SyncMapping
+        fields = (
+            'id', 'url', 'display', 'name', 'connection', 'netbox_content_type',
+            'inventree_endpoint', 'match_netbox_field', 'match_inventree_field',
+            'reconcile_interval_minutes', 'enabled', 'description', 'field_pairs',
+        )
+        brief_fields = ('id', 'url', 'display', 'name', 'enabled')
+
+    def validate(self, data):
+        pairs_data = data.get('field_pairs')
+        # The provisional mapping mirrors NetBox's own
+        # ValidatedModelSerializer: unsaved on create, the persisted
+        # instance patched with the posted attrs on update.
+        mapping = self.instance or SyncMapping()
+        for name, value in data.items():
+            if name != 'field_pairs':
+                setattr(mapping, name, value)
+        pairs = None
+        if pairs_data is not None:
+            # Validate the posted pairs against live NetBox introspection
+            # and the endpoint's OPTIONS metadata (the InvenTree side is
+            # stubbed in tests via sync.validation.InvenTreeClient).
+            pairs = [SyncFieldPair(**attrs) for attrs in pairs_data]
+            try:
+                pairs = validate_mapping(mapping, pairs)
+            except InvenTreeClientError as exc:
+                # Upstream failure while validating: 502, exactly like the
+                # fields endpoint — the request is fine, InvenTree is not.
+                raise InvenTreeUnavailable(str(exc))
+            except DjangoValidationError as exc:
+                raise self._drf_validation_error(exc)
+            data = {**data, 'field_pairs': pairs}
+        if pairs_data is not None or 'enabled' in data:
+            # Pairing-graph gate: a write that can change the graph (a new
+            # pair set adds edges; an enabled flip adds/removes a node)
+            # must not leave it cyclic.
+            try:
+                validate_mapping_graph_for_write(mapping, pairs)
+            except InvenTreeClientError as exc:
+                raise InvenTreeUnavailable(str(exc))
+            except DjangoValidationError as exc:
+                raise self._drf_validation_error(exc)
+        return super().validate(data)
+
+    def create(self, validated_data):
+        pairs = validated_data.pop('field_pairs', [])
+        instance = super().create(validated_data)
+        self._save_pairs(instance, pairs)
+        return instance
+
+    def update(self, instance, validated_data):
+        pairs = validated_data.pop('field_pairs', None)
+        instance = super().update(instance, validated_data)
+        if pairs is not None:
+            self._save_pairs(instance, pairs)
+        return instance
+
+    @staticmethod
+    def _save_pairs(mapping, pairs):
+        """Persist ``pairs`` as the mapping's complete pair set, atomically.
+
+        The full replace (delete-then-create) is one transaction so a
+        failure midway cannot leave the mapping with half its pairs.
+        """
+        with transaction.atomic():
+            mapping.field_pairs.all().delete()
+            for pair in pairs:
+                pair.pk = None
+                pair.mapping = mapping
+                pair.save()
+
+    @staticmethod
+    def _drf_validation_error(exc):
+        """Translate Django's coded ``ValidationError`` into a DRF one.
+
+        Keeps both message and code per error, so API consumers can
+        branch on the validator's codes (incompatible,
+        duplicate_target, unknown_field, pairing_missing,
+        pairing_ambiguous, subfield_required, cycle) the same way the
+        UI will.
+        """
+        if hasattr(exc, 'error_dict'):
+            details = {
+                key: [ErrorDetail(str(error), code=error.code) for error in errors]
+                for key, errors in exc.error_dict.items()
+            }
+        else:
+            details = [ErrorDetail(str(error), code=error.code) for error in exc.error_list]
+        return ValidationError({api_settings.NON_FIELD_ERRORS_KEY: details})
+
+
+class SyncedObjectSerializer(NetBoxModelSerializer):
+    mapping = SyncMappingSerializer(nested=True, read_only=True)
+
+    class Meta:
+        model = SyncedObject
+        fields = (
+            'id', 'url', 'display', 'mapping', 'netbox_object_id', 'inventree_pk',
+            'status', 'last_synced_at', 'last_payload_hash', 'last_error',
+        )
+        brief_fields = ('id', 'url', 'display', 'netbox_object_id', 'status')
+
+
+class SyncLogEntrySerializer(NetBoxModelSerializer):
+    synced = SyncedObjectSerializer(nested=True, allow_null=True, required=False)
+
+    class Meta:
+        model = SyncLogEntry
+        fields = (
+            'id', 'url', 'display', 'synced', 'action', 'payload',
+            'response_status', 'response_body', 'created',
+        )
+        brief_fields = ('id', 'url', 'display', 'action')
+
+
+# --- fields endpoint (schema documentation) -----------------------------------
+
+
+class MappableFieldsQuerySerializer(serializers.Serializer):
+    """Query parameters of ``GET /fields/`` (OpenAPI documentation only)."""
+
+    connection = serializers.IntegerField(help_text='ID of an enabled InvenTree instance')
+    content_type = serializers.IntegerField(help_text='ID of the NetBox content type to map')
+    endpoint = serializers.CharField(help_text='InvenTree endpoint path, e.g. /api/part/')
+
+
+class NetboxFieldSpecSerializer(serializers.Serializer):
+    """One mappable NetBox field, as returned by ``GET /fields/``."""
+
+    name = serializers.CharField()
+    label = serializers.CharField()
+    type = serializers.ChoiceField(choices=('text', 'boolean', 'integer', 'float', 'date', 'pointer'))
+    pointer_model = serializers.CharField(allow_null=True)
+    custom = serializers.BooleanField()
+    subfield_options = serializers.ListField(child=serializers.CharField())
+
+
+class InventreeFieldSpecSerializer(serializers.Serializer):
+    """One writable InvenTree field plus its compatible NetBox field names."""
+
+    name = serializers.CharField()
+    type = serializers.ChoiceField(choices=('string', 'boolean', 'integer', 'float', 'related'))
+    required = serializers.BooleanField()
+    max_length = serializers.IntegerField(allow_null=True)
+    related_model = serializers.CharField(allow_null=True)
+    compatible_netbox_fields = serializers.ListField(child=serializers.CharField())
+
+
+class MappableFieldsResponseSerializer(serializers.Serializer):
+    """Response body of ``GET /fields/`` — the mapping-builder matrix."""
+
+    netbox = NetboxFieldSpecSerializer(many=True, read_only=True)
+    inventree = InventreeFieldSpecSerializer(many=True, read_only=True)
+    available_pairings = serializers.ListField(child=serializers.CharField(), read_only=True)

netbox_inventree_sync/api/urls.py

@@ -0,0 +1,25 @@
+"""Router registration for the plugin's REST API.
+
+NetBox auto-discovers this module (``netbox/plugins/urls.py`` imports
+``<plugin>.api.urls`` and mounts its ``urlpatterns`` under
+``/api/plugins/netbox_inventree_sync/``), so nothing needs to reference
+it from the plugin's UI ``urls.py``.
+"""
+
+from django.urls import path
+from netbox.api.routers import NetBoxRouter
+
+from . import views
+
+app_name = 'netbox_inventree_sync-api'
+
+router = NetBoxRouter()
+router.register('connections', views.InvenTreeInstanceViewSet)
+router.register('mappings', views.SyncMappingViewSet)
+router.register('synced-objects', views.SyncedObjectViewSet)
+router.register('sync-log', views.SyncLogEntryViewSet)
+
+urlpatterns = [
+    path('fields/', views.MappableFieldsView.as_view(), name='fields'),
+    *router.urls,
+]

netbox_inventree_sync/api/views.py

@@ -0,0 +1,185 @@
+"""API views for the InvenTree sync plugin.
+
+Model viewsets follow NetBox's plugin conventions
+(``NetBoxModelViewSet`` with default ``TokenPermissions``: authenticated
+users plus per-model Django permissions). Two bespoke endpoints:
+
+* ``GET /fields/`` — the mapping-builder matrix: every mappable NetBox
+  field of a content type, every writable InvenTree field of an endpoint
+  (each annotated with the NetBox fields the compatibility matrix
+  accepts), and the content types available as pointer pairings.
+* ``POST /mappings/<id>/sync/`` — "Sync now": enqueue a one-shot
+  ``ReconcileJob`` for a mapping (in addition to any recurring
+  schedule), mirroring NetBox's own DataSource sync action.
+"""
+
+from dataclasses import asdict
+
+from django.contrib.contenttypes.models import ContentType
+from django.shortcuts import get_object_or_404
+from drf_spectacular.utils import extend_schema
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.exceptions import ValidationError
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+
+from netbox.api.viewsets import NetBoxModelViewSet, NetBoxReadOnlyModelViewSet
+
+from netbox_inventree_sync.api.exceptions import InvenTreeUnavailable
+from netbox_inventree_sync.filtersets import (
+    InvenTreeInstanceFilterSet,
+    SyncLogEntryFilterSet,
+    SyncMappingFilterSet,
+    SyncedObjectFilterSet,
+)
+from netbox_inventree_sync.jobs import ReconcileJob
+from netbox_inventree_sync.models import InvenTreeInstance, SyncLogEntry, SyncMapping, SyncedObject
+from netbox_inventree_sync.sync.client import InvenTreeClient, InvenTreeClientError
+from netbox_inventree_sync.sync.compatibility import compatible
+from netbox_inventree_sync.sync.fields import get_netbox_fields
+
+from . import serializers
+
+__all__ = (
+    'InvenTreeInstanceViewSet',
+    'InvenTreeUnavailable',
+    'MappableFieldsView',
+    'SyncLogEntryViewSet',
+    'SyncMappingViewSet',
+    'SyncedObjectViewSet',
+)
+
+
+class InvenTreeInstanceViewSet(NetBoxModelViewSet):
+    queryset = InvenTreeInstance.objects.all()
+    serializer_class = serializers.InvenTreeInstanceSerializer
+    filterset_class = InvenTreeInstanceFilterSet
+
+
+class SyncMappingViewSet(NetBoxModelViewSet):
+    queryset = SyncMapping.objects.all()
+    serializer_class = serializers.SyncMappingSerializer
+    filterset_class = SyncMappingFilterSet
+
+    @extend_schema(request=None)
+    @action(detail=True, methods=['post'])
+    def sync(self, request, pk):
+        """Enqueue a one-shot reconcile job for this mapping ("Sync now").
+
+        Unlike the recurring schedule maintained by the model, this job
+        carries no interval and runs at the first available opportunity.
+        """
+        mapping = get_object_or_404(self.get_queryset(), pk=pk)
+        job = ReconcileJob.enqueue(instance=mapping, mapping_id=mapping.pk, user=request.user)
+        return Response({
+            'job': {
+                'id': job.pk,
+                'url': reverse('core-api:job-detail', kwargs={'pk': job.pk}, request=request),
+                'status': job.status,
+            },
+        }, status=status.HTTP_202_ACCEPTED)
+
+
+class SyncedObjectViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = SyncedObject.objects.all()
+    serializer_class = serializers.SyncedObjectSerializer
+    filterset_class = SyncedObjectFilterSet
+
+
+class SyncLogEntryViewSet(NetBoxReadOnlyModelViewSet):
+    queryset = SyncLogEntry.objects.all()
+    serializer_class = serializers.SyncLogEntrySerializer
+    filterset_class = SyncLogEntryFilterSet
+
+
+class MappableFieldsView(APIView):
+    """Compatibility matrix between one NetBox content type and one InvenTree endpoint.
+
+    ``GET fields/?connection=<id>&content_type=<ct_id>&endpoint=<path>``
+    returns the NetBox field specs, the InvenTree field specs (each with
+    the ``compatible_netbox_fields`` names the Task 6 matrix accepts for
+    it), and the connection's available pairing keys (the
+    ``'<app>.<model>'`` content types of its enabled mappings).
+
+    NetBox's default ``TokenPermissions`` derives permission codes from a
+    viewset's queryset/model; this view deliberately spans two plugin
+    models, so it declares plain authentication-based permissions.
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    @extend_schema(
+        parameters=[serializers.MappableFieldsQuerySerializer],
+        responses={200: serializers.MappableFieldsResponseSerializer},
+    )
+    def get(self, request):
+        connection = self._get_connection(request)
+        content_type = self._get_content_type(request)
+        endpoint = (request.query_params.get('endpoint') or '').strip()
+        if not endpoint:
+            raise ValidationError({'endpoint': 'This query parameter is required (e.g. /api/part/).'})
+
+        netbox_specs = get_netbox_fields(content_type)
+        available_pairings = self._available_pairings(connection)
+        try:
+            client = InvenTreeClient(connection.url, connection.api_token)
+            inventree_specs = client.get_field_specs(endpoint)
+        except InvenTreeClientError as exc:
+            # 502-style: the failure is upstream, not in the request.
+            raise InvenTreeUnavailable(str(exc))
+
+        return Response({
+            'netbox': [asdict(spec) for spec in netbox_specs],
+            'inventree': [
+                {
+                    **asdict(spec),
+                    'compatible_netbox_fields': [
+                        netbox_spec.name for netbox_spec in netbox_specs
+                        if compatible(netbox_spec, spec, available_pairings)
+                    ],
+                }
+                for spec in inventree_specs
+            ],
+            'available_pairings': sorted(available_pairings),
+        })
+
+    @staticmethod
+    def _get_connection(request):
+        raw = request.query_params.get('connection')
+        if raw is None:
+            raise ValidationError({'connection': 'This query parameter is required.'})
+        # Restrict to connections the user may view, mirroring the viewsets'
+        # object-level restriction; a forbidden connection is then
+        # indistinguishable from a nonexistent one.
+        queryset = InvenTreeInstance.objects.restrict(request.user, 'view')
+        try:
+            connection = queryset.get(pk=raw)
+        except (InvenTreeInstance.DoesNotExist, ValueError, TypeError):
+            raise ValidationError({'connection': f'No InvenTree instance with ID {raw!r} exists.'})
+        if not connection.enabled:
+            raise ValidationError({'connection': f'InvenTree instance {connection.name!r} is disabled.'})
+        return connection
+
+    @staticmethod
+    def _get_content_type(request):
+        raw = request.query_params.get('content_type')
+        if raw is None:
+            raise ValidationError({'content_type': 'This query parameter is required.'})
+        try:
+            return ContentType.objects.get_for_id(raw)
+        except (ContentType.DoesNotExist, ValueError, TypeError):
+            raise ValidationError({'content_type': f'No content type with ID {raw!r} exists.'})
+
+    @staticmethod
+    def _available_pairings(connection) -> set:
+        """``'<app>.<model>'`` keys of the connection's enabled mappings."""
+        return set(
+            f'{app_label}.{model}'
+            for app_label, model in SyncMapping.objects.filter(
+                connection=connection,
+                enabled=True,
+            ).values_list('netbox_content_type__app_label', 'netbox_content_type__model')
+        )

netbox_inventree_sync/choices.py

@@ -0,0 +1,28 @@
+from django.db.models import TextChoices
+
+
+class SyncStatusChoices(TextChoices):
+    """Link-table states for a tracked NetBox object."""
+
+    PENDING = 'pending', 'Pending'
+    SYNCED = 'synced', 'Synced'
+    FAILED = 'failed', 'Failed'
+    ORPHANED = 'orphaned', 'Orphaned'
+
+
+class SyncActionChoices(TextChoices):
+    """Actions recorded in the sync log."""
+
+    CREATE = 'create', 'Create'
+    UPDATE = 'update', 'Update'
+    DEACTIVATE = 'deactivate', 'Deactivate'
+    ADOPT = 'adopt', 'Adopt'
+    ERROR = 'error', 'Error'
+
+
+class TransformChoices(TextChoices):
+    """Value transforms applied when pushing a NetBox field to InvenTree."""
+
+    NONE = 'none', 'None'
+    ISO_DATE = 'iso_date', 'ISO date'
+    STR = 'str', 'String'

netbox_inventree_sync/filtersets.py

@@ -0,0 +1,104 @@
+"""FilterSets for the plugin's list views."""
+
+import django_filters
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+
+from netbox.filtersets import NetBoxModelFilterSet
+
+from .choices import SyncActionChoices, SyncStatusChoices
+from .models import InvenTreeInstance, SyncLogEntry, SyncMapping, SyncedObject
+
+__all__ = (
+    'InvenTreeInstanceFilterSet',
+    'SyncLogEntryFilterSet',
+    'SyncMappingFilterSet',
+    'SyncedObjectFilterSet',
+)
+
+
+class InvenTreeInstanceFilterSet(NetBoxModelFilterSet):
+
+    class Meta:
+        model = InvenTreeInstance
+        fields = ('id', 'name', 'url', 'enabled')
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value) |
+            Q(url__icontains=value)
+        )
+
+
+class SyncMappingFilterSet(NetBoxModelFilterSet):
+    connection_id = django_filters.ModelMultipleChoiceFilter(
+        field_name='connection',
+        queryset=InvenTreeInstance.objects.all(),
+        label=_('Connection (ID)'),
+    )
+
+    class Meta:
+        model = SyncMapping
+        fields = ('id', 'name', 'inventree_endpoint', 'enabled', 'reconcile_interval_minutes')
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value) |
+            Q(description__icontains=value) |
+            Q(inventree_endpoint__icontains=value)
+        )
+
+
+class SyncedObjectFilterSet(NetBoxModelFilterSet):
+
+    status = django_filters.MultipleChoiceFilter(
+        choices=SyncStatusChoices,
+        distinct=False,
+    )
+    mapping_id = django_filters.ModelMultipleChoiceFilter(
+        field_name='mapping',
+        queryset=SyncMapping.objects.all(),
+        label=_('Mapping (ID)'),
+    )
+
+    class Meta:
+        model = SyncedObject
+        fields = ('id', 'status', 'mapping_id')
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(mapping__name__icontains=value) |
+            Q(mapping__inventree_endpoint__icontains=value) |
+            Q(last_error__icontains=value)
+        )
+
+
+class SyncLogEntryFilterSet(NetBoxModelFilterSet):
+
+    action = django_filters.MultipleChoiceFilter(
+        choices=SyncActionChoices,
+        distinct=False,
+    )
+    synced_id = django_filters.ModelMultipleChoiceFilter(
+        field_name='synced',
+        queryset=SyncedObject.objects.all(),
+        label=_('Synced object (ID)'),
+    )
+
+    class Meta:
+        model = SyncLogEntry
+        fields = ('id', 'action', 'synced_id')
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(synced__mapping__name__icontains=value) |
+            Q(response_body__icontains=value)
+        )