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

karrio/server/graph/serializers.py

@@ -68,10 +68,33 @@ class WorkspaceConfigModelSerializer(serializers.ModelSerializer):
 
 @serializers.owned_model_serializer
 class MetafieldModelSerializer(serializers.ModelSerializer):
+    object_type = serializers.CharField(required=False, allow_null=True)
+    object_id = serializers.CharField(required=False, allow_null=True)
+
     class Meta:
         model = core.Metafield
         extra_kwargs = {field: {"read_only": True} for field in ["id"]}
-        exclude = ["created_at", "updated_at", "created_by"]
+        exclude = ["created_at", "updated_at", "created_by", "content_type"]
+
+    def validate(self, data):
+        from django.contrib.contenttypes.models import ContentType
+
+        object_type = data.pop("object_type", None)
+        object_id = data.get("object_id")
+
+        if object_type and object_id:
+            ct = ContentType.objects.filter(model=object_type).first()
+            if not ct:
+                raise serializers.ValidationError(
+                    {"object_type": f"Invalid object type: {object_type}"}
+                )
+            data["content_type"] = ct
+        elif object_type or object_id:
+            raise serializers.ValidationError(
+                "Both object_type and object_id must be provided together"
+            )
+
+        return data
 
 
 @serializers.owned_model_serializer
@@ -98,53 +121,6 @@ class CommodityModelSerializer(serializers.ModelSerializer):
         extra_kwargs = {field: {"read_only": True} for field in ["id", "parent"]}
 
 
