123

alembic/env.py

@@ -7,7 +7,7 @@ from sqlalchemy.engine import Connection
 from alembic import context
 
 from backend.session import engine
-from models import BaseModel
+from database.stocks.models.base import BaseStocksModel as BaseModel
 
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.

database/__init__.py

@@ -1,4 +1,7 @@
 from sqlalchemy.orm import configure_mappers
-from .base import *
+
+from .stocks.models import *
+
+from .sipro.models import *
 
 configure_mappers()

database/sipro/__init__.py

@@ -0,0 +1 @@
+from .models import *

database/sipro/models/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseSiproModel
+from .general import *
+from .products import *

database/sipro/models/associations.py

@@ -0,0 +1,25 @@
+from .base import BaseSiproModel
+
+from sqlalchemy import Table, Column, ForeignKey
+
+marketplace_warehouses = Table(
+    'marketplace_warehouses',
+    BaseSiproModel.metadata,
+    Column('marketplace_id', ForeignKey('marketplaces.id')),
+    Column('warehouse_id', ForeignKey('warehouses.id'))
+)
+
+warehouse_suppliers = Table(
+    'warehouse_suppliers',
+    BaseSiproModel.metadata,
+    Column('warehouse_id', ForeignKey('warehouses.id')),
+    Column('supplier_id', ForeignKey('suppliers.id'))
+)
+
+warehouse_company_warehouses = Table(
+    'warehouse_company_warehouses',
+    BaseSiproModel.metadata,
+    Column('warehouse_id', ForeignKey('warehouses.id')),
+    Column('company_warehouse_id', ForeignKey('company_warehouses.id')),
+
+)

database/sipro/models/base.py

@@ -0,0 +1,10 @@
+from sqlalchemy import MetaData
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase
+
+
+class BaseSiproModel(AsyncAttrs, DeclarativeBase):
+    metadata = MetaData(schema='public')
+    __table_args__ = {
+        'schema': 'public',
+    }

database/sipro/models/general.py

@@ -0,0 +1,56 @@
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import mapped_column, Mapped, relationship
+
+from .base import BaseSiproModel
+from .associations import marketplace_warehouses, warehouse_company_warehouses, warehouse_suppliers
+
+
+class Company(BaseSiproModel):
+    __tablename__ = 'companies'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    warehouse: Mapped["CompanyWarehouse"] = relationship(
+        back_populates="company"
+    )
+    is_denco: Mapped[bool] = mapped_column()
+    balance: Mapped[int] = mapped_column()
+
+
+class CompanyWarehouse(BaseSiproModel):
+    __tablename__ = 'company_warehouses'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    company_id: Mapped[int] = mapped_column(ForeignKey('companies.id'))
+    company: Mapped["Company"] = relationship(back_populates='warehouse')
+
+
+class Supplier(BaseSiproModel):
+    __tablename__ = 'suppliers'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    is_pseudo: Mapped[bool] = mapped_column()
+
+
+class Warehouse(BaseSiproModel):
+    __tablename__ = 'warehouses'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    suppliers: Mapped[List["Supplier"]] = relationship(secondary=warehouse_suppliers)
+    company_warehouses: Mapped[List["CompanyWarehouse"]] = relationship(secondary=warehouse_company_warehouses)
+
+
+class Marketplace(BaseSiproModel):
+    __tablename__ = 'marketplaces'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column()
+    auth_data: Mapped[str] = mapped_column()
+
+    sell_mixes: Mapped[bool] = mapped_column()
+    sell_blocks: Mapped[bool] = mapped_column()
+    sell_warehouse_products: Mapped[bool] = mapped_column()
+    sell_from_price: Mapped[bool] = mapped_column()
+
+    warehouses: Mapped[List["Warehouse"]] = relationship(secondary=marketplace_warehouses)
+
+    company_id: Mapped[int] = mapped_column(ForeignKey('companies.id'))
+    company: Mapped["Company"] = relationship()

