karrio-server-manager 2026.1__py3-none-any.whl → 2026.1.3__py3-none-any.whl

karrio/server/manager/migrations/0075_populate_template_meta.py

@@ -0,0 +1,69 @@
+# Data migration: Transfer labels from Template model to meta.label
+# This ensures backward compatibility by preserving existing template labels
+
+from django.db import migrations
+
+
+def transfer_template_labels(apps, schema_editor):
+    """
+    Transfer label and is_default from Template model to Address/Parcel meta field.
+
+    The Template model (in graph module) stores:
+    - label: The template name
+    - is_default: Whether it's the default template
+    - address: OneToOne FK to Address
+    - parcel: OneToOne FK to Parcel
+
+    We copy these to the meta.label and meta.is_default fields on the related models.
+    Note: Customs templates are not migrated as the Customs model is being removed.
+    """
+    # Get models - Template is in graph module
+    Template = apps.get_model("graph", "Template")
+    Address = apps.get_model("manager", "Address")
+    Parcel = apps.get_model("manager", "Parcel")
+
+    # Process all templates
+    for template in Template.objects.all():
+        # Transfer to Address
+        if template.address_id:
+            try:
+                address = Address.objects.get(pk=template.address_id)
+                meta = address.meta or {}
+                meta["label"] = template.label
+                meta["is_default"] = template.is_default
+                address.meta = meta
+                address.save(update_fields=["meta"])
+            except Address.DoesNotExist:
+                pass
+
+        # Transfer to Parcel
+        if template.parcel_id:
+            try:
+                parcel = Parcel.objects.get(pk=template.parcel_id)
+                meta = parcel.meta or {}
+                meta["label"] = template.label
+                meta["is_default"] = template.is_default
+                parcel.meta = meta
+                parcel.save(update_fields=["meta"])
+            except Parcel.DoesNotExist:
+                pass
+
+
+def reverse_noop(apps, schema_editor):
+    """Reverse migration is a no-op - we don't want to remove labels."""
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("manager", "0074_clean_model_refactoring"),
+        ("graph", "0002_auto_20210512_1353"),  # Ensure Template model exists
+    ]
+
+    operations = [
+        migrations.RunPython(
+            transfer_template_labels,
+            reverse_noop,
+        ),
+    ]

karrio/server/manager/migrations/0076_remove_customs_model.py

@@ -0,0 +1,66 @@
+from django.db import migrations
+
+
+def cleanup_orgs_customs_links(apps, schema_editor):
+    """
+    Clean up any orgs link tables that reference Customs before deleting the model.
+    This handles the case where the database was created in insiders mode but migrations
+    are running in OSS mode.
+
+    In insiders mode, orgs.0024_remove_organization_customs runs first (via run_before)
+    and handles this cleanup properly. This is a fallback for OSS mode with insiders DB.
+    """
+    # Try to get orgs link models and clean them up using Django ORM
+    try:
+        CustomsLink = apps.get_model("orgs", "CustomsLink")
+        CustomsLink.objects.all().delete()
+    except LookupError:
+        # Model not registered - check if table exists using Django introspection
+        connection = schema_editor.connection
+        table_names = connection.introspection.table_names()
+        if "orgs_customslink" in table_names:
+            # Table exists but model isn't registered - use Django's cursor
+            with connection.cursor() as cursor:
+                cursor.execute("DELETE FROM orgs_customslink")
+
+    # Also try to clear any M2M relationship
+    try:
+        Organization = apps.get_model("orgs", "Organization")
+        for org in Organization.objects.all():
+            if hasattr(org, "customs"):
+                org.customs.clear()
+    except LookupError:
+        pass  # Model doesn't exist in OSS mode
+
+
+def noop(apps, schema_editor):
+    """Reverse migration is a no-op since we can't restore deleted links."""
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("manager", "0075_populate_template_meta"),
+        ("graph", "0003_remove_template_customs"),  # Remove template.customs FK first
+        # Note: orgs.0024_remove_organization_customs (insiders) uses run_before to ensure proper ordering
+    ]
+
+    operations = [
+        # Clean up any orgs link tables first (handles insiders DB in OSS mode)
+        migrations.RunPython(cleanup_orgs_customs_links, noop),
+        # Remove M2M relationship first (customs_commodities junction table)
+        migrations.RemoveField(
+            model_name="customs",
+            name="commodities",
+        ),
+        # Remove FK to Address
+        migrations.RemoveField(
+            model_name="customs",
+            name="duty_billing_address",
+        ),
+        # Then delete the model (drops the customs table)
+        migrations.DeleteModel(
+            name="Customs",
+        ),
+    ]

