karrio-server-core 2025.5__py3-none-any.whl

karrio/server/core/validators.py

@@ -0,0 +1,264 @@
+import re
+import phonenumbers
+from datetime import datetime
+from karrio.server.core.logging import logger
+
+import karrio.lib as lib
+import karrio.core.units as units
+import karrio.server.serializers as serializers
+
+DIMENSIONS = ["width", "height", "length"]
+
+
+def dimensions_required_together(value):
+    any_dimension_specified = any(value.get(dim) is not None for dim in DIMENSIONS)
+    has_any_dimension_undefined = any(value.get(dim) is None for dim in DIMENSIONS)
+    dimension_unit_is_undefined = value.get("dimension_unit") is None
+
+    if any_dimension_specified and has_any_dimension_undefined:
+        raise serializers.ValidationError(
+            {
+                "dimensions": "When one dimension is specified, all must be specified with a dimension_unit"
+            }
+        )
+
+    if (
+        any_dimension_specified
+        and not has_any_dimension_undefined
+        and dimension_unit_is_undefined
+    ):
+        raise serializers.ValidationError(
+            {
+                "dimension_unit": "dimension_unit is required when dimensions are specified"
+            }
+        )
+
+
+class TimeFormatValidator:
+    """Validator for HH:MM time format that can be pickled."""
+
+    def __init__(self, prop: str):
+        self.prop = prop
+
+    def __call__(self, value):
+        try:
+            datetime.strptime(value, "%H:%M")
+        except Exception:
+            raise serializers.ValidationError(
+                "The time format must match HH:HM",
+                code="invalid",
+            )
+
+
+class DateFormatValidator:
+    """Validator for YYYY-MM-DD date format that can be pickled."""
+
+    def __init__(self, prop: str):
+        self.prop = prop
+
+    def __call__(self, value):
+        try:
+            datetime.strptime(value, "%Y-%m-%d")
+        except Exception:
+            raise serializers.ValidationError(
+                "The date format must match YYYY-MM-DD",
+                code="invalid",
+            )
+
+
+class DateTimeFormatValidator:
+    """Validator for YYYY-MM-DD HH:MM datetime format that can be pickled."""
+
+    def __init__(self, prop: str):
+        self.prop = prop
+
+    def __call__(self, value):
+        try:
+            datetime.strptime(value, "%Y-%m-%d %H:%M")
+        except Exception:
+            raise serializers.ValidationError(
+                "The datetime format must match YYYY-MM-DD HH:HM",
+                code="invalid",
+            )
+
+
+def valid_time_format(prop: str):
+    """Factory function for time format validator."""
+    return TimeFormatValidator(prop)
+
+
+def valid_date_format(prop: str):
+    """Factory function for date format validator."""
+    return DateFormatValidator(prop)
+
+
+def valid_datetime_format(prop: str):
+    """Factory function for datetime format validator."""
+    return DateTimeFormatValidator(prop)
+
+
+class Base64Validator:
+    """Validator for base64 encoded content that can be pickled."""
+
+    def __init__(self, prop: str, max_size: int = 5242880):
+        self.prop = prop
+        self.max_size = max_size
+
+    def __call__(self, value: str):
+        error = None
+
+        try:
+            buffer = lib.to_buffer(value, validate=True)
+
+            if buffer.getbuffer().nbytes > self.max_size:
+                error = f"Error: file size exceeds {self.max_size} bytes."
+
+        except Exception as e:
+            logger.error("Invalid base64 file content", error=str(e))
+            error = "Invalid base64 file content"
+            raise serializers.ValidationError(
+                error,
+                code="invalid",
+            )
+
+        if error is not None:
+            raise serializers.ValidationError(error, code="invalid")
+
+
+def valid_base64(prop: str, max_size: int = 5242880):
+    """Factory function for base64 validator."""
+    return Base64Validator(prop, max_size)
+
+
+class OptionDefaultSerializer(serializers.Serializer):
+    def __init__(self, instance=None, **kwargs):
+        data = kwargs.get("data", {})
+        if data:
+            # Get existing options from data and instance
+            options = {
+                **(
+                    getattr(instance, "options", None) or {}
+                ),  # Start with instance options
+                **(data.get("options") or {}),  # Override with new options
+            }
+
+            # Get shipping_date from options or default to next business day
+            shipping_date = options.get("shipping_date")
+            shipment_date = options.get("shipment_date")
+
+            if not shipping_date:
+                shipping_date = lib.fdatetime(
+                    lib.to_next_business_datetime(
+                        lib.to_date(shipment_date) or datetime.now()
+                    ),
+                    output_format="%Y-%m-%dT%H:%M",
+                )
+
+            if not shipment_date:
+                shipment_date = lib.fdate(
+                    shipping_date, current_format="%Y-%m-%dT%H:%M"
+                )
+
+            # Update only the date fields in options
+            options.update(
+                {"shipping_date": shipping_date, "shipment_date": shipment_date}
+            )
+
+            # Update the data with merged options
+            kwargs["data"]["options"] = options
+
+        super().__init__(instance, **kwargs)
+
+
+class PresetSerializer(serializers.Serializer):
+    def validate(self, data):
+        import karrio.server.core.dataunits as dataunits
+
+        dimensions_required_together(data)
+
+        if data is not None and "package_preset" in data:
+            package_presets = dataunits.REFERENCE_MODELS.get("package_presets", {})
+            preset_name = data["package_preset"]
+
+            # Find the preset across all carriers
+            preset = lib.identity(
+                next(
+                    (
+                        presets[preset_name]
+                        for carrier_id, presets in package_presets.items()
+                        if preset_name in presets
+                    ),
+                    None,
+                )
+                or {}
+            )
+
+            data.update(
+                {
+                    **data,
+                    "width": data.get("width") or preset.get("width"),
+                    "length": data.get("length") or preset.get("length"),
+                    "height": data.get("height") or preset.get("height"),
+                    "dimension_unit": data.get("dimension_unit")
+                    or preset.get("dimension_unit"),
+                }
+            )
+
+        return data
+
+
+class AugmentedAddressSerializer(serializers.Serializer):
+    def validate(self, data):
+        # Format and validate Postal Code
+        if all(data.get(key) is not None for key in ["country_code", "postal_code"]):
+            postal_code = data["postal_code"]
+            country_code = data["country_code"]
+
+            if country_code == units.Country.CA.name:
+                formatted = "".join(
+                    [c for c in postal_code.split() if c not in ["-", "_"]]
+                ).upper()
+                if not re.match(r"^([A-Za-z]\d[A-Za-z][-]?\d[A-Za-z]\d)", formatted):
+                    raise serializers.ValidationError(
+                        {"postal_code": "The Canadian postal code must match Z9Z9Z9"}
+                    )
+
+            elif country_code == units.Country.US.name:
+                formatted = "".join(postal_code.split())
+                if not re.match(r"^\d{5}(-\d{4})?$", formatted):
+                    raise serializers.ValidationError(
+                        {
+                            "postal_code": "The American postal code must match 12345 or 12345-6789"
+                        }
+                    )
+
+            else:
+                formatted = postal_code
+
+            data.update({**data, "postal_code": formatted})
+
+        # Format and validate Phone Number
+        if all(
+            data.get(key) is not None and data.get(key) != ""
+            for key in ["country_code", "phone_number"]
+        ):
+            phone_number = data["phone_number"]
+            country_code = data["country_code"]
+
+            try:
+                formatted = phonenumbers.parse(phone_number, country_code)
+                data.update(
+                    {
+                        **data,
+                        "phone_number": phonenumbers.format_number(
+                            formatted, phonenumbers.PhoneNumberFormat.INTERNATIONAL
+                        ),
+                    }
+                )
+            except Exception as e:
+                logger.warning("Invalid phone number format", error=str(e))
+                raise serializers.ValidationError(
+                    {"phone_number": "Invalid phone number format"}
+                )
+
+        return data

