producteca 1.0.14__py3-none-any.whl → 2.0.57__py3-none-any.whl

producteca/sales_orders/search_sale_orders.py

@@ -0,0 +1,152 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class SalesOrderProduct(BaseModel):
+    id: int
+    name: str
+    code: Optional[str] = None
+    brand: Optional[str] = None
+
+
+class SalesOrderVariationAttribute(BaseModel):
+    key: Optional[str] = None
+    value: Optional[str] = None
+
+
+class SalesOrderVariation(BaseModel):
+    id: int
+    attributes: Optional[List[SalesOrderVariationAttribute]] = None
+    sku: Optional[str] = None
+    thumbnail: Optional[str] = None
+
+
+class SalesOrderLine(BaseModel):
+    product: SalesOrderProduct
+    variation: Optional[SalesOrderVariation] = None
+    quantity: int
+    price: float
+
+
+class SalesOrderCard(BaseModel):
+    payment_network: str = Field(alias="paymentNetwork")
+    first_six_digits: int = Field(alias="firstSixDigits")
+    last_four_digits: int = Field(alias="lastFourDigits")
+    cardholder_identification_number: str = Field(alias="cardholderIdentificationNumber")
+    cardholder_identification_type: str = Field(alias="cardholderIdentificationType")
+    cardholder_name: str = Field(alias="cardholderName")
+
+
+class SalesOrderPaymentIntegration(BaseModel):
+    integration_id: str = Field(alias="integrationId")
+    app: int
+
+
+class SalesOrderPayment(BaseModel):
+    date: str
+    amount: float
+    coupon_amount: Optional[float] = Field(default=None, alias="couponAmount")
+    status: Optional[str] = None
+    method: str
+    integration: Optional[SalesOrderPaymentIntegration] = None
+    transaction_fee: Optional[float] = Field(default=None, alias="transactionFee")
+    installments: Optional[int] = None
+    card: Optional[SalesOrderCard] = None
+    notes: Optional[str] = None
+    has_cancelable_status: Optional[bool] = Field(default=None, alias="hasCancelableStatus")
+    id: int
+
+
+class SalesOrderIntegration(BaseModel):
+    alternate_id: Optional[str] = Field(default=None, alias="alternateId")
+    integration_id: Union[str, int] = Field(alias="integrationId")
+    app: int
+
+
+class SalesOrderShipmentProduct(BaseModel):
+    product: int
+    variation: int
+    quantity: int
+
+
+class SalesOrderShipmentMethod(BaseModel):
+    tracking_number: Optional[str] = Field(alias="trackingNumber")
+    tracking_url: Optional[str] = Field(alias="trackingUrl")
+    courier: Optional[str] = None
+    mode: Optional[str] = None
+    cost: Optional[float] = None
+    type: Optional[str] = None
+    eta: Optional[Union[int, str]] = Field(None)
+    status: Optional[str] = None
+
+
+class SalesOrderShipmentIntegration(BaseModel):
+    id: int
+    integration_id: str = Field(alias="integrationId")
+    app: int
+    status: str
+
+
+class SalesOrderShipment(BaseModel):
+    date: str
+    products: List[SalesOrderShipmentProduct]
+    method: SalesOrderShipmentMethod
+    integration: Optional[SalesOrderShipmentIntegration] = None
+
+
+class SalesOrderResultItem(BaseModel):
+    codes: List[str]
+    contact_id: Optional[int] = Field(default=None, alias="contactId")
+    currency: str
+    date: str
+    delivery_method: str = Field(alias="deliveryMethod")
+    delivery_status: str = Field(alias="deliveryStatus")
+    id: str
+    integration_ids: List[str] = Field(alias="integrationIds")
+    integrations: List[SalesOrderIntegration]
+    invoice_integration_app: Optional[int] = Field(default=None, alias="invoiceIntegrationApp")
+    invoice_integration_id: Optional[str] = Field(default=None, alias="invoiceIntegrationId")
+    lines: List[SalesOrderLine]
+    payments: Optional[List[SalesOrderPayment]] = None
+    payment_status: str = Field(alias="paymentStatus")
+    payment_term: str = Field(alias="paymentTerm")
+    product_names: List[str] = Field(alias="productNames")
+    reserving_product_ids: Union[str, List[str]] = Field(alias="reservingProductIds")
+    sales_channel: int = Field(alias="salesChannel")
+    shipments: Optional[List[SalesOrderShipment]] = None
+    tracking_number: Optional[str] = Field(alias="trackingNumber")
+    skus: List[str]
+    status: str
+    tags: List[str]
+    warehouse: str
+    company_id: int = Field(alias="companyId")
+    shipping_cost: float = Field(alias="shippingCost")
+    contact_phone: Optional[str] = Field(default=None, alias="contactPhone")
+    brands: List[str]
+    courier: Optional[str] = None
+    order_id: int = Field(alias="orderId")
+    updated_at: str = Field(alias="updatedAt")
+    invoice_integration_created_at: Optional[str] = Field(default=None, alias="invoiceIntegrationCreatedAt")
+    invoice_integration_document_url: Optional[str] = Field(default=None, alias="invoiceIntegrationDocumentUrl")
+    has_document_url: bool = Field(alias="hasDocumentUrl")
+    integration_alternate_ids: Union[str, List[str]] = Field(alias="integrationAlternateIds")
+    cart_id: Optional[str] = Field(default=None, alias="cartId")
+    amount: float
+    has_any_shipments: bool = Field(alias="hasAnyShipments")
+
+
+class SearchSalesOrder(BaseModel):
+    count: int
+    results: List[SalesOrderResultItem]
+
+
+class SearchSalesOrderParams(BaseModel):
+    top: Optional[int]
+    skip: Optional[int]
+    filter: Optional[str] = Field(default=None, alias="$filter")
+
+    class Config:
+        validate_by_name = True