karrio/server/manager/migrations/0077_add_carrier_snapshot_fields.py

@@ -0,0 +1,83 @@
+# Add carrier JSONField to models before data migration
+
+import functools
+import karrio.server.core.utils as utils
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """
+    Step 1: Add carrier JSONField to Pickup, Tracking, DocumentUploadRecord, Manifest, Shipment.
+    Also adds carrier_ids JSONField to Shipment.
+
+    This migration adds the new carrier snapshot fields but does NOT remove the old FK fields yet.
+    The old FK fields are needed by the data migration (0078) to populate the carrier snapshots.
+    """
+
+    dependencies = [
+        ("manager", "0076_remove_customs_model"),
+    ]
+
+    operations = [
+        # Add carrier field to Pickup
+        migrations.AddField(
+            model_name="pickup",
+            name="carrier",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="Carrier snapshot at time of pickup creation",
+            ),
+        ),
+        # Add carrier field to Tracking
+        migrations.AddField(
+            model_name="tracking",
+            name="carrier",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="Carrier snapshot at time of tracker creation",
+            ),
+        ),
+        # Add carrier field to DocumentUploadRecord
+        migrations.AddField(
+            model_name="documentuploadrecord",
+            name="carrier",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="Carrier snapshot at time of document upload",
+            ),
+        ),
+        # Add carrier field to Manifest
+        migrations.AddField(
+            model_name="manifest",
+            name="carrier",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="Carrier snapshot at time of manifest creation",
+            ),
+        ),
+        # Add carrier field to Shipment (consistent with other models)
+        migrations.AddField(
+            model_name="shipment",
+            name="carrier",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="Carrier snapshot at time of label purchase",
+            ),
+        ),
+        # Add carrier_ids field to Shipment
+        migrations.AddField(
+            model_name="shipment",
+            name="carrier_ids",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                default=functools.partial(utils.identity, value=[]),
+                help_text="List of carrier IDs to filter rate requests",
+            ),
+        ),
+    ]

karrio/server/manager/migrations/0078_populate_carrier_snapshots.py