karrio/server/core/views/__init__.py

@@ -0,0 +1,2 @@
+import karrio.server.core.views.references
+from karrio.server.core.router import router

karrio/server/core/views/api.py

@@ -0,0 +1,133 @@
+import pydoc
+import typing
+from django.conf import settings
+from django.http import JsonResponse
+from rest_framework import generics, views
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.throttling import UserRateThrottle, AnonRateThrottle
+from rest_framework_tracking import mixins
+from rest_framework import status
+
+from karrio.core.utils import DP
+from karrio.server.serializers import link_org
+from karrio.server.tracing.utils import set_tracing_context
+from karrio.server.core.utils import failsafe
+from karrio.server.core.authentication import (
+    TokenAuthentication,
+    JWTAuthentication,
+    TokenBasicAuthentication,
+    OAuth2Authentication,
+)
+from karrio.server.core.models import APILogIndex
+
+AccessMixin: typing.Any = pydoc.locate(
+    getattr(settings, "ACCESS_METHOD", "karrio.server.core.authentication.AccessMixin")
+)
+
+
+class LoggingMixin(mixins.LoggingMixin):
+    def handle_log(self):
+        data = None if "data" not in self.log else DP.jsonify(self.log["data"])
+        query_params = (
+            None
+            if "query_params" not in self.log
+            else DP.jsonify(self.log["query_params"])
+        )
+        response = (
+            dict(response=response)
+            if "response" not in self.log
+            else (
+                DP.jsonify(self.log["response"])
+                if isinstance(DP.to_object(self.log["response"]), dict)
+                else self.log["response"]
+            )
+        )
+        entity_id = failsafe(lambda: DP.to_dict(response)["id"])
+        test_mode = failsafe(lambda: self.request.test_mode)
+
+        if test_mode is None and '"test_mode": true' in (self.log["response"] or ""):
+            test_mode = True
+        if test_mode is None and '"test_mode": false' in (self.log["response"] or ""):
+            test_mode = False
+
+        log = APILogIndex(
+            **{
+                **self.log,
+                "data": data,
+                "response": response,
+                "entity_id": entity_id,
+                "test_mode": test_mode,
+                "query_params": query_params,
+            }
+        )
+
+        log.save()
+        link_org(log, self.request)
+
+        set_tracing_context(
+            request_log_id=getattr(log, "id", None),
+            object_id=failsafe(lambda: (self.log.get("response") or {}).get("id")),
+        )
+
+
+class BaseView:
+    permission_classes = [IsAuthenticated]
+    throttle_classes = [UserRateThrottle, AnonRateThrottle]
+    authentication_classes = [
+        TokenAuthentication,
+        JWTAuthentication,
+        OAuth2Authentication,
+        TokenBasicAuthentication,
+    ]
+
+
+class BaseAPIView(views.APIView, BaseView):
+    pass
+
+
+class BaseGenericAPIView(generics.GenericAPIView, BaseView):
+    def get_queryset(self):
+        if hasattr(self, "model") and getattr(self, "swagger_fake_view", False):
+            # queryset just for schema generation metadata
+            return self.model.objects.none()
+
+        if hasattr(self, "model") and hasattr(self.model, "access_by"):
+            return self.model.access_by(self.request)
+
+        return getattr(self, "queryset", None)
+
+
+class GenericAPIView(LoggingMixin, BaseGenericAPIView):
+    logging_methods = ["POST", "PUT", "PATCH", "DELETE"]
+
+
+class APIView(LoggingMixin, BaseAPIView):
+    logging_methods = ["POST", "PUT", "PATCH", "DELETE"]
+
+
+class LoginRequiredView(AccessMixin):
+    def dispatch(self, request, *args, **kwargs):
+        auth = super().dispatch(request, *args, **kwargs)
+        if not request.user.is_authenticated:
+            return JsonResponse(
+                dict(
+                    errors=[
+                        {
+                            "code": "not_authenticated",
+                            "message": "Authentication credentials were not provided.",
+                        }
+                    ]
+                ),
+                status=status.HTTP_401_UNAUTHORIZED,
+            )
+
+        if not request.user.is_verified():
+            return JsonResponse(
+                dict(
+                    errors=[
+                        {"code": "not_verified", "message": "User is not verified."}
+                    ]
+                ),
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        return auth

karrio/server/core/views/metadata.py

@@ -0,0 +1,44 @@
+import rest_framework.request as request
+import rest_framework.response as response
+import rest_framework.renderers as renderers
+import rest_framework.decorators as decorators
+import rest_framework.permissions as permissions
+
+import karrio.server.conf as conf
+import karrio.server.openapi as openapi
+import karrio.server.core.dataunits as dataunits
+
+ENDPOINT_ID = "&&"  # This endpoint id is used to make operation ids unique make sure not to duplicate
+Metadata = openapi.OpenApiResponse(
+    openapi.OpenApiTypes.OBJECT,
+    examples=[
+        openapi.OpenApiExample(
+            name="Metadata",
+            value={
+                "VERSION": "",
+                "APP_NAME": "",
+                "APP_WEBSITE": "",
+                "HOST": "",
+                "ADMIN": "",
+                "OPENAPI": "",
+                "GRAPHQL": "",
+                **{flag: True for flag in conf.FEATURE_FLAGS},
+            },
+        )
+    ],
+)
+
+
+@openapi.extend_schema(
+    auth=[],
+    methods=["get"],
+    tags=["API"],
+    operation_id=f"{ENDPOINT_ID}ping",
+    summary="Instance Metadata",
+    responses={200: Metadata},
+)
+@decorators.api_view(["GET"])
+@decorators.permission_classes([permissions.AllowAny])
+@decorators.renderer_classes([renderers.JSONRenderer])
+def view(request: request.Request) -> response.Response:
+    return response.Response(dataunits.contextual_metadata(request))

karrio/server/core/views/oauth.py

@@ -0,0 +1,75 @@
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+from oauth2_provider.views import TokenView as BaseTokenView
+from karrio.server.core.logging import logger
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+class CustomTokenView(BaseTokenView):
+    """
+    Custom OAuth2 token view that handles grant type format conversion.
+
+    django-oauth-toolkit stores grant types with hyphens (e.g., 'authorization-code')
+    but OAuth2 spec uses underscores (e.g., 'authorization_code').
+    This view converts the format before processing.
+    """
+
+    def post(self, request, *args, **kwargs):
+        """
+        Handle token requests with grant type conversion.
+        """
+        logger.debug("CustomTokenView called")
+        logger.debug("Processing token request",
+                    method=request.method,
+                    content_type=request.content_type,
+                    post_data=dict(request.POST),
+                    body=request.body.decode('utf-8') if request.body else 'Empty')
+
+        # Parse the request body if POST data is empty
+        if not request.POST and request.body:
+            from django.http import QueryDict
+            import urllib.parse
+
+            # Parse the form data from the request body
+            body_data = urllib.parse.parse_qs(request.body.decode('utf-8'))
+            # Convert to single values (parse_qs returns lists)
+            parsed_data = {k: v[0] if v else '' for k, v in body_data.items()}
+
+            # Create a QueryDict from the parsed data
+            post_data = QueryDict('', mutable=True)
+            for key, value in parsed_data.items():
+                post_data[key] = value
+
+            # Replace the request POST data
+            request.POST = post_data
+            request._post = post_data
+
+        # Convert OAuth2 spec grant types to django-oauth-toolkit format
+        grant_type_mapping = {
+            'authorization_code': 'authorization-code',
+            'client_credentials': 'client-credentials',
+            'refresh_token': 'refresh-token',
+            'password': 'password',
+        }
+
+        original_grant_type = request.POST.get('grant_type')
+        logger.debug("Grant type parsed", grant_type=original_grant_type)
+
+        if original_grant_type in grant_type_mapping:
+            # Create a mutable copy of the POST data
+            post_data = request.POST.copy()
+            converted_grant_type = grant_type_mapping[original_grant_type]
+            logger.debug("Converting grant type",
+                        original=original_grant_type,
+                        converted=converted_grant_type)
+            post_data['grant_type'] = converted_grant_type
+
+            # Replace the request POST data
+            request.POST = post_data
+            request._post = post_data
+            logger.debug("Grant type updated", grant_type=request.POST.get('grant_type'))
+        else:
+            logger.debug("No grant type conversion needed", grant_type=original_grant_type)
+
+        # Call the parent token view with converted grant type
+        return super().post(request, *args, **kwargs)

karrio/server/core/views/references.py

@@ -0,0 +1,82 @@
+import yaml  # type: ignore
+from rest_framework import status
+from rest_framework.decorators import api_view, renderer_classes, permission_classes
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.request import Request
+from rest_framework.renderers import JSONRenderer
+from django.urls import path
+from django.conf import settings
+
+from karrio.server.conf import FEATURE_FLAGS
+from karrio.server.core.router import router
+import karrio.server.core.dataunits as dataunits
+import karrio.server.openapi as openapi
+
+ENDPOINT_ID = "&&"  # This endpoint id is used to make operation ids unique make sure not to duplicate
+BASE_PATH = getattr(settings, "BASE_PATH", "")
+References = openapi.OpenApiResponse(
+    openapi.OpenApiTypes.OBJECT,
+    examples=[
+        openapi.OpenApiExample(
+            name="References",
+            value={
+                "VERSION": "",
+                "APP_NAME": "",
+                "APP_WEBSITE": "",
+                "HOST": "",
+                "ADMIN": "",
+                "OPENAPI": "",
+                "GRAPHQL": "",
+                **{flag: True for flag in FEATURE_FLAGS},
+                "ADDRESS_AUTO_COMPLETE": {},
+                "countries": {},
+                "currencies": {},
+                "carriers": {},
+                "customs_content_type": {},
+                "incoterms": {},
+                "states": {},
+                "services": {},
+                "connection_configs": {},
+                "service_names": {},
+                "options": {},
+                "option_names": {},
+                "package_presets": {},
+                "packaging_types": {},
+                "payment_types": {},
+                "carrier_capabilities": {},
+                "service_levels": {},
+                "integration_status": {},
+            },
+        )
+    ],
+)
+
+
+@openapi.extend_schema(
+    auth=[],
+    methods=["get"],
+    tags=["API"],
+    operation_id=f"{ENDPOINT_ID}data",
+    summary="Data References",
+    responses={200: References},
+)
+@api_view(["GET"])
+@permission_classes([AllowAny])
+@renderer_classes([JSONRenderer])
+def references(request: Request):
+    try:
+        reduced = bool(yaml.safe_load(request.query_params.get("reduced", "true")))
+
+        return Response(
+            dataunits.contextual_reference(reduced=reduced),
+            status=status.HTTP_200_OK,
+        )
+    except Exception as e:
+        from karrio.server.core.logging import logger
+
+        logger.exception("Failed to retrieve references", error=str(e))
+        raise e
+
+
+router.urls.append(path("references", references))