tgshops-integrations 3.0__py3-none-any.whl → 3.2__py3-none-any.whl

tgshops_integrations/middlewares/gateway.py

@@ -23,8 +23,8 @@ from tgshops_integrations.nocodb_connector.model_mapping import (
     PRODUCT_IMAGES_LOOKUP_FIELD,
     PRODUCT_EXTERNAL_ID,
 )
-from services.nocodb_connector.categories import CategoryManager
-from services.nocodb_connector.products import ProductManager
+from tgshops_integrations.nocodb_connector.categories import CategoryManager
+from tgshops_integrations.nocodb_connector.products import ProductManager
 from loguru import logger
 
 

tgshops_integrations/models/products.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import Any, List, Optional
+from typing import Any, List,Dict, Optional
 from datetime import datetime
 
 from pydantic import BaseModel, Field, schema, validator
@@ -28,12 +28,12 @@ class ExternalProductModel(BaseModel):
 class ProductModel(BaseModel):
     id: Optional[str]
     external_id: Optional[str]
-    category: Optional[List[int]]
-    category_name: Optional[List[str]]
+    product_properties: Optional[List[str]]
+    categories_structure: Optional[Dict[str, Any]]
     name: str
     description: Optional[str]
     price: Optional[float]
-    final_price: Optional[int]
+    final_price: Optional[float]
     currency: Optional[str]
     stock_qty: int
     orders_qty: int = Field(0, hidden_field=True)

{tgshops_integrations-3.0.dist-info → tgshops_integrations-3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tgshops-integrations
-Version: 3.0
+Version: 3.2
 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-3.0.dist-info → tgshops_integrations-3.2.dist-info}/RECORD

@@ -1,18 +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=Gzr8gZWQ3B3tiqpE_iSqtAkINDbsm7QT_v_bjT1b8V4,6223
+tgshops_integrations/middlewares/gateway.py,sha256=-YQi3-62k6gkxJLx27FESe6wlRrD4_Ltqk8wZJ8ExYg,6247
 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=zkRqXLU-tAReDF5R9j3q58le686dw3PapxcFOGUpk7Q,1376
+tgshops_integrations/models/products.py,sha256=CpQ5LpeigklgVnkKPCm5jR9hfJsoFbWKSsDiTI32RSo,1405
 tgshops_integrations/nocodb_connector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tgshops_integrations/nocodb_connector/categories.py,sha256=eoAWRA0aSE84_ONrwflM1ZFXLSCFjYl_CFqUf7lA_EU,9063
 tgshops_integrations/nocodb_connector/categories_management.py,sha256=dvPXcrgruJyuWFT7Ho-8YRcjJxhR3Hcw0hJiVKQgcyA,6603
 tgshops_integrations/nocodb_connector/client.py,sha256=U2rNozjluWVul-VZroQW-8b2j6nEtKrhOkFMz1L8KmI,12022
 tgshops_integrations/nocodb_connector/model_mapping.py,sha256=ixv-uT1Pmt1szZCQ5pGsMbwRvmnHZmn0NqG77nxZkDM,8551
-tgshops_integrations/nocodb_connector/products.py,sha256=kAp7lUaRO7CkU_SumbIdLOJf38SmDBEyBBZCYyyyOFM,9313
 tgshops_integrations/nocodb_connector/products_management.py,sha256=t_ZDyIAPTe_6UrxLuJ32Uhlk8ssErP6Eo0n-TIZfEko,6046
 tgshops_integrations/nocodb_connector/tables.py,sha256=ha_QXZXd93mht0fR5E1nM0wUpz1ePon-pIdO2HI67l8,356
-tgshops_integrations-3.0.dist-info/METADATA,sha256=E4e2SV-nFT2HLUEzRZ90PWI1BTAzoaTtnXm-ZYalN5k,2774
-tgshops_integrations-3.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-tgshops_integrations-3.0.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
-tgshops_integrations-3.0.dist-info/RECORD,,
+tgshops_integrations-3.2.dist-info/METADATA,sha256=daiTMAx10_7qtGpB4ILTHYZCEnU9eFtuYENzwki-VTc,2774
+tgshops_integrations-3.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+tgshops_integrations-3.2.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
+tgshops_integrations-3.2.dist-info/RECORD,,

tgshops_integrations/nocodb_connector/categories.py