@@ -0,0 +1,112 @@
+# Data migration: Populate carrier JSONField from FK relationships
+
+from django.db import migrations
+
+
+def get_carrier_name(carrier):
+    """Get carrier name from carrier code."""
+    from karrio.core.utils import DP
+
+    try:
+        return DP.to_dict(carrier.data).get("carrier_name", carrier.carrier_code)
+    except Exception:
+        return carrier.carrier_code
+
+
+def create_carrier_snapshot(carrier):
+    """Create carrier snapshot dict from Carrier model instance."""
+    if carrier is None:
+        return None
+
+    return {
+        "connection_id": carrier.id,
+        "connection_type": "account",  # All existing carriers are account connections
+        "carrier_code": carrier.carrier_code,
+        "carrier_id": carrier.carrier_id,
+        "carrier_name": get_carrier_name(carrier),
+        "test_mode": carrier.test_mode,
+    }
+
+
+def populate_carrier_snapshots(apps, schema_editor):
+    """
+    Populate carrier JSONField from FK relationships.
+
+    This copies carrier information from:
+    - Pickup.pickup_carrier -> Pickup.carrier
+    - Tracking.tracking_carrier -> Tracking.carrier
+    - DocumentUploadRecord.upload_carrier -> DocumentUploadRecord.carrier
+    - Manifest.manifest_carrier -> Manifest.carrier
+    - Shipment.selected_rate_carrier -> Shipment.carrier (dedicated field, consistent with other models)
+    """
+    Pickup = apps.get_model("manager", "Pickup")
+    Tracking = apps.get_model("manager", "Tracking")
+    DocumentUploadRecord = apps.get_model("manager", "DocumentUploadRecord")
+    Manifest = apps.get_model("manager", "Manifest")
+    Shipment = apps.get_model("manager", "Shipment")
+
+    # Populate Pickup.carrier from pickup_carrier FK
+    for pickup in Pickup.objects.select_related("pickup_carrier").all():
+        if pickup.pickup_carrier and not pickup.carrier:
+            pickup.carrier = create_carrier_snapshot(pickup.pickup_carrier)
+            pickup.save(update_fields=["carrier"])
+
+    # Populate Tracking.carrier from tracking_carrier FK
+    for tracking in Tracking.objects.select_related("tracking_carrier").all():
+        if tracking.tracking_carrier and not tracking.carrier:
+            tracking.carrier = create_carrier_snapshot(tracking.tracking_carrier)
+            tracking.save(update_fields=["carrier"])
+
+    # Populate DocumentUploadRecord.carrier from upload_carrier FK
+    for record in DocumentUploadRecord.objects.select_related("upload_carrier").all():
+        if record.upload_carrier and not record.carrier:
+            record.carrier = create_carrier_snapshot(record.upload_carrier)
+            record.save(update_fields=["carrier"])
+
+    # Populate Manifest.carrier from manifest_carrier FK
+    for manifest in Manifest.objects.select_related("manifest_carrier").all():
+        if manifest.manifest_carrier and not manifest.carrier:
+            manifest.carrier = create_carrier_snapshot(manifest.manifest_carrier)
+            manifest.save(update_fields=["carrier"])
+
+    # Populate Shipment.carrier from selected_rate_carrier FK (consistent with other models)
+    for shipment in Shipment.objects.select_related("selected_rate_carrier").all():
+        if shipment.selected_rate_carrier and not shipment.carrier:
+            shipment.carrier = create_carrier_snapshot(shipment.selected_rate_carrier)
+            shipment.save(update_fields=["carrier"])
+
+
+def reverse_migration(apps, schema_editor):
+    """
+    Reverse migration: Clear carrier JSONField (data preserved in FKs).
+
+    Note: The FK data is still preserved, so this is safe to reverse.
+    """
+    Pickup = apps.get_model("manager", "Pickup")
+    Tracking = apps.get_model("manager", "Tracking")
+    DocumentUploadRecord = apps.get_model("manager", "DocumentUploadRecord")
+    Manifest = apps.get_model("manager", "Manifest")
+    Shipment = apps.get_model("manager", "Shipment")
+
+    Pickup.objects.update(carrier=None)
+    Tracking.objects.update(carrier=None)
+    DocumentUploadRecord.objects.update(carrier=None)
+    Manifest.objects.update(carrier=None)
+    Shipment.objects.update(carrier=None)
+
+
+class Migration(migrations.Migration):
+    """
+    Step 2: Data migration - Populate carrier snapshots from FK relationships.
+
+    This migration copies carrier information from FK fields to the new JSONField.
+    The FK fields are still preserved at this point.
+    """
+
+    dependencies = [
+        ("manager", "0077_add_carrier_snapshot_fields"),
+    ]
+
+    operations = [
+        migrations.RunPython(populate_carrier_snapshots, reverse_migration),
+    ]

karrio/server/manager/migrations/0079_remove_carrier_fk_fields.py