producteca/sales_orders/tests/search.json

@@ -0,0 +1,137 @@
+{
+    "count": 0,
+    "results": [
+      {
+        "codes": [
+          "string"
+        ],
+        "contactId": 0,
+        "currency": "Local",
+        "date": "string",
+        "deliveryMethod": "ToBeConfirmed",
+        "deliveryStatus": "ToBeConfirmed",
+        "id": "string",
+        "integrationIds": [
+          "string"
+        ],
+        "integrations": [
+          {
+            "alternateId": "string",
+            "integrationId": 0,
+            "app": 0
+          }
+        ],
+        "invoiceIntegrationApp": 0,
+        "invoiceIntegrationId": "string",
+        "lines": [
+          {
+            "product": {
+              "id": 0,
+              "name": "string",
+              "code": "string",
+              "brand": "string"
+            },
+            "variation": {
+              "id": 0,
+              "attributes": [
+                {
+                  "key": "string",
+                  "value": "string"
+                }
+              ],
+              "sku": "string",
+              "thumbnail": "string"
+            },
+            "quantity": 0,
+            "price": 0
+          }
+        ],
+        "payments": [
+          {
+            "date": "string",
+            "amount": 0,
+            "couponAmount": 0,
+            "status": "Pending",
+            "method": "Cash",
+            "integration": {
+              "integrationId": "string",
+              "app": 249
+            },
+            "transactionFee": 0,
+            "installments": 0,
+            "card": {
+              "paymentNetwork": "string",
+              "firstSixDigits": 0,
+              "lastFourDigits": 0,
+              "cardholderIdentificationNumber": "string",
+              "cardholderIdentificationType": "string",
+              "cardholderName": "string"
+            },
+            "notes": "string",
+            "hasCancelableStatus": true,
+            "id": 0
+          }
+        ],
+        "paymentStatus": "Pending",
+        "paymentTerm": "Advance",
+        "productNames": [
+          "string"
+        ],
+        "reservingProductIds": "string",
+        "salesChannel": 0,
+        "shipments": [
+          {
+            "date": "string",
+            "products": [
+              {
+                "product": 0,
+                "variation": 0,
+                "quantity": 0
+              }
+            ],
+            "method": {
+              "trackingNumber": "string",
+              "trackingUrl": "string",
+              "courier": "string",
+              "mode": "string",
+              "cost": 0,
+              "type": "Ship",
+              "eta": "string",
+              "status": "PickingPending"
+            },
+            "integration": {
+              "id": 0,
+              "integrationId": "string",
+              "app": 0,
+              "status": "NotAvailable"
+            }
+          }
+        ],
+        "trackingNumber": "string",
+        "skus": [
+          "string"
+        ],
+        "status": "Pending",
+        "tags": [
+          "string"
+        ],
+        "warehouse": "string",
+        "companyId": 0,
+        "shippingCost": 0,
+        "contactPhone": "string",
+        "brands": [
+          "string"
+        ],
+        "courier": "string",
+        "orderId": 0,
+        "updatedAt": "string",
+        "invoiceIntegrationCreatedAt": "string",
+        "invoiceIntegrationDocumentUrl": "string",
+        "hasDocumentUrl": true,
+        "integrationAlternateIds": "string",
+        "cartId": "string",
+        "amount": 0,
+        "hasAnyShipments": true
+      }
+    ]
+  }