@@ -1,168 +0,0 @@
-from typing import List
-from loguru import logger
-
-from aiocache import cached
-from tgshops_integrations.models.categories import CategoryModel,CategoryResponseModel,CategoryListResponseModel
-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,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,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_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]:
-        records = await self.get_table_records(table_id, self.required_fields, self.projection)
-        return [parse_category_data(record) for record in records]
-
-    @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_categories_v2(self,
-                                table_id: str,
-                                offset: int = None,
-                                limit: int = None) -> CategoryModel:
-        response = (await self.get_table_records_v2(table_name=self.categories_table,
-                                                    required_fields=self.required_fields,
-                                                    projection=self.projection,
-                                                    offset=offset,
-                                                    limit=limit))
-        page_info = get_pagination_info(page_info=response['pageInfo'])
-        categories = [parse_category_data(record) for record in response['list']]
-        return CategoryListResponseModel(categories=categories, page_info=page_info)
-
-    @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_category(self, table_id: str, category_id: str) -> CategoryModel:
-        record = await self.get_table_record(self.categories_table, category_id, self.required_fields, self.projection)
-        return parse_category_data(record)
-
-    async def create_category(self, table_id: str, category: CategoryModel) -> CategoryModel:
-        category_json = dump_category_data(category)
-        record = await self.create_table_record(self.categories_table, category_json)
-        return parse_category_data(record)
-
-    @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_categories_in_category(self, table_id: str, category_id: str) -> List[CategoryModel]:
-        # ! In case category_id == 0,
-        # we need to get all categories without parent by field CATEGORY_PARENT_FIELD not CATEGORY_PARENT_ID_FIELD
-        records = await self.get_table_records(
-            table_name=self.categories_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=(f"({CATEGORY_PARENT_ID_FIELD},eq,{category_id})"
-                         if category_id else f"({CATEGORY_PARENT_FIELD},eq,0)"))
-        return [parse_category_data(record) for record in records]
-
-    @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_categories_in_category_v2(self,
-                                            table_id: str,
-                                            category_id: str,
-                                            offset: int,
-                                            limit: int) -> CategoryModel:
-
-        response = await self.get_table_records_v2(
-            table_name=self.categories_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=(f"({CATEGORY_PARENT_ID_FIELD},eq,{category_id})"
-                         if category_id else f"({CATEGORY_PARENT_FIELD},eq,0)"),
-            offset=offset,
-            limit=limit)
-        categories = [parse_category_data(record) for record in response['list']]
-        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]) -> List[ProductModel]:
-        # Get the names of the tables from the DB for further handling
-        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:
-            # Check for new categories
-            # DEPRECATED 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 num,product in enumerate(external_products):
-            if not product.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/products.py

