создана часть бекенда

db/schemas/__init__.py

@@ -1,6 +1,144 @@
-from user import *
-from access import *
-from toolkit import *
-from categories import *
-from db.schemas.toolbox import *
-from stock import *
+from .user import *
+from .access import *
+from .toolkit import *
+from .categories import *
+from .toolbox import *
+from .stock import *
+
+from typing import Optional
+from sqlalchemy import inspect, text
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
+from sqlalchemy.schema import CreateTable
+from utils import logger
+
+# Импортируем все модели
+from db import Base
+from db.handlers import InitializeDatabase
+
+
+class DatabaseInitializer:
+    existing_tables: Optional[list[str]] = None
+
+    def __init__(self, database_url: str):
+        self.database_url = database_url
+        self.engine: Optional[AsyncEngine] = None
+        self.metadata = Base.metadata
+
+    async def initialize(self, force: bool = False, reNewDB: bool = False):
+        """Main database initialization method"""
+        try:
+            self.engine = create_async_engine(self.database_url)
+
+            async with self.engine.begin() as conn:
+                if force:
+                    logger.info("Принудительное удаление и создание баз...")
+                    await self._drop_all()
+                    await self._create_tables_directly()
+                    await self._initialize_data()
+                elif not await self._check_tables_exist(conn):
+                    logger.info("Не все необходимые таблицы существуют. Создаем...")
+                    await self._create_tables_directly()
+
+                    # Проверяем после создания
+                    async with self.engine.begin() as conn:
+                        if not await self._check_tables_exist(conn):
+                            raise RuntimeError("Не все необходимые таблицы существуют!")
+
+                    if reNewDB:
+                        logger.info("Принудительная загрузка данных...")
+                        await self._initialize_data()
+                else:
+                    logger.info("Все необходимые таблицы существуют. Пропускаем...")
+
+        except Exception as e:
+            logger.error(f"Инициализация базы завершилась ошибкой: {str(e)}")
+            raise
+        finally:
+            if self.engine:
+                await self.engine.dispose()
+
+    async def _check_tables_exist(self, conn) -> bool:
+        """Check if all tables from metadata exist"""
+        try:
+            DatabaseInitializer.existing_tables = await conn.run_sync(
+                lambda sync_conn: inspect(sync_conn).get_table_names()
+            )
+
+            required_tables = set(self.metadata.tables.keys())
+
+            if not required_tables:
+                logger.error("Нет данных о таблицах в метаданных")
+                return False
+
+            missing_tables = required_tables - set(DatabaseInitializer.existing_tables)
+            if missing_tables:
+                logger.warning("Существующие таблицы:")
+                logger.info(DatabaseInitializer.existing_tables)
+                logger.warning("Необходимые таблицы:")
+                logger.info(required_tables)
+                logger.warning("Отсутствующие таблицы:")
+                logger.info(missing_tables)
+                return False
+
+            return True
+        except Exception as e:
+            logger.warning(f"Проверка таблиц завершилась ошибкой: {str(e)}")
+            return False
+
+    async def _create_tables_directly(self):
+        """Create tables directly using SQLAlchemy (bypass Alembic)"""
+        async with self.engine.begin() as conn:
+            # Создаем все таблицы из метаданных
+            for table in self.metadata.sorted_tables:
+                try:
+                    if (
+                        DatabaseInitializer.existing_tables
+                        and table.name in DatabaseInitializer.existing_tables
+                    ):
+                        logger.debug(
+                            f"Таблица {table.name} уже существует. Пропускаем..."
+                        )
+                        continue
+                    create_stmt = CreateTable(table)
+                    logger.info(f"Создаем таблицу: {table.name}")
+                    await conn.execute(create_stmt)
+                except Exception as e:
+                    logger.error(f"Ошибка создания таблицы: {str(e)}")
+            logger.warning("Все таблицы успешно созданы")
+
+    async def _drop_all(self):
+        """Drop all tables"""
+        async with self.engine.begin() as conn:
+            # Получаем список всех таблиц
+            existing_tables = await conn.run_sync(
+                lambda sync_conn: inspect(sync_conn).get_table_names()
+            )
+
+            for table in existing_tables:
+                drop_stmt = text(
+                    f'DROP TABLE "{table}" CASCADE'
+                )  # Кавычки на случай спец. символов
+                logger.info(f"Удаляем таблицу: {table}")
+                await conn.execute(drop_stmt)
+
+            logger.warning("Все таблицы успешно удалены")
+
+    async def _initialize_data(self):
+        """Initialize required data"""
+        try:
+            logger.info("Инициализация данных...")
+            await InitializeDatabase.initialize()
+            logger.info("Данные успешно инициализированы")
+        except Exception as e:
+            logger.error(f"Инициализация данных завершилась ошибкой: {str(e)}")
+            raise
+
+
+__all__ = [
+    "User",
+    "Access",
+    "Toolbox",
+    "Category",
+    "Stock",
+    "Toolkit",
+]