@@ -0,0 +1,56 @@
+# Cleanup migration: Remove carrier FK/M2M fields after data migration
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    """
+    Step 3: Remove carrier FK/M2M fields after data has been migrated to JSONField.
+
+    This migration removes:
+    - Pickup.pickup_carrier (FK)
+    - Tracking.tracking_carrier (FK)
+    - DocumentUploadRecord.upload_carrier (FK)
+    - Manifest.manifest_carrier (FK)
+    - Shipment.selected_rate_carrier (FK)
+    - Shipment.carriers (M2M)
+
+    All carrier data is now stored in JSONField carrier snapshots.
+    """
+
+    dependencies = [
+        ("manager", "0078_populate_carrier_snapshots"),
+    ]
+
+    operations = [
+        # Remove Pickup.pickup_carrier FK
+        migrations.RemoveField(
+            model_name="pickup",
+            name="pickup_carrier",
+        ),
+        # Remove Tracking.tracking_carrier FK
+        migrations.RemoveField(
+            model_name="tracking",
+            name="tracking_carrier",
+        ),
+        # Remove DocumentUploadRecord.upload_carrier FK
+        migrations.RemoveField(
+            model_name="documentuploadrecord",
+            name="upload_carrier",
+        ),
+        # Remove Manifest.manifest_carrier FK
+        migrations.RemoveField(
+            model_name="manifest",
+            name="manifest_carrier",
+        ),
+        # Remove Shipment.selected_rate_carrier FK
+        migrations.RemoveField(
+            model_name="shipment",
+            name="selected_rate_carrier",
+        ),
+        # Remove Shipment.carriers M2M
+        migrations.RemoveField(
+            model_name="shipment",
+            name="carriers",
+        ),
+    ]

karrio/server/manager/migrations/0080_add_carrier_json_indexes.py

@@ -0,0 +1,137 @@
+# Add indexes on JSONFields for query optimization
+
+import django.db.models as models
+import django.db.models.fields.json as json_fields
+from django.db import migrations, connection
+
+
+def create_gin_indexes(apps, schema_editor):
+    """Create GIN indexes for PostgreSQL only."""
+    if "postgresql" not in connection.vendor:
+        return  # Skip for non-PostgreSQL databases
+
+    with connection.cursor() as cursor:
+        # Shipment GIN indexes
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "shipment_meta_gin_idx"
+            ON "shipments" USING gin ("meta" jsonb_path_ops)
+            WHERE "meta" IS NOT NULL;
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "shipment_options_gin_idx"
+            ON "shipments" USING gin ("options" jsonb_path_ops)
+            WHERE "options" IS NOT NULL;
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "shipment_metadata_gin_idx"
+            ON "shipments" USING gin ("metadata" jsonb_path_ops)
+            WHERE "metadata" IS NOT NULL;
+        """)
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "shipment_recipient_gin_idx"
+            ON "shipments" USING gin ("recipient" jsonb_path_ops)
+            WHERE "recipient" IS NOT NULL;
+        """)
+
+        # Tracking GIN indexes
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "tracking_meta_gin_idx"
+            ON "tracking-status" USING gin ("meta" jsonb_path_ops)
+            WHERE "meta" IS NOT NULL;
+        """)
+
+        # Pickup GIN index
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS "pickup_address_gin_idx"
+            ON "pickups" USING gin ("address" jsonb_path_ops)
+            WHERE "address" IS NOT NULL;
+        """)
+
+
+def drop_gin_indexes(apps, schema_editor):
+    """Drop GIN indexes (reverse migration)."""
+    if "postgresql" not in connection.vendor:
+        return
+
+    with connection.cursor() as cursor:
+        cursor.execute('DROP INDEX IF EXISTS "shipment_meta_gin_idx";')
+        cursor.execute('DROP INDEX IF EXISTS "shipment_options_gin_idx";')
+        cursor.execute('DROP INDEX IF EXISTS "shipment_metadata_gin_idx";')
+        cursor.execute('DROP INDEX IF EXISTS "shipment_recipient_gin_idx";')
+        cursor.execute('DROP INDEX IF EXISTS "tracking_meta_gin_idx";')
+        cursor.execute('DROP INDEX IF EXISTS "pickup_address_gin_idx";')
+
+
+class Migration(migrations.Migration):
+    """
+    Step 4: Add indexes on JSONFields for performance optimization.
+
+    Index Types:
+    1. KeyTextTransform indexes - For exact match queries on specific JSON keys
+       - carrier.carrier_code, carrier.connection_id
+    2. GIN indexes (PostgreSQL only) - For has_key, contains, and varied lookups
+       - meta, options, metadata, recipient fields
+
+    Notes:
+    - PostgreSQL: Full support for both index types
+    - SQLite: KeyTextTransform indexes created but not used; GIN indexes skipped
+    - Conditional indexes avoid indexing NULL values to save space
+    """
+
+    dependencies = [
+        ("manager", "0079_remove_carrier_fk_fields"),
+    ]
+
+    operations = [
+        # ─────────────────────────────────────────────────────────────────
+        # CARRIER SNAPSHOT INDEXES (KeyTextTransform - exact match queries)
+        # ─────────────────────────────────────────────────────────────────
+
+        # Shipment.carrier.carrier_code index
+        # Used by: ShipmentFilters.carrier_filter, ManifestSerializer shipment filter
+        migrations.AddIndex(
+            model_name="shipment",
+            index=models.Index(
+                json_fields.KeyTextTransform("carrier_code", "carrier"),
+                condition=models.Q(carrier__isnull=False),
+                name="shipment_carrier_code_idx",
+            ),
+        ),
+        # Tracking.carrier.carrier_code index
+        # Used by: TrackerFilters.carrier_filter, tracker views
+        migrations.AddIndex(
+            model_name="tracking",
+            index=models.Index(
+                json_fields.KeyTextTransform("carrier_code", "carrier"),
+                condition=models.Q(carrier__isnull=False),
+                name="tracking_carrier_code_idx",
+            ),
+        ),
+        # Tracking.carrier.connection_id index
+        # Used by: CarrierConnection serializer to find related trackers
+        migrations.AddIndex(
+            model_name="tracking",
+            index=models.Index(
+                json_fields.KeyTextTransform("connection_id", "carrier"),
+                condition=models.Q(carrier__isnull=False),
+                name="tracking_connection_id_idx",
+            ),
+        ),
+        # Manifest.carrier.carrier_code index
+        # Used by: ManifestFilters.carrier_filter
+        migrations.AddIndex(
+            model_name="manifest",
+            index=models.Index(
+                json_fields.KeyTextTransform("carrier_code", "carrier"),
+                condition=models.Q(carrier__isnull=False),
+                name="manifest_carrier_code_idx",
+            ),
+        ),
+
+        # ─────────────────────────────────────────────────────────────────
+        # GIN INDEXES (PostgreSQL only - for has_key, contains, text search)
+        # ─────────────────────────────────────────────────────────────────
+        # These indexes support: __has_key, __contains, __icontains on JSON keys
+        # RunPython is used to conditionally create indexes based on DB vendor
+        migrations.RunPython(create_gin_indexes, drop_gin_indexes),
+    ]

