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

producteca/sales_orders/sales_orders.py

@@ -1,10 +1,15 @@
 from pydantic import BaseModel, Field
 from typing import List, Optional
 import requests
-from ..config.config import ConfigProducteca
+from producteca.abstract.abstract_dataclass import BaseService
+from producteca.sales_orders.search_sale_orders import SearchSalesOrderParams, SearchSalesOrder
+from producteca.payments.payments import Payment
+from producteca.shipments.shipment import Shipment
+from dataclasses import dataclass
 import logging
 _logger = logging.getLogger(__name__)
 
+
 class SaleOrderLocation(BaseModel):
     streetName: Optional[str] = None
     streetNumber: Optional[str] = None
@@ -14,6 +19,7 @@ class SaleOrderLocation(BaseModel):
     neighborhood: Optional[str] = None
     zipCode: Optional[str] = None
 
+
 class SaleOrderBillingInfo(BaseModel):
     docType: Optional[str] = None
     docNumber: Optional[str] = None
@@ -29,11 +35,13 @@ class SaleOrderBillingInfo(BaseModel):
     lastName: Optional[str] = None
     businessName: Optional[str] = None
 
+
 class SaleOrderProfile(BaseModel):
     app: int
     integrationId: str
     nickname: Optional[str] = None
 
+
 class SaleOrderContact(BaseModel):
     id: int
     name: str
@@ -49,15 +57,18 @@ class SaleOrderContact(BaseModel):
     profile: Optional[SaleOrderProfile] = None
     billingInfo: Optional[SaleOrderBillingInfo] = None
 
+
 class SaleOrderIntegrationId(BaseModel):
     alternateId: Optional[str] = None
     integrationId: str
     app: int
 
+
 class SaleOrderVariationPicture(BaseModel):
     url: str
     id: Optional[int] = None
 
+
 class SaleOrderVariationStock(BaseModel):
     warehouseId: Optional[int] = None
     warehouse: str
@@ -66,10 +77,12 @@ class SaleOrderVariationStock(BaseModel):
     lastModified: Optional[str] = None
     available: int
 
+
 class SaleOrderVariationAttribute(BaseModel):
     key: str
     value: str
 
+
 class SaleOrderVariation(BaseModel):
     supplierCode: Optional[str] = None
     pictures: Optional[List[SaleOrderVariationPicture]] = None
@@ -86,15 +99,18 @@ class SaleOrderVariation(BaseModel):
     sku: str
     barcode: Optional[str] = None
 
+
 class SaleOrderProduct(BaseModel):
     name: str
     code: str
     brand: Optional[str] = None
     id: int
 
+
 class SaleOrderConversation(BaseModel):
     questions: Optional[List[str]] = None
 
+
 class SaleOrderLine(BaseModel):
     price: float
     originalPrice: Optional[float] = None
@@ -107,6 +123,7 @@ class SaleOrderLine(BaseModel):
     reserved: Optional[int] = None
     id: int
 
+
 class SaleOrderCard(BaseModel):
     paymentNetwork: Optional[str] = None
     firstSixDigits: Optional[int] = None
@@ -115,10 +132,12 @@ class SaleOrderCard(BaseModel):
     cardholderIdentificationType: Optional[str] = None
     cardholderName: Optional[str] = None
 
+
 class SaleOrderPaymentIntegration(BaseModel):
     integrationId: str
     app: int
 
+
 class SaleOrderPayment(BaseModel):
     date: Optional[str] = None
     amount: float
@@ -134,6 +153,7 @@ class SaleOrderPayment(BaseModel):
     hasCancelableStatus: Optional[bool] = None
     id: Optional[int] = None
 
+
 class SaleOrderShipmentMethod(BaseModel):
     trackingNumber: Optional[str] = None
     trackingUrl: Optional[str] = None
@@ -144,17 +164,20 @@ class SaleOrderShipmentMethod(BaseModel):
     eta: Optional[int] = None
     status: Optional[str] = None
 
+
 class SaleOrderShipmentProduct(BaseModel):
     product: int
     variation: int
     quantity: int
 
+
 class SaleOrderShipmentIntegration(BaseModel):
     app: int
     integrationId: str
     status: str
     id: int
 
+
 class SaleOrderShipment(BaseModel):
     date: str
     products: List[SaleOrderShipmentProduct]
@@ -163,6 +186,7 @@ class SaleOrderShipment(BaseModel):
     receiver: Optional[dict] = None
     id: int
 
+
 class SaleOrderInvoiceIntegration(BaseModel):
     id: Optional[int] = None
     integrationId: Optional[str] = None
@@ -172,6 +196,7 @@ class SaleOrderInvoiceIntegration(BaseModel):
     xmlUrl: Optional[str] = None
     decreaseStock: Optional[bool] = None
 
+
 class SaleOrder(BaseModel):
     tags: Optional[List[str]] = None
     integrations: Optional[List[SaleOrderIntegrationId]] = None
