toolbox/api/routers/toolkit.py

from fastapi import APIRouter, Depends
from sqlalchemy import select
from db import CRUD
from db.handlers.actions import StocksActions
from db.handlers.categories import CategoryHandler
from db.handlers.stock import PlacementHandler, StockHandler
from db.handlers.toolbox import ToolboxHandler
from db.handlers.toolkit import ToolkitHandler
from db.schemas.stock import Placement
from utils import requestDict, logger


router = APIRouter()


def handleResult(result: dict, response: dict) -> dict:
    if "errorMessage" in result.keys():
        response["message"] = result["errorMessage"]
    else:
        response["status"] = "ok"
    return response


@router.get("/", summary="Получение инструмента")
async def get_toolkit(reqData: dict = Depends(requestDict)):
    logger.info(f"Получение инструмента")
    response = {"status": "error"}
    toolkitId = reqData.get("query").get("toolkitId")
    if toolkitId:
        toolkit = await ToolkitHandler.get(int(toolkitId))
        if toolkit:
            response["status"] = "ok"
            response["data"] = toolkit
    return response


@router.post("/", summary="Запрос остатка инструмента")
async def toolkit_request(
    reqData: dict = Depends(requestDict),
):
    response = {"status": "error", "data": {}}
    toolkitId = reqData.get("body").get("toolkitId")
    logger.info(f"Получение запроса остатка инструмента #{toolkitId}")
    stocks = await StockHandler.getByToolkitId(toolkitId)
    if not stocks:
        return response
    userId = reqData.get("body").get("userId")
    allToolboxes = reqData.get("body").get("allToolboxes")
    toolboxes = (
        await ToolboxHandler.getByOwner(userId)
        if not allToolboxes
        else await ToolboxHandler.getAll()
    )
    if not toolboxes:
        return response
    toolboxesTitles = {toolbox["id"]: toolbox["title"] for toolbox in toolboxes}
    toolboxesOwners = {toolbox["id"]: toolbox["owner_id"] for toolbox in toolboxes}
    stocksData = {"count": 0, "toolboxes": {}}
    for stock in stocks:
        toolboxTitle = toolboxesTitles.get(stock["toolbox_id"], None)
        if not toolboxTitle:
            continue
        stocksData["count"] += stock["quantity"]
        if toolboxTitle not in stocksData["toolboxes"]:
            stocksData["toolboxes"][toolboxTitle] = {
                "count": stock["quantity"],
                "placement": stock["placement"],
            }
            if not toolboxesOwners.get(stock["toolbox_id"]):
                stocksData["toolboxes"][toolboxTitle]["id"] = stock["toolbox_id"]
                stocksData["toolboxes"][toolboxTitle]["totalCost"] = (
                    stock["price"] * stock["quantity"]
                )
        else:
            stocksData["toolboxes"][toolboxTitle]["count"] += stock["quantity"]
            if not toolboxesOwners.get(stock["toolbox_id"]):
                stocksData["toolboxes"][toolboxTitle]["totalCost"] += (
                    stock["price"] * stock["quantity"]
                )
    response["status"] = "ok"
    response["data"] = stocksData
    return response


@router.post("/comment", summary="Добавление комментария")
async def add_comment(reqData: dict = Depends(requestDict)):
    logger.info(f"Добавление комментария")
    response = {"status": "error"}
    try:
        logger.info(f"Добавление комментария")
        logger.info(reqData.get("body"))
        toolkitId = int(reqData.get("body").get("toolkitId"))
        comment = reqData.get("body").get("commentText")
        userId = int(reqData.get("body").get("userId"))
        result = await ToolkitHandler.addComment(toolkitId, userId, comment)
        response = handleResult(result, response)
    except Exception as e:
        logger.error(e)
    finally:
        return response


@router.post("/fill_prepare", summary="Подготовка заполнения ящика")
async def fill_toolbox():
    logger.info(f"Подготовка заполнения ящика")
    response = {"status": "error"}
    toolkits = await ToolkitHandler.getAll()
    categories = await CategoryHandler.getAll()
    placements = await PlacementHandler.getAll()
    if toolkits and categories:
        response["status"] = "ok"
        response["data"] = {
            "toolkits": sorted(toolkits, key=lambda toolkit: toolkit["title"]),
            "categories": sorted(categories, key=lambda category: category["title"]),
            "placements": [placement.toDict() for placement in placements],
        }
    return response


