1234

server/api-data-base/data_base/config.py

@@ -0,0 +1,32 @@
+from pydantic.generics import GenericModel  
+import re
+
+class Settings(GenericModel):
+    DB_HOST: str = "postgres"#"postgres"
+    DB_PORT: int = 5432
+    DB_USER: str = "tester"
+    DB_PASS: str = "tester"
+    DB_NAME: str = "test"
+
+    @classmethod
+    def validate_db_port(cls, v):
+        # Проверка и преобразование DB_PORT
+        if isinstance(v, str):
+            # Используем регулярное выражение для извлечения целого числа
+            match = re.search(r'\d+', v)
+            if match:
+                return int(match.group())
+            else:
+                raise ValueError(f"Invalid DB_PORT value: {v}")
+        return v
+
+    @property 
+    def DATABASE_URL_asyncpg(self) -> str:
+        return f"postgresql+asyncpg://{self.DB_USER}:{self.DB_PASS}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
+    
+    @property 
+    def DATABASE_URL_syncpg(self) -> str:
+        return f"postgresql+psycopg2://{self.DB_USER}:{self.DB_PASS}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
+
+# Загрузка настроек из файла .env
+settings = Settings()

server/api-data-base/data_base/data_base.py

@@ -0,0 +1,18 @@
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import sessionmaker, DeclarativeBase
+from sqlalchemy import create_engine
+from data_base.config import settings
+
+# Создание асинхронного движка
+async_engine = create_async_engine(url=settings.DATABASE_URL_asyncpg, echo=True)
+
+# Создание синхронного движка
+sync_engine = create_engine(url=settings.DATABASE_URL_syncpg, echo=True)
+
+# Создание асинхронной и синхронной сессий
+async_session = async_sessionmaker(async_engine)
+sync_session = sessionmaker(sync_engine)
+
+# Базовый класс для декларативных моделей
+class Base(DeclarativeBase):
+    pass

server/api-data-base/data_base/models/main_tables.py