db/schemas/access.py

@@ -23,7 +23,7 @@ class AccessLevel(Base):
     tools_registration = Column(Boolean, default=False)
     tools_registration_edit = Column(Boolean, default=False)
     tools_edit = Column(Boolean, default=False)
-    tools_achievement = Column(Boolean, default=False)
+    tools_delete = Column(Boolean, default=False)
     users_creation = Column(Boolean, default=False)
     users_edit = Column(Boolean, default=False)
     users_disabling = Column(Boolean, default=False)
@@ -31,6 +31,7 @@ class AccessLevel(Base):
     available_own_toolbox = Column(Boolean, default=False)
     view_all_toolboxes = Column(Boolean, default=False)
     view_requests = Column(Boolean, default=False)
+    view_services = Column(Boolean, default=False)
     access_level_view = Column(Boolean, default=False)
     access_level_edit = Column(Boolean, default=False)
     manage_toolboxes = Column(Boolean, default=False)

db/schemas/categories.py

@@ -9,7 +9,7 @@ class Category(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(String, unique=True, index=True)
-    description = Column(Text)
+    description = Column(Text, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
     updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
 

db/schemas/records.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
+from db import Base
+import utils
+
+
+class StocksRecords(Base):
+    __tablename__ = "stocks_records"
+
+    id = Column(Integer, primary_key=True, index=True)
+    action = Column(String, nullable=False)
+    source_toolbox_id = Column(
+        Integer, ForeignKey("toolboxes.id", ondelete="CASCADE"), nullable=False
+    )
+    target_toolbox_id = Column(
+        Integer, ForeignKey("toolboxes.id", ondelete="CASCADE"), nullable=True
+    )
+    toolkit_id = Column(
+        Integer, ForeignKey("toolkits.id", ondelete="CASCADE"), nullable=False
+    )
+    init_user_id = Column(
+        Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+    accept_user_id = Column(
+        Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=True
+    )
+    reason = Column(Text, nullable=False)
+    quantity = Column(Integer, nullable=False)
+    edit_user_id = Column(
+        Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=True
+    )
+    edited = Column(JSONB, nullable=True)
+    created_at = Column(DateTime, default=datetime.now)
+    accepted_at = Column(DateTime, nullable=True)
+    edited_at = Column(DateTime, nullable=True)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def toDict(self):
+        return utils.toDict(self)
+
+    async def save(self):
+        from db import CRUD
+
+        return await CRUD.create(self, refresh=True)
+
+    async def edit(self, **kwargs):
+        from db import CRUD
+
+        return await CRUD.update(StocksRecords, self.id, **kwargs)
+
+
+class ServicesRecords(Base):
+    __tablename__ = "services_records"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=True)
+    details = Column(JSONB, nullable=False)
+    created_at = Column(DateTime, default=datetime.now)
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def toDict(self):
+        return utils.toDict(self)
+
+    async def save(self):
+        from db import CRUD
+
+        return await CRUD.create(self, refresh=True)

db/schemas/stock.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from sqlalchemy import Column, DateTime, Float, ForeignKey, Integer
+from sqlalchemy import Column, DateTime, Float, ForeignKey, Integer, String
 from sqlalchemy.orm import relationship
 
 from db import Base
@@ -24,6 +24,7 @@ class Stock(Base):
     )
     quantity = Column(Integer, nullable=False)
     price = Column(Float, nullable=False)
+    placement = Column(String, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
     updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
 

db/schemas/toolbox.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text
 from db import Base
 import utils
 
@@ -9,10 +9,11 @@ class Toolbox(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(String, unique=True, index=True)
-    description = Column(Text)
+    description = Column(Text, nullable=True)
     owner_id = Column(
-        Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=True
+        Integer, ForeignKey("users.id", ondelete="CASCADE"), default=None, nullable=True
     )
+    monitoring = Column(Boolean, default=False)
     created_at = Column(DateTime, default=datetime.now)
     updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
 

db/schemas/toolkit.py

@@ -11,14 +11,13 @@ class Toolkit(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     title = Column(String, unique=True, index=True)
-    description = Column(Text)
+    description = Column(Text, nullable=True)
+    specifications = Column(JSONB, default={})
     category_id = Column(Integer, ForeignKey("categories.id", ondelete="CASCADE"))
     category_data = relationship(
         "Category", cascade="all, delete-orphan", lazy="joined", uselist=False
     )
-    image = Column(
-        JSONB, default={"main": "images/tools/default.png", "additional": []}
-    )
+    image = Column(JSONB)
     quantity_min = Column(Integer, nullable=True)
     quantity_min_extra = Column(Integer, nullable=True)
     external_link = Column(String, nullable=True)