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

karrio/server/iam/serializers.py

@@ -0,0 +1,39 @@
+import typing
+import karrio.lib as lib
+
+
+class PermissionGroup(lib.StrEnum):
+    manage_apps = "manage_apps"
+    manage_team = "manage_team"
+    manage_system = "manage_system"
+    manage_orders = "manage_orders"
+    manage_data = "manage_data"
+    manage_pickups = "manage_pickups"
+    manage_carriers = "manage_carriers"
+    manage_trackers = "manage_trackers"
+    manage_webhooks = "manage_webhooks"
+    manage_shipments = "manage_shipments"
+    manage_org_owner = "manage_org_owner"
+
+
+PERMISSION_GROUPS = [(p.name, p.name) for p in list(PermissionGroup)]
+ROLES_GROUPS: typing.Dict[str, typing.List[str]] = {
+    "owner": [
+        PermissionGroup.manage_org_owner.value,
+    ],
+    "admin": [
+        PermissionGroup.manage_team.value,
+        PermissionGroup.manage_apps.value,
+        PermissionGroup.manage_carriers.value,
+    ],
+    "developer": [
+        PermissionGroup.manage_webhooks.value,
+    ],
+    "member": [
+        PermissionGroup.manage_data.value,
+        PermissionGroup.manage_orders.value,
+        PermissionGroup.manage_pickups.value,
+        PermissionGroup.manage_trackers.value,
+        PermissionGroup.manage_shipments.value,
+    ],
+}

karrio/server/iam/signals.py

@@ -0,0 +1,20 @@
+import logging
+from django.db.models import signals
+
+import karrio.server.core.utils as utils
+import karrio.server.user.models as user
+import karrio.server.iam.models as models
+
+logger = logging.getLogger(__name__)
+
+
+def register_all():
+    signals.post_delete.connect(context_object_deleted, sender=user.Token)
+
+    logger.info("karrio.iam signals registered...")
+
+
+@utils.disable_for_loaddata
+def context_object_deleted(sender, instance, *args, **kwargs):
+    # clean up permission contexts when related objects are removed.
+    models.ContextPermission.objects.filter(object_pk=instance.pk).delete()

karrio/server/iam/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

karrio/server/iam/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

karrio/server/openapi.py

@@ -0,0 +1,75 @@
+from django.conf import settings
+from drf_spectacular.types import *
+from drf_spectacular.utils import *
+from drf_spectacular.extensions import OpenApiAuthenticationExtension
+
+
+class JWTAuthentication(OpenApiAuthenticationExtension):
+    target_class = "karrio.server.core.authentication.JWTAuthentication"
+    name = "JWT"
+
+    def get_security_definition(self, auto_schema):
+        return {
+            "in": "header",
+            "type": "apiKey",
+            "scheme": "bearer",
+            "bearerFormat": "JWT",
+            "name": "Authorization",
+            "description": "Authorization: Bearer xxx.xxx.xxx",
+        }
+
+
+class TokenAuthentication(OpenApiAuthenticationExtension):
+    target_class = "karrio.server.core.authentication.TokenAuthentication"
+    name = "Token"
+
+    def get_security_definition(self, auto_schema):
+        return {
+            "type": "apiKey",
+            "in": "header",
+            "name": "Authorization",
+            "description": "Authorization: Token key_xxxxxxxx",
+        }
+
+
+class TokenBasicAuthentication(OpenApiAuthenticationExtension):
+    target_class = "karrio.server.core.authentication.TokenBasicAuthentication"
+    name = "TokenBasic"
+
+    def get_security_definition(self, auto_schema):
+        return {
+            "type": "http",
+            "scheme": "basic",
+            "name": "Authorization",
+            "description": "-u key_xxxxxxxx:",
+        }
+
+
+class OAuth2Authentication(OpenApiAuthenticationExtension):
+    target_class = "karrio.server.core.authentication.OAuth2Authentication"
+    name = "OAuth2"
+
+    def get_security_definition(self, auto_schema):
+        return {
+            "type": "oauth2",
+            "in": "header",
+            "name": "Authorization",
+            "flows": {
+                "authorizationCode": {
+                    "authorizationUrl": "/oauth/authorize/",
+                    "tokenUrl": "/oauth/token/",
+                    "scopes": settings.OAUTH2_PROVIDER["SCOPES"],
+                }
+            },
+            "description": "Authorization: Bearer xxxxxxxx",
+        }
+
+
+def custom_postprocessing_hook(result, generator, request, public):
+    if "docs" in request.query_params:
+        for path in result["paths"].values():
+            for method in path.values():
+                if "x-operationId" in method:
+                    method["operationId"] = method["x-operationId"]
+
+    return result