@@ -210,46 +235,114 @@ class SaleOrder(BaseModel):
     notes: Optional[str] = None
     id: int
 
-    @classmethod
-    def get(cls, config: ConfigProducteca, sale_order_id: int) -> "SaleOrder":
-        endpoint = f'salesorders/{sale_order_id}'
-        url = config.get_endpoint(endpoint)
-        response = requests.get(url, headers=config.headers)
-        return cls(**response.json())
-
-    @classmethod
-    def get_shipping_labels(cls, config: ConfigProducteca, sale_order_id: int):
-        endpoint = f'salesorders/{sale_order_id}/labels'
-        url = config.get_endpoint(endpoint)
-        response = requests.get(url, headers=config.headers)
+
+@dataclass
+class SaleOrderService(BaseService[SaleOrder]):
+    endpoint: str = Field(default='salesorders', exclude=True)
+
+    def __call__(self, **payload):
+        self._record = SaleOrder(**payload)
+        return self
+
+    def get(self, sale_order_id: int) -> "SaleOrder":
+        endpoint = f'{self.endpoint}/{sale_order_id}'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.get(url, headers=self.config.headers)
+        if not response.ok:
+            raise Exception("Order could not be fetched")
+        return SaleOrder(**response.json())
+
+    def get_shipping_labels(self):
+        if not self._record:
+            raise Exception("You need to add a record id")
+        endpoint = f'{self.endpoint}/{self._record.id}/labels'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.get(url, headers=self.config.headers)
+        if not response.ok:
+            raise Exception("labels could not be gotten")
         return response.json()
 
-    @classmethod
-    def close(cls, config: ConfigProducteca, sale_order_id: int):
-        endpoint = f'salesorders/{sale_order_id}/close'
-        url = config.get_endpoint(endpoint)
-        response = requests.post(url, headers=config.headers)
-        return response.status_code, response.json()
-
-    @classmethod
-    def cancel(cls, config: ConfigProducteca, sale_order_id: int):
-        endpoint = f'salesorders/{sale_order_id}/cancel'
-        url = config.get_endpoint(endpoint)
-        response = requests.post(url, headers=config.headers)
-        return response.status_code, response.json()
-
-    @classmethod
-    def synchronize(cls, config: ConfigProducteca, payload: "SaleOrder") -> tuple[int, "SaleOrder"]:
-        endpoint = 'salesorders/synchronize'
-        url = config.get_endpoint(endpoint)
-        response = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return response.status_code, cls(**response.json())
-
-    @classmethod
-    def invoice_integration(cls, config: ConfigProducteca, sale_order_id: int, payload: "SaleOrder"):
-        endpoint = f'salesorders/{sale_order_id}/invoiceIntegration'
-        url = config.get_endpoint(endpoint)
-        response = requests.put(url, headers=config.headers, data=payload.model_dump_json(exclude_none=True))
-        if response.status_code == 200:
-            return response.status_code, {}
-        return response.status_code, response.json()
+    def close(self):
+        if not self._record:
+            raise Exception("You need to add a record id")
+        endpoint = f'{self.endpoint}/{self._record.id}/close'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.post(url, headers=self.config.headers)
+        if not response.ok:
+            raise Exception("Order could not be closed")
+
+    def cancel(self):
+        if not self._record:
+            raise Exception("You need to add a record id")
+        endpoint = f'{self.endpoint}/{self._record.id}/cancel'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.post(url, headers=self.config.headers)
+        if not response.ok:
+            raise Exception("Order could not be closed")
+
+    def synchronize(self, payload: "SaleOrder") -> "SaleOrder":
+        endpoint = f'{self.endpoint}/synchronize'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        if not response.ok:
+            raise Exception(f"Synchronize error {response.text}")
+        return SaleOrder(**response.json())
+
+    def invoice_integration(self):
+        if not self._record:
+            raise Exception("You need to add a record id")
+        endpoint = f'{self.endpoint}/{self._record.id}/invoiceIntegration'
+        url = self.config.get_endpoint(endpoint)
+        response = requests.put(url, headers=self.config.headers, data=self._record.model_dump_json(exclude_none=True))
+        if not response.ok:
+            raise Exception(f"Error on resposne {response.text}")
+        return SaleOrder(**response.json())
+
+    def search(self, params: SearchSalesOrderParams):
+        endpoint: str = f"search/{self.endpoint}"
+        headers = self.config.headers
+        url = self.config.get_endpoint(endpoint)
+        new_url = f"{url}?$filter={params.filter}&top={params.top}&skip={params.skip}"
+        response = requests.get(
+            new_url,
+            headers=headers,
+        )
+        if not response.ok:
+            raise Exception(f"Error on resposne {response.text}")
+        return SearchSalesOrder(**response.json())
+
+    def add_payment(self, payload: "Payment") -> "Payment":
+        if not self._record:
+            raise Exception("You need to add a record id")
+        url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/payments")
+        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        if not res.ok:
+            raise Exception(f"Error on resposne {res.text}")
+        return Payment(**res.json())
+
+    def update_payment(self, payment_id: int, payload: "Payment") -> "Payment":
+        if not self._record:
+            raise Exception("You need to add a record id")
+        url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/payments/{payment_id}")
+        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        if not res.ok:
+            raise Exception(f"Error on payment update {res.text}")
+        return Payment(**res.json())
+
+    def add_shipment(self, payload: "Shipment") -> "Shipment":
+        if not self._record:
+            raise Exception("You need to add a record id")
+        url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/shipments")
+        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        if not res.ok:
+            raise Exception(f"Error on shipment add {res.text}")
+        return Shipment(**res.json())
+
+    def update_shipment(self, shipment_id: str, payload: "Shipment") -> "Shipment":
+        if not self._record:
+            raise Exception("You need to add a record id")
+        url = self.config.get_endpoint(f"{self.endpoint}/{self._record.id}/shipments/{shipment_id}")
+        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=self.config.headers)
+        if not res.ok:
+            raise Exception(f"Error on shipment update {res.text}")
+        return Shipment(**res.json())