producteca/sales_orders/tests/test_sales_orders.py

@@ -1,17 +1,25 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.sales_orders.sales_orders import SaleOrder, SaleOrderInvoiceIntegration
+from producteca.sales_orders.sales_orders import SaleOrder
+from producteca.client import ProductecaClient
 
 
 class TestSaleOrder(unittest.TestCase):
+
     def setUp(self):
-        self.config = ConfigProducteca(token="test_client", api_key="test_secret")
+        self.client = ProductecaClient(token="test_client", api_key="test_secret")
         self.sale_order_id = 123
         self.mock_response = {
             "id": self.sale_order_id,
             "contact": {"id": 1, "name": "Test Contact"},
-            "lines": []
+            "lines": [],
+            "invoiceIntegration": {
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True
+            }
         }
 
     @patch('requests.get')
@@ -21,7 +29,7 @@ class TestSaleOrder(unittest.TestCase):
             json=lambda: self.mock_response
         )
 
-        sale_order = SaleOrder.get(self.config, self.sale_order_id)
+        sale_order = self.client.SalesOrder.get(self.sale_order_id)
         self.assertEqual(sale_order.id, self.sale_order_id)
         mock_get.assert_called_once()
 
@@ -33,20 +41,33 @@ class TestSaleOrder(unittest.TestCase):
             json=lambda: mock_labels
         )
 
-        labels = SaleOrder.get_shipping_labels(self.config, self.sale_order_id)
+        labels = self.client.SalesOrder(id=1234, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).get_shipping_labels()
         self.assertEqual(labels, mock_labels)
         mock_get.assert_called_once()
 
     @patch('requests.post')
     def test_close_sale_order(self, mock_post):
         mock_post.return_value = Mock(
-            status_code=200,
-            json=lambda: {"status": "closed"}
+            status_code=200
         )
 
-        status_code, response = SaleOrder.close(self.config, self.sale_order_id)
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response, {"status": "closed"})
+        self.client.SalesOrder(id=1234, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).close()
         mock_post.assert_called_once()
 
     @patch('requests.post')
@@ -56,9 +77,15 @@ class TestSaleOrder(unittest.TestCase):
             json=lambda: {"status": "cancelled"}
         )
 
-        status_code, response = SaleOrder.cancel(self.config, self.sale_order_id)
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response, {"status": "cancelled"})
+        self.client.SalesOrder(id=1234, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).cancel()
         mock_post.assert_called_once()
 
     @patch('requests.post')
@@ -69,30 +96,32 @@ class TestSaleOrder(unittest.TestCase):
             json=lambda: self.mock_response
         )
 
-        status_code, response = SaleOrder.synchronize(self.config, sale_order)
-        self.assertEqual(status_code, 200)
+        response = self.client.SalesOrder(**sale_order.model_dump(by_alias=True)).synchronize()
         self.assertEqual(response.id, self.sale_order_id)
         mock_post.assert_called_once()
 
     @patch('requests.put')
     def test_invoice_integration(self, mock_put):
         invoice_data = {
-            "id": 1,
-            "integrationId": "test123",
-            "app": 1
-        }
-        invoice_integration = SaleOrderInvoiceIntegration(**invoice_data)
-        sale_order = SaleOrder(id=self.sale_order_id, invoiceIntegration=invoice_integration)
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }
 
         mock_put.return_value = Mock(
             status_code=200,
-            json=lambda: {}
+            json=lambda: invoice_data,
+            ok=True
         )
 