database/sipro/models/products.py

@@ -0,0 +1,60 @@
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .base import BaseSiproModel
+from .general import Marketplace
+
+
+class Product(BaseSiproModel):
+    __tablename__ = 'products'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    denco_article: Mapped[int] = mapped_column(index=True)
+    article: Mapped[str] = mapped_column(index=True)
+
+
+class MarketplaceProduct(BaseSiproModel):
+    __tablename__ = 'marketplace_products'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    marketplace_id: Mapped[int] = mapped_column(ForeignKey('marketplaces.id'))
+    marketplace: Mapped["Marketplace"] = relationship()
+    mp_price_bought: Mapped[int] = mapped_column()
+    price_recommended: Mapped[int] = mapped_column()
+    is_archived: Mapped[bool] = mapped_column()
+
+    product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+    product: Mapped["Product"] = relationship()
+
+
+class SupplierProduct(BaseSiproModel):
+    __tablename__ = 'supplier_products'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    supplier_stock: Mapped[int] = mapped_column()
+    supplier_id: Mapped[int] = mapped_column()
+
+    product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+    product: Mapped["Product"] = relationship()
+
+    in_block: Mapped[int] = mapped_column()
+
+
+class CompanyWarehouseProduct(BaseSiproModel):
+    __tablename__ = 'company_warehouse_products'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    is_sold: Mapped[bool] = mapped_column()
+    company_warehouse_id: Mapped[int] = mapped_column()
+
+    product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+    product: Mapped["Product"] = relationship()
+
+
+class ProductRelation(BaseSiproModel):
+    __tablename__ = "products_relations"
+    id: Mapped[int] = mapped_column(primary_key=True, comment="ID связи в БД")
+
+    master_product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+    master_product: Mapped["Product"] = relationship(foreign_keys=[master_product_id])
+
+    slave_product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+    slave_product: Mapped["Product"] = relationship(foreign_keys=[slave_product_id])
+
+    relation_type: Mapped[int] = mapped_column(comment="Тип связи (ENUM)")

database/stocks/models/__init__.py

@@ -0,0 +1,2 @@
+from .base import BaseStocksModel
+from .general import *

database/stocks/models/base.py

@@ -0,0 +1,10 @@
+from sqlalchemy import MetaData
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase
+
+
+class BaseStocksModel(AsyncAttrs, DeclarativeBase):
+    metadata = MetaData(schema='stocks')
+    __table_args__ = {
+        'schema': 'stocks',
+    }

database/stocks/models/general.py

@@ -0,0 +1,10 @@
+from sqlalchemy.orm import mapped_column, Mapped
+
+from .base import BaseStocksModel
+
+
+class DailyStock(BaseStocksModel):
+    __tablename__ = 'daily_stocks'
+    product_id: Mapped[int] = mapped_column(primary_key=True)
+    sold_today: Mapped[int] = mapped_column()
+    test: Mapped[bool] = mapped_column()

main.py

@@ -1,11 +1,315 @@
-from fastapi import FastAPI
+from typing import Annotated
+
+from fastapi import FastAPI, Depends
+from sqlalchemy import select, func, and_, cast, String
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import joinedload
+
+from backend.session import get_session
+from database.sipro import *
 
 app = FastAPI()
 
 
