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

producteca/products/search_products.py

@@ -0,0 +1,136 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field
+
+
+class FacetValue(BaseModel):
+    count: int
+    value: Optional[Union[str, bool]] = None
+    label: Union[str, bool]
+
+
+class Facet(BaseModel):
+    key: str
+    value: List[FacetValue]
+    is_collection: Optional[bool] = False
+    translate: bool
+
+
+class SearchStocks(BaseModel):
+    warehouse: str
+    quantity: int
+    reserved: int
+
+
+class SearchPrices(BaseModel):
+    price_list_id: int = Field(..., alias='priceListId')
+    price_list: str = Field(..., alias='priceList') 
+    amount: float
+    currency: str
+
+
+class SearchIntegration(BaseModel):
+    app: Optional[int] = None
+    integration_id: Optional[str] = Field(None, alias='integrationId')
+    permalink: Optional[str] = None
+    status: Optional[str] = None
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    safety_stock: Optional[int] = Field(None, alias='safetyStock')
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    is_active: Optional[bool] = Field(None, alias='isActive')
+    is_active_or_paused: Optional[bool] = Field(None, alias='isActiveOrPaused')
+    id: Optional[int] = None
+
+
+class SearchDeals(BaseModel):
+    campaign: str
+    product: int
+    variation: str
+    deal_price: float
+    discount: float
+    regular_price: float
+    enabled: bool
+    currency: str
+    id: str
+
+
+class SearchResultItem(BaseModel):
+    search_score: float = Field(..., alias='@search.score')
+    id: int
+    product_id: Optional[int] = Field(None, alias='productId')
+    company_id: Optional[int] = Field(None, alias='companyId')
+    name:Optional[str] = None
+    code: Optional[str] = None
+    skus: List[str]
+    brand: Optional[str] = None
+    category: Optional[str] = None
+    thumbnail: Optional[str] = None
+    stocks: Optional[Union[List[SearchStocks], List]] = None
+    warehouses_with_stock: Optional[List[str]] = Field(None, alias='warehousesWithStock')
+    total_stock: Optional[int] = Field(None, alias='totalStock')
+    has_pictures: Optional[bool] = Field(None, alias='hasPictures')
+    buying_price: Optional[float] = Field(None, alias='buyingPrice')
+    prices: Optional[Union[List[SearchPrices], List]] = None
+    integration_ids: Optional[List[str]] = Field(None, alias='integrationIds')
+    integration_apps: Optional[List[str]] = Field(None, alias='integrationApps')
+    integrations: Optional[Union[List[SearchIntegration], List]] = None
+    campaigns: Optional[List[str]] = None
+    app: Optional[int] = None
+    status: Optional[str] = None
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    price_amount: Optional[float] = Field(None, alias='priceAmount')
+    price_currency: Optional[str] = Field(None, alias='priceCurrency')
+    category_id: Optional[str] = Field(None, alias='categoryId')
+    category_base_id: Optional[str] = Field(None, alias='categoryBaseId')
+    category_l1: Optional[str] = Field(None, alias='categoryL1')
+    category_l2: Optional[str] = Field(None, alias='categoryL2')
+    category_l3: Optional[str] = Field(None, alias='categoryL3')
+    category_l4: Optional[str] = Field(None, alias='categoryL4')
+    category_l5: Optional[str] = Field(None, alias='categoryL5')
+    category_l6: Optional[str] = Field(None, alias='categoryL6')
+    has_category: Optional[bool] = Field(None, alias='hasCategory')
+    category_fixed: Optional[bool] = Field(None, alias='categoryFixed')
+    accepts_mercadoenvios: Optional[bool] = Field(None, alias='acceptsMercadoenvios')
+    shipping_mode: Optional[str] = Field(None, alias='shippingMode')
+    local_pickup: Optional[bool] = Field(None, alias='localPickup')
+    mandatory_free_shipping: Optional[bool] = Field(None, alias='mandatoryFreeShipping')
+    free_shipping: Optional[bool] = Field(None, alias='freeShipping')
+    free_shipping_cost: Optional[float] = Field(None, alias='freeShippingCost')
+    template: Optional[int] = None
+    youtube_id: Optional[str] = Field(None, alias='youtubeId')
+    warranty: Optional[str] = None
+    permalink: Optional[str] = None
+    domain: Optional[str] = None
+    attribute_completion_status: Optional[str] = Field(None, alias='attributeCompletionStatus')
+    attribute_completion_count: Optional[int] = Field(None, alias='attributeCompletionCount')
+    attribute_completion_total: Optional[int] = Field(None, alias='attributeCompletionTotal')
+    deals: Optional[Union[SearchDeals, List]] = None
+    campaign_status: Optional[List[str]] = Field(None, alias='campaignStatus')
+    size_chart: Optional[str] = Field(None, alias='sizeChart')
+    channel_status: Optional[List[str]] = Field(None, alias='channelStatus')
+    channel_category_l1: Optional[List[str]] = Field(None, alias='channelCategoryL1')
+    channel_category_l2: Optional[List[str]] = Field(None, alias='channelCategoryL2')
+    channel_category_l3: Optional[List[str]] = Field(None, alias='channelCategoryL3')
+    channel_category_id: Optional[List[str]] = Field(None, alias='channelCategoryId')
+    channel_synchronizes_stock: Optional[List[str]] = Field(None, alias='channelSynchronizesStock')
+    channel_has_category: Optional[List[str]] = Field(None, alias='channelHasCategory')
+    catalog_products_status: Optional[List[str]] = Field(None, alias='catalogProductsStatus')
+    metadata: Optional[List[str]] = None
+    integration_tags: Optional[List[str]] = Field(None, alias='integrationTags')
+    variations_integration_ids: Optional[List[str]] = Field(None, alias='variationsIntegrationIds')
+    channel_pictures_templates: Optional[List[str]] = Field(None, alias='channelPicturesTemplates')
+    channel_pictures_templates_apps: Optional[List[str]] = Field(None, alias='channelPicturesTemplatesApps')
+
+
+class SearchProduct(BaseModel):
+    count: int
+    facets: List[Facet]
+    results: List[SearchResultItem]
+
+
+class SearchProductParams(BaseModel):
+    top: Optional[int]
+    skip: Optional[int]
+    filter: Optional[str] = Field(default=None, alias='$filter')
+    search: Optional[str] = Field(default=None)
+    sales_channel: Optional[str] = Field(default='2', alias='salesChannel')

