tgshops-integrations 0.5__py3-none-any.whl → 1.1__py3-none-any.whl

tgshops_integrations/middlewares/gateway.py

@@ -1,8 +1,11 @@
 from typing import List,Optional
+import importlib.util
+from pathlib import Path
 
 from aiocache import cached
 from tgshops_integrations.models.products import ProductModel
 from tgshops_integrations.nocodb_connector.client import NocodbClient
+
 from tgshops_integrations.nocodb_connector.model_mapping import dump_product_data,dump_product_data_with_check, get_pagination_info, ID_FIELD, \
     parse_product_data, PRODUCT_CATEGORY_ID_LOOKUP_FIELD, PRODUCT_NAME_FIELD, PRODUCT_PRICE_FIELD, \
     PRODUCT_STOCK_FIELD
@@ -10,59 +13,95 @@ from tgshops_integrations.nocodb_connector.model_mapping import dump_product_dat
 from tgshops_integrations.nocodb_connector.categories import CategoryManager
 from tgshops_integrations.nocodb_connector.products import ProductManager
 from tgshops_integrations.nocodb_connector.tables import *
-from loguru import logger
-import hashlib
+# from .config import NOCODB_CATEGORIES,NOCODB_PRODUCTS,NOCODB_STATUSES,NOCODB_BOT_MESSAGES,NOCODB_ORDERS
 
+from loguru import logger
 
 class Gateway(NocodbClient):
 
-    def __init__(self,logging=False,NOCODB_HOST=None,NOCODB_API_KEY=None,SOURCE=None):
+    def __init__(self,logging=False,NOCODB_HOST=None,NOCODB_API_KEY=None,SOURCE=None,filter_buttons=[],config_path=None,special_attributes=False):
         super().__init__(NOCODB_HOST=NOCODB_HOST,NOCODB_API_KEY=NOCODB_API_KEY,SOURCE=SOURCE)
-        self.NOCODB_HOST = NOCODB_HOST
-        self.NOCODB_API_KEY = NOCODB_API_KEY
-        self.logging=logging
-        self.required_fields = [PRODUCT_NAME_FIELD, PRODUCT_PRICE_FIELD]
+        if config_path:
+            self.load_config_from_path(config_path)
+
+        self.logging = logging
+        self.required_fields = [self.config.PRODUCT_NAME_FIELD, self.config.PRODUCT_PRICE_FIELD]
         self.projection = []
+        self.special_attributes = special_attributes
+        self.filter_buttons = filter_buttons
 
+    def load_config_from_path(self,config_path):
+        if config_path.exists():
+            spec = importlib.util.spec_from_file_location("config", config_path)
+            self.config = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(self.config)
+        else:
+            raise FileNotFoundError(f"Configuration file not found at {config_path}")
 
     async def load_data(self,SOURCE=None):
         self.SOURCE=SOURCE
         await self.get_all_tables()
-        self.category_manager=CategoryManager(table_id=self.tables_list[NOCODB_CATEGORIES],NOCODB_HOST=self.NOCODB_HOST,NOCODB_API_KEY=self.NOCODB_API_KEY)
-        self.product_manager=ProductManager(table_id=self.tables_list[NOCODB_PRODUCTS],NOCODB_HOST=self.NOCODB_HOST,NOCODB_API_KEY=self.NOCODB_API_KEY)
+        self.category_manager=CategoryManager(table_id=self.tables_list[self.config.NOCODB_CATEGORIES],NOCODB_HOST=self.NOCODB_HOST,NOCODB_API_KEY=self.NOCODB_API_KEY,logging=True,filter_buttons=self.filter_buttons)
+        self.product_manager=ProductManager(table_id=self.tables_list[self.config.NOCODB_PRODUCTS],NOCODB_HOST=self.NOCODB_HOST,NOCODB_API_KEY=self.NOCODB_API_KEY,logging=True)
 
     async def create_product(self,product: ProductModel) -> ProductModel:
-        products_table = self.tables_list[NOCODB_PRODUCTS]
+        products_table = self.tables_list[self.config.NOCODB_PRODUCTS]
         data = dump_product_data_with_check(data=product ,data_check=self.category_manager.categories)
         # product_json = dump_product_data_with_check(data=product,data_check=self.categories)
-        data.pop("ID")
+        external_id = data.pop("ID")
+        metadata = await self.get_table_meta(self.tables_list["Products"])
+        images_column=[column["id"] for column in metadata["columns"] if column["column_name"] == "Images"][0]
+        data["ExternalImages"]=[image['title'] for image in data['Images']]
+
+        for num,item in enumerate(data['Images']):
+            url_before=item['url']
+            image_name=item['title']
+            data['Images'][num]['url']=await self.save_image_to_nocodb(source_column_id=self.SOURCE,image_url=url_before,image_name=image_name,product_table_name=products_table,images_column_id=images_column)
+
         record = await self.create_table_record(table_name=products_table, record=data)