karrio/server/providers/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore

karrio/server/providers/admin.py

@@ -0,0 +1,364 @@
+import functools
+from django import forms
+from django.db import models
+from django.contrib import admin
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.utils.translation import gettext_lazy as _
+
+import karrio.lib as lib
+import karrio.references as ref
+import karrio.server.core.utils as utils
+import karrio.server.serializers as serializers
+import karrio.server.core.dataunits as dataunits
+import karrio.server.providers.models as providers
+
+User = get_user_model()
+
+
+def model_admin(ext: str, carrierProxy):
+    references = dataunits.contextual_reference(reduced=False)
+    class_name = carrierProxy.__name__
+    connection_fields = references["connection_fields"].get(ext) or {}
+    connection_configs = references["connection_configs"].get(ext) or {}
+    carrier_services = (references["services"].get(ext) or {}).keys()
+    carrier_options = (references["options"].get(ext) or {}).keys()
+
+    class _Form(forms.ModelForm):
+
+        for key, field in connection_fields.items():
+            if field["type"] == "boolean":
+                locals()[key] = forms.NullBooleanField(
+                    required=field.get("required", False),
+                    initial=None,
+                )
+
+            elif field["type"] == "integer":
+                locals()[key] = forms.IntegerField(
+                    required=field.get("required", False),
+                )
+
+            elif field["type"] == "float":
+                locals()[key] = forms.FloatField(
+                    required=field.get("required", False),
+                )
+
+            elif field["type"] == "string" and any(field.get("enum", [])):
+                locals()[key] = forms.ChoiceField(
+                    choices=[(None, ""), *[(_, _) for _ in field.get("enum", [])]],
+                    widget=forms.Select(attrs={"class": "vTextField"}),
+                    required=field.get("required", False),
+                    initial=field.get("default"),
+                )
+
+            elif field["type"] == "string":
+                locals()[key] = forms.CharField(
+                    required=field.get("required", False),
+                )
+
+            else:
+                pass
+
+        for key, field in connection_configs.items():
+
+            if key == "shipping_services":
+                shipping_services = forms.MultipleChoiceField(
+                    choices=[(_, _) for _ in carrier_services],
+                    widget=forms.SelectMultiple(attrs={"class": "vTextField"}),
+                    required=False,
+                    initial=None,
+                )
+                continue
+
+            if key == "shipping_options":
+                shipping_options = forms.MultipleChoiceField(
+                    choices=[(_, _) for _ in carrier_options],
+                    widget=forms.SelectMultiple(attrs={"class": "vTextField"}),
+                    required=False,
+                    initial=None,
+                )
+                continue
+
+            if field["type"] == "boolean":
+                locals()[key] = forms.NullBooleanField(
+                    required=False,
+                    initial=None,
+                )
+
+            elif field["type"] == "integer":
+                locals()[key] = forms.IntegerField(
+                    required=False,
+                )
+
+            elif field["type"] == "float":
+                locals()[key] = forms.FloatField(
+                    required=False,
+                )
+
+            elif field["type"] == "string" and any(field.get("enum", [])):
+                locals()[key] = forms.ChoiceField(
+                    choices=[(None, ""), *[(_, _) for _ in field.get("enum", [])]],
+                    widget=forms.Select(attrs={"class": "vTextField"}),
+                    required=field.get("required", False),
+                    initial=field.get("default"),
+                )
+
+            elif field["type"] == "string":
+                locals()[key] = forms.CharField(
+                    required=False,
+                )
+
+            else:
+                pass
+
+        class Meta:
+            model = carrierProxy
+            fields = "__all__"
+
+        def __init__(self, *args, instance: providers.Carrier = None, **kwargs):
+            if instance is not None:
+                kwargs.update({"instance": instance})
+                credentials = instance.credentials
+                config = providers.Carrier.resolve_config(
+                    instance, is_system_config=True
+                )
+
+                for key in [
+                    _ for _ in self.base_fields.keys() if _ in connection_fields.keys()
+                ]:
+                    self.base_fields[key].initial = (
+                        None if credentials is None else credentials.get(key)
+                    )
+
+                for key in [
+                    _ for _ in self.base_fields.keys() if _ in connection_configs.keys()
+                ]:
+                    self.base_fields[key].initial = (
+                        None if config is None else config.config.get(key)
+                    )
+
+            super(_Form, self).__init__(*args, **kwargs)
+
+        def save(self, commit: bool = True):
+            config_data = lib.to_dict(
+                {key: self.cleaned_data.get(key) for key in connection_configs.keys()}
+            )
+            credentials_data = lib.to_dict(
+                {key: self.cleaned_data.get(key) for key in connection_fields.keys()}
+            )
+
+            for key in connection_fields.keys():
+                if key in self.cleaned_data:
+                    self.cleaned_data.pop(key)
+
+            for key in connection_configs.keys():
+                if key in self.cleaned_data:
+                    self.cleaned_data.pop(key)
+
+            carrier = super(_Form, self).save(commit)
+
+            if any(connection_fields.keys()) and (commit or carrier.pk is not None):
+                carrier.credentials = serializers.process_dictionaries_mutations(
+                    ["credentials"], credentials_data, carrier
+                )
+                carrier.save()
+
+            if any(connection_configs.keys()) and (commit or carrier.pk is not None):
+                config = providers.Carrier.resolve_config(
+                    carrier, is_system_config=True
+                )
+                created_by = getattr(config, "created_by", self.request.user)
+                config_value = lib.to_dict(
+                    serializers.process_dictionaries_mutations(
+                        ["config"], config_data, config
+                    )
+                )
+
+                if config is None and len(config_value.keys()) == 0:
+                    # Skip configuration persistence...
+                    return carrier
+
+                # Save or update the carrier config...
+                lib.identity(
+                    providers.CarrierConfig.objects.create(
+                        created_by=created_by,
+                        carrier=carrier,
+                        config=config_value,
+                    )
+                    if config is None
+                    else providers.CarrierConfig.objects.filter(carrier=carrier).update(
+                        config=config_value
+                    )
+                )
+
+            return carrier
+
+    _form: forms.ModelForm = type(f"{class_name}AdminForm", (_Form,), {})
+    _fields = _form.base_fields.keys()
+
+    class _Admin(admin.ModelAdmin):
+        form = _form
+        inlines = []
+        list_display = ("__str__", "test_mode", "active")
+        exclude = ["active_users"]
+        fieldsets = [
+            (
+                None,
+                {
+                    "fields": [
+                        _
+                        for _ in _fields
+                        if _
+                        not in [
+                            *connection_fields.keys(),
+                            *connection_configs.keys(),
+                            "carrier_code",
+                            "credentials",
+                            "active_users",
+                            "is_system",
+                            "rate_sheet",
+                            "metadata",
+                        ]
+                    ],
+                },
+            ),
+        ]
+
+        if any(connection_fields.keys()):
+            fieldsets += [
+                (  # type: ignore
+                    "Connection Fields",
+                    {
+                        "fields": [_ for _ in connection_fields.keys() if _ in _fields],
+                    },
+                ),
+            ]
+
+        if any(connection_configs.keys()):
+            fieldsets += [
+                (  # type: ignore
+                    "Connection Config",
+                    {
+                        "fields": [
+                            _ for _ in connection_configs.keys() if _ in _fields
+                        ],
+                    },
+                ),
+            ]
+
+        formfield_overrides = {
+            models.CharField: {
+                "widget": forms.TextInput(
+                    attrs={
+                        "type": "text",
+                        "readonly": "true",
+                        "class": "vTextField",
+                        "data - lpignore": "true",
+                        "autocomplete": "keep-off",
+                        "onfocus": "this.removeAttribute('readonly');",
+                    }
+                )
+            },
+        }
+
+        if settings.MULTI_ORGANIZATIONS:
+
+            class ActiveOrgInline(admin.TabularInline):
+                model = carrierProxy.active_orgs.through
+                verbose_name = "Activated for organization"
+                extra = 0
+
+                def get_formset(self, request, obj, **kwargs):
+                    from karrio.server.orgs.models import Organization
+
+                    initial = []
+                    orgs = Organization.objects.filter(
+                        users__id=request.user.id
+                    ).distinct()
+                    self.max_num = orgs.count()
+
+                    if obj is None and request.method == "GET":
+                        self.extra = orgs.count()
+                        initial += [{"organization": o.id} for o in orgs]
+
+                    formset = super().get_formset(request, obj, **kwargs)
+                    formset.__init__ = functools.partialmethod(
+                        formset.__init__, initial=initial
+                    )
+                    organization_field = formset.form.base_fields["organization"]
+                    organization_field.queryset = orgs
+                    organization_field.widget.can_add_related = False
+                    organization_field.widget.can_change_related = False
+
+                    return formset
+
+            inlines += [ActiveOrgInline]
+
+        else:
+
+            class ActiveUserInline(admin.TabularInline):
+                model = carrierProxy.active_users.through
+                exta = 0
+                verbose_name = "Activated for user"
+
+                def get_formset(self, request, obj, **kwargs):
+                    initial = []
+                    users = User.objects.all()
+                    self.max_num = users.count()
+
+                    if obj is None and request.method == "GET":
+                        self.extra = users.count()
+                        initial += [{"user": o.id} for o in users]
+
+                    formset = super().get_formset(request, obj, **kwargs)
+                    formset.__init__ = functools.partialmethod(
+                        formset.__init__, initial=initial
+                    )
+                    user_field = formset.form.base_fields["user"]
+                    user_field.queryset = users
+                    user_field.widget.can_add_related = False
+                    user_field.widget.can_change_related = False
+
+                    return formset
+
+            inlines += [ActiveUserInline]
+
+        def get_queryset(self, request):
+            query = super().get_queryset(request)
+            return query.filter(models.Q(is_system=True) | models.Q(created_by=None))
+
+        def get_form(self, request, *args, **kwargs):
+            form = super(_Admin, self).get_form(request, *args, **kwargs)
+            form.request = request
+
+            # Customize capabilities options specific to a carrier.
+            raw_capabilities = ref.get_carrier_capabilities(ext)
+            form.base_fields["capabilities"].choices = [
+                (c, c) for c in raw_capabilities
+            ]
+            form.base_fields["capabilities"].initial = raw_capabilities
+
+            return form
+
+        def save_model(self, request, obj, form, change):
+            obj.is_system = True
+            obj.carrier_code = ext
+            return super().save_model(request, obj, form, change)
+
+    return type(f"{class_name}Admin", (_Admin,), {})
+
+
+@admin.register(providers.LabelTemplate)
+class LabelTemplateAdmin(admin.ModelAdmin):
+    def has_module_permission(self, request):
+        return False
+
+
+@utils.skip_on_commands()
+def register_carrier_admins():
+    for carrier_name, display_name in ref.REFERENCES["carriers"].items():
+        proxy = providers.create_carrier_proxy(carrier_name, display_name)
+        admin.site.register(proxy, model_admin(carrier_name, proxy))
+
+
+register_carrier_admins()

