karrio-server-manager 2025.5rc1__py3-none-any.whl

karrio/server/manager/views/manifests.py

@@ -0,0 +1,160 @@
+import io
+import base64
+import logging
+import django_downloadview
+import django.urls as urls
+import django.core.files.base as base
+import rest_framework.status as status
+import rest_framework.request as request
+import rest_framework.response as response
+import rest_framework.pagination as pagination
+import rest_framework.throttling as throttling
+import django_filters.rest_framework as django_filters
+
+import karrio.server.openapi as openapi
+import karrio.server.core.views.api as api
+import karrio.server.core.filters as filters
+import karrio.server.manager.models as models
+import karrio.server.manager.router as router
+import karrio.server.manager.serializers as serializers
+
+ENDPOINT_ID = "$$$$&&"  # This endpoint id is used to make operation ids unique make sure not to duplicate
+logger = logging.getLogger(__name__)
+Manifests = serializers.PaginatedResult("ManifestList", serializers.Manifest)
+
+
+class ManifestList(api.GenericAPIView):
+    throttle_scope = "carrier_request"
+    pagination_class = type(
+        "CustomPagination", (pagination.LimitOffsetPagination,), dict(default_limit=20)
+    )
+    filter_backends = (django_filters.DjangoFilterBackend,)
+    filterset_class = filters.ManifestFilters
+    serializer_class = Manifests
+    model = models.Manifest
+
+    def get_throttles(self):
+        if self.request.method == "POST":
+            return [throttling.ScopedRateThrottle()]
+        return super().get_throttles()
+
+    @openapi.extend_schema(
+        tags=["Manifests"],
+        operation_id=f"{ENDPOINT_ID}list",
+        extensions={"x-operationId": "listManifests"},
+        summary="List manifests",
+        responses={
+            200: Manifests(),
+            404: serializers.ErrorResponse(),
+            500: serializers.ErrorResponse(),
+        },
+        parameters=filters.ManifestFilters.parameters,
+    )
+    def get(self, request: request.Request):
+        """
+        Retrieve all manifests.
+        """
+        manifests = self.filter_queryset(self.get_queryset())
+        response = self.paginate_queryset(
+            serializers.Manifest(manifests, many=True).data
+        )
+        return self.get_paginated_response(response)
+
+    @openapi.extend_schema(
+        tags=["Manifests"],
+        operation_id=f"{ENDPOINT_ID}create",
+        extensions={"x-operationId": "createManifest"},
+        summary="Create a manifest",
+        responses={
+            201: serializers.Manifest(),
+            400: serializers.ErrorResponse(),
+            424: serializers.ErrorMessages(),
+            500: serializers.ErrorResponse(),
+        },
+        request=serializers.ManifestData(),
+    )
+    def post(self, request: request.HttpRequest):
+        """Create a manifest for one or many shipments with labels already purchased."""
+
+        manifest = (
+            serializers.ManifestSerializer.map(data=request.data, context=request)
+            .save()
+            .instance
+        )
+
+        return response.Response(
+            serializers.Manifest(manifest).data, status=status.HTTP_201_CREATED
+        )
+
+
+class ManifestDetails(api.APIView):
+
+    @openapi.extend_schema(
+        tags=["Manifests"],
+        operation_id=f"{ENDPOINT_ID}retrieve",
+        extensions={"x-operationId": "retrieveManifest"},
+        summary="Retrieve a manifest",
+        responses={
+            200: serializers.Manifest(),
+            404: serializers.ErrorResponse(),
+            500: serializers.ErrorResponse(),
+        },
+    )
+    def get(self, request: request.Request, pk: str):
+        """Retrieve a shipping manifest."""
+        manifest = models.Manifest.access_by(request).get(pk=pk)
+        return response.Response(serializers.Manifest(manifest).data)
+
+
+class ManifestDoc(django_downloadview.VirtualDownloadView):
+    @openapi.extend_schema(exclude=True)
+    def get(
+        self,
+        request: request.Request,
+        pk: str,
+        doc: str = "manifest",
+        format: str = "pdf",
+        **kwargs,
+    ):
+        """Retrieve a manifest file."""
+        self.manifest = models.Manifest.objects.get(pk=pk, manifest__isnull=False)
+        self.document = getattr(self.manifest, doc, None)
+        self.name = f"{doc}_{self.manifest.id}.{format}"
+
+        query_params = request.GET.dict()
+        self.preview = "preview" in query_params
+        self.attachment = "download" in query_params
+
+        response = super(ManifestDoc, self).get(request, pk, doc, format, **kwargs)
+        response["X-Frame-Options"] = "ALLOWALL"
+        return response
+
+    def get_file(self):
+        content = base64.b64decode(self.document or "")
+        buffer = io.BytesIO()
+        buffer.write(content)
+
+        return base.ContentFile(buffer.getvalue(), name=self.name)
+
+
+router.router.urls.append(
+    urls.path(
+        "manifests",
+        ManifestList.as_view(),
+        name="manifest-list",
+    )
+)
+router.router.urls.append(
+    urls.path(
+        "manifests/<str:pk>",
+        ManifestDetails.as_view(),
+        name="manifest-details",
+    )
+)
+router.router.urls.append(
+    urls.re_path(
+        r"^manifests/(?P<pk>\w+)/(?P<doc>[a-z0-9]+).(?P<format>[a-z0-9]+)",
+        ManifestDoc.as_view(),
+        name="manifest-docs",
+    )
+)