-        status_code, response = SaleOrder.invoice_integration(self.config, self.sale_order_id, sale_order)
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response, {})
+        response = self.client.SalesOrder(id=self.sale_order_id, invoiceIntegration=invoice_data).invoice_integration()
+        self.assertTrue(response)
         mock_put.assert_called_once()
 
+
 if __name__ == '__main__':
     unittest.main()

producteca/sales_orders/tests/test_search_so.py

@@ -0,0 +1,46 @@
+import unittest
+import json
+from unittest.mock import patch, Mock
+from producteca.sales_orders.search_sale_orders import SearchSalesOrderParams, SalesOrderResultItem
+from producteca.client import ProductecaClient
+
+
+class TestSearchSalesOrder(unittest.TestCase):
+
+    def setUp(self):
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
+        self.params = SearchSalesOrderParams(
+            top=10,
+            skip=0,
+            filter="status eq 'confirmed'"
+        )
+
+    @patch('requests.get')
+    def test_search_saleorder_success(self, mock_get):
+        # Mock successful response
+        mock_response = Mock()
+        with open('producteca/sales_orders/tests/search.json', 'r') as f:
+            results = json.loads(f.read())
+            mock_response.json.return_value = results
+            mock_response.status_code = 200
+            mock_get.return_value = mock_response
+
+        response = self.client.SalesOrder.search(self.params)
+
+        self.assertEqual(response.count, 0)
+        self.assertEqual(len(response.results), 1)
+        self.assertEqual(response.results[0].id, "string")
+        self.assertIsInstance(response.results[0], SalesOrderResultItem)
+
+    @patch('requests.get')
+    def test_search_saleorder_error(self, mock_get):
+        mock_response = Mock()
+        mock_response.json.return_value = {"error": "Invalid request"}
+        mock_response.status_code = 400
+        mock_get.return_value = mock_response
+        with self.assertRaises(Exception):
+            self.client.SalesOrder.search(self.params)
+
+
+if __name__ == '__main__':
+    unittest.main()

producteca/shipments/shipment.py

@@ -1,7 +1,5 @@
 from typing import List, Optional
 from pydantic import BaseModel
-import requests
-from ..config.config import ConfigProducteca
 
 
 class ShipmentProduct(BaseModel):
@@ -33,15 +31,3 @@ class Shipment(BaseModel):
     products: Optional[List[ShipmentProduct]] = None
     method: Optional[ShipmentMethod] = None
     integration: Optional[ShipmentIntegration] = None
-
-    @classmethod
-    def create(cls, config: ConfigProducteca, sale_order_id: int, payload: "Shipment") -> "Shipment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/shipments")
-        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return res.status_code, res.json()
-
-    @classmethod
-    def update(cls, config: ConfigProducteca, sale_order_id: int, shipment_id: str, payload: "Shipment") -> "Shipment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/shipments/{shipment_id}")
-        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return res.status_code, res.json()

producteca/shipments/tests/test_shipment.py

@@ -1,57 +1,62 @@
 import unittest
 from unittest.mock import patch, MagicMock
-from producteca.shipments.shipment import Shipment, ShipmentProduct, ShipmentMethod, ShipmentIntegration, ConfigProducteca
+from producteca.shipments.shipment import Shipment, ShipmentProduct, ShipmentMethod, ShipmentIntegration
+from producteca.client import ProductecaClient
 
 
 class TestShipment(unittest.TestCase):
-
+    def setUp(self):
+        self.client = ProductecaClient(token="test_id", api_key="test_secret")
+        
     @patch('requests.post')
     def test_create_shipment(self, mock_post):
         # Arrange
-        config = ConfigProducteca(token="test_token", api_key="as")
-        sale_order_id = 123
         products = [ShipmentProduct(product=1, variation=2, quantity=3)]
         method = ShipmentMethod(trackingNumber="TN123", trackingUrl="http://track.url", courier="DHL", mode="air", cost=10.5, type="express", eta=5, status="shipped")
         integration = ShipmentIntegration(id=1, integrationId="int123", app=10, status="active")