producteca/sales_orders/search_sale_orders.py

@@ -0,0 +1,152 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class SalesOrderProduct(BaseModel):
+    id: int
+    name: str
+    code: str
+    brand: str
+
+
+class SalesOrderVariationAttribute(BaseModel):
+    key: str
+    value: str
+
+
+class SalesOrderVariation(BaseModel):
+    id: int
+    attributes: List[SalesOrderVariationAttribute]
+    sku: str
+    thumbnail: str
+
+
+class SalesOrderLine(BaseModel):
+    product: SalesOrderProduct
+    variation: SalesOrderVariation
+    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: float = Field(alias="couponAmount")
+    status: str
+    method: str
+    integration: SalesOrderPaymentIntegration
+    transaction_fee: float = Field(alias="transactionFee")
+    installments: int
+    card: SalesOrderCard
+    notes: str
+    has_cancelable_status: bool = Field(alias="hasCancelableStatus")
+    id: int
+
+
+class SalesOrderIntegration(BaseModel):
+    alternate_id: str = Field(alias="alternateId")
+    integration_id: int = Field(alias="integrationId")
+    app: int
+
+
+class SalesOrderShipmentProduct(BaseModel):
+    product: int
+    variation: int
+    quantity: int
+
+
+class SalesOrderShipmentMethod(BaseModel):
+    tracking_number: str = Field(alias="trackingNumber")
+    tracking_url: str = Field(alias="trackingUrl")
+    courier: str
+    mode: str
+    cost: float
+    type: str
+    eta: str
+    status: str
+
+
+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: SalesOrderShipmentIntegration
+
+
+class SalesOrderResultItem(BaseModel):
+    codes: List[str]
+    contact_id: int = Field(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: int = Field(alias="invoiceIntegrationApp")
+    invoice_integration_id: str = Field(alias="invoiceIntegrationId")
+    lines: List[SalesOrderLine]
+    payments: List[SalesOrderPayment]
+    payment_status: str = Field(alias="paymentStatus")
+    payment_term: str = Field(alias="paymentTerm")
+    product_names: List[str] = Field(alias="productNames")
+    reserving_product_ids: str = Field(alias="reservingProductIds")
+    sales_channel: int = Field(alias="salesChannel")
+    shipments: List[SalesOrderShipment]
+    tracking_number: 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: str = Field(alias="contactPhone")
+    brands: List[str]
+    courier: str
+    order_id: int = Field(alias="orderId")
+    updated_at: str = Field(alias="updatedAt")
+    invoice_integration_created_at: str = Field(alias="invoiceIntegrationCreatedAt")
+    invoice_integration_document_url: str = Field(alias="invoiceIntegrationDocumentUrl")
+    has_document_url: bool = Field(alias="hasDocumentUrl")
+    integration_alternate_ids: str = Field(alias="integrationAlternateIds")
+    cart_id: str = Field(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,12 +1,13 @@
 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.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,
@@ -21,7 +22,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 +34,17 @@ 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).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).close()
         mock_post.assert_called_once()
 
     @patch('requests.post')
@@ -56,9 +54,7 @@ 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).cancel()
         mock_post.assert_called_once()
 
     @patch('requests.post')
@@ -69,8 +65,7 @@ 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.synchronize(sale_order)
         self.assertEqual(response.id, self.sale_order_id)
         mock_post.assert_called_once()
 
@@ -86,13 +81,17 @@ class TestSaleOrder(unittest.TestCase):
 
         mock_put.return_value = Mock(
             status_code=200,
-            json=lambda: {}
+            json=lambda: {
+                "id": 1,
+                "integrationId": "test123",
+                "app": 1
+                }
         )
 
-        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(**sale_order.model_dump()).invoice_integration()
+        self.assertIsInstance(response, SaleOrder)
         mock_put.assert_called_once()
 
+
 if __name__ == '__main__':
     unittest.main()