karrio/server/providers/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+
+
+class ProvidersConfig(AppConfig):
+    name = "karrio.server.providers"
+
+    def ready(self):
+        from karrio.server.providers import signals
+
+        signals.register_signals()

karrio/server/providers/extension/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore

karrio/server/providers/extension/models/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore

karrio/server/providers/extension/models/allied_express.py

@@ -0,0 +1,22 @@
+import django.db.models as models
+
+import karrio.server.providers.models.carrier as providers
+
+
+class AlliedExpressSettings(providers.Carrier):
+    class Meta:
+        db_table = "allied-express-settings"
+        verbose_name = "Allied Express Settings"
+        verbose_name_plural = "Allied Express Settings"
+
+    username = models.CharField(max_length=50)
+    password = models.CharField(max_length=50)
+    account = models.CharField(max_length=50, null=True, blank=True)
+    service_type = models.CharField(max_length=50, null=True, blank=True)
+
+    @property
+    def carrier_name(self) -> str:
+        return "allied_express"
+
+
+SETTINGS = AlliedExpressSettings

karrio/server/providers/extension/models/allied_express_local.py

@@ -0,0 +1,22 @@
+import django.db.models as models
+
+import karrio.server.providers.models.carrier as providers
+
+
+class AlliedExpressLocalSettings(providers.Carrier):
+    class Meta:
+        db_table = "allied-express-local-settings"
+        verbose_name = "Allied Express Local Settings"
+        verbose_name_plural = "Allied Express Local Settings"
+
+    username = models.CharField(max_length=50)
+    password = models.CharField(max_length=50)
+    account = models.CharField(max_length=50, null=True, blank=True)
+    service_type = models.CharField(max_length=50, null=True, blank=True)
+
+    @property
+    def carrier_name(self) -> str:
+        return "allied_express_local"
+
+
+SETTINGS = AlliedExpressLocalSettings