@@ -1,181 +0,0 @@
-from typing import List,Optional
-
-from aiocache import cached
-from tgshops_integrations.models.products import ProductModel
-from tgshops_integrations.models.products import ProductModel, ProductModel
-from tgshops_integrations.nocodb_connector.client import custom_key_builder, 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,PRODUCT_EXTERNAL_ID,PRODUCT_IMAGES_LOOKUP_FIELD
-
-from tgshops_integrations.nocodb_connector.tables import *
-from loguru import logger
-import hashlib
-
-
-class ProductManager(NocodbClient):
-
-    def __init__(self, table_id=None, logging=False, NOCODB_HOST=None, NOCODB_API_KEY=None, SOURCE=None):
-        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.logging = logging
-        self.required_fields = [PRODUCT_NAME_FIELD, PRODUCT_PRICE_FIELD]
-        self.projection = []
-        self.external_categories = {}
-        self.products_table = table_id
-        self.actual_products = []
-        self.columns = []
-
-    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_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()
-        return hex_dig
-
-    @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_products(self, table_id: str) -> List[ProductModel]:
-        records = await self.get_table_records(self.products_table, self.required_fields, self.projection)
-        return [parse_product_data(record) for record in records]
-
-    # @cached(ttl=30, key_builder=custom_key_builder)
-    async def get_products_v2(self, offset: int, limit: int, table_id: Optional[str] = None) -> List[ProductModel]:
-        # Get the names of the tables from the DB for further handling
-        await self.get_all_tables()
-        response = await self.get_table_records_v2(table_name=self.products_table,
-                                                   required_fields=self.required_fields,
-                                                   projection=self.projection,
-                                                   offset=offset,
-                                                   limit=limit)
-        products = [await parse_product_data(record) for record in response['list']]
-
-        return products
-
-    @cached(ttl=180, key_builder=custom_key_builder)
-    async def search_products(self, table_id: str, search_string: str, limit: int) -> List[ProductModel]:
-        records = await self.get_table_records(
-            table_name=self.products_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=f"({PRODUCT_NAME_FIELD},like,%{search_string}%)",  # Update with actual product name field
-            limit=limit
-        )
-        return [parse_product_data(record) for record in records]
-
-    @cached(ttl=180, key_builder=custom_key_builder)
-    async def search_products_v2(self, table_id: str, search_string: str, limit: int) -> List[ProductModel]:
-        records = (await self.get_table_records_v2(
-            table_name=self.products_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=f"({PRODUCT_NAME_FIELD},like,%{search_string}%)",  # Update with actual product name field
-            limit=limit
-        ))['list']
-        return [parse_product_data(record) for record in records]
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def get_product(self, table_id: str, product_id: str) -> ProductModel:
-        record = await self.get_table_record(self.products_table, product_id)
-        return parse_product_data(record)
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def get_product_v2(self, table_id: str, product_id: str) -> ProductModel:
-        record = await self.get_table_record(self.products_table, product_id)
-        product = parse_product_data(record)
-
-        related_products = await self.get_table_records_v2(
-            table_name=self.products_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=(f'({PRODUCT_STOCK_FIELD},gt,0)~and'
-                         f"({PRODUCT_CATEGORY_ID_LOOKUP_FIELD},eq,{product.category[0]})~and"
-                         f'({PRODUCT_NAME_FIELD},neq,{product.name})'),
-            limit=5
-        )
-        related_products = [parse_product_data(product) for product in related_products['list']]
-
-        product.related_products = related_products
-        return product
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def get_product_in_category(self, table_id: str, category_id: str = None) -> List[ProductModel]:
-        if category_id is None:
-            return await self.get_products(table_id=self.products_table)
-
-        records = await self.get_table_records(
-            table_name=self.products_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=(f'({PRODUCT_STOCK_FIELD},gt,0)~and'
-                         f"({PRODUCT_CATEGORY_ID_LOOKUP_FIELD},eq,{category_id})")
-        )
-        return [parse_product_data(record) for record in records]
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def get_product_in_category_v2(self,
-                                         table_id: str,
-                                         offset: int,
-                                         limit: int,
-                                         category_id: str = None) -> ProductModel:
-        if category_id is None:
-            return await self.get_products_v2(table_id=self.products_table, offset=offset, limit=limit)
-
-        response = (await self.get_table_records_v2(
-            table_name=self.products_table,
-            required_fields=self.required_fields,
-            projection=self.projection,
-            extra_where=(f'({PRODUCT_STOCK_FIELD},gt,0)~and'
-                         f"({PRODUCT_CATEGORY_ID_LOOKUP_FIELD},eq,{category_id})"),
-            offset=offset,
-            limit=limit
-        ))
-        page_info = get_pagination_info(page_info=response['pageInfo'])
-        products = [parse_product_data(record) for record in response['list']]
-        return ProductModel(products=products, page_info=page_info)
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def get_products_by_ids(self, table_id: str, product_ids: list) -> List[ProductModel]:
-        product_ids_str = ','.join(str(product_id) for product_id in product_ids)
-
-        records = await self.get_table_records(
-            table_name=self.products_table,
-            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]   
-
-    @cached(ttl=60, key_builder=custom_key_builder)
-    async def update_attributes(self,products:List[ProductModel]):
-        system_attributes = [PRODUCT_EXTERNAL_ID,PRODUCT_IMAGES_LOOKUP_FIELD]
-        attributes=await self.get_table_meta(table_name=self.products_table)    
-        self.columns =[item['title'].lower() for item in attributes.get('columns', [])]
-
-        #TODO Requires Validation
-        for attribute_name in system_attributes:
-            if attribute_name.lower() not in self.columns:
-                response =await self.create_table_column(table_name=self.products_table,name=attribute_name)
-                logger.info(f"Created attribute: {attribute_name}")
-
-        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:
-            if product.name == name:
-                return product.id
-        return None  # Return None if no product is found with the given name