def trace(self, request, pk): """ Trace a complete cable path and return each segment as a three-tuple of (termination, cable, termination). """ obj = get_object_or_404(self.queryset, pk=pk) # Initialize the path array path = [] for near_end, cable, far_end in obj.trace(): if near_end is None: # Split paths break # Serialize each object serializer_a = get_serializer_for_model(near_end, prefix="Nested") x = serializer_a(near_end, context={"request": request}).data if cable is not None: y = serializers.TracedCableSerializer(cable, context={ "request": request }).data else: y = None if far_end is not None: serializer_b = get_serializer_for_model(far_end, prefix="Nested") z = serializer_b(far_end, context={"request": request}).data else: z = None path.append((x, y, z)) return Response(path)
def get_path(self, obj): ret = [] for node in obj.get_path(): serializer = get_serializer_for_model(node, prefix="Nested") context = {"request": self.context["request"]} ret.append(serializer(node, context=context).data) return ret
def get_origin(self, obj): """ Return the appropriate serializer for the origin. """ serializer = get_serializer_for_model(obj.origin, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj.origin, context=context).data
def get_assigned_object(self, obj): if obj.assigned_object is None: return None serializer = get_serializer_for_model(obj.assigned_object, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj.assigned_object, context=context).data
def get_cable_peer(self, obj): """ Return the appropriate serializer for the cable termination model. """ if obj._cable_peer is not None: serializer = get_serializer_for_model(obj._cable_peer, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj._cable_peer, context=context).data return None
def get_destination(self, obj): """ Return the appropriate serializer for the destination, if any. """ if obj.destination_id is not None: serializer = get_serializer_for_model(obj.destination, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj.destination, context=context).data return None
def get_connected_endpoint(self, obj): """ Return the appropriate serializer for the type of connected object. """ if obj._path is not None and obj._path.destination is not None: serializer = get_serializer_for_model(obj._path.destination, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj._path.destination, context=context).data return None
def members(self, request, pk, *args, **kwargs): """List member objects of the same type as the `content_type` for this dynamic group.""" instance = get_object_or_404(self.queryset, pk=pk) # Retrieve the serializer for the content_type and paginate the results member_model_class = instance.content_type.model_class() member_serializer_class = get_serializer_for_model(member_model_class) members = self.paginate_queryset(instance.members) member_serializer = member_serializer_class(members, many=True, context={"request": request}) return self.get_paginated_response(member_serializer.data)
def _get_termination(self, obj, side): """ Serialize a nested representation of a termination. """ if side.lower() not in ["a", "b"]: raise ValueError("Termination side must be either A or B.") termination = getattr(obj, "termination_{}".format(side.lower())) if termination is None: return None serializer = get_serializer_for_model(termination, prefix="Nested") context = {"request": self.context["request"]} data = serializer(termination, context=context).data return data
def get_serializer_class(self): logger = logging.getLogger("nautobot.core.api.views.ModelViewSet") # If using 'brief' mode, find and return the nested serializer for this model, if one exists if self.brief: logger.debug("Request is for 'brief' format; initializing nested serializer") try: serializer = get_serializer_for_model(self.queryset.model, prefix="Nested") logger.debug(f"Using serializer {serializer}") return serializer except SerializerNotFound: logger.debug(f"Nested serializer for {self.queryset.model} not found!") # Fall back to the hard-coded serializer class return self.serializer_class
def get_changed_object(self, obj): """ Serialize a nested representation of the changed object. """ if obj.changed_object is None: return None try: serializer = get_serializer_for_model(obj.changed_object, prefix="Nested") except SerializerNotFound: return obj.object_repr context = {"request": self.context["request"]} data = serializer(obj.changed_object, context=context).data return data
def serialize_object_v2(obj): """ Return a JSON serialized representation of an object using obj's serializer. """ from nautobot.core.api.exceptions import SerializerNotFound from nautobot.utilities.api import get_serializer_for_model # Try serializing obj(model instance) using its API Serializer try: serializer_class = get_serializer_for_model(obj.__class__) data = serializer_class(obj, context={"request": None}).data except SerializerNotFound: # Fall back to generic JSON representation of obj data = serialize_object(obj) return data
def enqueue_webhooks(instance, user, request_id, action): """ Find Webhook(s) assigned to this instance + action and enqueue them to be processed """ # Determine whether this type of object supports webhooks app_label = instance._meta.app_label model_name = instance._meta.model_name if model_name not in registry["model_features"]["webhooks"].get( app_label, []): return # Retrieve any applicable Webhooks content_type = ContentType.objects.get_for_model(instance) action_flag = { ObjectChangeActionChoices.ACTION_CREATE: "type_create", ObjectChangeActionChoices.ACTION_UPDATE: "type_update", ObjectChangeActionChoices.ACTION_DELETE: "type_delete", }[action] webhooks = Webhook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True}) if webhooks.exists(): # Get the Model's API serializer class and serialize the object serializer_class = get_serializer_for_model(instance.__class__) serializer_context = { "request": None, } serializer = serializer_class(instance, context=serializer_context) # Enqueue the webhooks for webhook in webhooks: args = [ webhook.pk, serializer.data, instance._meta.model_name, action, str(timezone.now()), user.username, request_id, ] process_webhook.apply_async(args=args)
def get_owner(self, obj): if obj.owner is None: return None serializer = get_serializer_for_model(obj.owner, prefix="Nested") context = {"request": self.context["request"]} return serializer(obj.owner, context=context).data