producteca/products/tests/test_products.py

@@ -1,95 +1,168 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.products.products import Product, MeliProduct
+from producteca.products.products import Product
+from producteca.client import ProductecaClient
 
 
 class TestProduct(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(token="test_id", api_key="test_secret")
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
         self.test_product = Product(
-            config=self.config,
             sku="TEST001",
             name="Test Product",
-            code="TEST001"
+            code="TEST001",
+            category="Test"
         )
+        self.product_to_create_payload = {
+            "sku": "9817234",
+            "code": "871234",
+            "name": "Hola test",
+            "buyingPrice": 0,
+            "deals": [
+                {
+                "campaign": "string",
+                "regularPrice": 0,
+                "dealPrice": 0
+                }
+            ],
+                "prices": [
+                {
+                "amount": 10,
+                "currency": "Local",
+                "priceList": "Default"
+                }
+            ],
+                "stocks": [
+                    {
+                    "quantity": 2,
+                    "availableQuantity": 2,
+                    "warehouse": "Default"
+                    }
+                ],
+            }
 
     @patch('requests.post')
     def test_create_product_success(self, mock_post):
         # Mock successful response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.create()
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(self.product_to_create_payload)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
-
-    @patch('requests.post')
-    def test_create_product_not_exist(self, mock_post):
-        # Mock product not found response
-        mock_response = Mock()
-        mock_response.status_code = 204
-        mock_post.return_value = mock_response
-
-        response, status_code = self.test_product.create()
-        
-        self.assertEqual(status_code, 204)
-        self.assertEqual(response["Message"], "Product does not exist and the request cant create if it does not exist")
+        self.assertEqual(response.sku, "TEST001")
 
     @patch('requests.post')
     def test_update_product_success(self, mock_post):
-        # Mock successful update
+        payload = self.product_to_create_payload
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001", "name": "Updated Product"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.update()
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(payload)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["name"], "Updated Product")
+        self.assertEqual(response.name, "Test Product")
 
     @patch('requests.get')
     def test_get_product(self, mock_get):
         # Mock get product response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_get.return_value = mock_response
 
