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

karrio/server/core/management/commands/cli.py

@@ -0,0 +1,19 @@
+from django.core.management.base import BaseCommand
+import sys
+
+class Command(BaseCommand):
+    help = "Run kcli commands from the Django CLI."
+
+    def run_from_argv(self, argv):
+        # Remove the management command name ("kcli") from argv
+        kcli_args = argv[2:]
+        try:
+            from kcli.__main__ import app
+            # Call the Typer app with the forwarded arguments
+            app(prog_name="karrio cli", args=kcli_args)
+        except SystemExit as e:
+            # Typer uses SystemExit for normal CLI exit, so suppress traceback
+            sys.exit(e.code)
+        except ImportError:
+            self.stderr.write(self.style.ERROR("Could not import kcli CLI app."))
+            sys.exit(1)

karrio/server/core/management/commands/create_oauth_client.py

@@ -0,0 +1,41 @@
+from django.core.management.base import BaseCommand
+from oauth2_provider.models import Application
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+class Command(BaseCommand):
+    help = 'Creates an OAuth2 client application'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--name', required=True)
+        parser.add_argument('--client_id', required=True)
+        parser.add_argument('--client_secret', required=True)
+        parser.add_argument('--redirect_uri', required=True)
+        parser.add_argument('--user_email', required=True)
+
+    def handle(self, *args, **options):
+        try:
+            user = User.objects.get(email=options['user_email'])
+        except User.DoesNotExist:
+            self.stdout.write(self.style.ERROR(f"User with email {options['user_email']} does not exist"))
+            return
+
+        # Check if application with this client_id already exists
+        app, created = Application.objects.update_or_create(
+            client_id=options['client_id'],
+            defaults={
+                'name': options['name'],
+                'user': user,
+                'client_type': Application.CLIENT_CONFIDENTIAL,
+                'authorization_grant_type': Application.GRANT_AUTHORIZATION_CODE,
+                'client_secret': options['client_secret'],
+                'redirect_uris': options['redirect_uri'],
+                'skip_authorization': True,
+            }
+        )
+
+        if created:
+            self.stdout.write(self.style.SUCCESS(f"Successfully created OAuth2 application: {options['name']}"))
+        else:
+            self.stdout.write(self.style.SUCCESS(f"Successfully updated OAuth2 application: {options['name']}"))

karrio/server/core/middleware.py