karrio/server/manager/views/parcels.py

@@ -0,0 +1,155 @@
+import logging
+
+from django.urls import path
+from rest_framework import status
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.pagination import LimitOffsetPagination
+
+from karrio.server.manager.router import router
+from karrio.server.core.views.api import GenericAPIView, APIView
+from karrio.server.manager.serializers import (
+    PaginatedResult,
+    ErrorResponse,
+    ParcelData,
+    Parcel,
+    ParcelSerializer,
+    can_mutate_parcel,
+)
+import karrio.server.manager.models as models
+import karrio.server.openapi as openapi
+
+logger = logging.getLogger(__name__)
+ENDPOINT_ID = "$$$"  # This endpoint id is used to make operation ids unique make sure not to duplicate
+Parcels = PaginatedResult("ParcelList", Parcel)
+
+
+class ParcelList(GenericAPIView):
+    queryset = models.Parcel.objects
+    pagination_class = type(
+        "CustomPagination", (LimitOffsetPagination,), dict(default_limit=20)
+    )
+    serializer_class = Parcels
+
+    @openapi.extend_schema(
+        tags=["Parcels"],
+        operation_id=f"{ENDPOINT_ID}list",
+        extensions={"x-operationId": "listParcels"},
+        summary="List all parcels",
+        responses={
+            200: Parcels(),
+            404: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def get(self, request: Request):
+        """
+        Retrieve all stored parcels.
+        """
+        parcels = models.Parcel.access_by(request).filter(
+            **{
+                f"{prop}__isnull": True
+                for prop in models.Parcel.HIDDEN_PROPS
+                if prop != "org"
+            }
+        )
+        serializer = Parcel(parcels, many=True)
+        response = self.paginate_queryset(serializer.data)
+
+        return self.get_paginated_response(response)
+
+    @openapi.extend_schema(
+        tags=["Parcels"],
+        operation_id=f"{ENDPOINT_ID}create",
+        extensions={"x-operationId": "createParcel"},
+        summary="Create a parcel",
+        request=ParcelData(),
+        responses={
+            201: Parcel(),
+            400: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def post(self, request: Request):
+        """
+        Create a new parcel.
+        """
+        parcel = (
+            ParcelSerializer.map(data=request.data, context=request).save().instance
+        )
+        return Response(Parcel(parcel).data, status=status.HTTP_201_CREATED)
+
+
+class ParcelDetail(APIView):
+
+    @openapi.extend_schema(
+        tags=["Parcels"],
+        operation_id=f"{ENDPOINT_ID}retrieve",
+        extensions={"x-operationId": "retrieveParcel"},
+        summary="Retrieve a parcel",
+        responses={
+            200: Parcel(),
+            404: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def get(self, request: Request, pk: str):
+        """
+        Retrieve a parcel.
+        """
+        address = models.Parcel.access_by(request).get(pk=pk)
+        return Response(Parcel(address).data)
+
+    @openapi.extend_schema(
+        tags=["Parcels"],
+        operation_id=f"{ENDPOINT_ID}update",
+        extensions={"x-operationId": "updateParcel"},
+        summary="Update a parcel",
+        request=ParcelData(),
+        responses={
+            200: Parcel(),
+            400: ErrorResponse(),
+            404: ErrorResponse(),
+            409: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def patch(self, request: Request, pk: str):
+        """
+        modify an existing parcel's details.
+        """
+        parcel = models.Parcel.access_by(request).get(pk=pk)
+        can_mutate_parcel(parcel, update=True)
+
+        ParcelSerializer.map(parcel, data=request.data).save()
+
+        return Response(Parcel(parcel).data)
+
+    @openapi.extend_schema(
+        tags=["Parcels"],
+        operation_id=f"{ENDPOINT_ID}discard",
+        extensions={"x-operationId": "discardParcel"},
+        summary="Remove a parcel",
+        responses={
+            200: Parcel(),
+            404: ErrorResponse(),
+            409: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def delete(self, request: Request, pk: str):
+        """
+        Remove a parcel.
+        """
+        parcel = models.Parcel.access_by(request).get(pk=pk)
+        can_mutate_parcel(parcel, update=True, delete=True)
+
+        parcel.delete(keep_parents=True)
+
+        return Response(Parcel(parcel).data)
+
+
+router.urls.append(path("parcels", ParcelList.as_view(), name="parcel-list"))
+router.urls.append(
+    path("parcels/<str:pk>", ParcelDetail.as_view(), name="parcel-details")
+)

karrio/server/manager/views/pickups.py

@@ -0,0 +1,182 @@
+import logging
+
+from django.urls import path
+from rest_framework import status
+from rest_framework.pagination import LimitOffsetPagination
+from rest_framework.response import Response
+from rest_framework.request import Request
+from django_filters.rest_framework import DjangoFilterBackend
+
+from karrio.server.core.views.api import GenericAPIView, APIView
+from karrio.server.core.filters import PickupFilters
+from karrio.server.manager.router import router
+from karrio.server.manager.serializers import (
+    PaginatedResult,
+    Pickup,
+    ErrorResponse,
+    ErrorMessages,
+    PickupData,
+    PickupUpdateData,
+    PickupCancelData,
+)
+import karrio.server.manager.models as models
+import karrio.server.openapi as openapi
+
+ENDPOINT_ID = "$$$$"  # This endpoint id is used to make operation ids unique make sure not to duplicate
+logger = logging.getLogger(__name__)
+Pickups = PaginatedResult("PickupList", Pickup)
+
+
+class PickupList(GenericAPIView):
+    pagination_class = type(
+        "CustomPagination", (LimitOffsetPagination,), dict(default_limit=20)
+    )
+    filter_backends = (DjangoFilterBackend,)
+    filterset_class = PickupFilters
+    serializer_class = Pickups
+    model = models.Pickup
+
+    @openapi.extend_schema(
+        tags=["Pickups"],
+        operation_id=f"{ENDPOINT_ID}list",
+        extensions={"x-operationId": "listPickups"},
+        summary="List shipment pickups",
+        responses={
+            200: Pickups(),
+            404: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+        parameters=PickupFilters.parameters,
+    )
+    def get(self, request: Request):
+        """
+        Retrieve all scheduled pickups.
+        """
+        pickups = self.filter_queryset(self.get_queryset())
+        response = self.paginate_queryset(Pickup(pickups, many=True).data)
+        return self.get_paginated_response(response)
+
+
+class PickupRequest(APIView):
+    throttle_scope = "carrier_request"
+
+    @openapi.extend_schema(
+        tags=["Pickups"],
+        operation_id=f"{ENDPOINT_ID}schedule",
+        extensions={"x-operationId": "schedulePickup"},
+        summary="Schedule a pickup",
+        responses={
+            201: Pickup(),
+            400: ErrorResponse(),
+            424: ErrorMessages(),
+            500: ErrorResponse(),
+        },
+        request=PickupData(),
+    )
+    def post(self, request: Request, carrier_name: str):
+        """
+        Schedule a pickup for one or many shipments with labels already purchased.
+        """
+        carrier_filter = {
+            "carrier_name": carrier_name,
+        }
+
+        pickup = (
+            PickupData.map(data=request.data, context=request)
+            .save(carrier_filter=carrier_filter)
+            .instance
+        )
+
+        return Response(Pickup(pickup).data, status=status.HTTP_201_CREATED)
+
+
+class PickupDetails(APIView):
+    throttle_scope = "carrier_request"
+
+    @openapi.extend_schema(
+        tags=["Pickups"],
+        operation_id=f"{ENDPOINT_ID}retrieve",
+        extensions={"x-operationId": "retrievePickup"},
+        summary="Retrieve a pickup",
+        responses={
+            200: Pickup(),
+            404: ErrorResponse(),
+            500: ErrorResponse(),
+        },
+    )
+    def get(self, request: Request, pk: str):
+        """Retrieve a scheduled pickup."""
+        pickup = models.Pickup.access_by(request).get(pk=pk)
+        return Response(Pickup(pickup).data)
+
+    @openapi.extend_schema(
+        tags=["Pickups"],
+        operation_id=f"{ENDPOINT_ID}update",
+        extensions={"x-operationId": "updatePickup"},
+        summary="Update a pickup",
+        responses={
+            200: Pickup(),
+            404: ErrorResponse(),
+            400: ErrorResponse(),
+            424: ErrorMessages(),
+            500: ErrorResponse(),
+        },
+        request=PickupUpdateData(),
+    )
+    def post(self, request: Request, pk: str):
+        """
+        Modify a pickup for one or many shipments with labels already purchased.
+        """
+        pickup = models.Pickup.access_by(request).get(pk=pk)
+        instance = (
+            PickupUpdateData.map(pickup, data=request.data, context=request)
+            .save()
+            .instance
+        )
+
+        return Response(Pickup(instance).data, status=status.HTTP_200_OK)
+
+
+class PickupCancel(APIView):
+
+    @openapi.extend_schema(
+        tags=["Pickups"],
+        operation_id=f"{ENDPOINT_ID}cancel",
+        extensions={"x-operationId": "cancelPickup"},
+        summary="Cancel a pickup",
+        responses={
+            200: Pickup(),
+            404: ErrorResponse(),
+            409: ErrorResponse(),
+            424: ErrorMessages(),
+            500: ErrorResponse(),
+        },
+        request=PickupCancelData(),
+    )
+    def post(self, request: Request, pk: str):
+        """
+        Cancel a pickup of one or more shipments.
+        """
+        pickup = models.Pickup.access_by(request).get(pk=pk)
+
+        update = PickupCancelData.map(pickup, data=request.data).save().instance
+
+        return Response(Pickup(update).data)
+
+
+router.urls.append(path("pickups", PickupList.as_view(), name="shipment-pickup-list"))
+router.urls.append(
+    path("pickups/<str:pk>", PickupDetails.as_view(), name="shipment-pickup-details")
+)
+router.urls.append(
+    path(
+        "pickups/<str:pk>/cancel", PickupCancel.as_view(), name="shipment-pickup-cancel"
+    )
+)
+router.urls.append(
+    path(
+        "pickups/<str:carrier_name>/schedule",
+        PickupRequest.as_view(),
+        name="shipment-pickup-request",
+    )
+)