tgshops-integrations 0.1__py3-none-any.whl → 0.2__py3-none-any.whl

tgshops_integrations/middlewares/gateway.py

@@ -0,0 +1,111 @@
+from typing import List,Optional
+
+from aiocache import cached
+from models.products import ProductModel
+from nocodb_connector.client import NocodbClient
+from 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
+
+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
+
+
+class Gateway(NocodbClient):
+
+    def __init__(self,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.logging=logging
+        self.required_fields = [PRODUCT_NAME_FIELD, PRODUCT_PRICE_FIELD]
+        self.projection = []
+
+
+    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)
+
+    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")
+        record = await self.create_table_record(table_name=products_table, record=data)
+        logger.info(f"Created product {record['id']}")
+        return parse_product_data(record)
+
+    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)
+        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]):
+                    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]
+        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}")
+        
+        
+    def find_product_id_by_name(self,name: str):
+        for product in self.product_manager.actual_products.products:
+            if product.name == name:
+                return product.id
+        return None  # Return None if no product is found with the given name
+    
+    async def create_table_column(self, name: str, table_id: Optional[str] = None):
+
+        BEARER_TOKEN = "jpdxJtyfDXdjbvxKAcIij1HA8HGalgalLLXZ46DV"
+        
+        headers = {
+            "Authorization": f"Bearer {BEARER_TOKEN}"
+        }
+        if not table_id:
+            table_id = self.tables_list[NOCODB_PRODUCTS]
+
+        response = await self.httpx_client.post(
+            f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_id}/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
+            },
+            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]    
+        for num,item in enumerate(items):
+            await self.delete_table_record(products_table, item.id)

tgshops_integrations/models/categories.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel
+from pydantic import BaseModel, Field, schema, validator
+from typing import List
+
+class PaginationResponseModel(BaseModel):
+    total_rows: int
+    page: int
+    page_size: int
+    is_first_page: bool
+    is_last_page: bool
+
+
+class ExternalCategoryModel(BaseModel):
+    external_id: str
+    name: str
+    parent_category: str
+    preview_url: str
+
+
+class CategoryModel(ExternalCategoryModel):
+    name: str
+    parent_category: str = ''
+    preview_url: str = ''
+
+    @validator('name')
+    def not_empty_string(cls, value):
+        if not value:
+            raise ValueError('Name cannot be an empty string.')
+        return value
+    
+
+class CategoryResponseModel(BaseModel):
+    id: str
+    name: str
+    parent_category: str
+    preview_url: str
+
+    # TODO: add bitrix category id here
+    external_id: str = None
+
+class CategoryListResponseModel(BaseModel):
+    categories: List[CategoryResponseModel]
+    page_info: PaginationResponseModel

tgshops_integrations/models/products.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from typing import Any, List, Optional
+from datetime import datetime
+
+from pydantic import BaseModel, Field, schema, validator
+
+
+class ExtraAttribute(BaseModel):
+    name: str
+    description: Optional[str]
+
+class ExternalProductModel(BaseModel):
+    external_id: 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] = []
+
+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] = []
+
+
+
+class ProductModel(ExternalProductModel):
+    id: str

tgshops_integrations/nocodb_connector/categories.py

@@ -0,0 +1,102 @@
+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, 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):
+        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.categories_table=table_id
+        self.external_categories={}
+        self.logging=logging
+        self.required_fields = [CATEGORY_NAME_FIELD]
+        self.projection = ["Id", CATEGORY_NAME_FIELD, CATEGORY_PARENT_ID_FIELD, CATEGORY_IMAGE_FIELD]
+
+    @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]):
+        # 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)
+        
+        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
+    
+    async def map_categories(self,external_products: List[ProductModel]) -> List[ProductModel]:
+        for product in external_products:
+            if not product.category:
+                for category in product.category_name:
+                    product.category.append(self.categories[category])
+        return external_products

tgshops_integrations/nocodb_connector/client.py