-        logger.info(f"Created product {record['id']}")
-        return parse_product_data(record)
+        # logger.info(f"Created product {record['id']}")
+        logger.info(f"Created product {external_id}")
 
+    async def get_all_products(self):
+        actual_products=[]
+        products_portion=[]
+        portion=200
+        # TODO Check once busy
+        for i in range(10):
+            products_portion=await self.product_manager.get_products_v2(offset=i*portion,limit=portion)
+            actual_products.extend(products_portion)
+            if len(products_portion) < 200:
+                break
+        return actual_products
+    
     async def update_products(self, external_products: List[ProductModel]):
-        products_table = self.tables_list[NOCODB_PRODUCTS]
-        self.product_manager.actual_products=await self.product_manager.get_products_v2(offset=0,limit=200)
+        products_table = self.tables_list[self.config.NOCODB_PRODUCTS]
+        await self.product_manager.update_attributes(products=external_products)
+        # Updates categories if there were a new ones created
+        external_products=await self.category_manager.map_categories(external_products=external_products)
+        self.product_manager.actual_products=await self.get_all_products()
+        # self.product_manager.actual_products = await self.product_manager.get_products_v2(offset=0,limit=200)
+
         self.ids_mapping={product.external_id : product.id for product in self.product_manager.actual_products}
         products_meta= {product.external_id : product for product in self.product_manager.actual_products}
 
         for product in external_products:
             if product.external_id in self.ids_mapping.keys():
                 product.id=self.ids_mapping[product.external_id]
-                if self.product_manager.hash_product(product)!=self.product_manager.hash_product(products_meta[product.external_id]):
+                if self.product_manager.hash_product(product,special_attributes=self.special_attributes)!=self.product_manager.hash_product(products_meta[product.external_id],special_attributes=self.special_attributes):
                     await self.update_product(product=product)
             else:
                 await self.create_product(product=product)
         
     async def update_product(self, product: ProductModel):
-        products_table = self.tables_list[NOCODB_PRODUCTS]
+        products_table = self.tables_list[self.config.NOCODB_PRODUCTS]
         data = dump_product_data_with_check(data=product ,data_check=self.category_manager.categories)
 
         await self.update_table_record(
             table_name=products_table,
             record_id=product.id,
             updated_data=data)
-        logger.info(f"Updated product {product.id}")
+        logger.info(f"Updated product {product.external_id}")
         
         
     def find_product_id_by_name(self,name: str):
@@ -73,13 +112,14 @@ class Gateway(NocodbClient):
     
     async def create_table_column(self, name: str, table_id: Optional[str] = None):
 
+        #TODO needs to be deleted
         BEARER_TOKEN = "jpdxJtyfDXdjbvxKAcIij1HA8HGalgalLLXZ46DV"
         
         headers = {
             "Authorization": f"Bearer {BEARER_TOKEN}"
         }
         if not table_id:
-            table_id = self.tables_list[NOCODB_PRODUCTS]
+            table_id = self.tables_list[self.config.NOCODB_PRODUCTS]
 
         response = await self.httpx_client.post(
             f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_id}/columns",
@@ -99,13 +139,12 @@ class Gateway(NocodbClient):
             },
             headers=headers
         )
-
         logger.info(response.text())
 
         return response.json()
     
     async def delete_all_products(self):  
-        items = await self.product_manager.get_products_v2(offset=0,limit=100)
-        products_table = self.tables_list[NOCODB_PRODUCTS]    
+        items = await self.product_manager.get_products_v2(offset=0,limit=200)
+        products_table = self.tables_list[self.config.NOCODB_PRODUCTS]    
         for num,item in enumerate(items):
             await self.delete_table_record(products_table, item.id)

tgshops_integrations/nocodb_connector/categories.py

@@ -6,20 +6,24 @@ from tgshops_integrations.models.categories import CategoryModel,CategoryRespons
 from tgshops_integrations.models.products import ProductModel
 from tgshops_integrations.nocodb_connector.client import custom_key_builder, NocodbClient
 from tgshops_integrations.nocodb_connector.model_mapping import CATEGORY_IMAGE_FIELD, CATEGORY_NAME_FIELD, CATEGORY_PARENT_FIELD, \
-    CATEGORY_PARENT_ID_FIELD, PRODUCT_NAME_FIELD, dump_category_data, get_pagination_info, parse_category_data
+    CATEGORY_PARENT_ID_FIELD, PRODUCT_NAME_FIELD,CATEGORY_ID_OF_CATEGORY_FIELD, dump_category_data, get_pagination_info, parse_category_data
 
 
 class CategoryManager(NocodbClient):