@@ -0,0 +1,95 @@
+import json
+import threading
+from django.db.models import Q
+from django.http import HttpResponse
+from karrio.core.utils import Tracer
+from karrio.server.conf import settings
+
+
+class CreatorAccess:
+    def __call__(self, context, key: str = "created_by", **kwargs) -> Q:
+        user_key = f"{key}_id"
+        user = getattr(context, "user", None)
+
+        return Q(**{user_key: getattr(user, "id", None)})
+
+
+class WideAccess:
+    def __call__(self, *args, **kwargs) -> Q:
+        return Q()
+
+
+class UserToken:
+    def __call__(self, context, **kwargs) -> dict:
+        return dict(user=getattr(context, "user", context))
+
+
+class SessionContext:
+    _threadmap: dict = {}
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+        # One-time configuration and initialization.
+
+    def __call__(self, request):
+        # Code to be executed for each request before
+        # the view (and later middleware) are called.
+        request.tracer = Tracer()
+        self._threadmap[threading.get_ident()] = request
+
+        response = self.get_response(request)
+
+        # Code to be executed for each request/response after
+        # the view is called.
+        try:
+            self._save_tracing_records(request, schema=settings.schema)
+            del self._threadmap[threading.get_ident()]
+        except KeyError:
+            pass
+
+        return response
+
+    def _save_tracing_records(self, request, schema: str = None):
+        from karrio.server.tracing.utils import save_tracing_records
+
+        save_tracing_records(request, schema=schema)
+
+    @classmethod
+    def get_current_request(cls):
+        return cls._threadmap.get(threading.get_ident())
+
+
+class NonHtmlDebugToolbarMiddleware:
+    """
+    The Django Debug Toolbar usually only works for views that return HTML.
+    This middleware wraps any non-HTML response in HTML if the request
+    has a 'debug' query parameter (e.g. http://localhost/foo?debug)
+    Special handling for json (pretty printing) and
+    binary data (only show data length)
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+
+        if request.GET.get("debug") == "":
+            if response["Content-Type"] == "application/octet-stream":
+                new_content = (
+                    "<html><body>Binary Data, "
+                    "Length: {}</body></html>".format(len(response.content))
+                )
+                response = HttpResponse(new_content)
+            elif response["Content-Type"] != "text/html":
+                content = response.content
+                try:
+                    json_ = json.loads(content)
+                    content = json.dumps(json_, sort_keys=True, indent=2)
+                except ValueError:
+                    pass
+                response = HttpResponse(
+                    "<html><body><pre>{}" "</pre></body></html>".format(content)
+                )
+
+        return response

karrio/server/core/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+# Generated by Django 3.2.3 on 2021-05-18 10:53
+
+from django.db import migrations
+import karrio.server.core.models.base
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('rest_framework_tracking', '0011_auto_20201117_2016'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='APILog',
+            fields=[
+            ],
+            options={
+                'ordering': ['-requested_at'],
+                'proxy': True,
+                'indexes': [],
+                'constraints': [],
+            },
+            bases=('rest_framework_tracking.apirequestlog', karrio.server.core.models.base.ControlledAccessModel),
+        ),
+    ]

karrio/server/core/migrations/0002_apilogindex.py

@@ -0,0 +1,69 @@
+# Generated by Django 3.2.13 on 2022-07-18 12:05
+
+from django.db import migrations, models
+import django.db.models.deletion
+import karrio.server.core.utils as utils
+
+
+def forwards_func(apps, schema_editor):
+    db_alias = schema_editor.connection.alias
+    APILog = apps.get_model("core", "APILog")
+    APILogIndex = apps.get_model("core", "APILogIndex")
+    logs = APILog.objects.using(db_alias).filter(response__isnull=False).iterator()
+
+    for log in logs:
+        response = utils.failsafe(
+            lambda: utils.DP.to_dict(utils.DP.to_dict(log.response))
+        )
+        entity_id = utils.failsafe(lambda: response["id"])
+
+        if entity_id is not None:
+            _index = APILogIndex(
+                apirequestlog_ptr=log,
+                entity_id=entity_id,
+            )
+            _index.save_base(raw=True)
+
+        if isinstance(response, dict):
+            log.response = utils.DP.jsonify(response)
+            log.save()
+
+
+def reverse_func(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("rest_framework_tracking", "0011_auto_20201117_2016"),
+        ("core", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="APILogIndex",
+            fields=[
+                (
+                    "apirequestlog_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="rest_framework_tracking.apirequestlog",
+                    ),
+                ),
+                (
+                    "entity_id",
+                    models.CharField(db_index=True, max_length=50, null=True),
+                ),
+            ],
+            options={
+                "verbose_name": "API Request Log",
+                "abstract": False,
+            },
+            bases=("core.apilog",),
+        ),
+        migrations.RunPython(forwards_func, reverse_func),
+    ]

karrio/server/core/migrations/0003_apilogindex_test_mode.py

@@ -0,0 +1,62 @@
+# Generated by Django 4.1.4 on 2022-12-17 11:46
+
+from django.db import migrations, models
+import karrio.server.core.utils as utils
+import karrio.lib as lib
+
+
+def forwards_func(apps, schema_editor):
+    db_alias = schema_editor.connection.alias
+    APILog = apps.get_model("core", "APILog")
+    APILogIndex = apps.get_model("core", "APILogIndex")
+    logs = (
+        APILog.objects.using(db_alias)
+        .filter(models.Q(response__icontains="test_mode"))
+        .iterator()
+    )
+
+    for log in logs:
+        response = utils.failsafe(lambda: lib.to_dict(lib.to_dict(log.response)))
+        entity_id = utils.failsafe(lambda: response["id"])
+        test_mode = utils.failsafe(lambda: response["test_mode"])
+
+        if test_mode is None and '"test_mode": true' in log.response:
+            test_mode = True
+        if test_mode is None and '"test_mode": false' in log.response:
+            test_mode = False
+
+        if test_mode is not None and hasattr(log, "apilogindex"):
+            log.apilogindex.test_mode = test_mode
+            log.apilogindex.save()
+
+        if hasattr(log, "apilogindex") is False:
+            _index = APILogIndex(
+                apirequestlog_ptr=log,
+                entity_id=entity_id,
+                test_mode=test_mode,
+            )
+            _index.save_base(raw=True)
+
+        log.response = utils.DP.jsonify(response)
+        log.save()
+
+
+def reverse_func(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("core", "0002_apilogindex"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="apilogindex",
+            name="test_mode",
+            field=models.BooleanField(
+                default=True, help_text="execution context", null=True
+            ),
+        ),
+        migrations.RunPython(forwards_func, reverse_func),
+    ]

karrio/server/core/migrations/0004_metafield.py

@@ -0,0 +1,74 @@
+# Generated by Django 4.2.8 on 2024-01-13 22:41
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import functools
+import karrio.server.core.models.base
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("core", "0003_apilogindex_test_mode"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Metafield",
+            fields=[
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "id",
+                    models.CharField(
+                        default=functools.partial(
+                            karrio.server.core.models.base.uuid,
+                            *(),
+                            **{"prefix": "metaf_"}
+                        ),
+                        editable=False,
+                        max_length=50,
+                        primary_key=True,
+                        serialize=False,
+                    ),
+                ),
+                (
+                    "key",
+                    models.CharField(db_index=True, max_length=50, verbose_name="name"),
+                ),
+                ("value", models.CharField(blank=True, max_length=250, null=True)),
+                (
+                    "type",
+                    models.CharField(
+                        choices=[
+                            ("text", "text"),
+                            ("number", "number"),
+                            ("boolean", "boolean"),
+                        ],
+                        db_index=True,
+                        default="text",
+                        max_length=50,
+                        verbose_name="type",
+                    ),
+                ),
+                ("is_required", models.BooleanField(default=False)),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        editable=False,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Metafield",
+                "verbose_name_plural": "Metafields",
+                "db_table": "metafield",
+            },
+            bases=(karrio.server.core.models.base.ControlledAccessModel, models.Model),
+        ),
+    ]

karrio/server/core/migrations/0005_alter_metafield_type_alter_metafield_value.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.2.3 on 2025-06-19 05:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0004_metafield'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='metafield',
+            name='type',
+            field=models.CharField(choices=[('text', 'text'), ('number', 'number'), ('boolean', 'boolean'), ('json', 'json'), ('date', 'date'), ('date_time', 'date_time'), ('password', 'password')], db_index=True, default='text', max_length=50, verbose_name='type'),
+        ),
+        migrations.AlterField(
+            model_name='metafield',
+            name='value',
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

karrio/server/core/models/__init__.py

@@ -0,0 +1,48 @@
+import ast
+import yaml
+import typing
+import functools
+
+import karrio.lib as lib
+from karrio.server.core.models.base import (
+    ControlledAccessModel,
+    get_access_filter,
+    register_model,
+    uuid,
+    MetafieldType,
+    METAFIELD_TYPE,
+)
+from karrio.server.core.models.third_party import (
+    APILog,
+    APILogIndex,
+)
+from karrio.server.core.models.metafield import (
+    Metafield,
+)
+from karrio.server.core.models.entity import Entity, OwnedEntity
+
+
+def _identity(value: typing.Any):
+    return value
+
+
+def field_default(value: typing.Any) -> typing.Callable:
+    return functools.partial(_identity, value=value)
+
+
+def metafields_to_dict(metafields: typing.List[Metafield]) -> dict:
+    _values = {}
+
+    for _ in metafields:
+        # Skip metafields with None or empty values
+        if _.value is None or _.value == "":
+            continue
+
+        if _.type == "number":
+            _values.update({_.key: lib.failsafe(lambda: ast.literal_eval(_.value))})
+        elif _.type == "boolean":
+            _values.update({_.key: lib.failsafe(lambda: bool(yaml.safe_load(_.value)))})
+        else:
+            _values.update({_.key: _.value})
+
+    return _values

karrio/server/core/models/base.py

@@ -0,0 +1,70 @@
+import pydoc
+import typing
+import functools
+from uuid import uuid4
+from django.db import models
+from django.conf import settings
+
+import karrio.lib as lib
+
+T = typing.TypeVar("T")
+MODEL_TRANSFORMERS = getattr(settings, "MODEL_TRANSFORMERS", [])
+ACCESS_METHOD = getattr(
+    settings,
+    "KARRIO_ENTITY_ACCESS_METHOD",
+    "karrio.server.core.middleware.WideAccess",
+)
+get_access_filter = pydoc.locate(ACCESS_METHOD)()
+
+
+def uuid(prefix: str = None):
+    return f'{prefix or ""}{uuid4().hex}'
+
+
+class ControlledAccessModel:
+    @classmethod
+    def access_by(cls: models.Model, context, manager: str = "objects"):
+        test_mode = (
+            context.get("test_mode")
+            if isinstance(context, dict)
+            else getattr(context, "test_mode", None)
+        )
+
+        if hasattr(cls, "created_by"):
+            key = "created_by"
+        elif hasattr(cls, "actor"):
+            key = "actor"
+        else:
+            key = "user"
+
+        query = get_access_filter(context, key)
+
+        if hasattr(cls, "test_mode") and test_mode is not None:
+            query = query & models.Q(
+                models.Q(test_mode=context.test_mode) | models.Q(test_mode__isnull=True)
+            )
+
+        queryset = getattr(cls, manager, cls.objects)
+
+        return queryset.filter(query)
+
+
+def register_model(model: T) -> T:
+    transform = lambda model, transformer: (
+        model if transformer is None else pydoc.locate(transformer)(model)
+    )
+
+    return functools.reduce(transform, MODEL_TRANSFORMERS, model)
+
+
+class MetafieldType(lib.StrEnum):
+    text = "text"
+    number = "number"
+    boolean = "boolean"
+    json = "json"
+    date = "date"
+    date_time = "date_time"
+    password = "password"
+
+
+METAFIELD_TYPE = [(c.name, c.name) for c in list(MetafieldType)]

karrio/server/core/models/entity.py

@@ -0,0 +1,22 @@
+from django.db import models
+from django.conf import settings
+from karrio.server.core.models.base import uuid, ControlledAccessModel
+
+
+class Entity(models.Model):
+    class Meta:
+        abstract = True
+
+    id = models.CharField(max_length=50, primary_key=True, default=uuid, editable=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.id
+
+
+class OwnedEntity(ControlledAccessModel, Entity):
+    class Meta:
+        abstract = True
+
+    created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)