Журнал перемещений, упрощение и чистка

db/handlers/access.py

@@ -90,21 +90,16 @@ class AccessLevelHandler:
             "admin": {
                 "title": "Администратор",
                 "description": "Администратор. Полный доступ",
-                "receiving_edit": True,
-                "refund_request_edit": True,
                 "refund_request_confirm": True,
-                "debit_request_edit": True,
                 "debit_request_confirm": True,
                 "tools_creation": True,
                 "tools_registration": True,
-                "tools_registration_edit": True,
                 "tools_edit": True,
                 "tools_delete": True,
                 "users_creation": True,
                 "users_edit": True,
                 "users_disabling": True,
                 "users_view": True,
-                "available_own_toolbox": False,
                 "view_all_toolboxes": True,
                 "view_requests": True,
                 "view_services": True,

db/handlers/actions.py

@@ -270,7 +270,7 @@ class StocksActions:
         if not accept:
             return accept
 
-        totalRecordsIds = [record_id]
+        totalRecordsIds = [record_id] if not record else [record.id]
 
         if len(stocksMovements) > 1:
             for stock in stocksMovements[1:]:
@@ -298,7 +298,7 @@ class StocksActions:
                 )
                 if not accept:
                     return False
-                totalRecordsIds.append(recorded)
+                totalRecordsIds.append(recorded.id)
 
         logger.info(
             f"Записи {', '.join(map(str, totalRecordsIds))} о {movingRecord.action} инструмента успешно приняты {user_id}"

db/handlers/records.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import date, datetime, time, timedelta
 
 from sqlalchemy import select
 
@@ -142,39 +142,69 @@ class StocksRecordsHandler:
             logger.error(f"Ошибка обновления записи: {str(e)}")
             return False
 
-    async def get(user_id: int = None, days: int = 30):
+    async def getLogs(startDate: date, endDate: date):
         from db import CRUD
 
         try:
-            if user_id:
-                userInfo = f"пользователя {user_id} "
-                decided = "не решенных "
-                daysLimit = ""
-                query = select(StocksRecords).where(
-                    StocksRecords.init_user_id == user_id,
-                    StocksRecords.decision_user_id == None,
+            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 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:
-                userInfo = "всех пользователей "
-                decided = ""
-                daysLimit = f"за последние {days} дн."
-                query = select(StocksRecords).where(
-                    StocksRecords.created_at > datetime.now() - timedelta(days=days),
+                query = (
+                    select(StocksRecords)
+                    .where(
+                        StocksRecords.init_user_id == user_id,
+                        StocksRecords.decision_user_id == None,
+                    )
+                    .order_by(StocksRecords.created_at.asc())
                 )
-            logger.debug(f"Получение всех {decided}записей {userInfo}{daysLimit}")
+            logger.debug(f"Получение всех записей без решения")
             records = await CRUD.read(query, True)
-            logger.debug(
-                f"{len(records)} {decided}записей {userInfo}{daysLimit} успешно получены"
-            )
-            if len(records) == 0:
-                return []
-            records.sort(key=lambda x: x.created_at, reverse=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 False
+            return []
 
     async def getById(record_id: int, record: bool = False):
         from db import CRUD