-    def __init__(self,table_id=None,logging=False,NOCODB_HOST=None,NOCODB_API_KEY=None,SOURCE=None):
+    def __init__(self,table_id=None,logging=False,config_type=None,NOCODB_HOST=None,NOCODB_API_KEY=None,SOURCE=None,filter_buttons=[]):
         super().__init__(NOCODB_HOST=NOCODB_HOST,NOCODB_API_KEY=NOCODB_API_KEY,SOURCE=SOURCE)
         self.NOCODB_HOST = NOCODB_HOST
         self.NOCODB_API_KEY = NOCODB_API_KEY
         self.SOURCE=SOURCE
+        self.CONFIG_TYPE=config_type
         self.categories_table=table_id
         self.external_categories={}
         self.logging=logging
+        self.filter_categories=[]
+        self.filter_buttons=filter_buttons
         self.required_fields = [CATEGORY_NAME_FIELD]
-        self.projection = ["Id", CATEGORY_NAME_FIELD, CATEGORY_PARENT_ID_FIELD, CATEGORY_IMAGE_FIELD]
+        self.projection = ["Id", CATEGORY_NAME_FIELD, CATEGORY_PARENT_ID_FIELD, CATEGORY_ID_OF_CATEGORY_FIELD]
+        # self.projection = ["Id"]
 
     @cached(ttl=30, key_builder=custom_key_builder)
     async def get_categories(self, table_id: str) -> List[CategoryModel]:
@@ -81,22 +85,84 @@ class CategoryManager(NocodbClient):
         page_info = get_pagination_info(page_info=response['pageInfo'])
         return CategoryModel(categories=categories, page_info=page_info)
 
-    async def update_categories(self,external_products: List[ProductModel]):
+    async def update_categories(self,external_products: List[ProductModel]) -> List[ProductModel]:
         # Get the names of the tables from the DB for further handling
-        await self.get_product_categories(table_id=self.categories_table, table_name=PRODUCT_NAME_FIELD)
-        await self.map_categories(external_products=external_products)
-        
+        self.categories=await self.get_product_categories(table_id=self.categories_table, table_name=PRODUCT_NAME_FIELD)
+
+        categories_list=[*self.categories.keys()]
+        categories_to_create=[]
+
         for product in external_products:
-            for external_category_id,category_name in zip(product.category,product.category_name):
-                if category_name not in self.categories.keys():
-                    new_category= await self.create_product_category(table_id=self.categories_table,category_name=category_name,category_id=external_category_id,table_name=PRODUCT_NAME_FIELD)
-                    if self.logging:
-                        logger.info(f"New Category {new_category}")
-                    self.external_categories[new_category["Id"]]=external_category_id
+            # Check for new categories
+            # IF some category number exists on external side
+            if product.category:
+                for external_category_id,category_name in zip(product.category,product.category_name):
+                    if category_name not in [*self.categories.keys()]:
+                        new_category= await self.create_product_category(table_id=self.categories_table,category_name=category_name,category_id=external_category_id,table_name=PRODUCT_NAME_FIELD)
+                        if self.logging:
+                            logger.info(f"New Category {new_category}")
+                        self.external_categories[new_category["Id"]]=external_category_id
+                        self.categories=await self.get_product_categories(table_id=self.categories_table, table_name=PRODUCT_NAME_FIELD)
+            #Else if there is just the name, create the category with new id
+            else:
+                #Needs the buttons to be initialized, can connect items to buttons , which allows filtered acces through the menu
+                for num,category_name in enumerate(product.category_name):
+                    if category_name not in categories_list:
+                        if self.filter_buttons:
+                            parent_id=self.categories[self.filter_buttons[num]]
+                        else:
+                            parent_id=self.categories[product.category_II_name[0]]
+                        categories_to_create.append([category_name,parent_id])
+                        categories_list.append(category_name)
+
+        if categories_to_create:
+            categories_to_create.sort(key=lambda x: x[0]) 
+            if [*self.categories.values()]:
+                new_id=max(self.categories.values())+1
+            else:
+                new_id=1
+            for category,parent_id in categories_to_create:
+                new_category= await self.create_product_category(table_id=self.categories_table,category_name=category,category_id=new_id,table_name=PRODUCT_NAME_FIELD)
+                if self.logging:
+                    logger.info(f"New Category {new_category}")
+                # if self.filter_buttons:
+                #     #Rewind categories
+                #     await self.link_categories(parent_id=parent_id,child_id=new_id)
+                new_id+=1
+
+    async def link_categories(self,parent_id:int,child_id:int):
+        metadata = await self.get_table_meta(self.categories_table)
+
+        linked_column = None
+        for col in metadata['columns']:
+            if (col["title"]=="Set parent category" and col["uidt"] == "Links"):
+                linked_column = col
+                break
+        await self.link_table_record(
+            linked_column["base_id"],
+            linked_column["fk_model_id"],
+            child_id,
+            linked_column["id"],
+            parent_id)
+        
+    async def unlink_categories(self,parent_id:int,child_id:int):
+        metadata = await self.get_table_meta(self.categories_table)
+
+        linked_column = None
+        for col in metadata['columns']:
+            if col["uidt"] == "Links":
+                linked_column = col
+                break
+        await self.unlink_table_record(
+            linked_column["base_id"],
+            linked_column["fk_model_id"],
+            parent_id,
+            linked_column["id"],
+            child_id)
     
     async def map_categories(self,external_products: List[ProductModel]) -> List[ProductModel]:
