style(database): Fixed the issue with long function declarations

api/auth.py

@@ -1,7 +1,5 @@
 from flask import Blueprint, request, jsonify
 from model.user import User
-from db.repositories.user_repository import UserRepository  # FIXME: authenticate_user as get_user
-from utils.token import generateKey as getToken
 
 auth = Blueprint("auth", __name__)
 
@@ -23,13 +21,8 @@ def login():
         if len(password.strip()) < 8:
             return "Password is too short", 400
 
-        user = UserRepository().authenticate_user(email, password)
-        if not user:
-            return "Wrong credentials", 400
-
-        token = getToken(user)
-
-        return jsonify({'token': token, 'user': {'id': user.id, 'name': user.name, 'role': user.role}})
+        user = User(email, password)
+        return jsonify(user.toJson())
 
     else:
         return "Request is not a json", 400

db/connection.py

@@ -1,29 +1,21 @@
 import psycopg2
 import os
+import logging
 from contextlib import contextmanager
 from typing import Generator
-from loguru import logger
 
 from utils.loadDotEnv import initializeENV
 
 initializeENV()
 
+logger = logging.getLogger(__name__)
 
 def PSQLConnect():
-    conn_str = os.getenv('POSTGRES_CONNECTION')
-
-    if not conn_str:
-        logger.error("POSTGRES_CONNECTION не найден в .env файле")
-        raise ValueError("POSTGRES_CONNECTION не найден в .env файле")
-
-    conn = psycopg2.connect(conn_str)
-    logger.debug("Подключение к БД установлено")
+    conn = psycopg2.connect(os.getenv('POSTDRESS_CONNECTION'))
     return conn
 
-
 def PSQLCursor(conn):
-    cur = conn.cursor()
-    logger.debug("Курсор БД создан")
+    cur =  conn.cursor()
     return cur
 
 
@@ -32,34 +24,38 @@ def get_connection() -> Generator[psycopg2.extensions.connection, None, None]:
     conn = None
     try:
         conn = PSQLConnect()
-        logger.debug("Контекст подключения к БД открыт")
+        logger.info("Подключение к БД установлено")
         yield conn
+    except psycopg2.OperationalError as e:
+        logger.error(f"Ошибка подключения к БД: {e}")
+        raise
+    except psycopg2.Error as e:
+        logger.error(f"Ошибка PostgreSQL: {e}")
+        raise
     except Exception as e:
-        logger.error(f"Ошибка в контексте подключения: {e}")
-        if conn:
-            conn.rollback()
-            logger.debug("Откат транзакции выполнен")
+        logger.error(f"Неожиданная ошибка при работе с БД: {e}")
         raise
     finally:
         if conn:
-            conn.close()
-            logger.debug("Подключение к БД закрыто")
-
+            try:
+                conn.close()
+                logger.info("Соединение с БД закрыто")
+            except Exception as e:
+                logger.warning(f"Ошибка при закрытии соединения: {e}")
 
 def test_connection() -> bool:
     try:
         with get_connection() as conn:
             cur = PSQLCursor(conn)
-            cur.execute("SELECT version();")
-            version = cur.fetchone()
-            logger.info(f"Подключение к БД успешно: {version[0]}")
-            cur.close()
-            logger.debug("Курсор БД закрыт")
-            return True
+            try:
+                cur.execute("SELECT version();")
+                version = cur.fetchone()
+                logger.info(f"Версия PostgreSQL: {version[0]}")
+                return True
+            finally:
+                cur.close()
+                logger.debug("Курсор закрыт")
     except Exception as e:
-        logger.error(f"Ошибка подключения к БД: {e}")
+        logger.error(f"Тест подключения к БД провален: {e}")
         return False
-
-
-if __name__ == "__main__":
-    test_connection()
+print(test_connection())

db/init.py