-        payload = Shipment(date="2023-01-01", products=products, method=method, integration=integration)
+        payload = Shipment(date="2023-01-01", products=products, method=method, integration=integration).model_dump(by_alias=True)
 
         mock_response = MagicMock()
         mock_response.status_code = 201
-        mock_response.json.return_value = {'success': True}
+        mock_response.json.return_value = payload
         mock_post.return_value = mock_response
-
         # Act
-        status_code, response_json = Shipment.create(config, sale_order_id, payload)
-
-        # Assert
-        self.assertEqual(status_code, 201)
-        self.assertEqual(response_json, {'success': True})
+        shipment = self.client.SalesOrder(id=1234, invoiceIntegration={
+            'id': 1,
+            'integrationId': 'test-integration',
+            'app': 1,
+            'createdAt': '2023-01-01',
+            'decreaseStock': True
+        }).add_shipment(payload)
+
+        self.assertIsInstance(shipment, Shipment)
         mock_post.assert_called_once()
 
     @patch('requests.put')
     def test_update_shipment(self, mock_put):
         # Arrange
-        config = ConfigProducteca(token="test_token", api_key="as")
-        sale_order_id = 123
         shipment_id = 'abc'
         products = [ShipmentProduct(product=4, quantity=7)]
         method = ShipmentMethod(courier="FedEx", cost=15.0)
         integration = ShipmentIntegration(status="pending")
-        payload = Shipment(date="2023-02-02", products=products, method=method, integration=integration)
+        payload = Shipment(date="2023-02-02", products=products, method=method, integration=integration).model_dump(by_alias=True)
 
         mock_response = MagicMock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {'updated': True}
+        mock_response.json.return_value = payload
         mock_put.return_value = mock_response
-
         # Act
-        status_code, response_json = Shipment.update(config, sale_order_id, shipment_id, payload)
-
-        # Assert
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response_json, {'updated': True})
+        shipment = self.client.SalesOrder(id=1234, invoiceIntegration={
+            'id': 1,
+            'integrationId': 'test-integration',
+            'app': 1,
+            'createdAt': '2023-01-01',
+            'decreaseStock': True
+        }).update_shipment(shipment_id, payload)
+
+        self.assertIsInstance(shipment, Shipment)
         mock_put.assert_called_once()
 
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

producteca/utils.py

@@ -0,0 +1,50 @@
+"""
+Utility functions for the producteca package
+"""
+from typing import Any, Dict, List, Union
+from pydantic import BaseModel
+
+
+def exclude_empty_values(obj: Any) -> Any:
+    """Recursively remove None, empty lists, empty strings, and empty dicts
+    
+    Note: Preserves 0 values for numeric fields as they are valid prices/quantities
+    Special case: Preserves empty list [] for 'updatableProperties' to allow explicit updates
+    """
+    if isinstance(obj, dict):
+        filtered_dict = {}
+        for k, v in obj.items():
+            # Special case: preserve empty list for updatableProperties
+            # This allows explicitly sending [] to clear/update the field
+            if k == 'updatableProperties' and v == []:
+                filtered_dict[k] = v
+                continue
+            
+            # Skip None, empty lists, empty strings, empty dicts
+            if v is None or v == [] or v == "" or v == {}:
+                continue
+            # Keep numeric 0 values - they are valid for prices, quantities, etc.
+            filtered_dict[k] = exclude_empty_values(v)
+        return filtered_dict
+    elif isinstance(obj, list):
+        filtered_list = [exclude_empty_values(item) for item in obj if item is not None]
+        return [item for item in filtered_list if item != [] and item != "" and item != {}]
+    else:
+        return obj
+
+
+def clean_model_dump(model: BaseModel, by_alias: bool = True, exclude_none: bool = True, **kwargs) -> Dict[str, Any]:
+    """
+    Enhanced model_dump that automatically cleans empty values
+    
+    Args:
+        model: Pydantic model instance
+        by_alias: Use field aliases in output
+        exclude_none: Exclude None values
+        **kwargs: Additional arguments to pass to model_dump
+    
+    Returns:
+        Clean dictionary with empty values removed
+    """
+    raw_data = model.model_dump(by_alias=by_alias, exclude_none=exclude_none, **kwargs)
+    return exclude_empty_values(raw_data)