@router.post("/categories_batch", summary="Управление категориями")
async def categories_batch(reqData: dict = Depends(requestDict)):
    logger.info(f"Управление категориями")
    response = {"status": "error"}
    userId = reqData.get("body").get("userId")
    changesData = reqData.get("body").get("changes")
    success = True
    for newCategoryData in changesData.get("create", []):
        logger.info(f"Добавление категории: {newCategoryData.get('title')}")
        result = await CategoryHandler.add(newCategoryData, userId)
        if not result:
            success = False
    for updateCategoryData in changesData.get("update", []):
        logger.info(f"Обновление категории: {updateCategoryData.get('title')}")
        result = await CategoryHandler.edit(updateCategoryData, userId)
        if not result:
            success = False
    for deleteCategoryId in changesData.get("delete", []):
        logger.info(f"Удаление категории: {deleteCategoryId}")
        result = await CategoryHandler.delete(deleteCategoryId, userId)
        if not result:
            success = False
    if success:
        response["status"] = "ok"
    return response


@router.get("/categories", summary="Получение категорий")
async def get_categories():
    logger.info(f"Получение категорий")
    response = {"status": "error"}
    categories = await CategoryHandler.getAll()
    if categories:
        categoriesDict = {
            category["id"]: {
                "id": category["id"],
                "title": category["title"],
                "description": category["description"],
            }
            for category in categories
        }
        response["status"] = "ok"
        response["data"] = categoriesDict
    return response


@router.post("/hide", summary="Скрытие инструмента")
async def hide_toolkit(reqData: dict = Depends(requestDict)):

    logger.info(f"Скрытие/отображение инструмента")
    response = {"status": "error"}
    toolkitId = int(reqData.get("body").get("toolkitId"))
    userId = reqData.get("body").get("userId")
    hidden = reqData.get("body").get("hidden")
    result = await ToolkitHandler.hideToolkit(userId, toolkitId, hidden)
    response = handleResult(result, response)
    return response


@router.post("/manage", summary="Управление инструментами")
async def manage_toolkit(reqData: dict = Depends(requestDict)):

    logger.info(f"Управление инструментами")
    response = {"status": "error"}
    action = reqData.get("body").get("action")
    userId = reqData.get("body").get("userId")
    toolkitData = reqData.get("body").get("formData")
    if "category_id" in toolkitData:
        toolkitData["category_id"] = int(toolkitData.get("category_id"))
    if "image" in toolkitData:
        if (
            not toolkitData.get("image").get("main")
            or toolkitData.get("image").get("main") == ""
        ):
            if len(toolkitData.get("image").get("additional")) == 0:
                toolkitData.pop("image")
    match action:
        case "create":
            toolkit = await ToolkitHandler.add(toolkitData, userId)
            response = handleResult(toolkit, response)
        case "copy":
            toolkitData.pop("id")
            toolkit = await ToolkitHandler.add(toolkitData, userId)
            response = handleResult(toolkit, response)
        case "update":
            toolkit = await ToolkitHandler.edit(userId, **toolkitData)
            response = handleResult(toolkit, response)
        case "delete":
            toolkit = await ToolkitHandler.delete(toolkitData.get("id"), userId)
            response = handleResult(toolkit, response)
        case _:
            pass
    logger.info(
        f"Управление инструментами ({action}) прошло {'успешно' if response.get('status') == 'ok' else 'неуспешно'}"
    )
    return response


@router.post("/quick_action", summary="Быстрое действие")
async def quick_action(reqData: dict = Depends(requestDict)):
    logger.info(f"Быстрое действие")
    response = {"status": "error"}
    action = reqData.get("body").get("action")
    toolboxId = int(reqData.get("body").get("toolboxId"))
    toolkitId = int(reqData.get("body").get("toolkitId"))
    userId = reqData.get("body").get("userId")
    data = reqData.get("body").get("data")
    match action:
        case "fill":
            toolkit = await StocksActions.registration(
                toolkitId,
                toolboxId,
                userId,
                int(data.get("amount")),
                float(data.get("price")),
                "",
                data.get("reason"),
            )
            response = handleResult(toolkit, response)
        case "move":
            try:
                placement = await CRUD.read(
                    select(Placement).where(
                        Placement.toolkit_id == toolkitId,
                        Placement.toolbox_id == toolboxId,
                    )
                )
                await placement.edit(data.get("location"))
                response["status"] = "ok"
            except Exception as e:
                logger.error(e)
        case _:
            pass
    return response