-        for product in external_products:
+        for num,product in enumerate(external_products):
             if not product.category:
-                for category in product.category_name:
-                    product.category.append(self.categories[category])
+                if product.category_name:
+                    external_products[num].category=[str(self.categories[category_name]) for category_name in product.category_name]
         return external_products

tgshops_integrations/nocodb_connector/client.py

@@ -2,6 +2,8 @@ from typing import List,Optional
 
 import httpx
 import requests
+import io
+
 from loguru import logger
 
 from tgshops_integrations.nocodb_connector.model_mapping import ID_FIELD
@@ -20,7 +22,7 @@ class NocodbClient:
         self.NOCODB_HOST = NOCODB_HOST
         self.NOCODB_API_KEY = NOCODB_API_KEY
         self.SOURCE=SOURCE
-        self.httpx_client = httpx.AsyncClient()
+        self.httpx_client = httpx.AsyncClient(timeout=60.0)
         self.httpx_client.headers = {
             "xc-token": self.NOCODB_API_KEY
         }
@@ -76,12 +78,6 @@ class NocodbClient:
         if response.status_code == 200:
             return response.json()
         raise Exception(response.text)
-    
-    # class ProductModel(BaseProductModel):
-    #     extra_option_choice_required: bool = False
-    #     extra_option_categories: List[ExtraOptionCategoriesResponseModel] = []
-    #     related_products: List[BaseProductModel] = None
-    #     metadata : ProductModel
 
     async def get_table_record(self,
                                table_name: str,
@@ -112,9 +108,11 @@ class NocodbClient:
             return response.json().get("count", 0)
         raise Exception(response.text)
 
-    async def update_table_record(self, table_name: str, record_id: str, updated_data: dict) -> bool:
+    async def update_table_record(self, table_name: str, record_id: str, updated_data: dict) -> bool:        
         url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
-        updated_data[ID_FIELD] = record_id
+        updated_data[ID_FIELD] = int(record_id)
+        if updated_data["ID"]:
+            updated_data.pop("ID")
         response = await self.httpx_client.patch(url, json=updated_data)
         if response.status_code == 200:
             return True
@@ -135,8 +133,12 @@ class NocodbClient:
         response = await self.httpx_client.get(url, params=extra_params)
 
         if response.status_code == 200:
-            self.categories={category[table_name] : category["Id"] for category in response.json()["list"]}
-        # raise Exception(response.text)
+            categories={category[table_name] : category["Id"] for category in response.json()["list"]}
+            return categories
+        raise Exception(response.text)
+        return {}
+        
+    
     
     async def create_product_category(self, table_id: str, category_name : str, table_name : str, category_id : int = 0)  -> dict:
         url = f"{self.NOCODB_HOST}/tables/{table_id}/records"
@@ -145,10 +147,7 @@ class NocodbClient:
 
         response = await self.httpx_client.post(url, json=record)
         if response.status_code == 200:
-            # record["id"] = response.json().get("Id")
-            # if not record["id"]:
-            #     record["id"] = response.json().get("Id")
-            await self.get_product_categories(table_id=table_id, table_name=table_name)
+            self.categories = await self.get_product_categories(table_id=table_id, table_name=table_name)
             return record
         raise Exception(response.text)
     
@@ -171,16 +170,107 @@ class NocodbClient:
         return (await self.httpx_client.get(
             f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/projects/")).json().get(
             'list', [])
+    
+    async def get_table_meta(self, table_name: str):
+        return (await self.httpx_client.get(
+            f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_name}")).json()
+    
+
+    async def create_table_column(self, table_name: str, name: str):
+        return (await self.httpx_client.post(
+            f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_name}/columns",
+            json={
+                "column_name": name,
+                "dt": "character varying",
+                "dtx": "specificType",
+                "ct": "varchar(45)",
+                "clen": 45,
+                "dtxp": "45",
+                "dtxs": "",
+                "altered": 1,
+                "uidt": "SingleLineText",
+                "uip": "",
+                "uicn": "",
+                "title": name
+            })).json()
 
-    def link_tables(self, source: str, parent_id: str, child_id: str, parent_table: str, child_table: str):
+    async def link_table_record(
+            self,
+            base_id: str,
+            fk_model_id: str,
+            record_id: str,
+            source_column_id: str,
+            linked_record_id: str) -> dict:
         """
-        Связывает таблицы
-        :param source:
-        :param parent_id:
-        :param child_id:
-        :param parent_table:
-        :param child_table:
-        :return:
+        base_id
+        fk_model_id - ID of linked column
+        record_id - ID of source record to be linked
+        source_column_id -ID of source column
+        linked_record_id - ID of linked record
+
+        POST /api/v1/db/data/noco/pwb8m0yee7nvw6m/mtk2pg9eiix11qs/242/mm/ct5sskewp6sg54q/91
+        /fk_model- smr8uvm11kurzprp
         """
-        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/data/noco/{source}/{parent_table}/{parent_id}/mm/{child_table}/{child_id}"
-        return requests.post(url, headers=self.httpx_client.headers).json()
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/data/noco/{base_id}/{fk_model_id}/{record_id}/mm/{source_column_id}/{linked_record_id}"
+        response = await self.httpx_client.post(url,headers=self.httpx_client.headers)
+        if response.status_code == 200:
+            return response.json()
+        raise Exception(response.text)
+
+    async def unlink_table_record(
+            self,
+            base_id: str,
+            fk_model_id: str,
+            record_id: str,
+            source_column_id: str,
+            linked_record_id: str) -> dict:
+        """
+        base_id
+        fk_model_id - ID of linked column
+        record_id - ID of source record to be linked
+        source_column_id -ID of source column
+        linked_record_id - ID of linked record
+
+        POST /api/v1/db/data/noco/pwb8m0yee7nvw6m/mtk2pg9eiix11qs/242/mm/ct5sskewp6sg54q/91
+        """
+        path = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/data/noco/{base_id}/{fk_model_id}/{record_id}/mm/{source_column_id}/{linked_record_id}"
+        response = await self.httpx_client.delete(path)
+        if response.status_code == 200:
+            return response.json()
+        raise Exception(response.text)
+
+    async def save_image_to_nocodb(
+            self,
+            image_url: str,
+            image_name: str,
+            source_column_id: str,
+            product_table_name: str,
+            images_column_id: str) -> dict:
+        """
+        source
+        fk_model_id - ID of linked column
+        record_id - ID of source record to be linked
+        source_column_id -ID of source column
+        linked_record_id - ID of linked record
+        """
+
+        response = requests.get(image_url)
+        if response.status_code == 200:
+            file = io.BytesIO(response.content)
+        else:
+            raise Exception(f"Failed to fetch the image. Status code: {response.status_code}")
+        
+        file_size = file.getbuffer().nbytes
+
+        if file_size:
+
+            files = {'file': (image_name, file, 'image/jpeg')}
+
+            url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/storage/upload?path=noco/{source_column_id}/{product_table_name}/{images_column_id}"
+            timeout = httpx.Timeout(100.0)
+            response = await self.httpx_client.post(url,files=files,headers=self.httpx_client.headers,timeout=timeout)
+            if response.status_code == 200:
+                return response.json()[0]['url']
+            raise Exception(response.text)
+        else:
+            return ""

tgshops_integrations/nocodb_connector/model_mapping.py

@@ -8,6 +8,62 @@ from tgshops_integrations.models.products import ExtraAttribute, ProductModel
 from tgshops_integrations.models.categories import CategoryResponseModel,PaginationResponseModel
 from tgshops_integrations.models.products import  ProductModel
 
+import importlib.util
+from pathlib import Path
+
+
+# Helper function to load config.py dynamically
+def load_config(config_path):
+    config_path = Path(config_path)
+    if config_path.exists():
+        spec = importlib.util.spec_from_file_location("config", config_path)
+        config = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(config)
+        return config
+    else:
+        raise FileNotFoundError(f"Configuration file not found at {config_path}")
+
+# Modify this to accept config_path dynamically
+def initialize_model_mapping(config_path):
+    global CATEGORY_IMAGE_FIELD, ID_FIELD, CATEGORY_NAME_FIELD, CATEGORY_PARENT_ID_FIELD, CATEGORY_PARENT_FIELD,CATEGORY_ID_OF_CATEGORY_FIELD
+    global PRODUCT_NAME_FIELD, PRODUCT_DESCRIPTION_FIELD, PRODUCT_PRICE_FIELD, PRODUCT_CURRENCY_FIELD, PRODUCT_STOCK_FIELD
+    global PRODUCT_CATEGORY_NAME_FIELD, PRODUCT_CATEGORY_ID_FIELD, PRODUCT_IMAGE_FIELD, PRODUCT_DISCOUNT_PRICE_FIELD
+    global PRODUCT_CATEGORY_ID_LOOKUP_FIELD, PRODUCT_REQUIRED_OPTIONS_FIELD, PRODUCT_CATEGORIES_EXTRA_OPTIONS_FIELD
+    global PRODUCT_CATEGORIES_EXTRA_OPTION_NAMES_FIELD, PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD, PRODUCT_ID_FIELD
+    global PRODUCT_EXTERNAL_ID, PRODUCT_CHECKOUT_MODE, NEW_ID_FIELD, NOCODB_CHECKOUT_MODES
+    
+    config = load_config(config_path)
+    
+    # Step 3: Load all required constants from config.py
+    CATEGORY_IMAGE_FIELD = config.CATEGORY_IMAGE_FIELD
+    ID_FIELD = config.ID_FIELD
+    CATEGORY_NAME_FIELD = config.CATEGORY_NAME_FIELD
+    CATEGORY_PARENT_ID_FIELD = config.CATEGORY_PARENT_ID_FIELD
+    CATEGORY_PARENT_FIELD = config.CATEGORY_PARENT_FIELD
+    CATEGORY_ID_OF_CATEGORY_FIELD = config.CATEGORY_ID_OF_CATEGORY_FIELD
+
+    PRODUCT_NAME_FIELD = config.PRODUCT_NAME_FIELD
+    PRODUCT_DESCRIPTION_FIELD = config.PRODUCT_DESCRIPTION_FIELD
+    PRODUCT_PRICE_FIELD = config.PRODUCT_PRICE_FIELD
+    PRODUCT_CURRENCY_FIELD = config.PRODUCT_CURRENCY_FIELD
+    PRODUCT_STOCK_FIELD = config.PRODUCT_STOCK_FIELD
+    PRODUCT_CATEGORY_NAME_FIELD = config.PRODUCT_CATEGORY_NAME_FIELD
+    
+    PRODUCT_CATEGORY_ID_FIELD = config.PRODUCT_CATEGORY_ID_FIELD
+    PRODUCT_IMAGE_FIELD = config.PRODUCT_IMAGE_FIELD
+    PRODUCT_DISCOUNT_PRICE_FIELD = config.PRODUCT_DISCOUNT_PRICE_FIELD
+    PRODUCT_CATEGORY_ID_LOOKUP_FIELD = config.PRODUCT_CATEGORY_ID_LOOKUP_FIELD
+    PRODUCT_REQUIRED_OPTIONS_FIELD = config.PRODUCT_REQUIRED_OPTIONS_FIELD
+    PRODUCT_CATEGORIES_EXTRA_OPTIONS_FIELD = config.PRODUCT_CATEGORIES_EXTRA_OPTIONS_FIELD
+    PRODUCT_CATEGORIES_EXTRA_OPTION_NAMES_FIELD = config.PRODUCT_CATEGORIES_EXTRA_OPTION_NAMES_FIELD
+    PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD = config.PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD
+    PRODUCT_ID_FIELD = config.PRODUCT_ID_FIELD
+    PRODUCT_EXTERNAL_ID = config.PRODUCT_EXTERNAL_ID
+    PRODUCT_CHECKOUT_MODE = config.PRODUCT_CHECKOUT_MODE
+    NEW_ID_FIELD = config.NEW_ID_FIELD
+
+    NOCODB_CHECKOUT_MODES = config.NOCODB_CHECKOUT_MODES
+
 
 def get_pagination_info(page_info: dict) -> PaginationResponseModel:
     page_info = PaginationResponseModel(total_rows=page_info['totalRows'],
@@ -17,15 +73,6 @@ def get_pagination_info(page_info: dict) -> PaginationResponseModel:
                                         is_last_page=page_info['isLastPage'])
     return page_info
 
-
-ID_FIELD = "Id"
-NEW_ID_FIELD = "id"
-CATEGORY_IMAGE_FIELD = "Изображение"
-CATEGORY_NAME_FIELD = "Название"
-CATEGORY_PARENT_FIELD = "Назначить родительскую категорию"
-CATEGORY_PARENT_ID_FIELD = "ID родительской категории"
-
-
 def parse_category_data(data: dict) -> CategoryResponseModel:
     preview_url = ""
     if data.get(CATEGORY_IMAGE_FIELD):
@@ -47,37 +94,8 @@ def dump_category_data(data: CategoryModel) -> dict:
     }
 
 
-# PRODUCT_IMAGE_FIELD = "Изображения"
-# PRODUCT_NAME_FIELD = "Название"
-# PRODUCT_STOCK_FIELD = "Доступное количество"
-# PRODUCT_PRICE_FIELD = "Стоимость"
-# PRODUCT_CURRENCY_FIELD = "Валюта"
-# PRODUCT_DESCRIPTION_FIELD = "Описание"
-# PRODUCT_CATEGORY_NAME_FIELD = "Название категорий"
-# PRODUCT_DISCOUNT_PRICE_FIELD = "Стоимость со скидкой"
-
-PRODUCT_IMAGE_FIELD="Images"
-PRODUCT_NAME_FIELD="Name"
-PRODUCT_DESCRIPTION_FIELD = "Description"
-PRODUCT_ID_FIELD="ID"
-PRODUCT_EXTERNAL_ID="ExternalId"
-PRODUCT_PRICE_FIELD="Price"
-PRODUCT_CURRENCY_FIELD = "Currency"
-PRODUCT_STOCK_FIELD = "Number of pieces"
-PRODUCT_CATEGORY_ID_FIELD = "Category"
-PRODUCT_DISCOUNT_PRICE_FIELD = "Discounted price"
-PRODUCT_CATEGORY_NAME_FIELD = "Name of categories"
-# PRODUCT_CATEGORY_ID_LOOKUP_FIELD = "ID Категории"
-PRODUCT_CATEGORY_ID_LOOKUP_FIELD = "ID of category"
-PRODUCT_REQUIRED_OPTIONS_FIELD = "Выбор обязательных опций"
-PRODUCT_CATEGORIES_EXTRA_OPTIONS_FIELD = "Выбор категории доп опций"
-PRODUCT_CATEGORIES_EXTRA_OPTION_NAMES_FIELD = "Названия категорий доп опций"
-PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD = "Обязательный выбор?"
-
-
 def dump_product_data(data: ProductModel) -> dict:
-    if data.external_id=="21":
-        print("Hoi")
+
     preview_url = ([{'url': image_url,
                      'title': f'{secrets.token_hex(6)}.jpeg',
                      'mimetype': 'image/jpeg'}
@@ -91,9 +109,7 @@ def dump_product_data(data: ProductModel) -> dict:
         PRODUCT_PRICE_FIELD: data.price,
         PRODUCT_CURRENCY_FIELD: data.currency,
         PRODUCT_STOCK_FIELD: data.stock_qty,
-        #TODO Add for several categories
         PRODUCT_CATEGORY_NAME_FIELD:[data.category_name] if data.category_name else None,
-        # PRODUCT_CATEGORY_ID_FIELD: [{"id": int(data.category[0])}] if data.category else None,
         PRODUCT_CATEGORY_ID_FIELD: [{'Id': data.category}] if data.category else None,
         PRODUCT_IMAGE_FIELD: preview_url,
         PRODUCT_DISCOUNT_PRICE_FIELD: data.final_price
@@ -107,6 +123,9 @@ def dump_product_data_with_check(data: ProductModel, data_check: dict) -> dict:
                 for image_url in data.preview_url]
                 if data.preview_url
                 else [])
+    
+    extra_data = {item.name : item.description for item in data.extra_attributes}
+
     product_data = {
         PRODUCT_ID_FIELD: data.id,
         PRODUCT_EXTERNAL_ID: data.external_id,
@@ -115,13 +134,15 @@ def dump_product_data_with_check(data: ProductModel, data_check: dict) -> dict:
         PRODUCT_PRICE_FIELD: data.price,
         PRODUCT_CURRENCY_FIELD: data.currency,
         PRODUCT_STOCK_FIELD: data.stock_qty,
-        #TODO Add for several categories
         PRODUCT_CATEGORY_NAME_FIELD:[data.category_name] if data.category_name else None,
-        #TODO Add for several categories
-        PRODUCT_CATEGORY_ID_FIELD: [{'Id': data_check[data.category_name[0]]}] if data.category else None,
+        PRODUCT_CATEGORY_ID_FIELD: [{'Id': data_check[item]} for item in data.category_name] if data.category else None,
         PRODUCT_IMAGE_FIELD: preview_url,
-        PRODUCT_DISCOUNT_PRICE_FIELD: data.final_price
+        PRODUCT_CHECKOUT_MODE: NOCODB_CHECKOUT_MODES,
+        PRODUCT_DISCOUNT_PRICE_FIELD: data.final_price,
         }
+    
+    if len(extra_data)>0:
+        product_data.update(extra_data)
     return product_data
 
 

tgshops_integrations/nocodb_connector/products.py

@@ -26,10 +26,16 @@ class ProductManager(NocodbClient):
         self.external_categories={}
         self.products_table=table_id
         self.actual_products=[]
+        self.columns=[]
 
-    def hash_product(self,product):
+    def hash_product(self,product,special_attributes=False):
+        if special_attributes:
+            hash_string = ''.join(attr.description for attr in product.extra_attributes if attr.name.endswith('*'))
+            # hash_string = f"{product.external_id}{product.price}{product.category_name.sort()}{product.name}{product.description}"
+        else:
         # Concatenate relevant attributes into a single string
-        hash_string = f"{product.external_id}{product.price}{product.category}{product.name}{product.description}{product.preview_url}"
+            hash_string = f"{product.external_id}{product.price}{product.category_name.sort()}{product.name}{product.description}"
+        # hash_string = f"{product.external_id}{product.price}{product.category_name}{product.name}{product.description}{product.preview_url}"
         # Hash the concatenated string
         hash_object = hashlib.sha256(hash_string.encode())
         hex_dig = hash_object.hexdigest()
@@ -144,7 +150,18 @@ class ProductManager(NocodbClient):
             required_fields=self.required_fields,
             projection=self.projection,
             extra_where=f"({ID_FIELD},in,{product_ids_str})")