@@ -1,147 +0,0 @@
-from db.connection import get_connection
-from loguru import logger
-
-def create_tables():
-    try:
-        with get_connection() as conn:
-            with conn.cursor() as cur:
-                # Пользователи
-                cur.execute("""
-                    CREATE TABLE IF NOT EXISTS users (
-                        id SERIAL PRIMARY KEY,
-                        email VARCHAR(255) UNIQUE NOT NULL,
-                        password_hash VARCHAR(255) NOT NULL,
-                        name VARCHAR(255) NOT NULL,
-                        role VARCHAR(50) NOT NULL DEFAULT 'viewer',
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-
-                # Роботы
-                cur.execute("""
-                    CREATE TABLE IF NOT EXISTS robots (
-                        id VARCHAR(50) PRIMARY KEY,
-                        status VARCHAR(50) DEFAULT 'active',
-                        battery_level INTEGER DEFAULT 100,
-                        last_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        current_zone VARCHAR(10),
-                        current_row INTEGER,
-                        current_shelf INTEGER
-                    )
-                """)
-
-                # Товары
-                cur.execute("""
-                    CREATE TABLE IF NOT EXISTS products (
-                        id VARCHAR(50) PRIMARY KEY,
-                        name VARCHAR(255) NOT NULL,
-                        category VARCHAR(100),
-                        min_stock INTEGER DEFAULT 10,
-                        optimal_stock INTEGER DEFAULT 100
-                    )
-                """)
-
-                # История инвентаризации
-                cur.execute("""
-                    CREATE TABLE IF NOT EXISTS inventory_history (
-                        id SERIAL PRIMARY KEY,
-                        robot_id VARCHAR(50) REFERENCES robots(id),
-                        product_id VARCHAR(50) REFERENCES products(id),
-                        quantity INTEGER NOT NULL,
-                        zone VARCHAR(10) NOT NULL,
-                        row_number INTEGER,
-                        shelf_number INTEGER,
-                        status VARCHAR(50),
-                        scanned_at TIMESTAMP NOT NULL,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-
-                # Прогнозы ИИ
-                cur.execute("""
-                    CREATE TABLE IF NOT EXISTS ai_predictions (
-                        id SERIAL PRIMARY KEY,
-                        product_id VARCHAR(50) REFERENCES products(id),
-                        prediction_date DATE NOT NULL,
-                        days_until_stockout INTEGER,
-                        recommended_order INTEGER,
-                        confidence_score DECIMAL(3,2),
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-
-                conn.commit()
-                logger.debug("Все таблицы успешно созданы")
-
-    except Exception as e:
-        logger.error(f"Ошибка создания таблиц: {e}")
-        raise
-
-
-def create_indexes():
-    try:
-        with get_connection() as conn:
-            with conn.cursor() as cur:
-                cur.execute("CREATE INDEX IF NOT EXISTS idx_inventory_scanned ON inventory_history(scanned_at DESC)")
-                cur.execute("CREATE INDEX IF NOT EXISTS idx_inventory_product ON inventory_history(product_id)")
-                cur.execute("CREATE INDEX IF NOT EXISTS idx_inventory_zone ON inventory_history(zone)")
-
-                conn.commit()
-                logger.debug("Индексы созданы")
-
-    except Exception as e:
-        logger.error(f"Ошибка создания индексов: {e}")
-        raise
-
-
-def insert_sample_data():
-    try:
-        with get_connection() as conn:
-            with conn.cursor() as cur:
-                cur.execute("""
-                    INSERT INTO users (email, password_hash, name, role) 
-                    VALUES 
-                    ('admin@warehouse.com', 'hash1', 'Администратор', 'admin'),
-                    ('operator@warehouse.com', 'hash2', 'Оператор Иванов', 'operator'),
-                    ('viewer@warehouse.com', 'hash3', 'Наблюдатель Петров', 'viewer')
-                    ON CONFLICT (email) DO NOTHING
-                """)
-
-                cur.execute("""
-                    INSERT INTO robots (id, status, battery_level, current_zone) 
-                    VALUES 
-                    ('RB-001', 'active', 85, 'A'),
-                    ('RB-002', 'active', 45, 'B'), 
-                    ('RB-003', 'maintenance', 100, NULL)
-                    ON CONFLICT (id) DO NOTHING
-                """)
-
-                cur.execute("""
-                    INSERT INTO products (id, name, category, min_stock, optimal_stock) 
-                    VALUES 
-                    ('TEL-1234', 'Смартфон X', 'Электроника', 5, 50),
-                    ('NOTE-567', 'Ноутбук Pro', 'Электроника', 3, 20),
-                    ('ACC-999', 'Чехол для телефона', 'Аксессуары', 10, 100)
-                    ON CONFLICT (id) DO NOTHING
-                """)
-
-                conn.commit()
-                logger.debug("Тестовые данные добавлены")
-
-    except Exception as e:
-        logger.error(f"Ошибка добавления тестовых данных: {e}")
-        raise
-
-
-def initialize_database():
-    logger.info("Начинаем инициализацию базы данных...")
-
-    create_tables()
-    create_indexes()
-    insert_sample_data()
-
-    logger.debug("База данных успешно инициализирована!")
-
-
-if __name__ == "__main__":
-    initialize_database()

db/repositories/ai_prediction_repository.py

@@ -1,9 +1,11 @@
 from typing import List, Optional
 from datetime import datetime, date
-from loguru import logger
+import logging
 from db.connection import get_connection
 from model.ai_prediction import AIPrediction
 
+logger = logging.getLogger(__name__)
+
 class AIPredictionsRepository:
     def get_all(self) -> List[AIPrediction]:
         try:
@@ -21,7 +23,7 @@ class AIPredictionsRepository:
                             created_at=row[6]
                         ) for row in cur.fetchall()
                     ]
-                    logger.debug(f"Получено {len(predictions)} прогнозов")
+                    logger.info(f"Получено {len(predictions)} прогнозов")
                     return predictions
         except Exception as e:
             logger.error(f"Ошибка получения прогнозов: {e}")
@@ -34,7 +36,7 @@ class AIPredictionsRepository:
                     cur.execute("SELECT * FROM ai_predictions WHERE id = %s", (prediction_id,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Прогноз {prediction_id} найден")
+                        logger.info(f"Прогноз {prediction_id} найден")
                         return AIPrediction(*row)
                     logger.warning(f"Прогноз {prediction_id} не найден")
                     return None
@@ -53,7 +55,7 @@ class AIPredictionsRepository:
                         LIMIT %s
                     """, (product_id, limit))
                     predictions = [AIPrediction(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(predictions)} прогнозов для товара {product_id}")
+                    logger.info(f"Получено {len(predictions)} прогнозов для товара {product_id}")
                     return predictions
         except Exception as e:
             logger.error(f"Ошибка получения прогноза по товару {product_id}: {e}")
@@ -69,7 +71,7 @@ class AIPredictionsRepository:
                         ORDER BY product_id, prediction_date DESC
                     """)
                     predictions = [AIPrediction(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(predictions)} последних прогнозов по товарам")
+                    logger.info(f"Получено {len(predictions)} последних прогнозов по товарам")
                     return predictions
         except Exception as e:
             logger.error(f"Ошибка получения последних прогнозов по товарам: {e}")
@@ -95,7 +97,7 @@ class AIPredictionsRepository:
 
                     prediction_id = cur.fetchone()[0]
                     conn.commit()
-                    logger.debug(f"Создан новый прогноз ID: {prediction_id} для товара {product_id}")
+                    logger.info(f"Создан новый прогноз ID: {prediction_id} для товара {product_id}")
                     return prediction_id
         except Exception as e:
             logger.error(f"Ошибка создания прогноза: {e}")
@@ -111,7 +113,7 @@ class AIPredictionsRepository:
                     """, (older_than_days,))
                     deleted_count = cur.rowcount
                     conn.commit()
-                    logger.debug(f"Удалено {deleted_count} старых прогнозов старше {older_than_days} дней")
+                    logger.info(f"Удалено {deleted_count} старых прогнозов старше {older_than_days} дней")
                     return deleted_count
         except Exception as e:
             logger.error(f"Ошибка удаления старых прогнозов: {e}")

db/repositories/inventory_repository.py

@@ -1,10 +1,12 @@
 # db/repositories/inventory_repository.py
 from typing import List, Optional, Tuple
 from datetime import datetime
-from loguru import logger
+import logging
 from db.connection import get_connection
 from model.inventory import InventoryRecord
 
+logger = logging.getLogger(__name__)
+
 class InventoryRepository:
     def get_all(self) -> List[InventoryRecord]:
         try:
@@ -25,7 +27,7 @@ class InventoryRepository:
                             created_at=row[9]
                         ) for row in cur.fetchall()
                     ]