-        response, status_code = Product.get(self.config, 1)
+        response = self.client.Product.get(1)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
+        self.assertEqual(response.sku, "TEST001")
 
     @patch('requests.get')
     def test_get_bundle(self, mock_get):
         # Mock get bundle response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"sku": "TEST001", "bundles": []}
+        test_prod = {
+                "results": [
+                    {
+                    "companyId": 0,
+                    "productId": 0,
+                    "variations": [
+                        {
+                        "variationId": 0,
+                        "components": [
+                            {
+                            "quantity": 0,
+                            "variationId": 0,
+                            "productId": 0
+                            }
+                        ]
+                        }
+                    ],
+                    "id": "string"
+                    }
+                ],
+                "count": 0
+                }
+        mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_bundle(self.config, 1)
+        product = self.client.Product.get_bundle(1)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(product.sku, "TEST001")
+        self.assertEqual(product.count, 0)
 
     @patch('requests.get')
     def test_get_ml_integration(self, mock_get):
         # Mock ML integration response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"sku": "TEST001", "integrations": []}
+        meli_product = {
+            "hasCustomShippingCosts": True,
+            "productId": 0,
+            "shipping": {
+                "localPickup": True,
+                "mode": "string",
+                "freeShipping": True,
+                "freeShippingCost": 0,
+                "mandatoryFreeShipping": True,
+                "freeShippingMethod": "string"
+            },
+            "mShopsShipping": {
+                "enabled": True
+            },
+            "addFreeShippingCostToPrice": True,
+            "category": {
+                "meliId": "string",
+                "acceptsMercadoenvios": True,
+                "suggest": True,
+                "fixed": True
+            },
+            "attributeCompletion": {
+                "productIdentifierStatus": "Complete",
+                "dataSheetStatus": "Complete",
+                "status": "Complete",
+                "count": 0,
+                "total": 0
+            },
+            "catalogProducts": [
+                "string"
+            ],
+            "warranty": "string",
+            "domain": "string",
+            "listingTypeId": "GoldSpecial",
+            "catalogProductsStatus": "Unlinked",
+            "tags": [
+                "string"
+            ]
+            }
+        
+        mock_response.json.return_value = meli_product
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_ml_integration(self.config, 1)
+        product = self.client.Product.get_ml_integration(1)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(product.sku, "TEST001")
+        self.assertEqual(product.listing_type_id, "GoldSpecial")
+
 
 if __name__ == '__main__':
     unittest.main()

producteca/{search/tests/test_search.py → products/tests/test_search_products.py}