-        return [parse_product_data(record) for record in records]    
+        return [parse_product_data(record) for record in records]   
+
+    @cached(ttl=60, key_builder=custom_key_builder)
+    async def update_attributes(self,products:List[ProductModel]):
+        for item in products:
+            attributes=await self.get_table_meta(table_name=self.products_table)
+            self.columns =[item['title'].lower() for item in attributes.get('columns', [])]
+            for attribute in item.extra_attributes:
+                if attribute.name.rstrip().lower() not in self.columns:
+                    response =await self.create_table_column(table_name=self.products_table,name=attribute.name.lower())
+                    logger.info(f"Created attribute: {attribute.name.lower()}")
+
         
     def find_product_id_by_name(self,name: str):
         for product in self.actual_products.products:

{tgshops_integrations-0.5.dist-info → tgshops_integrations-1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tgshops-integrations
-Version: 0.5
+Version: 1.1
 Summary: Library is intended to provide the integration of the external service or CRM system with the TelegramShops/It allows to configure the relationship between NocoDB list of the products used further to display in the shop/As a resultss the products can be synchronized and updated uppon the request.
 Home-page: https://git.the-devs.com/virtual-shops/shop-system/shop-backend-integrations/integration-library/integration-library
 Author: Dimi Latoff

tgshops_integrations-1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+tgshops_integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgshops_integrations/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgshops_integrations/middlewares/gateway.py,sha256=ib7s39K9_VefobHQwtv7ajR3mTDjDziAZd00GBSZ1wA,7391
+tgshops_integrations/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgshops_integrations/models/categories.py,sha256=EG6C8g5dOfXB2MH-vtqH13aqB7_VyOobY2FHpDb-fsY,977
+tgshops_integrations/models/products.py,sha256=i0vP_eJMVCB-W25BCoodIB0AhsMTqYiDO48N-B6Ueo0,1379
+tgshops_integrations/nocodb_connector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgshops_integrations/nocodb_connector/categories.py,sha256=YfQQ8UAkOonNZKO-oTH36vODu0eE-ElG-Me2bH5LdEM,9072
+tgshops_integrations/nocodb_connector/client.py,sha256=MD08P25jYWg0ZoLGk9cZ7cH8WJ6vtMn9oXW1N0LuyZ0,11504
+tgshops_integrations/nocodb_connector/model_mapping.py,sha256=CeGAwEZLK_NlK_eBTtsH6oRsjo6Z-QxWdC9KnwEhtPw,8770
+tgshops_integrations/nocodb_connector/products.py,sha256=23uXnmznJN6fZw3tZ3a7dJg06LkI2QaNfVhSKochPn4,8677
+tgshops_integrations/nocodb_connector/tables.py,sha256=ha_QXZXd93mht0fR5E1nM0wUpz1ePon-pIdO2HI67l8,356
+tgshops_integrations-1.1.dist-info/METADATA,sha256=uU8JvqZdrwZETXch9M3YmqvDD_ByhPieCHMTdB1LEpU,2774
+tgshops_integrations-1.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+tgshops_integrations-1.1.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
+tgshops_integrations-1.1.dist-info/RECORD,,

tgshops_integrations-0.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-tgshops_integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tgshops_integrations/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tgshops_integrations/middlewares/gateway.py,sha256=tZMJZJBRVmmIrlKmspm5KMbmNDCv4RgXFjydcayx56k,5042
-tgshops_integrations/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tgshops_integrations/models/categories.py,sha256=EG6C8g5dOfXB2MH-vtqH13aqB7_VyOobY2FHpDb-fsY,977
-tgshops_integrations/models/products.py,sha256=i0vP_eJMVCB-W25BCoodIB0AhsMTqYiDO48N-B6Ueo0,1379
-tgshops_integrations/nocodb_connector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tgshops_integrations/nocodb_connector/categories.py,sha256=GHB7vEns9viK3NbgR4fY42UzMCUVnr4R1HKP1NORaHg,5900
-tgshops_integrations/nocodb_connector/client.py,sha256=qq2UQDbRCOqcH0ng49l1xOihY2-Zc3tMm2yqQUMk_pk,8307
-tgshops_integrations/nocodb_connector/model_mapping.py,sha256=9199eOz4ISqduDv5BkxWgPXt-QT6fd5dtCGVMZoOAN4,7471
-tgshops_integrations/nocodb_connector/products.py,sha256=TZGBfEfH11NxOeeqZQoEiMi1WEuSMpmTJ7JDu8KtgNw,7548
-tgshops_integrations/nocodb_connector/tables.py,sha256=ha_QXZXd93mht0fR5E1nM0wUpz1ePon-pIdO2HI67l8,356
-tgshops_integrations-0.5.dist-info/METADATA,sha256=69nGOSfX2e1gdThBxwhPsqe-nvWPbgIZ6Lkv2h-K9EY,2774
-tgshops_integrations-0.5.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-tgshops_integrations-0.5.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
-tgshops_integrations-0.5.dist-info/RECORD,,