karrio/server/manager/migrations/0081_cleanup.py

@@ -0,0 +1,62 @@
+# Generated by Django 5.2.10 on 2026-01-22 14:29
+
+import functools
+import karrio.server.core.utils
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("manager", "0080_add_carrier_json_indexes"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="shipment",
+            name="billing_address",
+            field=models.JSONField(
+                blank=True, help_text="Billing address (embedded JSON)", null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="shipment",
+            name="customs",
+            field=models.JSONField(
+                blank=True, help_text="Customs information (embedded JSON)", null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="shipment",
+            name="parcels",
+            field=models.JSONField(
+                blank=True,
+                default=functools.partial(
+                    karrio.server.core.utils.identity, *(), **{"value": []}
+                ),
+                help_text="Parcels array with nested items (embedded JSON)",
+                null=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="shipment",
+            name="recipient",
+            field=models.JSONField(
+                blank=True, help_text="Recipient address (embedded JSON)", null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="shipment",
+            name="return_address",
+            field=models.JSONField(
+                blank=True, help_text="Return address (embedded JSON)", null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="shipment",
+            name="shipper",
+            field=models.JSONField(
+                blank=True, help_text="Shipper address (embedded JSON)", null=True
+            ),
+        ),
+    ]

karrio/server/manager/migrations/0082_shipment_fees.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.2.10 on 2026-01-29
+# Adds applied_fees field to Shipment for tracking COGS accounting data
+
+import functools
+from django.db import migrations, models
+import karrio.server.core.utils as utils
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("manager", "0081_cleanup"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="shipment",
+            name="applied_fees",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                default=functools.partial(utils.identity, value=[]),
+                help_text="Applied fees for accounting: addons + surcharge COGS values",
+            ),
+        ),
+    ]