337 lines
13 KiB
Python
337 lines
13 KiB
Python
from datetime import date, datetime, time, timedelta
|
|
|
|
from sqlalchemy import func, select
|
|
|
|
from db.handlers.stock import StockHandler
|
|
from db.schemas.records import StocksRecords, ServicesRecords
|
|
from utils import logger
|
|
|
|
|
|
class StocksRecordsHandler:
|
|
|
|
async def add(
|
|
action: str,
|
|
source_stock_id: int,
|
|
target_stock_id: int,
|
|
toolkit_id: int,
|
|
init_user_id: int,
|
|
reason: str,
|
|
quantity: int,
|
|
price: float,
|
|
source_toolbox_id: int = None,
|
|
target_toolbox_id: int = None,
|
|
return_record: bool = False,
|
|
):
|
|
recordData = {
|
|
"action": action,
|
|
"source_stock_id": source_stock_id,
|
|
"target_stock_id": target_stock_id,
|
|
"source_toolbox_id": source_toolbox_id,
|
|
"target_toolbox_id": target_toolbox_id,
|
|
"toolkit_id": toolkit_id,
|
|
"init_user_id": init_user_id,
|
|
"reason": reason,
|
|
"quantity": quantity,
|
|
"price": price,
|
|
}
|
|
try:
|
|
logger.debug(f"Создание записи: {action} от {init_user_id}")
|
|
logger.debug(recordData)
|
|
record = StocksRecords(**recordData)
|
|
await record.save()
|
|
logger.debug(f"Запись успешно создана, id: {record.id}")
|
|
return True if not return_record else record
|
|
except Exception as e:
|
|
logger.error(f"Ошибка создания записи: {str(e)}")
|
|
return False
|
|
|
|
async def decide(
|
|
record: StocksRecords,
|
|
decision_user_id: int,
|
|
source_stock_id: int,
|
|
quantity: int,
|
|
price: float,
|
|
accept: bool = True,
|
|
):
|
|
try:
|
|
logger.debug(
|
|
f"{'Принятие' if accept else 'Отклонение'} записи {record.id} от {decision_user_id}"
|
|
)
|
|
record.decision_user_id = decision_user_id
|
|
record.decided_at = datetime.now()
|
|
record.source_stock_id = source_stock_id
|
|
record.quantity = quantity
|
|
record.price = price
|
|
record.accepted = accept
|
|
await record.save()
|
|
logger.debug(
|
|
f"Запись {record.id} успешно {'принята' if accept else 'отклонена'} {decision_user_id} в {record.decided_at.strftime('%Y-%m-%d %H:%M:%S')}"
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(
|
|
f"Ошибка {'принятия' if accept else 'отклонения'} записи: {str(e)}"
|
|
)
|
|
return False
|
|
|
|
async def edit(record_id: int, edit_user_id: int, **kwargs):
|
|
def updateStockRecord(recordDB, editData):
|
|
whatchList = ["toolkit_id", "quantity", "price", "placement"]
|
|
for key in whatchList:
|
|
if key in editData:
|
|
setattr(recordDB, key, editData[key])
|
|
return recordDB
|
|
|
|
try:
|
|
logger.debug(f"Обновление записи {record_id} от {edit_user_id}")
|
|
|
|
record = await StocksRecords.get(id=record_id)
|
|
record.edit_user_id = edit_user_id
|
|
record.edited_at = datetime.now()
|
|
|
|
logger.debug("Вносим изменения в записи о движении инструмента")
|
|
|
|
if record.source_stock_id:
|
|
logger.debug(
|
|
"Вносим изменения в записи о движении инструмента из исходного склада"
|
|
)
|
|
sourceStockRecord = await StockHandler.get(
|
|
record.source_stock_id, record=True
|
|
)
|
|
if "source_toolbox_id" in kwargs:
|
|
sourceStockRecord.toolbox_id = kwargs["source_toolbox_id"]
|
|
|
|
sourceStockRecord = updateStockRecord(sourceStockRecord, kwargs)
|
|
await sourceStockRecord.save()
|
|
logger.debug(
|
|
"Внесли изменения в записи о движении инструмента из исходного склада"
|
|
)
|
|
|
|
if record.target_stock_id:
|
|
logger.debug(
|
|
"Вносим изменения в записи о движении инструмента в целевой склад"
|
|
)
|
|
targetStockRecord = await StockHandler.get(
|
|
record.target_stock_id, record=True
|
|
)
|
|
if "target_toolbox_id" in kwargs:
|
|
targetStockRecord.toolbox_id = kwargs["target_toolbox_id"]
|
|
|
|
targetStockRecord = updateStockRecord(targetStockRecord, kwargs)
|
|
await targetStockRecord.save()
|
|
logger.debug(
|
|
"Внесли изменения в записи о движении инструмента в целевой склад"
|
|
)
|
|
|
|
logger.debug("Внесли изменения в записи о движении инструмента")
|
|
|
|
edited = {}
|
|
for key, value in kwargs.items():
|
|
originalValue = getattr(record, key)
|
|
setattr(record, key, value)
|
|
edited[key] = {"original": originalValue, "new": value}
|
|
record.edited = edited
|
|
await record.save()
|
|
logger.debug(
|
|
f"Запись {record_id} успешно обновлена {edit_user_id} в {record.updated_at.strftime('%Y-%m-%d %H:%M:%S')}"
|
|
)
|
|
logger.debug(edited)
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f"Ошибка обновления записи: {str(e)}")
|
|
return False
|
|
|
|
async def getLogs(startDate: date, endDate: date):
|
|
from db import CRUD
|
|
|
|
try:
|
|
start_dt = datetime.combine(startDate, time.min)
|
|
end_dt = datetime.combine(endDate, time.max)
|
|
|
|
query = (
|
|
select(StocksRecords)
|
|
.where(
|
|
StocksRecords.created_at.between(start_dt, end_dt),
|
|
StocksRecords.decision_user_id != None,
|
|
)
|
|
.order_by(StocksRecords.created_at.desc())
|
|
)
|
|
|
|
logger.debug("Получение записей за период %s - %s", startDate, endDate)
|
|
|
|
records = await CRUD.read(query, True)
|
|
|
|
logger.debug(
|
|
"%d записей за период %s - %s успешно получены",
|
|
len(records),
|
|
startDate,
|
|
endDate,
|
|
)
|
|
|
|
return [record.toDict() for record in records]
|
|
|
|
except Exception:
|
|
logger.exception("Ошибка получения записей")
|
|
return []
|
|
|
|
async def getUserRecords(user_id: int) -> int:
|
|
from db import CRUD
|
|
|
|
try:
|
|
query = select(func.count(StocksRecords.id)).where(
|
|
StocksRecords.init_user_id == user_id,
|
|
)
|
|
logger.debug(f"Получение всех записей пользователя {user_id}")
|
|
records = await CRUD.read(query)
|
|
logger.debug(f"{records} записей пользователя {user_id} успешно получены")
|
|
return records
|
|
except Exception as e:
|
|
logger.error(f"Ошибка получения записей: {str(e)}")
|
|
return 0
|
|
|
|
async def get(user_id: int, manager: bool):
|
|
from db import CRUD
|
|
|
|
try:
|
|
if manager:
|
|
query = (
|
|
select(StocksRecords)
|
|
.where(
|
|
StocksRecords.decision_user_id == None,
|
|
)
|
|
.order_by(StocksRecords.created_at.asc())
|
|
)
|
|
else:
|
|
query = (
|
|
select(StocksRecords)
|
|
.where(
|
|
StocksRecords.init_user_id == user_id,
|
|
StocksRecords.decision_user_id == None,
|
|
)
|
|
.order_by(StocksRecords.created_at.asc())
|
|
)
|
|
logger.debug(f"Получение всех записей без решения")
|
|
records = await CRUD.read(query, True)
|
|
logger.debug(f"{len(records)} записей без решения успешно получены")
|
|
recordsData = [record.toDict() for record in records]
|
|
logger.debug(recordsData)
|
|
return recordsData
|
|
except Exception as e:
|
|
logger.error(f"Ошибка получения записей: {str(e)}")
|
|
return []
|
|
|
|
async def getById(record_id: int, record: bool = False):
|
|
from db import CRUD
|
|
|
|
try:
|
|
logger.debug(f"Получение записи {record_id}")
|
|
query = select(StocksRecords).where(StocksRecords.id == record_id)
|
|
stocksRecord = await CRUD.read(query)
|
|
if not stocksRecord:
|
|
logger.debug(f"Запись {record_id} не найдена")
|
|
return False
|
|
logger.debug(f"Запись {record_id} успешно получена")
|
|
return stocksRecord.toDict() if not record else stocksRecord
|
|
except Exception as e:
|
|
logger.error(f"Ошибка получения записи: {str(e)}")
|
|
return False
|
|
|
|
async def getOriginalToolboxId(toolkitId: int, targetToolboxId: int):
|
|
from db import CRUD
|
|
|
|
try:
|
|
logger.debug(
|
|
f"Получение записи о перемещении инструмента {toolkitId} на склад {targetToolboxId}"
|
|
)
|
|
query = select(StocksRecords).where(
|
|
StocksRecords.toolkit_id == toolkitId,
|
|
StocksRecords.target_toolbox_id == targetToolboxId,
|
|
)
|
|
stocksRecord = await CRUD.read(query)
|
|
if not stocksRecord:
|
|
logger.debug(f"Запись {toolkitId} не найдена")
|
|
return False
|
|
logger.debug(f"Запись {toolkitId} успешно получена")
|
|
return stocksRecord.source_toolbox_id
|
|
except Exception as e:
|
|
logger.error(f"Ошибка получения записи: {str(e)}")
|
|
return False
|
|
|
|
|
|
class ServiceRecordsHandler:
|
|
async def add(user_id: int, details: dict):
|
|
try:
|
|
logger.debug(f"Создание записи: {user_id}")
|
|
logger.debug(details)
|
|
record = ServicesRecords(user_id=user_id, details=details)
|
|
await record.save()
|
|
logger.debug(f"Запись успешно создана, id: {record.id}")
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Ошибка создания записи: {str(e)}")
|
|
return False
|
|
|
|
async def get(user_id: int = None, days: int = 30):
|
|
from db import CRUD
|
|
|
|
try:
|
|
if user_id:
|
|
userInfo = f"пользователя {user_id} "
|
|
daysLimit = ""
|
|
query = select(ServicesRecords).where(
|
|
ServicesRecords.user_id == user_id,
|
|
)
|
|
else:
|
|
userInfo = "всех пользователей "
|
|
daysLimit = f"за последние {days} дн."
|
|
query = select(ServicesRecords).where(
|
|
ServicesRecords.created_at > datetime.now() - timedelta(days=days),
|
|
)
|
|
logger.debug(f"Получение всех записей {userInfo}{daysLimit}")
|
|
records = await CRUD.read(query, True)
|
|
logger.debug(
|
|
f"{len(records)} записей {userInfo}{daysLimit} успешно получены"
|
|
)
|
|
if len(records) == 0:
|
|
return []
|
|
records.sort(key=lambda x: x.created_at, reverse=True)
|
|
recordsData = [record.toDict() for record in records]
|
|
logger.debug(recordsData)
|
|
return recordsData
|
|
except Exception as e:
|
|
logger.error(f"Ошибка получения записей: {str(e)}")
|
|
return False
|
|
|
|
async def getLogs(startDate: date, endDate: date):
|
|
from db import CRUD
|
|
|
|
try:
|
|
start_dt = datetime.combine(startDate, time.min)
|
|
end_dt = datetime.combine(endDate, time.max)
|
|
|
|
query = (
|
|
select(ServicesRecords)
|
|
.where(
|
|
ServicesRecords.created_at.between(start_dt, end_dt),
|
|
)
|
|
.order_by(ServicesRecords.created_at.desc())
|
|
)
|
|
|
|
logger.debug("Получение записей за период %s - %s", startDate, endDate)
|
|
|
|
records = await CRUD.read(query, True)
|
|
|
|
logger.debug(
|
|
"%d записей за период %s - %s успешно получены",
|
|
len(records),
|
|
startDate,
|
|
endDate,
|
|
)
|
|
|
|
return [record.toDict() for record in records]
|
|
|
|
except Exception:
|
|
logger.exception("Ошибка получения записей")
|
|
return []
|