+def get_marketplace_suppliers_and_company_warehouses(marketplace: Marketplace):
+    company = marketplace.company
+    suppliers = set()
+    company_warehouses = set()
+    for warehouse in marketplace.warehouses:
+        for supplier in warehouse.suppliers:
+            if supplier.is_pseudo:
+                continue
+            suppliers.add(supplier)
+        company_warehouses.update(warehouse.company_warehouses)
+    if marketplace.sell_warehouse_products:
+        company_warehouse = company.warehouse
+        if company_warehouse and not company.is_denco:
+            company_warehouses.add(company_warehouse)
+    return suppliers, company_warehouses
+
+
+# def get_stocks_data(marketplace: Marketplace):
+#     suppliers, company_warehouses = get_marketplace_suppliers_and_company_warehouses(marketplace)
+#     supplier_ids = [supplier.id for supplier in suppliers]
+#     company_warehouse_ids = [warehouse.id for warehouse in company_warehouses]
+#
+#     sell_mixes: bool = marketplace.sell_mixes
+#     sell_blocks: bool = marketplace.sell_blocks
+#     sell_warehouse_products: bool = marketplace.sell_warehouse_products
+#     sell_from_price: int = marketplace.sell_from_price
+#
+#     stmt = (
+#         select(
+#             MarketplaceProduct
+#         )
+#         .join(
+#             Product
+#         )
+#         .options(
+#             joinedload(MarketplaceProduct.product)
+#         )
+#         .where(
+#             MarketplaceProduct.marketplace_id == marketplace.id
+#         )
+#     )
+#     supplier_stock_subquery = (
+#         select(
+#             func.sum(SupplierProduct.supplier_stock).label('supplier_stock'),
+#             Product.id.label('product_id')
+#         )
+#         .join(
+#             Product
+#         )
+#         .where(
+#             SupplierProduct.supplier_id.in_(supplier_ids)
+#         )
+#         .group_by(
+#             Product.id
+#         )
+#         .subquery()
+#     )
+#
+#     warehouse_stock_subquery = (
+#         select(
+#             func.count(CompanyWarehouseProduct.is_sold).label('warehouse_stock'),
+#             CompanyWarehouseProduct.product_id.label('product_id')
+#         )
+#         .where(
+#             CompanyWarehouseProduct.is_sold == False,
+#             CompanyWarehouseProduct.company_warehouse_id.in_(company_warehouse_ids)
+#         )
+#         .group_by(
+#             CompanyWarehouseProduct.product_id
+#         )
+#         .subquery()
+#     )
+
+async def get_stocks_data(session: AsyncSession, marketplace: Marketplace):
+    company = marketplace.company
+    suppliers, company_warehouses = get_marketplace_suppliers_and_company_warehouses(marketplace)
+    supplier_ids = [supplier.id for supplier in suppliers]
+    company_warehouse_ids = [warehouse.id for warehouse in company_warehouses]
+
+    sell_mixes: bool = marketplace.sell_mixes
+    sell_blocks: bool = marketplace.sell_blocks
+    sell_warehouse_products: bool = marketplace.sell_warehouse_products
+    sell_from_price: int = marketplace.sell_from_price
+
+    supplier_stock_subquery = (
+        select(
+            func.sum(SupplierProduct.supplier_stock).label('supplier_stock'),
+            SupplierProduct.product_id.label('product_id')
+        )
+        .select_from(SupplierProduct)
+        .join(Product)
+        .where(SupplierProduct.supplier_id.in_(supplier_ids))
+        .group_by(SupplierProduct.product_id)
+        .subquery()
+    )
+
+    warehouse_stock_subquery = (
+        select(
+            func.count(CompanyWarehouseProduct.is_sold).label('warehouse_stock'),
+            CompanyWarehouseProduct.product_id.label('product_id')
+        )
+        .select_from(CompanyWarehouseProduct)
+        .where(
+            CompanyWarehouseProduct.is_sold == False,
+            CompanyWarehouseProduct.company_warehouse_id.in_(company_warehouse_ids)
+        )
+        .group_by(CompanyWarehouseProduct.product_id)
+        .subquery()
+    )
+
+    mix_stock_first_subquery = (
+        select(
+            func.sum(SupplierProduct.supplier_stock).label('master_stock'),
+            SupplierProduct.product_id.label('product_id')
+        )
+        .select_from(SupplierProduct)
+        .where(SupplierProduct.supplier_id.in_(supplier_ids))
+        .group_by(SupplierProduct.product_id)
+        .subquery()
+    )
+
+    mix_stock_full_subquery = (
+        select(
+            func.min(SupplierProduct.in_block).label('mix_stock'),
+            Product.id.label('product_id')
+        )
+        .select_from(Product)
+        .join(SupplierProduct)
+        .join(ProductRelation, Product.id == ProductRelation.slave_product_id)
+        .join(mix_stock_first_subquery, mix_stock_first_subquery.c.product_id == ProductRelation.master_product_id)
+        .where(
+            ProductRelation.relation_type == 5,
+            mix_stock_first_subquery.c.master_stock > 0
+        )
+        .group_by(Product.id)
+        .subquery()
+    )
+
+    is_master_first_subquery = (
+        select(
+            ProductRelation.master_product_id,
+            (func.count(ProductRelation.master_product_id) > 0).label('is_master')
+        )
+        .where(
+            ProductRelation.relation_type == 5
+        )
+        .group_by(ProductRelation.master_product_id)
+        .subquery()
+    )
+
+    is_master_subquery = (
+        select(
+            Product.id.label('product_id'),
+            func.coalesce(is_master_first_subquery.c.is_master, False).label('is_master')
+        )
+        .select_from(
+            Product
+        )
+        .outerjoin(
+            is_master_first_subquery,
+            Product.id == is_master_first_subquery.c.master_product_id
+        )
+        .subquery()
+    )
+
+    in_block_subquery = (
+        select(
+            Product.id.label('product_id'),
+            func.min(SupplierProduct.in_block).label('in_block_value')
+        )
+        .select_from(Product)
+        .join(SupplierProduct)
+        .where(
+            SupplierProduct.supplier_id.in_(supplier_ids),
+            SupplierProduct.supplier_stock > 0
+        )
+        .group_by(Product.id)
+        .subquery()
+    )
+    slaves_stock_first_subquery = (
+        select(
+            ProductRelation.master_product_id.label('product_id'),
+            func.sum(SupplierProduct.supplier_stock).label('slaves_stock')
+        )
+        .select_from(ProductRelation)
+        .join(SupplierProduct, and_(
+            ProductRelation.slave_product_id == SupplierProduct.product_id,
+            ProductRelation.relation_type == 7
+        ))
+        .where(SupplierProduct.supplier_id.in_(supplier_ids))
+        .group_by(ProductRelation.master_product_id)
+        .subquery()
+    )
+
+    slaves_stock_subquery = (
+        select(
+            Product.id.label('product_id'),
+            slaves_stock_first_subquery.c.slaves_stock.label('slaves_stock')
+        )
+        .select_from(Product)
+        .join(slaves_stock_first_subquery, slaves_stock_first_subquery.c.product_id == Product.id)
+        .subquery()
+    )
+
+    stmt = (
+        select(
+            MarketplaceProduct,
+            func.coalesce(Product.article, cast(Product.denco_article, String)).label('denco_article'),
+            MarketplaceProduct.mp_price_bought.label('price_purchase'),
+            supplier_stock_subquery.c.supplier_stock.label('supplier_stock'),
+            warehouse_stock_subquery.c.warehouse_stock.label('warehouse_stock'),
+            mix_stock_full_subquery.c.mix_stock.label('mix_stock'),
+            in_block_subquery.c.in_block_value.label('in_block_value'),
+            is_master_subquery.c.is_master.label('is_master'),
+            slaves_stock_subquery.c.slaves_stock.label('slaves_stock'),
+            MarketplaceProduct.price_recommended.label('price_recommended'),
+            MarketplaceProduct.is_archived.label('is_archived')
+        )
+        .select_from(MarketplaceProduct)
+        .join(Product)
+        .options(joinedload(MarketplaceProduct.product))
+        .where(MarketplaceProduct.marketplace_id == marketplace.id)
+        .outerjoin(supplier_stock_subquery, supplier_stock_subquery.c.product_id == MarketplaceProduct.product_id)
+        .outerjoin(warehouse_stock_subquery, warehouse_stock_subquery.c.product_id == MarketplaceProduct.product_id)
+        .outerjoin(mix_stock_full_subquery, mix_stock_full_subquery.c.product_id == MarketplaceProduct.product_id)
+        .outerjoin(in_block_subquery, in_block_subquery.c.product_id == MarketplaceProduct.product_id)
+        .outerjoin(is_master_subquery, is_master_subquery.c.product_id == MarketplaceProduct.product_id)
+        .outerjoin(slaves_stock_subquery, slaves_stock_subquery.c.product_id == MarketplaceProduct.product_id)
+    )
+    print(stmt.compile(compile_kwargs={
+        'literal_binds': True
+    }))
+
+    result = await session.execute(stmt)
+    marketplace_products = result.all()
+    result = []
+    for marketplace_product, denco_article, price_purchase, supplier_stock, warehouse_stock, mix_stock, in_block_value, is_master, slaves_stock, price_recommended, is_archived in marketplace_products:
+        if is_archived or (sell_from_price > price_recommended):
+            result.append({
+                'denco_article': denco_article,
+                'full_stock': 0,
+                # 'marketplace_product': marketplace_product,
+            })
+            continue
+
+        is_mix = mix_stock is not None
+
+        in_block_value = in_block_value or 1
+        price_purchase = price_purchase or 0
+        supplier_stock = supplier_stock or 0
+        warehouse_stock = warehouse_stock or 0
+        mix_stock = mix_stock or 0
+        slaves_stock = slaves_stock or 0
+
+        if not sell_warehouse_products:
+            warehouse_stock = 0
+
+        if all([is_mix, slaves_stock > 0]):
+            mix_stock = 0
+        balance_limit = price_purchase > company.balance
+
+        if balance_limit:
+            supplier_stock = 0
+        full_stock = supplier_stock + warehouse_stock
+
+        if all([not is_mix, not sell_blocks, in_block_value > 1]):
+            full_stock = warehouse_stock
+        if sell_mixes and (not balance_limit):
+            full_stock += mix_stock
+        if (not sell_mixes) and is_master:
+            full_stock = warehouse_stock
+        if (not sell_mixes) and is_mix:
+            full_stock = warehouse_stock
+        if 45 > company.balance:
+            full_stock = 0
+        full_stock = max([0, full_stock])
+
+        result.append({
+            'denco_article': denco_article,
+            'full_stock': full_stock,
+            # 'marketplace_product': marketplace_product,
+        })
+
+    return result
+
+
 @app.get("/")