@@ -0,0 +1,186 @@
+from typing import List,Optional
+
+import httpx
+import requests
+from loguru import logger
+
+from tgshops_integrations.nocodb_connector.model_mapping import ID_FIELD
+
+
+def custom_key_builder(func, *args, **kwargs):
+    # Exclude 'self' by starting args processing from args[1:]
+    args_key_part = "-".join(str(arg) for arg in args[1:])
+    kwargs_key_part = "-".join(f"{key}-{value}" for key, value in sorted(kwargs.items()))
+    return f"{func.__name__}-{args_key_part}-{kwargs_key_part}"
+
+
+class NocodbClient:
+      
+    def __init__(self,NOCODB_HOST=None,NOCODB_API_KEY=None,SOURCE=None):
+        self.NOCODB_HOST = NOCODB_HOST
+        self.NOCODB_API_KEY = NOCODB_API_KEY
+        self.SOURCE=SOURCE
+        self.httpx_client = httpx.AsyncClient()
+        self.httpx_client.headers = {
+            "xc-token": self.NOCODB_API_KEY
+        }
+
+    def construct_get_params(self,
+                             required_fields: list = None,
+                             projection: list = None,
+                             extra_where: str = None,
+                             offset: int = None,
+                             limit: int = None) -> dict:
+        extra_params = {}
+        if projection:
+            extra_params["fields"] = ','.join(projection)
+        if required_fields:
+            extra_params["where"] = ""
+            for field in required_fields:
+                extra_params["where"] += f"({field},isnot,null)~and"
+            extra_params["where"] = extra_params["where"].rstrip("~and")
+        if extra_where:
+            if not extra_params.get("where"):
+                extra_params["where"] = extra_where
+            else:
+                extra_params["where"] += f"~and{extra_where}"
+        if offset:
+            extra_params['offset'] = offset
+        if limit:
+            extra_params["limit"] = limit
+        return extra_params
+
+    async def get_table_records(self,
+                                table_name: str,
+                                required_fields: list = None,
+                                projection: list = None,
+                                extra_where: str = None,
+                                limit: int = None) -> List[dict]:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        extra_params = self.construct_get_params(required_fields, projection, extra_where, limit=limit)
+        response = await self.httpx_client.get(url, params=extra_params)
+        if response.status_code == 200:
+            return response.json()["list"]
+        raise Exception(response.text)
+
+    async def get_table_records_v2(self,
+                                   table_name: str,
+                                   required_fields: list = None,
+                                   projection: list = None,
+                                   extra_where: str = None,
+                                   offset: int = None,
+                                   limit: int = 25) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        extra_params = self.construct_get_params(required_fields, projection, extra_where, offset=offset, limit=limit)
+        response = await self.httpx_client.get(url, params=extra_params)
+        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,
+                               record_id: str,
+                               required_fields: list = None,
+                               projection: list = None) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records/{record_id}"
+        extra_params = self.construct_get_params(required_fields, projection)
+        response = await self.httpx_client.get(url, params=extra_params)
+        if response.status_code == 200:
+            return response.json()
+        raise Exception(response.text)
+
+    async def create_table_record(self, table_name: str, record: dict) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        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")
+            return record
+        raise Exception(response.text)
+
+    async def count_table_records(self, table_name: str) -> int:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records/count"
+        response = await self.httpx_client.get(url)
+        if response.status_code == 200:
+            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:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        updated_data[ID_FIELD] = record_id
+        response = await self.httpx_client.patch(url, json=updated_data)
+        if response.status_code == 200:
+            return True
+        raise Exception(response.text)
+
+    async def delete_table_record(self, table_name: str, record_id: str) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        response = requests.delete(url, json={"Id": record_id}, headers=self.httpx_client.headers)
+        if response.status_code == 200:
+            logger.info(f"Deleted item {record_id}")
+        return response.json()
+
+    # Not transport
+    async def get_product_categories(self, table_id: str,table_name : str) -> int:
+        url = f"{self.NOCODB_HOST}/tables/{table_id}/records"
+        limit=75
+        extra_params = self.construct_get_params(limit=limit)
+        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)
+    
+    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"
+
+        record={table_name: category_name, "Id" : category_id}
+
+        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)
+            return record
+        raise Exception(response.text)
+    
+    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 get_all_tables(self, source: Optional[str] = None):
+        if not source:
+            source=self.SOURCE
+
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/projects/{source}/tables?includeM2M=false"
+        response=(await self.httpx_client.get(url)).json()
+        tables_info=response.get('list', [])
+        self.tables_list={table["title"] : table["id"] for table in tables_info}
+        return self.tables_list
+
+    async def get_sources(self):
+        return (await self.httpx_client.get(
+            f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/projects/")).json().get(
+            'list', [])
+
+    def link_tables(self, source: str, parent_id: str, child_id: str, parent_table: str, child_table: str):
+        """
+        Связывает таблицы
+        :param source:
+        :param parent_id:
+        :param child_id:
+        :param parent_table:
+        :param child_table:
+        :return:
+        """
+        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()

tgshops_integrations/nocodb_connector/model_mapping.py

@@ -0,0 +1,166 @@
+import json
+import secrets
+
+import markdown
+
+from tgshops_integrations.models.categories import CategoryModel
+from tgshops_integrations.models.products import ExtraAttribute, ProductModel
+from tgshops_integrations.models.categories import CategoryResponseModel,PaginationResponseModel
+from tgshops_integrations.models.products import  ProductModel
+
+
+def get_pagination_info(page_info: dict) -> PaginationResponseModel:
+    page_info = PaginationResponseModel(total_rows=page_info['totalRows'],
+                                        page=page_info['page'],
+                                        page_size=page_info['pageSize'],
+                                        is_first_page=page_info['isFirstPage'],
+                                        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):
+        preview_url = data[CATEGORY_IMAGE_FIELD][0].get("url", "")
+    return CategoryResponseModel(
+        id=str(data[ID_FIELD]),
+        name=data.get(CATEGORY_NAME_FIELD, ""),
+        parent_category=str(data.get(CATEGORY_PARENT_ID_FIELD, 0)),
+        preview_url=preview_url,
+    )
+
+
+def dump_category_data(data: CategoryModel) -> dict:
+    return {
+        CATEGORY_NAME_FIELD: data.name,
+        CATEGORY_PARENT_FIELD: data.parent_category,
+        CATEGORY_IMAGE_FIELD: [
+            {"url": data.preview_url, 'title': f'{secrets.token_hex(6)}.jpeg', 'mimetype': 'image/jpeg'}]
+    }
+
+
+# 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'}
+                    for image_url in data.preview_url]
+                   if data.preview_url
+                   else [])
+
+    return {
+        PRODUCT_NAME_FIELD: data.name,
+        PRODUCT_DESCRIPTION_FIELD: data.description,
+        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
+    }
+
+def dump_product_data_with_check(data: ProductModel, data_check: dict) -> dict:
+ 
+    preview_url = ([{'url': image_url,
+                    'title': f'{secrets.token_hex(6)}.jpeg',
+                    'mimetype': 'image/jpeg'}
+                for image_url in data.preview_url]
+                if data.preview_url
+                else [])
+    product_data = {
+        PRODUCT_ID_FIELD: data.id,
+        PRODUCT_EXTERNAL_ID: data.external_id,
+        PRODUCT_NAME_FIELD: data.name,
+        PRODUCT_DESCRIPTION_FIELD: data.description,
+        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_IMAGE_FIELD: preview_url,
+        PRODUCT_DISCOUNT_PRICE_FIELD: data.final_price
+        }
+    return product_data
+
+
+async def parse_product_data(data: dict) -> ProductModel:
+    preview_url = [image['url'] for image in data[PRODUCT_IMAGE_FIELD]] if data.get(PRODUCT_IMAGE_FIELD, '') else []
+    primary_keys = [ID_FIELD,PRODUCT_NAME_FIELD, PRODUCT_DESCRIPTION_FIELD, PRODUCT_PRICE_FIELD,
+                    PRODUCT_CURRENCY_FIELD, PRODUCT_STOCK_FIELD, PRODUCT_CATEGORY_ID_FIELD, PRODUCT_IMAGE_FIELD,
+                    PRODUCT_CATEGORY_NAME_FIELD, PRODUCT_DISCOUNT_PRICE_FIELD, PRODUCT_CATEGORY_ID_LOOKUP_FIELD,
+                    PRODUCT_REQUIRED_OPTIONS_FIELD, PRODUCT_CATEGORIES_EXTRA_OPTIONS_FIELD,
+                    PRODUCT_CATEGORIES_EXTRA_OPTION_NAMES_FIELD, PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD,
+                    "UpdatedAt", "CreatedAt"]
+
+    # Dynamically adding extra attributes
+    extra_attributes = []
+    for key, value in data.items():
+        if key not in primary_keys and value is not None and type(value) in [str, int, float]:
+            extra_attributes.append(ExtraAttribute(name=key, description=str(value)))
+
+    product = ProductModel(
+        id=str(data[ID_FIELD]) if data.get(ID_FIELD) else data.get(NEW_ID_FIELD),
+        external_id=data.get(PRODUCT_EXTERNAL_ID, ""),
+        name=data.get(PRODUCT_NAME_FIELD, ""),
+        description=data.get(PRODUCT_DESCRIPTION_FIELD, "") if data.get(PRODUCT_DESCRIPTION_FIELD) else "",
+        price=data.get(PRODUCT_PRICE_FIELD, 0.0),
+        currency=data.get(PRODUCT_CURRENCY_FIELD, ["RUB","CZK","GBP"]) if data.get(PRODUCT_CURRENCY_FIELD) else "RUB",
+        stock_qty=data.get(PRODUCT_STOCK_FIELD, 0),
+        preview_url=preview_url,
+        category_name=data.get(PRODUCT_CATEGORY_NAME_FIELD, []) if data.get(PRODUCT_CATEGORY_NAME_FIELD) else [],
+        category=data.get(PRODUCT_CATEGORY_ID_LOOKUP_FIELD, []) if data.get(PRODUCT_CATEGORY_ID_LOOKUP_FIELD) else [],
+        # category=[],
+        extra_attributes=extra_attributes,
+        extra_option_choice_required=any(data.get(PRODUCT_EXTRA_CHOICE_REQUIRED_FIELD, [])),
+        metadata = data
+    )
+    if data.get(PRODUCT_DISCOUNT_PRICE_FIELD, data.get(PRODUCT_PRICE_FIELD, 0.0)):
+        product.final_price = data.get(PRODUCT_DISCOUNT_PRICE_FIELD, data.get(PRODUCT_PRICE_FIELD, 0.0))
+    
+    return product
+
+
+
+

