release

db/handlers/orders.py

@@ -1,6 +1,7 @@
 from datetime import date, datetime, time
 from sqlalchemy import func, select
 from db import CRUD
+from db.handlers.records import ServiceRecordsHandler
 from db.schemas.orders import Orders
 from utils.loggers import logger
 
@@ -10,6 +11,10 @@ class OrdersHandler:
     async def new(user_id: int, order: str):
         try:
             await Orders(customer_id=user_id, customer_comment=order).save()
+            await ServiceRecordsHandler.add(
+                user_id,
+                {f"Добавлен заказ": f"{order}"},
+            )
         except Exception as e:
             logger.error(f"Ошибка создания заказа: {str(e)}")
             return {"errorMessage": f"Ошибка создания заказа: {str(e)}"}
@@ -92,6 +97,10 @@ class OrdersHandler:
             if comment:
                 changeData["executor_comment"] = comment
             await order.edit(**changeData)
+            await ServiceRecordsHandler.add(
+                user_id,
+                {f"Обновлен заказ": f"{order.customer_comment}"},
+            )
         except Exception as e:
             logger.error(f"Ошибка обновления заказа: {str(e)}")
             return {"errorMessage": f"Ошибка обновления заказа: {str(e)}"}

db/handlers/toolkit.py

@@ -3,7 +3,7 @@ from db.handlers.stock import StockHandler
 from db.handlers.user import UserHandler
 from utils import logger, saveImage, safeFilename
 from db import CRUD
-from db.schemas.toolkit import Toolkit
+from db.schemas.toolkit import Toolkit, ToolkitCompatibility
 from sqlalchemy import select
 from db.handlers.records import ServiceRecordsHandler
 from utils.image import deleteImage
@@ -173,7 +173,7 @@ class ToolkitHandler:
 
     @staticmethod
     async def getAll():
-        query = select(Toolkit)
+        query = select(Toolkit).order_by(Toolkit.id)
         toolkits = await CRUD.read(query, True)
         return [toolkit.toDict() for toolkit in toolkits] if toolkits else []
 
@@ -184,16 +184,15 @@ class ToolkitHandler:
         if not toolkit:
             logger.error("Инструмент не найден")
             return {}
+        data = toolkit.toDict()
         if toolkit.comment_user_id:
             user_data = await UserHandler.get(toolkit.comment_user_id)
-        data = toolkit.toDict()
-        data["comment_user_data"] = user_data
-        logger.info(data)
+            data["comment_user_data"] = user_data
         return data
 
     @staticmethod
     async def getSeveral(toolkitIds: list[int]) -> list[dict]:
-        query = select(Toolkit).where(Toolkit.id.in_(toolkitIds))
+        query = select(Toolkit).where(Toolkit.id.in_(toolkitIds)).order_by(Toolkit.id)
         toolkits = await CRUD.read(query, True)
         return [toolkit.toDict() for toolkit in toolkits] if toolkits else []
 
@@ -230,9 +229,6 @@ class ToolkitHandler:
 
     @staticmethod
     async def addComment(toolkitId: int, user_id: int, comment: str):
-        logger.info(f"Добавление комментария к инструменту {toolkitId}...")
-        logger.info(f"Комментарий: {comment}")
-        logger.info(f"Пользователь: {user_id}")
         query = select(Toolkit).where(Toolkit.id == toolkitId)
         toolkit = await CRUD.read(query)
         if not toolkit:
@@ -248,6 +244,45 @@ class ToolkitHandler:
         logger.info(f"Комментарий к инструменту {toolkit.title} успешно добавлен")
         return {"status": "ok"}
 
+    @staticmethod
+    async def addCompatibility(userId, data):
+        newCompatibility = await ToolkitCompatibility.add_compatibility(
+            int(data.get("toolkitId")), int(data.get("compatibleToolkitId"))
+        )
+        if "errorMessage" not in newCompatibility:
+            await ServiceRecordsHandler.add(
+                userId,
+                {
+                    f"Добавлена совместимость": f"{data.get('toolkitId')} - {data.get('compatibleToolkitId')}"
+                },
+            )
+        return newCompatibility
+
+    @staticmethod
+    async def deleteCompatibility(userId, data):
+        deleteCompatibility = await ToolkitCompatibility.remove_compatibility(
+            int(data.get("toolkitId")), int(data.get("compatibleToolkitId"))
+        )
+        if "errorMessage" not in deleteCompatibility:
+            await ServiceRecordsHandler.add(
+                userId,
+                {
+                    f"Удалена совместимость": f"{data.get('toolkitId')} - {data.get('compatibleToolkitId')}"
+                },
+            )
+        return deleteCompatibility
+
+    @staticmethod
+    async def getCompatibility(toolkitId: int):
+        result = await ToolkitCompatibility.get_compatibility(toolkitId)
+        if "errorMessage" in result:
+            return result
+        toolkitsIds = list(result.get("data").values())
+        toolkitsList = await ToolkitHandler.getSeveral(toolkitsIds)
+        toolkitsData = {toolkit["id"]: toolkit for toolkit in toolkitsList}
+        data = {"records": result.get("data"), "toolkits": toolkitsData}
+        return {"status": "ok", "data": data}
+
     @staticmethod
     async def initialize():
         from .categories import CategoryHandler