-                    logger.debug(f"Получено {len(records)} записей инвентаризации")
+                    logger.info(f"Получено {len(records)} записей инвентаризации")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения истории инвентаризации: {e}")
@@ -38,7 +40,7 @@ class InventoryRepository:
                     cur.execute("SELECT * FROM inventory_history WHERE id = %s", (record_id,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Запись инвентаризации {record_id} найдена")
+                        logger.info(f"Запись инвентаризации {record_id} найдена")
                         return InventoryRecord(*row)
                     logger.warning(f"Запись инвентаризации {record_id} не найдена")
                     return None
@@ -69,7 +71,7 @@ class InventoryRepository:
 
                     record_id = cur.fetchone()[0]
                     conn.commit()
-                    logger.debug(f"Создана новая запись инвентаризации ID: {record_id}")
+                    logger.info(f"Создана новая запись инвентаризации ID: {record_id}")
                     return record_id
         except Exception as e:
             logger.error(f"Ошибка создания записи инвентаризации: {e}")
@@ -85,7 +87,7 @@ class InventoryRepository:
                         ORDER BY product_id, scanned_at DESC
                     """)
                     records = [InventoryRecord(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(records)} последних записей инвентаризации по товарам")
+                    logger.info(f"Получено {len(records)} последних записей инвентаризации по товарам")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения последней записи инвентаризации по каждому товару: {e}")
@@ -102,7 +104,7 @@ class InventoryRepository:
                         LIMIT %s
                     """, (product_id, limit))
                     records = [InventoryRecord(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(records)} записей инвентаризации для товара {product_id}")
+                    logger.info(f"Получено {len(records)} записей инвентаризации для товара {product_id}")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения записи инвентаризации по продукту {product_id}: {e}")
@@ -119,7 +121,7 @@ class InventoryRepository:
                         LIMIT %s
                     """, (robot_id, limit))
                     records = [InventoryRecord(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(records)} записей инвентаризации для робота {robot_id}")
+                    logger.info(f"Получено {len(records)} записей инвентаризации для робота {robot_id}")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения записи инвентаризации по роботу {robot_id}: {e}")
@@ -136,7 +138,7 @@ class InventoryRepository:
                         LIMIT %s
                     """, (zone, limit))
                     records = [InventoryRecord(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(records)} записей инвентаризации для зоны {zone}")
+                    logger.info(f"Получено {len(records)} записей инвентаризации для зоны {zone}")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения записи инвентаризации по зоне {zone}: {e}")
@@ -153,7 +155,7 @@ class InventoryRepository:
                         ORDER BY scanned_at DESC
                     """, (hours,))
                     records = [InventoryRecord(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(records)} критических товаров за последние {hours} часов")
+                    logger.info(f"Получено {len(records)} критических товаров за последние {hours} часов")
                     return records
         except Exception as e:
             logger.error(f"Ошибка получения товаров с критическим статусом: {e}")

db/repositories/product_repository.py

@@ -1,8 +1,10 @@
 from typing import List, Optional
-from loguru import logger
+import logging
 from db.connection import get_connection
 from model.product import Product
 
+logger = logging.getLogger(__name__)
+
 class ProductRepository:
     def get_all(self) -> List[Product]:
         try:
@@ -18,7 +20,7 @@ class ProductRepository:
                             optimal_stock=row[4]
                         ) for row in cur.fetchall()
                     ]
-                    logger.debug(f"Получено {len(products)} товаров")
+                    logger.info(f"Получено {len(products)} товаров")
                     return products
         except Exception as e:
             logger.error(f"Ошибка получения продуктов: {e}")
@@ -31,7 +33,7 @@ class ProductRepository:
                     cur.execute("SELECT * FROM products WHERE id = %s", (product_id,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Товар {product_id} найден")
+                        logger.info(f"Товар {product_id} найден")
                         return Product(*row)
                     logger.warning(f"Товар {product_id} не найден")
                     return None
@@ -45,7 +47,7 @@ class ProductRepository:
                 with conn.cursor() as cur:
                     cur.execute("SELECT * FROM products WHERE category = %s ORDER BY name", (category,))
                     products = [Product(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(products)} товаров категории {category}")
+                    logger.info(f"Получено {len(products)} товаров категории {category}")
                     return products
         except Exception as e:
             logger.error(f"Ошибка получения товаров по категории {category}: {e}")
@@ -63,7 +65,7 @@ class ProductRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Создан новый товар {product_id}: {name}")
+                        logger.info(f"Создан новый товар {product_id}: {name}")
                     else:
                         logger.warning(f"Не удалось создать товар {product_id}")
                     return success
@@ -106,7 +108,7 @@ class ProductRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Товар {product_id} успешно обновлен")
+                        logger.info(f"Товар {product_id} успешно обновлен")
                     else:
                         logger.warning(f"Товар {product_id} не найден для обновления")
                     return success
@@ -122,7 +124,7 @@ class ProductRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Товар {product_id} удален")
+                        logger.info(f"Товар {product_id} удален")
                     else:
                         logger.warning(f"Товар {product_id} не найден для удаления")
                     return success
@@ -140,7 +142,7 @@ class ProductRepository:
                         ORDER BY name
                     """, (f'%{search_term}%', f'%{search_term}%'))
                     products = [Product(*row) for row in cur.fetchall()]
-                    logger.debug(f"Найдено {len(products)} товаров по запросу '{search_term}'")
+                    logger.info(f"Найдено {len(products)} товаров по запросу '{search_term}'")
                     return products
         except Exception as e:
             logger.error(f"Ошибка поиска товаров по названию '{search_term}': {e}")
@@ -159,7 +161,7 @@ class ProductRepository:
                         ORDER BY p.name
                     """)
                     products = [Product(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(products)} товаров с низким запасом")
+                    logger.info(f"Получено {len(products)} товаров с низким запасом")
                     return products
         except Exception as e:
             logger.error(f"Ошибка получения товаров с низким запасом: {e}")

db/repositories/robot_repository.py

@@ -1,8 +1,10 @@
 from typing import List, Optional
-from loguru import logger
+import logging
 from db.connection import get_connection
 from model.robot import Robot
 
+logger = logging.getLogger(__name__)
+
 class RobotRepository:
     def get_all(self) -> List[Robot]:
         try:
@@ -20,7 +22,7 @@ class RobotRepository:
                             current_shelf=row[6]
                         ) for row in cur.fetchall()
                     ]
-                    logger.debug(f"Получено {len(robots)} роботов")
+                    logger.info(f"Получено {len(robots)} роботов")
                     return robots
         except Exception as e:
             logger.error(f"Ошибка получения всех роботов: {e}")
@@ -33,7 +35,7 @@ class RobotRepository:
                     cur.execute("SELECT * FROM robots WHERE id = %s", (robot_id,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Робот {robot_id} найден")
+                        logger.info(f"Робот {robot_id} найден")
                         return Robot(*row)
                     logger.warning(f"Робот {robot_id} не найден")
                     return None
@@ -83,7 +85,7 @@ class RobotRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Робот {robot_id} успешно обновлен")
+                        logger.info(f"Робот {robot_id} успешно обновлен")
                     else:
                         logger.warning(f"Робот {robot_id} не найден для обновления")
                     return success
@@ -97,7 +99,7 @@ class RobotRepository:
                 with conn.cursor() as cur:
                     cur.execute("SELECT * FROM robots WHERE status = %s ORDER BY id", (status,))
                     robots = [Robot(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(robots)} роботов со статусом {status}")
+                    logger.info(f"Получено {len(robots)} роботов со статусом {status}")
                     return robots
         except Exception as e:
             logger.error(f"Ошибка получения роботов по статусу {status}: {e}")
@@ -113,7 +115,7 @@ class RobotRepository:
                         ORDER BY battery_level ASC
                     """, (threshold,))
                     robots = [Robot(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(robots)} роботов с низким зарядом (<{threshold}%)")
+                    logger.info(f"Получено {len(robots)} роботов с низким зарядом (<{threshold}%)")
                     return robots
         except Exception as e:
             logger.error(f"Ошибка получения роботов с низким зарядом: {e}")
@@ -125,7 +127,7 @@ class RobotRepository:
                 with conn.cursor() as cur:
                     cur.execute("SELECT * FROM robots WHERE current_zone = %s ORDER BY id", (zone,))
                     robots = [Robot(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(robots)} роботов в зоне {zone}")
+                    logger.info(f"Получено {len(robots)} роботов в зоне {zone}")
                     return robots
         except Exception as e:
             logger.error(f"Ошибка получения роботов в зоне {zone}: {e}")
@@ -147,7 +149,7 @@ class RobotRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Создан новый робот {robot_id}")
+                        logger.info(f"Создан новый робот {robot_id}")
                     else:
                         logger.warning(f"Не удалось создать робота {robot_id}")
                     return success
@@ -163,7 +165,7 @@ class RobotRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Робот {robot_id} удален")
+                        logger.info(f"Робот {robot_id} удален")
                     else:
                         logger.warning(f"Робот {robot_id} не найден для удаления")
                     return success

db/repositories/user_repository.py

@@ -1,8 +1,10 @@
 from typing import List, Optional
-from loguru import logger
+import logging
 from model.user import User
 from db.connection import get_connection
 
+logger = logging.getLogger(__name__)
+
 class UserRepository:
     def get_all(self) -> List[User]:
         try:
@@ -19,7 +21,7 @@ class UserRepository:
                             created_at=row[5]
                         ) for row in cur.fetchall()
                     ]