tgshops_integrations/nocodb_connector/products.py

@@ -0,0 +1,153 @@
+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
+
+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=[]
+
+    def hash_product(self,product):
+        # 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 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]    
+        
+    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

tgshops_integrations/nocodb_connector/tables.py

@@ -0,0 +1,11 @@
+NOCODB_CATEGORIES="Categories"
+NOCODB_PRODUCTS="Products"
+NOCODB_STATUSES="Order statuses"
+NOCODB_BOT_MESSAGES="Bot messages"
+NOCODB_ORDERS="Orders"
+
+# NOCODB_CATEGORIES="Категории"
+# NOCODB_PRODUCTS="Товары"
+# NOCODB_STATUSES="Статусы заказов"
+# NOCODB_BOT_MESSAGES="Сообщения бота"
+# NOCODB_ORDERS="Заказы"

{tgshops_integrations-0.1.dist-info → tgshops_integrations-0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tgshops-integrations
-Version: 0.1
+Version: 0.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-0.2.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=ze7e0JB0DpwVHTu8HSZSW3r884wNTy17P-e7Sk9HyNA,4979
+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.2.dist-info/METADATA,sha256=1qDeJ1TrLut0tfjloxGEVFVjyU4CwQc-e_0FuFd4jZ8,2391
+tgshops_integrations-0.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+tgshops_integrations-0.2.dist-info/top_level.txt,sha256=HFNtxqDpzmlF4ZLnMiwhbU7pOa_YozxU2zBl0bnUmcY,21
+tgshops_integrations-0.2.dist-info/RECORD,,

tgshops_integrations-0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+tgshops_integrations

tgshops_integrations-0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-tgshops_integrations-0.1.dist-info/METADATA,sha256=tmTHSs-Fv4h1eCpzSWz9ciefn0kh5kKYGOgDBaMA2TU,2391
-tgshops_integrations-0.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-tgshops_integrations-0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-tgshops_integrations-0.1.dist-info/RECORD,,

tgshops_integrations-0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-