tgshops-integrations 0.3__py3-none-any.whl → 1.0__py3-none-any.whl

tgshops_integrations/middlewares/gateway.py

@@ -1,4 +1,6 @@
 from typing import List,Optional
+import importlib.util
+from pathlib import Path
 
 from aiocache import cached
 from tgshops_integrations.models.products import ProductModel
@@ -10,46 +12,88 @@ 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 .config import NOCODB_CATEGORIES,NOCODB_PRODUCTS,NOCODB_STATUSES,NOCODB_BOT_MESSAGES,NOCODB_ORDERS
+
 from loguru import logger
-import hashlib
 
+# Step 1: Define the path to config.py (one level above)
+config_path = Path(__file__).resolve().parent.parent / '../config.py'
+
+# Step 2: Load config.py dynamically using importlib
+spec = importlib.util.spec_from_file_location("config", config_path)
+config = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(config)
+
+# Step 3: Access variables from config.py
+NOCODB_CATEGORIES = config.NOCODB_CATEGORIES
+NOCODB_PRODUCTS = config.NOCODB_PRODUCTS
+NOCODB_STATUSES = config.NOCODB_STATUSES
+NOCODB_BOT_MESSAGES = config.NOCODB_BOT_MESSAGES
+NOCODB_ORDERS = config.NOCODB_ORDERS
 
 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=[],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]
         self.projection = []
-
+        self.special_attributes=special_attributes
+        self.filter_buttons=filter_buttons
 
     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[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[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]
         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)
+        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)
@@ -62,7 +106,7 @@ class Gateway(NocodbClient):
             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):
@@ -99,13 +143,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)
+        items = await self.product_manager.get_products_v2(offset=0,limit=200)
         products_table = self.tables_list[NOCODB_PRODUCTS]    
         for num,item in enumerate(items):
             await self.delete_table_record(products_table, item.id)

tgshops_integrations/models/products.py

@@ -29,7 +29,6 @@ class ExternalProductModel(BaseModel):
 class ProductModel(BaseModel):
     id: Optional[str]
     external_id: Optional[str]
-    
     category: Optional[List[str]]
     category_name: Optional[List[str]]
     name: str
@@ -43,8 +42,3 @@ class ProductModel(BaseModel):
     updated: datetime = Field(default=datetime.now, hidden_field=True)
     preview_url: List[str] = []
     extra_attributes: List[ExtraAttribute] = []
-
-
-
-class ProductModel(ExternalProductModel):
-    id: str

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,45 @@ 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
+
+# Step 1: Define the path to config.py (one level above)
+config_path = Path(__file__).resolve().parent.parent / '../config.py'
+
+# Step 2: Load config.py dynamically using importlib
+spec = importlib.util.spec_from_file_location("config", config_path)
+config = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(config)
+
+# 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
+
+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 +56,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 +77,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 +92,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 +106,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 +117,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-1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: tgshops-integrations
+Version: 1.0
+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
+Author-email: drpozd@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+
+
+
+
+
+```python
+
+from typing import List
+import asyncio
+
+from config import NocoDBConfig
+from tgshops_integrations.middlewares.gateway import Gateway
+from services.bitrix.client import BitrixClient
+
+# Your credentials are here and source of the target table
+NOCODB_HOST = NocoDBConfig.HOST
+NOCODB_API_KEY = NocoDBConfig.API_KEY
+SOURCE=NocoDBConfig.source_table
+
+async def main():
+
+    # Here is your client to upload data from your service
+    bitrixService=BitrixClient()
+
+    # Products have to be in a according to the ProductModel
+        # class ProductModel(BaseModel):
+            # id: Optional[str]
+            # external_id: Optional[str]
+            # category: Optional[List[str]]
+            # category_name: Optional[List[str]]
+            # name: str
+            # description: Optional[str]
+            # price: Optional[float]
+            # final_price: Optional[float]
+            # currency: Optional[str]
+            # stock_qty: int
+            # orders_qty: int = Field(0, hidden_field=True)
+            # created: datetime = Field(default=datetime.now, hidden_field=True)
+            # updated: datetime = Field(default=datetime.now, hidden_field=True)
+            # preview_url: List[str] = []
+            # extra_attributes: List[ExtraAttribute] = []
+
+    bitrix_product_list=await bitrixService.get_crm_product_list()
+
+    NocoGateway = Gateway(NOCODB_HOST=NOCODB_HOST,NOCODB_API_KEY=NOCODB_API_KEY)
+    
+    # Example how to clean your table
+    # await NocoGateway.load_data(SOURCE=SOURCE)
+    # await NocoGateway.delete_all_products()
+
+
+    # In order to obtain data from the table need to call load data, to obtain it for further comparation
+    await NocoGateway.load_data(SOURCE=SOURCE)
+    # Initializes any missing categories
+    await NocoGateway.category_manager.update_categories(external_products=bitrix_product_list)
+
+    # Creates or updates the products
+    await NocoGateway.update_products(external_products=bitrix_product_list)
+
+
+asyncio.run(main())
+
+
+
+
+
+```