@@ -1,81 +1,12 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.search.search_sale_orders import SearchSalesOrder, SearchSalesOrderParams, SearchSalesOrderResponse
-from producteca.search.search import SearchProduct, SearchProductParams
-
-class TestSearchSalesOrder(unittest.TestCase):
-    def setUp(self):
-        self.config = ConfigProducteca(
-            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()
-        mock_response.json.return_value = {
-            "count": 1,
-            "results": [{
-                "id": "123",
-                "status": "confirmed",
-                "lines": [],
-                "payments": [],
-                "shipments": [],
-                "integrations": [],
-                "codes": [],
-                "integration_ids": [],
-                "product_names": [],
-                "skus": [],
-                "tags": [],
-                "brands": []
-            }]
-        }
-        mock_response.status_code = 200
-        mock_get.return_value = mock_response
-
-        response, status_code = SearchSalesOrder.search_saleorder(self.config, self.params)
-        
-        # Validate response
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["count"], 1)
-        self.assertEqual(len(response["results"]), 1)
-        self.assertEqual(response["results"][0]["id"], "123")
-
-        # Verify the request was made with correct parameters
-        expected_url = f"{self.config.get_endpoint(SearchSalesOrder.endpoint)}?$filter={self.params.filter}&top={self.params.top}&skip={self.params.skip}"
-        mock_get.assert_called_once_with(
-            expected_url,
-            headers=self.config.headers
-        )
-
-    @patch('requests.get')
-    def test_search_saleorder_error(self, mock_get):
-        # Mock error response
-        mock_response = Mock()
-        mock_response.json.return_value = {"error": "Invalid request"}
-        mock_response.status_code = 400
-        mock_get.return_value = mock_response
-
-        response, status_code = SearchSalesOrder.search_saleorder(self.config, self.params)
-        
-        # Validate error response
-        self.assertEqual(status_code, 400)
-        self.assertEqual(response["error"], "Invalid request")
+from producteca.products.search_products import SearchProductParams
+from producteca.client import ProductecaClient
 
 
 class TestSearchProduct(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(
-            token="test_client_id",
-            api_key="test_client_secret",
-        )
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
         self.params = SearchProductParams(
             top=10,
             skip=0,
@@ -103,8 +34,8 @@ class TestSearchProduct(unittest.TestCase):
             "results": [{
                 "@search.score": 1.0,
                 "id": 123,
-                "product_id": 456,
-                "company_id": 789,
+                "productId": 456,
+                "companyId": 789,
                 "name": "Test Product",
                 "code": "TEST-001",
                 "skus": ["SKU001"],
@@ -116,18 +47,18 @@ class TestSearchProduct(unittest.TestCase):
                     "quantity": 10,
                     "reserved": 0
                 }],
-                "warehouses_with_stock": ["Main"],
-                "total_stock": 10,
-                "has_pictures": True,
-                "buying_price": 100.0,
+                "warehousesWithStock": ["Main"],
+                "totalStock": 10,
+                "hasPictures": True,
+                "buyingPrice": 100.0,
                 "prices": [{
-                    "price_list_id": 1,
-                    "price_list": "Default",
+                    "priceListId": 1,
+                    "priceList": "Default",
                     "amount": 200.0,
                     "currency": "USD"
                 }],
-                "integration_ids": ["INT001"],
-                "integration_apps": ["APP1"],
+                "integrationIds": ["INT001"],
+                "integrationApps": ["APP1"],
                 "integrations": [],
                 "campaigns": [],
                 "app": None,
@@ -181,15 +112,13 @@ class TestSearchProduct(unittest.TestCase):
         mock_response.status_code = 200
         mock_get.return_value = mock_response
 
-        response = SearchProduct.search_product(self.config, self.params)
+        response = self.client.Product.search(self.params)
         
         # Validate response
         self.assertEqual(response.count, 1)
         self.assertEqual(len(response.results), 1)
         self.assertEqual(response.results[0].id, 123)
         self.assertEqual(response.results[0].name, "Test Product")
-        
-        
 
     @patch('requests.get')
     def test_search_product_error(self, mock_get):
@@ -200,7 +129,7 @@ class TestSearchProduct(unittest.TestCase):
         mock_get.return_value = mock_response
         # TODO: Fix this
         # with self.assertRaises(Exception):
-        #     SearchProduct.search_product(self.config, self.params)
+        #     self.client.Product.search(self.params)
 
 
 if __name__ == '__main__':

producteca/sales_orders/__init__.py

@@ -1 +0,0 @@
-from . import sales_orders