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

karrio/server/user/models.py

@@ -0,0 +1,203 @@
+import os
+import binascii
+import functools
+from django.db import models
+from django.conf import settings
+from django.contrib.auth import models as auth
+from rest_framework.authtoken import models as authtoken
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext_lazy as _
+
+import karrio.server.core.models as core
+
+
+class UserManager(auth.UserManager):
+    def _create_user(self, email, password, **extra_fields):
+        """
+        Create and save a user with the given username, email, and password.
+        """
+        if not email:
+            raise ValueError("The given email must be set")
+        email = self.normalize_email(email)
+        user = self.model(email=email, **extra_fields)
+        user.set_password(password)
+        user.save(using=self._db)
+        return user
+
+    def create_user(self, email, password=None, **extra_fields):
+        extra_fields.setdefault("is_staff", False)
+        extra_fields.setdefault("is_superuser", False)
+        return self._create_user(email, password, **extra_fields)
+
+    def create_superuser(self, email, password=None, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+
+        if extra_fields.get("is_staff") is not True:
+            raise ValueError("Superuser must have is_staff=True.")
+        if extra_fields.get("is_superuser") is not True:
+            raise ValueError("Superuser must have is_superuser=True.")
+
+        return self._create_user(email, password, **extra_fields)
+
+
+@core.register_model
+class User(auth.AbstractUser):
+    full_name = models.CharField(_("full name"), max_length=150, blank=True)
+    email = models.EmailField(_("email address"), unique=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS: list = []
+
+    objects = UserManager()
+
+    username = None
+    first_name = None
+    last_name = None
+
+    def __str__(self):
+        return self.email
+
+    def delete(self, *args, **kwargs):
+        self.tokens.all().delete()
+        super().delete(*args, **kwargs)
+
+    @property
+    def object_type(self):
+        return "user"
+
+    @property
+    def permissions(self):
+        import karrio.server.conf as conf
+        import karrio.server.iam.models as iam
+        import karrio.server.core.middleware as middleware
+
+        ctx = middleware.SessionContext.get_current_request()
+        _permissions = []
+
+        if conf.settings.MULTI_ORGANIZATIONS and ctx.org is not None:
+            org_user = ctx.org.organization_users.filter(user_id=self.pk)
+            _permissions = (
+                iam.ContextPermission.objects.get(
+                    object_pk=org_user.first().pk,
+                    content_type=ContentType.objects.get_for_model(org_user.first()),
+                )
+                .groups.all()
+                .values_list("name", flat=True)
+                if org_user.exists()
+                else []
+            )
+
+        if not any(_permissions):
+            _permissions = self.groups.all().values_list("name", flat=True)
+
+        if not any(_permissions) and self.is_superuser:
+            return Group.objects.all().values_list("name", flat=True)
+
+        if not any(_permissions) and self.is_staff:
+            return Group.objects.exclude(
+                name__in=["manage_system", "manage_team", "manage_org_owner"]
+            ).values_list("name", flat=True)
+
+        return _permissions
+
+
+@core.register_model
+class Token(authtoken.Token, core.ControlledAccessModel):
+    label = models.CharField(_("label"), max_length=50)
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="tokens"
+    )
+    test_mode = models.BooleanField(null=False, default=core.field_default(False))
+
+    class Meta:
+        verbose_name = _("Token")
+        verbose_name_plural = _("Tokens")
+
+    @property
+    def pk(self):
+        return self.key
+
+    @classmethod
+    def generate_key(cls):
+        return f"key_{binascii.hexlify(os.urandom(16)).decode()}"
+
+    @property
+    def organization(self):
+        return self.org.first() if hasattr(self, "org") else None
+
+    @property
+    def object_type(self):
+        return "token"
+
+    @property
+    def permissions(self):
+        import karrio.server.conf as conf
+        import karrio.server.iam.models as iam
+
+        _permissions = []
+
+        if iam.ContextPermission.objects.filter(object_pk=self.pk).exists():
+            _permissions = (
+                iam.ContextPermission.objects.get(
+                    object_pk=self.pk,
+                    content_type=ContentType.objects.get_for_model(Token),
+                )
+                .groups.all()
+                .values_list("name", flat=True)
+            )
+
+        if (
+            not any(_permissions)
+            and conf.settings.MULTI_ORGANIZATIONS
+            and self.org.exists()
+        ):
+            org_user = self.org.first().organization_users.filter(user_id=self.user_id)
+            _permissions = (
+                iam.ContextPermission.objects.get(
+                    object_pk=org_user.first().pk,
+                    content_type=ContentType.objects.get_for_model(org_user.first()),
+                )
+                .groups.all()
+                .values_list("name", flat=True)
+                if org_user.exists()
+                else []
+            )
+
+        return _permissions if any(_permissions) else self.user.permissions
+
+
+@core.register_model
+class Group(auth.Group):
+    pass
+
+
+@core.register_model
+class WorkspaceConfig(core.OwnedEntity):
+    class Meta:
+        db_table = "workspace-config"
+        verbose_name = "Workspace Config"
+        verbose_name_plural = "Workspace Configs"
+
+    id = models.CharField(
+        max_length=50,
+        editable=False,
+        primary_key=True,
+        default=functools.partial(core.uuid, prefix="wcfg_"),
+    )
+    config = models.JSONField(
+        null=False,
+        blank=False,
+        default=core.field_default({}),
+    )
+    created_by = models.ForeignKey(
+        User,
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE,
+        editable=False,
+    )
+
+    @property
+    def object_type(self):
+        return "workspace-config"

karrio/server/user/serializers.py

@@ -0,0 +1,46 @@
+import karrio.server.conf as conf
+import karrio.server.user.models as models
+import karrio.server.serializers as serializers
+
+
+@serializers.owned_model_serializer
+class TokenSerializer(serializers.Serializer):
+    label = serializers.CharField(required=False)
+
+    def create(
+        self, validated_data: dict, context: serializers.Context
+    ) -> models.Token:
+        return models.Token.objects.create(
+            user=context.user,
+            test_mode=context.test_mode,
+            label=validated_data.get("label") or "Default API Key",
+        )
+
+    @staticmethod
+    def retrieve_token(context, org_id: str = None):
+        org = getattr(context, "org", None)
+        org_id = org_id or getattr(org, "id", None)
+
+        queyset = models.Token.objects.filter(
+            **{
+                "test_mode": getattr(context, "test_mode", None),
+                "user__id": getattr(getattr(context, "user", None), "id", None),
+                **({"org__id": org_id} if org_id is not None else {}),
+            }
+        )
+
+        if queyset.exists():
+            return queyset.first()
+
+        if org_id is not None and conf.settings.MULTI_ORGANIZATIONS:
+            import karrio.server.orgs.models as orgs
+
+            org = orgs.Organization.objects.get(id=org_id, users__id=context.user.id)
+
+        ctx = serializers.Context(
+            org=org,
+            user=getattr(context, "user", None),
+            test_mode=getattr(context, "test_mode", None),
+        )
+
+        return TokenSerializer.map(data={}, context=ctx).save().instance

karrio/server/user/templates/registration/login.html

@@ -0,0 +1,108 @@
+{% extends "admin/base_site.html" %}
+{% load i18n static %}
+
+{% block extrastyle %}
+  {{ block.super }}
+  <link rel="stylesheet" type="text/css" href="{% static "css/login.css" %}">
+  {{ form.media }}
+{% endblock %}
+
+
+{% block bodyclass %}{{ block.super }} login{% endblock %}
+
+{% block usertools %}{% endblock %}
+
+{% block nav-global %}{% endblock %}
+
+{% block nav-sidebar %}{% endblock %}
+
+{% block content_title %}{% endblock %}
+
+{% block breadcrumbs %}{% endblock %}
+
+{% block content %}
+  <div id="content-main">
+
+    {% if wizard.steps.current == 'token' %}
+      {% if device.method == 'call' %}
+        <p>{% blocktrans trimmed %}We are calling your phone right now, please enter the
+          digits you hear.{% endblocktrans %}</p>
+      {% elif device.method == 'sms' %}
+        <p>{% blocktrans trimmed %}We sent you a text message, please enter the tokens we
+          sent.{% endblocktrans %}</p>
+      {% else %}
+        <p>{% blocktrans trimmed %}Please enter the tokens generated by your token
+          generator.{% endblocktrans %}</p>
+      {% endif %}
+    {% elif wizard.steps.current == 'backup' %}
+      <p>{% blocktrans trimmed %}Use this form for entering backup tokens for logging in.
+        These tokens have been generated for you to print and keep safe. Please
+        enter one of these backup tokens to login to your account.{% endblocktrans %}</p>
+    {% endif %}
+
+    {% if form.errors and not form.non_field_errors %}
+      <p class="errornote">
+        {% if form.errors.items|length == 1 %}
+          {% translate "Please correct the error below." %}
+        {% else %}
+          {% translate "Please correct the errors below." %}
+        {% endif %}
+      </p>
+    {% endif %}
+    {% if form.non_field_errors %}
+      {% for error in form.non_field_errors %}
+        <p class="errornote">{{ error }}</p>
+      {% endfor %}
+    {% endif %}
+
+    <form action="" method="post" id="login-form">{% csrf_token %}
+      {{ wizard.management_form }}
+
+      {% if wizard.steps.current == 'auth' %}
+        <div class="form-row">
+          {{ form.username.errors }}
+          {{ form.username.label_tag }} {{ form.username }}
+        </div>
+        <div class="form-row">
+          {{ form.password.errors }}
+          {{ form.password.label_tag }} {{ form.password }}
+        </div>
+        <div class="submit-row">
+          <input type="submit" value="{% translate 'Log in' %}">
+        </div>
+      {% else %}
+        <div class="form-row">
+          {{ form.otp_token.errors }}
+          {{ form.otp_token.label_tag }} {{ form.otp_token }}
+        </div>
+
+        <div class="submit-row">
+          <input type="submit" value="{% translate 'Continue' %}">
+        </div>
+      {% endif %}
+
+      {% if other_devices %}
+        <p>{% trans "Or, alternatively, use one of your backup phones:" %}</p>
+        <p>
+          {% for other in other_devices %}
+          <button name="challenge_device" value="{{ other.persistent_id }}"
+                  class="btn btn-secondary btn-block" type="submit">
+            {{ other.generate_challenge_button_title }}
+          </button>
+        {% endfor %}</p>
+      {% endif %}
+      {% if backup_tokens %}
+        <p>{% trans "As a last resort, you can use a backup token:" %}</p>
+        <p>
+          <button name="wizard_goto_step" type="submit" value="backup"
+                  class="btn btn-secondary btn-block">{% trans "Use Backup Token" %}</button>
+        </p>
+      {% endif %}
+
+      <input type="hidden" name="next" value="{{ request.GET.next }}"/>
+      {# hidden submit button to enable [enter] key #}
+      <input type="submit" value="" style="display: none;" />
+    </form>
+  </div>
+{% endblock %}
+

karrio/server/user/templates/registration/registration_confirm_email.html

@@ -0,0 +1,10 @@
+{% load i18n %}{% autoescape off %}
+{% block title %}Email confirmation{% endblock %}
+
+<p>{% trans "You are almost there," %}</p>
+
+<p>{% trans "Please click the following link to verify your email address." %}</p>
+
+{{ link }}
+
+{% endautoescape %}

karrio/server/user/templates/registration/registration_confirm_email.txt

@@ -0,0 +1,3 @@
+You are almost there,
+Please click the following link to verify your email address:
+{{ link }}

karrio/server/user/tests.py

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

karrio/server/user/urls.py

@@ -0,0 +1,10 @@
+"""
+karrio server user module urls
+"""
+from django.urls import include, path
+from django_email_verification import urls as mail_urls
+
+urlpatterns = [
+    path("email/", include(mail_urls)),
+    path("", include("karrio.server.user.views")),
+]

karrio/server/user/utils.py

@@ -0,0 +1,60 @@
+import datetime
+from django_email_verification.token_utils import default_token_generator
+from django_email_verification.confirm import (
+    Thread,
+    InvalidUserModel,
+    EmailMultiAlternatives,
+    _get_validated_field,
+    render_to_string,
+)
+
+
+def send_email(user, redirect_url, thread=True, expiry=None, **kwargs):
+    try:
+        user.save()
+
+        if kwargs.get("custom_salt"):
+            default_token_generator.key_salt = kwargs["custom_salt"]
+
+        _expiry = expiry or (datetime.datetime.now() + datetime.timedelta(days=30))
+        token, __expiry = default_token_generator.make_token(user, _expiry, kind="MAIL")
+
+        domain = redirect_url
+        sender = _get_validated_field("EMAIL_FROM_ADDRESS")
+        subject = _get_validated_field("EMAIL_MAIL_SUBJECT")
+        mail_plain = _get_validated_field("EMAIL_MAIL_PLAIN")
+        mail_html = _get_validated_field("EMAIL_MAIL_HTML")
+
+        args = (
+            user,
+            token,
+            __expiry,
+            sender,
+            domain,
+            subject,
+            mail_plain,
+            mail_html,
+        )
+        if thread:
+            t = Thread(target=send_email_thread, args=args)
+            t.start()
+        else:
+            send_email_thread(*args)
+    except AttributeError:
+        raise InvalidUserModel("The user model you provided is invalid")
+
+
+def send_email_thread(
+    user, token, expiry, sender, domain, subject, mail_plain, mail_html
+):
+    domain += "/" if not domain.endswith("/") else ""
+    link = domain + token
+
+    context = {"link": link, "expiry": expiry, "user": user}
+
+    text = render_to_string(mail_plain, context)
+    html = render_to_string(mail_html, context)
+
+    msg = EmailMultiAlternatives(subject, text, sender, [user.email])
+    msg.attach_alternative(html, "text/html")
+    msg.send()

karrio/server/user/views.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from two_factor.views import LoginView as BaseLoginView
+
+
+class LoginView(BaseLoginView):
+    template_name = "registration/login.html"
+
+
+urlpatterns = [path("login/", LoginView.as_view(), name="login")]

karrio_server_core-2025.5rc1.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: karrio_server_core
+Version: 2025.5rc1
+Summary: Multi-carrier shipping API Core module
+Author-email: karrio <hello@karrio.io>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/karrioapi/karrio
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: karrio
+Requires-Dist: psycopg2-binary
+Requires-Dist: django-health-check
+Requires-Dist: psutil
+Requires-Dist: pyyaml
+Requires-Dist: Jinja2
+
+# karrio.server.core
+
+This package is a module of the [karrio](https://pypi.org/project/karrio.server) universal shipping API.
+
+## Requirements
+
+`Python 3.11+`
+
+## Installation
+
+```bash
+pip install karrio.server.core
+```
+
+Check the [karrio docs](https://docs.karrio.io) to get started.