@@ -0,0 +1,94 @@
+from sqlalchemy import Integer, String,PrimaryKeyConstraint,UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column
+from data_base.data_base import Base
+
+
+
+class users(Base):
+    __tablename__ = "users"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name_poo:Mapped[str]=mapped_column(String(50))
+    inn:Mapped[str]=mapped_column(String(50))#login
+    password:Mapped[str]=mapped_column(String(120))
+    mail:Mapped[str]=mapped_column(String(50))
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='user_pk'),
+        UniqueConstraint('inn')
+    )
+    
+class Classification_professions(Base):
+    """Классификация профессий"""
+    __tablename__ = "Classification_professions"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='id_pk_Classification_professions'),
+        UniqueConstraint('name')
+    )
+    
+class Professions(Base):
+    """Профессии"""
+    __tablename__ = "Professions"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='id_pk_Professions'),
+        UniqueConstraint('name')
+    )
+    
+class Positions(Base):
+    """Должность"""
+    __tablename__ = "Positions"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='id_pk_Positions'),
+        UniqueConstraint('name')
+    )
+    
+class Specialization(Base):
+    """Специализация"""
+    __tablename__ = "Specialization"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='id_pk_Specialization'),
+        UniqueConstraint('name')
+    )
+
+class Manufacturing_enterprises(Base):
+    """
+    производственные предприятия
+    (id:int,name:str,INN_company:str)
+    """
+    __tablename__ = "Manufacturing_enterprises"
+    id:Mapped[int]=mapped_column(Integer(),primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    INN_company:Mapped[str]=mapped_column(String(), nullable=False)
+    
+
+class Enterprises(Base):
+    """Предприятия"""
+    __tablename__ = "Enterprises"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    name:Mapped[str]=mapped_column(String(),nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('id', name='id_pk_Enterprises'),
+        UniqueConstraint('name')
+    )
+
+class Сollection_form_opk(Base):
+    """Поо"""
+    __tablename__="Сollection_form_opk"
+    id:Mapped[int]=mapped_column(Integer(), primary_key=True)
+    время_создания:Mapped[str]=mapped_column(String(),nullable=False)
+    указаное_время:Mapped[str]=mapped_column(String(),nullable=False)
+    ПОО:Mapped[str]=mapped_column(String(),nullable=False)
+    Субъект_рф:Mapped[str]=mapped_column(String(),nullable=False)
+    ИНН_ОПК:Mapped[str]=mapped_column(String(),nullable=False)
+    ОПК:Mapped[str]=mapped_column(String(),nullable=False)
+    Группа_профессий_должностей:Mapped[str]=mapped_column(String(),nullable=False)
+    Наименование_профессии:Mapped[str]=mapped_column(String(),nullable=False)
+    Разряд:Mapped[str]=mapped_column(String(),nullable=False)
+    Профессии_специальности_СПО:Mapped[str]=mapped_column(String(),nullable=False)
+    Количество_вакансий:Mapped[str]=mapped_column(String(),nullable=False)

server/api-data-base/data_base/requests.py

@@ -0,0 +1,154 @@
+from data_base.data_base import async_session, Base, async_engine
+import data_base.models.main_tables as mt
+import json
+import model_messege as mm
+from sqlalchemy.future import select
+from sqlalchemy import MetaData, inspect, text, insert, Table
+
+class JsonJober:
+    data = []
+
+    @classmethod
+    def create_table(cls, table_name):
+        """"Создание объектов таблицы"""
+        temp_table = []
+        if mt.Professions.__tablename__ == table_name:
+            for row in JsonJober.data[table_name]:
+                temp_table.append(mt.Professions(name=row))
+                print(f"Added to Professions: {row}")
+        elif mt.Positions.__tablename__ == table_name:
+            for row in JsonJober.data[table_name]:
+                temp_table.append(mt.Positions(name=row))
+                print(f"Added to Positions: {row}")
+        elif mt.Classification_professions.__tablename__ == table_name:
+            for row in JsonJober.data[table_name]:
+                temp_table.append(mt.Classification_professions(name=row))
+                print(f"Added to Classification_professions: {row}")
+        elif mt.Manufacturing_enterprises.__tablename__ == table_name:
+            for i, name in enumerate(JsonJober.data[table_name]["name"]):
+                inn = JsonJober.data[table_name]["inn"][i]
+                temp_table.append(mt.Manufacturing_enterprises(name=name, INN_company=inn))
+                print(f"Added to Manufacturing_enterprises: {name}, {inn}")
+        else:
+            print(f"Unknown table name: {table_name}")
+        return temp_table
+
+    @classmethod
+    def ReadJson(cls, path_file: str = ""):
+        """Чтение json файла"""
+        JsonJober.data = []
+        mass_table = []
+        with open(path_file, "r", encoding="utf-8") as read_file:
+            JsonJober.data = json.load(read_file)
+            for table in JsonJober.data:
+                mass_table.append(JsonJober.create_table(table_name=table))
+        return mass_table
+
+class Request():
+    @classmethod
+    async def load_preset(cls):
+        """"Загрузка пресета"""
+        await cls.craete_all_table()
+        mass_table = JsonJober.ReadJson(path_file="./data_base/preset/test.json")
+        await cls.insert_mass_table(mass_table=mass_table)
+    
+    @classmethod
+    async def insert_mass_table(cls, mass_table):
+        """Добавление множества таблиц"""
+        async with async_session() as session:
+            async with session.begin():
+                for table in mass_table:
+                    session.add_all(table)
+            await session.commit()
+
+    @classmethod
+    async def select_drop_down_list(cls):
+        """Возвращает все выподающие списки"""
+        async with async_session() as session:
+            result = {}
+            tables = [mt.Professions, mt.Positions, mt.Classification_professions, mt.Manufacturing_enterprises]
+            for table in tables:
+                query = select(table)
+                result_proxy = await session.execute(query)
+                result[table.__tablename__] = [row._asdict() for row in result_proxy.fetchall()]
+            return result
+
+    @staticmethod
+    async def craete_all_table():
+        """"Создание всех таблиц"""
+        async with async_engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+            await conn.run_sync(Base.metadata.create_all)
+    
+    @classmethod
+    async def login(cls, auth_request) -> mt.users:
+        """Авторизация"""
+        async with async_session() as session:
+            stmt = select(mt.users).where(
+                mt.users.inn == auth_request.login,
+            )
+            result = await session.execute(stmt)
+            return result.scalars().first()
+        
+    @classmethod
+    async def add_column(cls, table_name: str, column_name: str, data_type: str):
+        """Добавление столбца в таблицу"""
+        async with async_engine.connect() as connection:
+            if data_type == 'String':
+                data_type_sql = "VARCHAR"
+            elif data_type == 'Integer':
+                data_type_sql = "INTEGER"
+            else:
+                raise ValueError("Unsupported data type")
+            
+            alter_stmt = text(f'ALTER TABLE {table_name} ADD COLUMN {column_name} {data_type_sql}')
+            await connection.execute(alter_stmt)
+            await connection.commit()
+
+    @classmethod
+    async def drop_column(cls, table_name: str, column_name: str):
+        """Удаление столбца из таблицы"""
+        async with async_engine.connect() as connection:
+            alter_stmt = text(f'ALTER TABLE {table_name} DROP COLUMN {column_name}')
+            await connection.execute(alter_stmt)
+            await connection.commit()
+            
+    @classmethod
+    async def get_table_columns(cls, table_name: str):
+        """Получение заголовков (имен столбцов) указанной таблицы"""
+        async with async_engine.connect() as connection:
+            def sync_inspect(conn):
+                inspector = inspect(conn)
+                columns = inspector.get_columns(table_name)
+                return [column['name'] for column in columns]
+            
+            column_names = await connection.run_sync(sync_inspect)
+            return column_names
+
+    @classmethod
+    async def insert_table(cls, data: list, table_name:str = "Сollection_form_opk"):
+        data = data["data"]
+        metadata = MetaData()
+        async with async_engine.connect() as connection:
+            await connection.run_sync(metadata.reflect)
+            table = Table(table_name, metadata, autoload_with=connection)
+        async with async_session() as session:
+            async with session.begin():
+                for row in data:
+                    stmt = insert(table).values(**row)
+                    await session.execute(stmt)
+                await session.commit()
+
+    @classmethod
+    async def select_rows_with_filter(cls, value:str, table_name: str = "Сollection_form_opk", column_name: str = "ПОО"):
+        """Выгрузка строк с фильтром по указанному столбцу и значению"""
+        metadata = MetaData()
+        async with async_engine.connect() as connection:
+            await connection.run_sync(metadata.reflect)
+            table = Table(table_name, metadata, autoload_with=connection)
+        
+        async with async_session() as session:
+            query = select(table).where(table.c[column_name] == value)
+            result_proxy = await session.execute(query)
+            result = [row._asdict() for row in result_proxy.fetchall()]
+            return result