karrio/server/providers/extension/models/amazon_shipping.py

@@ -0,0 +1,27 @@
+from django.db import models
+from karrio.server.providers.models.carrier import Carrier
+
+
+class AmazonShippingSettings(Carrier):
+    CARRIER_NAME = "amazon_shipping"
+
+    class Meta:
+        db_table = "amazon_shipping-settings"
+        verbose_name = "Amazon Shipping Settings"
+        verbose_name_plural = "Amazon Shipping Settings"
+
+    seller_id = models.CharField(max_length=50)
+    developer_id = models.CharField(max_length=50)
+    mws_auth_token = models.CharField(max_length=50)
+    aws_region = models.CharField(max_length=50, default="us-east-1")
+
+    @property
+    def carrier_name(self) -> str:
+        return self.CARRIER_NAME
+
+    @property
+    def x_amz_access_token(self) -> str:
+        return ""  # Setup the access token here.
+
+
+SETTINGS = AmazonShippingSettings

karrio/server/providers/extension/models/aramex.py

@@ -0,0 +1,25 @@
+from django.db import models
+from karrio.server.providers.models.carrier import Carrier, COUNTRIES
+
+
+class AramexSettings(Carrier):
+    class Meta:
+        db_table = "aramex-settings"
+        verbose_name = "Aramex Settings"
+        verbose_name_plural = "Aramex Settings"
+
+    username = models.CharField(max_length=200)
+    password = models.CharField(max_length=200)
+    account_pin = models.CharField(max_length=200)
+    account_entity = models.CharField(max_length=200)
+    account_number = models.CharField(max_length=200)
+    account_country_code = models.CharField(
+        max_length=3, blank=True, null=True, choices=COUNTRIES
+    )
+
+    @property
+    def carrier_name(self) -> str:
+        return "aramex"
+
+
+SETTINGS = AramexSettings