-                    logger.debug(f"Получено {len(users)} пользователей")
+                    logger.info(f"Получено {len(users)} пользователей")
                     return users
         except Exception as e:
             logger.error(f"Ошибка получения пользователей: {e}")
@@ -32,7 +34,7 @@ class UserRepository:
                     cur.execute("SELECT * FROM users WHERE id = %s", (user_id,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Пользователь {user_id} найден")
+                        logger.info(f"Пользователь {user_id} найден")
                         return User(*row)
                     logger.warning(f"Пользователь {user_id} не найден")
                     return None
@@ -47,7 +49,7 @@ class UserRepository:
                     cur.execute("SELECT * FROM users WHERE email = %s", (email,))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Пользователь с email {email} найден")
+                        logger.info(f"Пользователь с email {email} найден")
                         return User(*row)
                     logger.warning(f"Пользователь с email {email} не найден")
                     return None
@@ -75,7 +77,7 @@ class UserRepository:
                     conn.commit()
 
                     if row:
-                        logger.debug(f"Создан новый пользователь {email} с ID {row[0]}")
+                        logger.info(f"Создан новый пользователь {email} с ID {row[0]}")
                         return User(*row)
                     logger.warning(f"Не удалось создать пользователя {email}")
                     return None
@@ -109,7 +111,7 @@ class UserRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Пользователь {user_id} успешно обновлен")
+                        logger.info(f"Пользователь {user_id} успешно обновлен")
                     else:
                         logger.warning(f"Пользователь {user_id} не найден для обновления")
                     return success
@@ -125,7 +127,7 @@ class UserRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Пользователь {user_id} удален")
+                        logger.info(f"Пользователь {user_id} удален")
                     else:
                         logger.warning(f"Пользователь {user_id} не найден для удаления")
                     return success
@@ -139,7 +141,7 @@ class UserRepository:
                 with conn.cursor() as cur:
                     cur.execute("SELECT * FROM users WHERE role = %s ORDER BY name", (role,))
                     users = [User(*row) for row in cur.fetchall()]
-                    logger.debug(f"Получено {len(users)} пользователей с ролью {role}")
+                    logger.info(f"Получено {len(users)} пользователей с ролью {role}")
                     return users
         except Exception as e:
             logger.error(f"Ошибка получения пользователей по роли {role}: {e}")
@@ -157,7 +159,7 @@ class UserRepository:
                     conn.commit()
                     success = cur.rowcount > 0
                     if success:
-                        logger.debug(f"Пароль пользователя {user_id} изменен")
+                        logger.info(f"Пароль пользователя {user_id} изменен")
                     else:
                         logger.warning(f"Пользователь {user_id} не найден для смены пароля")
                     return success
@@ -166,9 +168,6 @@ class UserRepository:
             return False
 
     def authenticate_user(self, email: str, password_hash: str) -> Optional[User]:
-        if not self.user_exists(email):
-            return
-
         try:
             with get_connection() as conn:
                 with conn.cursor() as cur:
@@ -178,7 +177,7 @@ class UserRepository:
                     """, (email, password_hash))
                     row = cur.fetchone()
                     if row:
-                        logger.debug(f"Успешная аутентификация пользователя {email}")
+                        logger.info(f"Успешная аутентификация пользователя {email}")
                         return User(*row)
                     logger.warning(f"Неудачная аутентификация пользователя {email}")
                     return None
@@ -186,6 +185,24 @@ class UserRepository:
             logger.error(f"Ошибка аутентификации пользователя {email}: {e}")
             return None
 
+    def is_valid_authenticate(self, email: str, password_hash: str) -> bool:
+        try:
+            with get_connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("""
+                        SELECT 1 FROM users 
+                        WHERE email = %s AND password_hash = %s
+                    """, (email, password_hash))
+                    is_valid = cur.fetchone() is not None
+                    if is_valid:
+                        logger.info(f"Валидные учетные данные для пользователя {email}")
+                    else:
+                        logger.warning(f"Невалидные учетные данные для пользователя {email}")
+                    return is_valid
+        except Exception as e:
+            logger.error(f"Ошибка проверки учетных данных пользователя {email}: {e}")
+            return False
+
     def user_exists(self, email: str) -> bool:
         try:
             with get_connection() as conn:
@@ -193,9 +210,9 @@ class UserRepository:
                     cur.execute("SELECT 1 FROM users WHERE email = %s", (email,))
                     exists = cur.fetchone() is not None
                     if exists:
-                        logger.debug(f"Пользователь с email {email} существует")
+                        logger.info(f"Пользователь с email {email} существует")
                     else:
-                        logger.debug(f"Пользователь с email {email} не существует")
+                        logger.info(f"Пользователь с email {email} не существует")
                     return exists
         except Exception as e:
             logger.error(f"Ошибка проверки существования пользователя {email}: {e}")

model/user.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
+from utils.token import generateKey
 
 
 @dataclass
@@ -10,3 +11,13 @@ class User:
     name: str
     role: str
     created_at: datetime
+
+    def __init__(self, email: str, passwd: str):
+        #us = getUsModel() #возвращает словарь
+        self.id = 1#us['id']
+        self.name = 'Bob'#us['name']
+        self.role = 'Backend'#us['role']
+        self.token = generateKey(email, passwd)
+
+    def toJson(self):
+        return {"user": {"id": self.id, "name": self.name, "role": self.role}, "token": self.token}

utils/token.py

@@ -1,18 +1,8 @@
 import jwt
 import os
 from time import time
-from model.user import User
 
-def generateKey(user: User) -> dict:
+def generateKey(email, passwd):
     key = os.getenv('KEY')
-    encoded = jwt.encode(
-        {
-            'id': user.id,
-            'name': user.name,
-            'role': user.role,
-            'iat': time()
-        },
-        key,
-        algorithm="HS256"
-    )
+    encoded = jwt.encode({email: passwd, 'iat': time()}, key, algorithm="HS256")
     return encoded