-async def root():
-    return {"message": "Helldasdo 312World"}
+async def root(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        marketplace_id: int
+):
+    marketplace = await session.get(Marketplace, marketplace_id, options=[
+        joinedload(Marketplace.warehouses).joinedload(Warehouse.suppliers),
+        joinedload(Marketplace.warehouses).joinedload(Warehouse.company_warehouses),
+        joinedload(Marketplace.company).joinedload(Company.warehouse)
+    ])
+    data = await get_stocks_data(session, marketplace)
+    data = sorted(data, key=lambda x: x['denco_article'])
+    return {"message": data}
 
 
 @app.get("/hello/{name}")

migrate.bat

@@ -0,0 +1,2 @@
+alembic revision --autogenerate
+alembic upgrade head

models/base.py

@@ -1,13 +0,0 @@
-from sqlalchemy import MetaData, ForeignKey
-from sqlalchemy.orm import declarative_base, Mapped, mapped_column
-
-BaseModel = declarative_base(metadata=MetaData(schema='stocks'))
-
-
-class DailyStock(BaseModel):
-    __tablename__ = 'daily_stocks'
-    __table_args__ = {
-        'schema': 'stocks',
-    }
-    product_id: Mapped[int] = mapped_column( primary_key=True)
-    sold_today: Mapped[int] = mapped_column()