karrio/server/providers/extension/models/asendia_us.py

@@ -0,0 +1,21 @@
+import django.db.models as models
+import karrio.server.providers.models.carrier as providers
+
+
+class AsendiaUSSettings(providers.Carrier):
+    class Meta:
+        db_table = "asendia-us-settings"
+        verbose_name = "Asendia US Settings"
+        verbose_name_plural = "Asendia US Settings"
+
+    username = models.CharField(max_length=100)
+    password = models.CharField(max_length=100)
+    api_key = models.CharField(max_length=100)
+    account_number = models.CharField(max_length=100, blank=True)
+
+    @property
+    def carrier_name(self) -> str:
+        return "asendia_us"
+
+
+SETTINGS = AsendiaUSSettings

karrio/server/providers/extension/models/australiapost.py

@@ -0,0 +1,20 @@
+from django.db import models
+from karrio.server.providers.models.carrier import Carrier
+
+
+class AustraliaPostSettings(Carrier):
+    class Meta:
+        db_table = "australia-post-settings"
+        verbose_name = "Australia Post Settings"
+        verbose_name_plural = "Australia Post Settings"
+
+    api_key = models.CharField(max_length=200)
+    password = models.CharField(max_length=200)
+    account_number = models.CharField(max_length=200)
+
+    @property
+    def carrier_name(self) -> str:
+        return "australiapost"
+
+
+SETTINGS = AustraliaPostSettings