-@serializers.owned_model_serializer
-class CustomsModelSerializer(serializers.ModelSerializer):
-    NESTED_FIELDS = ["commodities"]
-
-    incoterm = serializers.CharField(required=False, allow_null=True, allow_blank=True)
-    commodities = serializers.make_fields_optional(CommodityModelSerializer)(
-        many=True, allow_null=True, required=False
-    )
-
-    class Meta:
-        model = manager.Customs
-        exclude = ["created_at", "updated_at", "created_by"]
-        extra_kwargs = {field: {"read_only": True} for field in ["id"]}
-
-    @transaction.atomic
-    def create(self, validated_data: dict, context: dict):
-        data = {
-            name: value
-            for name, value in validated_data.items()
-            if name not in self.NESTED_FIELDS
-        }
-
-        instance = super().create(data)
-
-        serializers.save_many_to_many_data(
-            "commodities",
-            CommodityModelSerializer,
-            instance,
-            payload=validated_data,
-            context=context,
-        )
-
-        return instance
-
-    @transaction.atomic
-    def update(
-        self, instance: manager.Customs, validated_data: dict, **kwargs
-    ) -> manager.Customs:
-        data = {
-            name: value
-            for name, value in validated_data.items()
-            if name not in self.NESTED_FIELDS
-        }
-
-        return super().update(instance, data)
-
-
 @serializers.owned_model_serializer
 class ParcelModelSerializer(validators.PresetSerializer, serializers.ModelSerializer):
     weight_unit = serializers.CharField(
@@ -163,7 +139,6 @@ class ParcelModelSerializer(validators.PresetSerializer, serializers.ModelSerial
 @serializers.owned_model_serializer
 class TemplateModelSerializer(serializers.ModelSerializer):
     address = serializers.make_fields_optional(AddressModelSerializer)(required=False)
-    customs = serializers.make_fields_optional(CustomsModelSerializer)(required=False)
     parcel = serializers.make_fields_optional(ParcelModelSerializer)(required=False)
 
     class Meta:
@@ -181,12 +156,6 @@ class TemplateModelSerializer(serializers.ModelSerializer):
                 payload=validated_data,
                 context=context,
             ),
-            "customs": serializers.save_one_to_one_data(
-                "customs",
-                CustomsModelSerializer,
-                payload=validated_data,
-                context=context,
-            ),
             "parcel": serializers.save_one_to_one_data(
                 "parcel", ParcelModelSerializer, payload=validated_data, context=context
             ),
@@ -203,15 +172,12 @@ class TemplateModelSerializer(serializers.ModelSerializer):
         data = {
             key: value
             for key, value in validated_data.items()
-            if key not in ["address", "customs", "parcel"]
+            if key not in ["address", "parcel"]
         }
 
         serializers.save_one_to_one_data(
             "address", AddressModelSerializer, instance, payload=validated_data
         )
-        serializers.save_one_to_one_data(
-            "customs", CustomsModelSerializer, instance, payload=validated_data
-        )
         serializers.save_one_to_one_data(
             "parcel", ParcelModelSerializer, instance, payload=validated_data
         )

karrio/server/graph/tests/base.py

@@ -52,7 +52,7 @@ class GraphTestCase(BaseAPITestCase):
         self.client.credentials(HTTP_AUTHORIZATION="Token " + self.token.key)
 
         # Setup test carrier connections.
-        self.carrier = providers.Carrier.objects.create(
+        self.carrier = providers.CarrierConnection.objects.create(
             carrier_code="canadapost",
             carrier_id="canadapost",
             test_mode=False,
@@ -65,7 +65,7 @@ class GraphTestCase(BaseAPITestCase):
             ),
             capabilities=["pickup", "rating", "tracking", "shipping"],
         )
-        self.ups_carrier = providers.Carrier.objects.create(
+        self.ups_carrier = providers.CarrierConnection.objects.create(
             carrier_code="ups",
             carrier_id="ups_package",
             test_mode=False,
@@ -77,10 +77,11 @@ class GraphTestCase(BaseAPITestCase):
             ),
             capabilities=["pickup", "rating", "tracking", "shipping"],
         )
-        self.fedex_carrier = providers.Carrier.objects.create(
+        self.fedex_carrier = providers.CarrierConnection.objects.create(
             carrier_code="fedex",
             carrier_id="fedex_express",
             test_mode=False,
+            created_by=self.user,
             credentials=dict(
                 api_key="test",
                 secret_key="password",
@@ -89,13 +90,12 @@ class GraphTestCase(BaseAPITestCase):
                 track_secret_key="password",
             ),
             capabilities=["pickup", "rating", "tracking", "shipping"],
-            is_system=True,
         )
-        self.dhl_carrier = providers.Carrier.objects.create(
+        self.dhl_carrier = providers.CarrierConnection.objects.create(
             carrier_code="dhl_universal",
             carrier_id="dhl_universal",
             test_mode=False,
-            is_system=True,
+            created_by=self.user,
             credentials=dict(
                 consumer_key="test",
                 consumer_secret="password",
@@ -103,6 +103,33 @@ class GraphTestCase(BaseAPITestCase):
             capabilities=["tracking"],
         )
 
+        # Setup system connections for system_connections queries
+        self.dhl_system_connection = providers.SystemConnection.objects.create(
+            carrier_code="dhl_universal",
+            carrier_id="dhl_universal",
+            test_mode=False,
+            active=True,
+            credentials=dict(
+                consumer_key="system_test",
+                consumer_secret="system_password",
+            ),
+            capabilities=["tracking"],
+        )
+        self.fedex_system_connection = providers.SystemConnection.objects.create(
+            carrier_code="fedex",
+            carrier_id="fedex_express",
+            test_mode=False,
+            active=True,
+            credentials=dict(
+                api_key="system_test",
+                secret_key="system_password",
+                account_number="000000",
+                track_api_key="system_test",
+                track_secret_key="system_password",
+            ),
+            capabilities=["pickup", "rating", "tracking", "shipping"],
+        )
+
     def query(
         self,
         query: str,

karrio/server/graph/tests/test_carrier_connections.py

@@ -121,8 +121,8 @@ SYSTEM_CONNECTIONS = {
                 {
                     "node": {
                         "active": True,
-                        "carrier_id": "dhl_universal",
-                        "carrier_name": "dhl_universal",
+                        "carrier_id": "fedex_express",
+                        "carrier_name": "fedex",
                         "id": ANY,
                         "test_mode": False,
                     }
@@ -130,8 +130,8 @@ SYSTEM_CONNECTIONS = {
                 {
                     "node": {
                         "active": True,
-                        "carrier_id": "fedex_express",
-                        "carrier_name": "fedex",
+                        "carrier_id": "dhl_universal",
+                        "carrier_name": "dhl_universal",
                         "id": ANY,
                         "test_mode": False,
                     }
@@ -145,6 +145,35 @@ USER_CONNECTIONS = {
     "data": {
         "user_connections": {
             "edges": [
+                {
+                    "node": {
+                        "active": True,
+                        "carrier_id": "dhl_universal",
+                        "carrier_name": "dhl_universal",
+                        "credentials": {
+                            "consumer_key": "test",
+                            "consumer_secret": "password",
+                        },
+                        "id": ANY,
+                        "test_mode": False,
+                    }
+                },
+                {
+                    "node": {
+                        "active": True,
+                        "carrier_id": "fedex_express",
+                        "carrier_name": "fedex",
+                        "credentials": {
+                            "account_number": "000000",
+                            "api_key": "test",
+                            "secret_key": "password",
+                            "track_api_key": "test",
+                            "track_secret_key": "password",
+                        },
+                        "id": ANY,
+                        "test_mode": False,
+                    }
+                },
                 {
                     "node": {
                         "active": True,

karrio/server/graph/tests/test_pickups.py

@@ -0,0 +1,333 @@
+"""GraphQL pickup query tests following AGENTS.md patterns."""
+
+import karrio.lib as lib
+from karrio.server.graph.tests.base import GraphTestCase
+from karrio.server.core.utils import create_carrier_snapshot
+import karrio.server.manager.models as models
+
+
+class TestPickupQueries(GraphTestCase):
+    def setUp(self):
+        super().setUp()
+        self.maxDiff = None
+
+        # Create a shipment for the pickup
+        self.shipment = models.Shipment.objects.create(
+            shipper={
+                "postal_code": "E1C4Z8",
+                "city": "Moncton",
+                "person_name": "John Doe",
+                "company_name": "A corp.",
+                "country_code": "CA",
+                "phone_number": "514 000 0000",
+                "state_code": "NB",
+                "address_line1": "125 Church St",
+            },
+            recipient={
+                "postal_code": "V6M2V9",
+                "city": "Vancouver",
+                "person_name": "Jane Doe",
+                "company_name": "B corp.",
+                "country_code": "CA",
+                "phone_number": "604 000 0000",
+                "state_code": "BC",
+                "address_line1": "5840 Oak St",
+            },
+            parcels=[
+                {
+                    "weight": 1.0,
+                    "weight_unit": "KG",
+                    "package_preset": "canadapost_corrugated_small_box",
+                }
+            ],
+            created_by=self.user,
+            test_mode=False,
+            tracking_number="123456789012",
+            carrier=create_carrier_snapshot(self.carrier),
+        )
+
+        # Create test pickup (test_mode must match token's test_mode)
+        self.pickup = models.Pickup.objects.create(
+            address={
+                "id": "adr_001122334455",
+                "postal_code": "E1C4Z8",
+                "city": "Moncton",
+                "person_name": "John Poop",
+                "company_name": "A corp.",
+                "country_code": "CA",
+                "phone_number": "514 000 0000",
+                "state_code": "NB",
+                "address_line1": "125 Church St",
+            },
+            carrier=create_carrier_snapshot(self.carrier),
+            created_by=self.user,
+            test_mode=False,
+            pickup_date="2020-10-25",
+            ready_time="13:00",
+            closing_time="17:00",
+            instruction="Should not be folded",
+            package_location="At the main entrance hall",
+            confirmation_number="00110215",
+            pickup_charge={"name": "Pickup fees", "amount": 0.0, "currency": "CAD"},
+        )
+        self.pickup.shipments.set([self.shipment])
+
+    def test_query_pickup(self):
+        """Verify single pickup query."""
+        response = self.query(
+            """
+            query get_pickup($id: String!) {
+                pickup(id: $id) {
+                    id
+                    object_type
+                    confirmation_number
+                    pickup_date
+                    ready_time
+                    closing_time
+                    carrier_name
+                    carrier_id
+                    test_mode
+                }
+            }
+            """,
+            operation_name="get_pickup",
+            variables={"id": self.pickup.id},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(
+            lib.to_dict(response.data),
+            {
+                "data": {
+                    "pickup": {
+                        "id": self.pickup.id,
+                        "object_type": "pickup",
+                        "confirmation_number": "00110215",
+                        "pickup_date": "2020-10-25",
+                        "ready_time": "13:00",
+                        "closing_time": "17:00",
+                        "carrier_name": "canadapost",
+                        "carrier_id": "canadapost",
+                        "test_mode": False,
+                    }
+                }
+            },
+        )
+
+    def test_query_pickup_with_address(self):
+        """Verify pickup query includes address."""
+        response = self.query(
+            """
+            query get_pickup($id: String!) {
+                pickup(id: $id) {
+                    id
+                    address {
+                        city
+                        country_code
+                        postal_code
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickup",
+            variables={"id": self.pickup.id},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(
+            response.data["data"]["pickup"]["address"]["city"],
+            "Moncton",
+        )
+        self.assertEqual(
+            response.data["data"]["pickup"]["address"]["country_code"],
+            "CA",
+        )
+
+    def test_query_pickup_with_tracking_numbers(self):
+        """Verify pickup query includes tracking numbers from shipments."""
+        response = self.query(
+            """
+            query get_pickup($id: String!) {
+                pickup(id: $id) {
+                    id
+                    tracking_numbers
+                }
+            }
+            """,
+            operation_name="get_pickup",
+            variables={"id": self.pickup.id},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(
+            response.data["data"]["pickup"]["tracking_numbers"],
+            ["123456789012"],
+        )
+
+    def test_query_pickups_list(self):
+        """Verify pickup list query with pagination."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    page_info {
+                        count
+                        has_next_page
+                    }
+                    edges {
+                        node {
+                            id
+                            confirmation_number
+                            carrier_name
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={"filter": {"first": 20, "offset": 0}},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(response.data["data"]["pickups"]["page_info"]["count"], 1)
+        self.assertEqual(
+            response.data["data"]["pickups"]["edges"][0]["node"]["confirmation_number"],
+            "00110215",
+        )
+
+    def test_query_pickups_filter_by_carrier(self):
+        """Verify pickup filtering by carrier_name."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    edges {
+                        node {
+                            id
+                            carrier_name
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={"filter": {"carrier_name": ["canadapost"]}},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(len(response.data["data"]["pickups"]["edges"]), 1)
+
+    def test_query_pickups_filter_by_carrier_no_match(self):
+        """Verify pickup filtering with non-matching carrier returns empty."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    edges {
+                        node {
+                            id
+                            carrier_name
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={"filter": {"carrier_name": ["ups"]}},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(len(response.data["data"]["pickups"]["edges"]), 0)
+
+    def test_query_pickups_filter_by_confirmation_number(self):
+        """Verify pickup filtering by confirmation_number."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    edges {
+                        node {
+                            id
+                            confirmation_number
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={"filter": {"confirmation_number": "00110215"}},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(len(response.data["data"]["pickups"]["edges"]), 1)
+
+    def test_query_pickups_filter_by_date_range(self):
+        """Verify pickup filtering by date range."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    edges {
+                        node {
+                            id
+                            pickup_date
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={
+                "filter": {
+                    "pickup_date_after": "2020-10-01",
+                    "pickup_date_before": "2020-10-31",
+                }
+            },
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(len(response.data["data"]["pickups"]["edges"]), 1)
+
+    def test_query_pickups_filter_by_date_range_no_match(self):
+        """Verify pickup filtering with date range outside returns empty."""
+        response = self.query(
+            """
+            query get_pickups($filter: PickupFilter) {
+                pickups(filter: $filter) {
+                    edges {
+                        node {
+                            id
+                            pickup_date
+                        }
+                    }
+                }
+            }
+            """,
+            operation_name="get_pickups",
+            variables={
+                "filter": {
+                    "pickup_date_after": "2021-01-01",
+                    "pickup_date_before": "2021-12-31",
+                }
+            },
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertEqual(len(response.data["data"]["pickups"]["edges"]), 0)
+
+    def test_query_pickup_not_found(self):
+        """Verify querying non-existent pickup returns null."""
+        response = self.query(
+            """
+            query get_pickup($id: String!) {
+                pickup(id: $id) {
+                    id
+                }
+            }
+            """,
+            operation_name="get_pickup",
+            variables={"id": "pck_nonexistent"},
+        )
+
+        self.assertResponseNoErrors(response)
+        self.assertIsNone(response.data["data"]["pickup"])

karrio/server/graph/tests/test_rate_sheets.py

@@ -124,7 +124,6 @@ class TestRateSheets(GraphTestCase):
         )
         response_data = response.data
 
-        print(response)  # Debug print as per AGENTS.md guidelines
         self.assertResponseNoErrors(response)
         self.assertDictEqual(
             lib.to_dict(response_data, clear_empty=False),