tgshops_integrations-1.0.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=GxXs-lVtrdWq3WTh_j0Hi1ffGsIOCCKJfOu3eyiRI2g,7441
+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=xLmfHGZBM4aEf2ZxVuitx5ckXQFSF9VpYms6qy2ao8Y,7653
+tgshops_integrations/nocodb_connector/products.py,sha256=23uXnmznJN6fZw3tZ3a7dJg06LkI2QaNfVhSKochPn4,8677
+tgshops_integrations/nocodb_connector/tables.py,sha256=ha_QXZXd93mht0fR5E1nM0wUpz1ePon-pIdO2HI67l8,356
+tgshops_integrations-1.0.dist-info/METADATA,sha256=7D9nxdGywF15S1rf_XBFr3DKX3skyvq_P9O-EQ1oeyo,2774
+tgshops_integrations-1.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+tgshops_integrations-1.0.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
+tgshops_integrations-1.0.dist-info/RECORD,,

tgshops_integrations-0.3.dist-info/METADATA

@@ -1,75 +0,0 @@
-Metadata-Version: 2.1
-Name: tgshops-integrations
-Version: 0.3
-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
-Author-email: drpozd@gmail.com
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
-
-
-
-
-
-```python
-
-import tgshops_integrations
-import ExternalProductModel, ExternalCategoryModel from tgshops_integrations.models
-
-# Load external data
-external_categories = [ExternalCategoryModel(
-    name="Drinks",
-    image_url="https://example.com/image.jpg",
-    external_id="0"
-), CategoryModel(
-    name="Coffee",
-    image_url="https://example.com/image.jpg",
-    external_id="1"
-)]
-external_products = [ExternalProductModel(
-    name="Coffee",
-    description="",
-    price=10.0,
-    currency="USD",
-    image_url="https://example.com/image.jpg",
-    category=List["0", "1"],
-    external_id="0"
-)]
-
-
-# Initialise
-product_service = tgshops_integrations.ProductService(token="your_token_here")
-
-await product_service.update_categories(
-    external_categories=external_categories
-)
-
-await product_service.update_products(
-    external_products=external_products
-)
-
-# Here is the the custom integration of your service, which has to return products according to the ExternalProductModel
-bitrixService=BitrixClient()
-bitrix_product_list=await bitrixService.get_crm_product_list()
-
-# One gateway can work with several table / DBs
-NocoGateway = Gateway(NOCODB_HOST=NOCODB_HOST,NOCODB_API_KEY=NOCODB_API_KEY)
-
-# await NocoGateway.load_data()
-# await NocoGateway.delete_all_products()
-
-# Load data provides the access to the certain table and allows to obtain the data about the products or catergories
-await NocoGateway.load_data(SOURCE=SOURCE)
-await NocoGateway.category_manager.update_categories(external_products=bitrix_product_list)
-await NocoGateway.update_products(external_products=bitrix_product_list)
-
-
-
-
-```

tgshops_integrations-0.3.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=rRVwEo1NP5pvarzvbwD9NbkTqtqxRDfIHCpNfx54Aus,1440
-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.3.dist-info/METADATA,sha256=A5rJekXxjrEVJ6aXaR42G-fH4pgOwUntpyn4YYqH5NY,2391
-tgshops_integrations-0.3.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-tgshops_integrations-0.3.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
-tgshops_integrations-0.3.dist-info/RECORD,,