db/schemas/toolkit.py

@@ -1,9 +1,154 @@
 from datetime import datetime
-from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Integer,
+    String,
+    Text,
+    select,
+)
 from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import relationship
 from db import Base, CRUD
 import utils
+from sqlalchemy import Column, Integer, ForeignKey, UniqueConstraint, CheckConstraint
+
+
+class ToolkitCompatibility(Base):
+    __tablename__ = "toolkit_compatibility"
+
+    id = Column(Integer, primary_key=True)
+    toolkit_id = Column(
+        Integer, ForeignKey("toolkits.id", ondelete="CASCADE"), nullable=False
+    )
+    compatible_toolkit_id = Column(
+        Integer, ForeignKey("toolkits.id", ondelete="CASCADE"), nullable=False
+    )
+    __table_args__ = (
+        # Запрещаем дубли (A-B и A-B)
+        UniqueConstraint(
+            "toolkit_id", "compatible_toolkit_id", name="uq_toolkit_compatibility"
+        ),
+        # Запрещаем связь с самим собой
+        CheckConstraint(
+            "toolkit_id <> compatible_toolkit_id", name="ck_toolkit_not_self"
+        ),
+    )
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def toDict(self):
+        return {
+            "id": self.id,
+            "toolkit_id": self.toolkit_id,
+            "compatible_toolkit_id": self.compatible_toolkit_id,
+        }
+
+    @staticmethod
+    def getUnique(
+        compatibles: list["ToolkitCompatibility"], originalToolkitId: int
+    ) -> dict:
+        unique = []
+        uniqueData = {}
+        for c in compatibles:
+            if c.toolkit_id not in unique and c.toolkit_id != originalToolkitId:
+                unique.append(c.toolkit_id)
+                uniqueData[c.id] = c.toolkit_id
+            if (
+                c.compatible_toolkit_id not in unique
+                and c.compatible_toolkit_id != originalToolkitId
+            ):
+                unique.append(c.compatible_toolkit_id)
+                uniqueData[c.id] = c.compatible_toolkit_id
+        return uniqueData
+
+    async def save(self):
+        await CRUD.create(self)
+
+    @staticmethod
+    async def add_compatibility(a_id: int, b_id: int):
+        errorMsg = {
+            "status": "error",
+        }
+
+        if a_id == b_id:
+            utils.logger.error("Невозможно добавить совместимость с самим собой")
+            errorMsg["errorMessage"] = "Невозможно добавить совместимость с самим собой"
+            return errorMsg
+
+        toolkit_id, compatible_id = sorted([a_id, b_id])
+        try:
+
+            await ToolkitCompatibility(
+                toolkit_id=toolkit_id, compatible_toolkit_id=compatible_id
+            ).save()
+
+            return {"status": "ok"}
+
+        except Exception as e:
+            utils.logger.error(f"Ошибка добавления совместимости: {str(e)}")
+            errorMsg["errorMessage"] = f"Ошибка добавления совместимости: {str(e)}"
+            return errorMsg
+
+    @staticmethod
+    async def remove_compatibility(a_id: int, b_id: int):
+        errorMsg = {
+            "status": "error",
+        }
+        if a_id == b_id:
+            utils.logger.error("Невозможно удалить совместимость с самим собой")
+            errorMsg["errorMessage"] = "Невозможно удалить совместимость с самим собой"
+            return errorMsg
+
+        toolkit_id, compatible_id = sorted([a_id, b_id])
+
+        try:
+            compatibility = await CRUD.read(
+                select(ToolkitCompatibility).where(
+                    ToolkitCompatibility.toolkit_id == toolkit_id,
+                    ToolkitCompatibility.compatible_toolkit_id == compatible_id,
+                )
+            )
+
+            if not compatibility:
+                utils.logger.error("Совместимость не найдена")
+                errorMsg["errorMessage"] = "Совместимость не найдена"
+                return errorMsg
+
+            await CRUD.delete(compatibility)
+
+            return {"status": "ok"}
+
+        except Exception as e:
+            utils.logger.error(f"Ошибка удаления совместимости: {str(e)}")
+            errorMsg["errorMessage"] = f"Ошибка удаления совместимости: {str(e)}"
+            return errorMsg
+
+    @staticmethod
+    async def get_compatibility(toolkit_id: int):
+        try:
+
+            result = await CRUD.read(
+                select(ToolkitCompatibility).where(
+                    (ToolkitCompatibility.toolkit_id == toolkit_id)
+                    | (ToolkitCompatibility.compatible_toolkit_id == toolkit_id)
+                ),
+                True,
+            )
+            if not result:
+                return {"status": "ok", "data": {}}
+
+            return {
+                "status": "ok",
+                "data": ToolkitCompatibility.getUnique(result, toolkit_id),
+            }
+
+        except Exception as e:
+            utils.logger.error(f"Ошибка получения совместимости: {str(e)}")
+            return {"errorMessage": f"Ошибка получения совместимости: {str(e)}"}
 
 
 class Toolkit(Base):