Vorkout/connect
4
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: refactor project with ruff

Browse Source
This commit is contained in:
Vladislav Syrochkin
2025-05-20 11:43:05 +05:00
parent de06890f6a
commit 881a72a66c
31 changed files with 326 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/api/__main__.py
View File

@@ -21,7 +21,6 @@ def bind_routes(application: FastAPI, setting: DefaultSettings) -> None:
application.include_router(route, prefix=setting.PATH_PREFIX)
def get_app() -> FastAPI:
"""Creates application and all dependable objects."""
loguru.logger.remove()
@@ -80,7 +79,6 @@ app.add_middleware(
allow_credentials=True,
allow_methods=["GET", "POST", "OPTIONS", "DELETE", "PUT"],
allow_headers=["*"],
)
app.add_middleware(MiddlewareAccessTokenValidadtion)

9
api/api/config/default.py
View File

@@ -44,16 +44,11 @@ class DefaultSettings(BaseSettings):
REDIS_DB: int = int(environ.get("REDIS_DB", "0"))
REDIS_PASSWORD: str = environ.get("REDIS_PASSWORD", "hackme")
SECRET_KEY: str = environ.get("SECRET_KEY", "secret")
ALGORITHM: str = environ.get("ALGORITHM", "HS256")
ACCESS_TOKEN_EXPIRE_MINUTES: int = int(
environ.get("ACCESS_TOKEN_EXPIRE_MINUTES", 600)
)
ACCESS_TOKEN_EXPIRE_MINUTES: int = int(environ.get("ACCESS_TOKEN_EXPIRE_MINUTES", 600))
REFRESH_TOKEN_EXPIRE_DAYS: int = int(
environ.get("REFRESH_TOKEN_EXPIRE_DAYS_LONG", 365)
)
REFRESH_TOKEN_EXPIRE_DAYS: int = int(environ.get("REFRESH_TOKEN_EXPIRE_DAYS_LONG", 365))
@cached_property
def database_settings(self) -> dict:

7
api/api/db/connection/session.py
View File

@@ -8,18 +8,16 @@ import asyncio
import sqlalchemy
from loguru import logger
from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
from sqlalchemy import URL,create_engine, text
from sqlalchemy import URL, create_engine, text
from api.config import get_settings
from api.config.default import DbCredentialsSchema
class SessionManager:
engines: Any
def __init__(self, database_uri=get_settings().database_uri) -> None:
self.database_uri = database_uri
self.refresh(database_uri)
@@ -44,9 +42,11 @@ class SessionManager:
pool_size=get_settings().CONNECTION_POOL_SIZE,
max_overflow=get_settings().CONNECTION_OVERFLOW,
)
def get_engine_by_db_uri(self, database_uri) -> AsyncEngine:
return self.engines[database_uri]
@contextlib.asynccontextmanager
async def get_connection(
database_uri=None,
@@ -58,6 +58,7 @@ async def get_connection(
async with engine.connect() as conn:
yield conn
async def get_connection_dep() -> AsyncConnection:
async with get_connection() as conn:
yield conn

34
api/api/db/logic/account.py
View File

@@ -16,10 +16,7 @@ async def get_user_id(connection: AsyncConnection, id: int) -> Optional[User]:
"""
Получает юзера по id.
"""
query = (
select(account_table)
.where(account_table.c.id == id)
)
query = select(account_table).where(account_table.c.id == id)
user_db_cursor = await connection.execute(query)
user_db = user_db_cursor.one_or_none()
@@ -28,8 +25,11 @@ async def get_user_id(connection: AsyncConnection, id: int) -> Optional[User]:
return None
user_data = {
column.name: (getattr(user_db, column.name).name if isinstance(
getattr(user_db, column.name), Enum) else getattr(user_db, column.name))
column.name: (
getattr(user_db, column.name).name
if isinstance(getattr(user_db, column.name), Enum)
else getattr(user_db, column.name)
)
for column in account_table.columns
}
@@ -40,10 +40,7 @@ async def get_user_login(connection: AsyncConnection, login: str) -> Optional[Us
"""
Получает юзера по login.
"""
query = (
select(account_table)
.where(account_table.c.login == login)
)
query = select(account_table).where(account_table.c.login == login)
user_db_cursor = await connection.execute(query)
user_db = user_db_cursor.one_or_none()
@@ -52,8 +49,11 @@ async def get_user_login(connection: AsyncConnection, login: str) -> Optional[Us
return None
user_data = {
column.name: (getattr(user_db, column.name).name if isinstance(
getattr(user_db, column.name), Enum) else getattr(user_db, column.name))
column.name: (
getattr(user_db, column.name).name
if isinstance(getattr(user_db, column.name), Enum)
else getattr(user_db, column.name)
)
for column in account_table.columns
}
@@ -64,11 +64,7 @@ async def update_user_id(connection: AsyncConnection, update_values, user) -> Op
"""
Вносит изменеия в нужное поле таблицы account_table.
"""
await connection.execute(
account_table.update()
.where(account_table.c.id == user.id)
.values(**update_values)
)
await connection.execute(account_table.update().where(account_table.c.id == user.id).values(**update_values))
await connection.commit()
@@ -86,11 +82,9 @@ async def create_user(connection: AsyncConnection, user: User, creator_id: int)
meta=user.meta,
creator_id=creator_id,
created_at=datetime.now(timezone.utc),
status=user.status.value
status=user.status.value,
)
await connection.execute(query)
await connection.commit()

33
api/api/db/logic/auth.py
View File

@@ -1,6 +1,6 @@
from typing import Optional
from sqlalchemy import select, update
from sqlalchemy import select, update
from sqlalchemy.ext.asyncio import AsyncConnection
from enum import Enum
@@ -11,16 +11,14 @@ from api.schemas.account.account_keyring import AccountKeyring
from api.utils.key_id_gen import KeyIdGenerator
from datetime import datetime, timezone
from datetime import datetime, timezone
async def get_user(connection: AsyncConnection, login: str) -> Optional[User]:
query = (
select(account_table, account_keyring_table)
.join(account_keyring_table, account_table.c.id == account_keyring_table.c.owner_id)
.where(account_table.c.login == login,
account_keyring_table.c.key_type == KeyType.PASSWORD)
.where(account_table.c.login == login, account_keyring_table.c.key_type == KeyType.PASSWORD)
)
user_db_cursor = await connection.execute(query)
@@ -29,16 +27,21 @@ async def get_user(connection: AsyncConnection, login: str) -> Optional[User]:
if not user_db:
return None, None
user_data = {
column.name: (getattr(user_db, column.name).name if isinstance(
getattr(user_db, column.name), Enum) else getattr(user_db, column.name))
column.name: (
getattr(user_db, column.name).name
if isinstance(getattr(user_db, column.name), Enum)
else getattr(user_db, column.name)
)
for column in account_table.columns
}
password_data = {
column.name: (getattr(user_db, column.name).name if isinstance(
getattr(user_db, column.name), Enum) else getattr(user_db, column.name))
column.name: (
getattr(user_db, column.name).name
if isinstance(getattr(user_db, column.name), Enum)
else getattr(user_db, column.name)
)
for column in account_keyring_table.columns
}
@@ -47,8 +50,7 @@ async def get_user(connection: AsyncConnection, login: str) -> Optional[User]:
return user, password
async def upgrade_old_refresh_token(connection: AsyncConnection, user,refresh_token) -> Optional[User]:
async def upgrade_old_refresh_token(connection: AsyncConnection, user, refresh_token) -> Optional[User]:
new_status = KeyStatus.EXPIRED
update_query = (
@@ -57,7 +59,7 @@ async def upgrade_old_refresh_token(connection: AsyncConnection, user,refresh_to
account_table.c.id == user.id,
account_keyring_table.c.status == KeyStatus.ACTIVE,
account_keyring_table.c.key_type == KeyType.REFRESH_TOKEN,
account_keyring_table.c.key_value == refresh_token
account_keyring_table.c.key_value == refresh_token,
)
.values(status=new_status)
)
@@ -67,8 +69,9 @@ async def upgrade_old_refresh_token(connection: AsyncConnection, user,refresh_to
await connection.commit()
async def add_new_refresh_token(connection: AsyncConnection, new_refresh_token, new_refresh_token_expires_time, user) -> Optional[User]:
async def add_new_refresh_token(
connection: AsyncConnection, new_refresh_token, new_refresh_token_expires_time, user
) -> Optional[User]:
new_refresh_token = account_keyring_table.insert().values(
owner_id=user.id,
key_type=KeyType.REFRESH_TOKEN,

41
api/api/db/logic/keyring.py
View File

@@ -5,21 +5,17 @@ from enum import Enum
from sqlalchemy import insert, select
from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.tables.account import account_keyring_table
from api.db.tables.account import account_keyring_table
from api.schemas.account.account_keyring import AccountKeyring
from api.schemas.endpoints.account_keyring import AccountKeyringUpdate, StatusKey, TypeKey
async def get_key_id(connection: AsyncConnection, key_id: str) -> Optional[AccountKeyring]:
"""
Получает key по key_id.
"""
query = (
select(account_keyring_table)
.where(account_keyring_table.c.key_id == key_id)
)
query = select(account_keyring_table).where(account_keyring_table.c.key_id == key_id)
user_db_cursor = await connection.execute(query)
user_db = user_db_cursor.one_or_none()
@@ -28,8 +24,11 @@ async def get_key_id(connection: AsyncConnection, key_id: str) -> Optional[Accou
return None
user_data = {
column.name: (getattr(user_db, column.name).name if isinstance(
getattr(user_db, column.name), Enum) else getattr(user_db, column.name))
column.name: (
getattr(user_db, column.name).name
if isinstance(getattr(user_db, column.name), Enum)
else getattr(user_db, column.name)
)
for column in account_keyring_table.columns
}
@@ -41,30 +40,28 @@ async def update_key_id(connection: AsyncConnection, update_values, key) -> Opti
Вносит изменеия в нужное поле таблицы account_keyring_table.
"""
await connection.execute(
account_keyring_table.update()
.where(account_keyring_table.c.key_id == key.key_id)
.values(**update_values)
)
account_keyring_table.update().where(account_keyring_table.c.key_id == key.key_id).values(**update_values)
)
await connection.commit()
async def create_key(connection: AsyncConnection, key: AccountKeyring, key_id:int) -> Optional[AccountKeyring]:
async def create_key(connection: AsyncConnection, key: AccountKeyring, key_id: int) -> Optional[AccountKeyring]:
"""
Создает нове поле в таблице account_keyring_table).
"""
query = insert(account_keyring_table).values(
owner_id = key.owner_id,
key_type= key.key_type.value,
key_id= key_id,
key_value= key.key_value,
created_at= datetime.now(timezone.utc),
expiry= key.expiry,
status= key.status.value
owner_id=key.owner_id,
key_type=key.key_type.value,
key_id=key_id,
key_value=key.key_value,
created_at=datetime.now(timezone.utc),
expiry=key.expiry,
status=key.status.value,
)
key.created_at= datetime.now(timezone.utc)
key.key_id= key_id
key.created_at = datetime.now(timezone.utc)
key.key_id = key_id
await connection.execute(query)

2
api/api/db/tables/__init__.py
View File

@@ -1 +1 @@
from . import account,events,process
from . import account, events, process

58
api/api/db/tables/account.py
View File

@@ -7,13 +7,14 @@ from api.db.sql_types import UnsignedInt
from api.db import metadata
class AccountRole(str,Enum):
class AccountRole(str, Enum):
OWNER = auto()
ADMIN = auto()
EDITOR = auto()
VIEWER = auto()
class AccountStatus(str,Enum):
class AccountStatus(str, Enum):
ACTIVE = auto()
DISABLED = auto()
BLOCKED = auto()
@@ -21,39 +22,44 @@ class AccountStatus(str,Enum):
account_table = Table(
'account', metadata,
Column('id', UnsignedInt, primary_key=True, autoincrement=True),
Column('name', String(100), nullable=False),
Column('login', String(100), nullable=False),
Column('email', String(100), nullable=True),
Column('bind_tenant_id', String(40), nullable=True),
Column('role', SQLAEnum(AccountRole), nullable=False),
Column('meta', JSON, default={}),
Column('creator_id', UnsignedInt, ForeignKey('account.id'), nullable=True),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('status', SQLAEnum(AccountStatus), nullable=False),
Index('idx_login', 'login'),
Index('idx_name', 'name'),
"account",
metadata,
Column("id", UnsignedInt, primary_key=True, autoincrement=True),
Column("name", String(100), nullable=False),
Column("login", String(100), nullable=False),
Column("email", String(100), nullable=True),
Column("bind_tenant_id", String(40), nullable=True),
Column("role", SQLAEnum(AccountRole), nullable=False),
Column("meta", JSON, default={}),
Column("creator_id", UnsignedInt, ForeignKey("account.id"), nullable=True),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("status", SQLAEnum(AccountStatus), nullable=False),
Index("idx_login", "login"),
Index("idx_name", "name"),
)
class KeyType(str,Enum):
class KeyType(str, Enum):
PASSWORD = auto()
ACCESS_TOKEN = auto()
REFRESH_TOKEN = auto()
API_KEY = auto()
class KeyStatus(str,Enum):
class KeyStatus(str, Enum):
ACTIVE = auto()
EXPIRED = auto()
DELETED = auto()
account_keyring_table = Table(
'account_keyring', metadata,
Column('owner_id', UnsignedInt, ForeignKey('account.id'), primary_key=True, nullable=False),
Column('key_type', SQLAEnum(KeyType), primary_key=True, nullable=False),
Column('key_id', String(40),primary_key=True, default=None),
Column('key_value', String(255), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('expiry', DateTime(timezone=True), nullable=True),
Column('status', SQLAEnum(KeyStatus), nullable=False), )
"account_keyring",
metadata,
Column("owner_id", UnsignedInt, ForeignKey("account.id"), primary_key=True, nullable=False),
Column("key_type", SQLAEnum(KeyType), primary_key=True, nullable=False),
Column("key_id", String(40), primary_key=True, default=None),
Column("key_value", String(255), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("expiry", DateTime(timezone=True), nullable=True),
Column("status", SQLAEnum(KeyStatus), nullable=False),
)

21
api/api/db/tables/events.py
View File

@@ -6,10 +6,12 @@ from api.db.sql_types import UnsignedInt
from api.db import metadata
class EventState(str, Enum):
AUTO = auto()
DESCRIPTED = auto()
class EventStatus(str, Enum):
ACTIVE = auto()
DISABLED = auto()
@@ -17,13 +19,14 @@ class EventStatus(str, Enum):
list_events_table = Table(
'list_events', metadata,
Column('id', UnsignedInt, primary_key=True, autoincrement=True),
Column('name', String(40, collation='latin1_bin'), nullable=False,unique=True),
Column('title', String(64), nullable=False),
Column('creator_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('schema', JSON, default={}),
Column('state', SQLAEnum(EventState), nullable=False),
Column('status', SQLAEnum(EventStatus), nullable=False),
"list_events",
metadata,
Column("id", UnsignedInt, primary_key=True, autoincrement=True),
Column("name", String(40, collation="latin1_bin"), nullable=False, unique=True),
Column("title", String(64), nullable=False),
Column("creator_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("schema", JSON, default={}),
Column("state", SQLAEnum(EventState), nullable=False),
Column("status", SQLAEnum(EventStatus), nullable=False),
)

116
api/api/db/tables/process.py
View File

@@ -1,4 +1,16 @@
from sqlalchemy import Table, Column, Integer, String, Text, Enum as SQLAEnum, JSON, ForeignKey, DateTime, Index, PrimaryKeyConstraint
from sqlalchemy import (
Table,
Column,
Integer,
String,
Text,
Enum as SQLAEnum,
JSON,
ForeignKey,
DateTime,
Index,
PrimaryKeyConstraint,
)
from sqlalchemy.sql import func
from enum import Enum, auto
@@ -7,7 +19,6 @@ from api.db.sql_types import UnsignedInt
from api.db import metadata
class ProcessStatus(str, Enum):
ACTIVE = auto()
STOPPING = auto()
@@ -16,69 +27,80 @@ class ProcessStatus(str, Enum):
process_schema_table = Table(
'process_schema', metadata,
Column('id', UnsignedInt, primary_key=True, autoincrement=True),
Column('title', String(100), nullable=False),
Column('description', Text, nullable=False),
Column('owner_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('creator_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('settings', JSON, default={}),
Column('status', SQLAEnum(ProcessStatus), nullable=False),
Index('idx_owner_id', 'owner_id',)
"process_schema",
metadata,
Column("id", UnsignedInt, primary_key=True, autoincrement=True),
Column("title", String(100), nullable=False),
Column("description", Text, nullable=False),
Column("owner_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("creator_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("settings", JSON, default={}),
Column("status", SQLAEnum(ProcessStatus), nullable=False),
Index(
"idx_owner_id",
"owner_id",
),
)
process_version_archive_table = Table(
'process_version_archive', metadata,
Column('id', UnsignedInt, autoincrement=True, nullable=False),
Column('ps_id', UnsignedInt, ForeignKey('process_schema.id'), nullable=False),
Column('version', UnsignedInt, default=1, nullable=False),
Column('snapshot', JSON, default={}),
Column('owner_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('is_last', UnsignedInt, default=0),
PrimaryKeyConstraint('id', 'version') )
"process_version_archive",
metadata,
Column("id", UnsignedInt, autoincrement=True, nullable=False),
Column("ps_id", UnsignedInt, ForeignKey("process_schema.id"), nullable=False),
Column("version", UnsignedInt, default=1, nullable=False),
Column("snapshot", JSON, default={}),
Column("owner_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("is_last", UnsignedInt, default=0),
PrimaryKeyConstraint("id", "version"),
)
class NodeStatus(str, Enum):
ACTIVE = auto()
DISABLED = auto()
DELETED = auto()
class NodeType(Enum):
TYPE1 = 'Type1'
TYPE2 = 'Type2'
TYPE3 = 'Type3'
TYPE1 = "Type1"
TYPE2 = "Type2"
TYPE3 = "Type3"
ps_node_table = Table(
'ps_node', metadata,
Column('id', UnsignedInt, autoincrement=True, primary_key=True, nullable=False),
Column('ps_id', UnsignedInt, ForeignKey('process_schema.id'), nullable=False),
Column('node_type', SQLAEnum(NodeType), nullable=False),
Column('settings', JSON, default={}),
Column('creator_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('status', SQLAEnum(NodeStatus), nullable=False),
Index('idx_ps_id', 'ps_id')
"ps_node",
metadata,
Column("id", UnsignedInt, autoincrement=True, primary_key=True, nullable=False),
Column("ps_id", UnsignedInt, ForeignKey("process_schema.id"), nullable=False),
Column("node_type", SQLAEnum(NodeType), nullable=False),
Column("settings", JSON, default={}),
Column("creator_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("status", SQLAEnum(NodeStatus), nullable=False),
Index("idx_ps_id", "ps_id"),
)
class NodeLinkStatus(str, Enum):
ACTIVE = auto()
STOPPING = auto()
STOPPED = auto()
DELETED = auto()
node_link_table = Table(
'node_link', metadata,
Column('id', UnsignedInt, autoincrement=True, primary_key=True, nullable=False),
Column('link_name', String(20), nullable=False),
Column('node_id', UnsignedInt, ForeignKey('ps_node.id'), nullable=False),
Column('next_node_id', UnsignedInt, ForeignKey('ps_node.id'), nullable=False),
Column('settings', JSON, default={}),
Column('creator_id', UnsignedInt, ForeignKey('account.id'), nullable=False),
Column('created_at', DateTime(timezone=True), server_default=func.now()),
Column('status', SQLAEnum(NodeLinkStatus),nullable=False),
Index('idx_node_id', 'node_id'),
Index('idx_next_node_id', 'next_node_id'))
node_link_table = Table(
"node_link",
metadata,
Column("id", UnsignedInt, autoincrement=True, primary_key=True, nullable=False),
Column("link_name", String(20), nullable=False),
Column("node_id", UnsignedInt, ForeignKey("ps_node.id"), nullable=False),
Column("next_node_id", UnsignedInt, ForeignKey("ps_node.id"), nullable=False),
Column("settings", JSON, default={}),
Column("creator_id", UnsignedInt, ForeignKey("account.id"), nullable=False),
Column("created_at", DateTime(timezone=True), server_default=func.now()),
Column("status", SQLAEnum(NodeLinkStatus), nullable=False),
Index("idx_node_id", "node_id"),
Index("idx_next_node_id", "next_node_id"),
)

7
api/api/endpoints/__init__.py
View File

@@ -2,11 +2,8 @@ from api.endpoints.auth import api_router as auth_router
from api.endpoints.profile import api_router as profile_router
from api.endpoints.account import api_router as account_router
from api.endpoints.keyring import api_router as keyring_router
list_of_routes = [
auth_router,
profile_router,
account_router,
keyring_router]
list_of_routes = [auth_router, profile_router, account_router, keyring_router]
__all__ = [
"list_of_routes",

68
api/api/endpoints/account.py
View File

@@ -14,9 +14,9 @@ from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.connection.session import get_connection_dep
from api.db.logic.account import get_user_id, update_user_id, create_user,get_user_login
from api.db.logic.account import get_user_id, update_user_id, create_user, get_user_login
from api.schemas.account.account import User,Status
from api.schemas.account.account import User, Status
from api.schemas.endpoints.account import UserUpdate
@@ -30,34 +30,21 @@ api_router = APIRouter(
)
@api_router.get("/{user_id}")
async def get_account(user_id: int,
request: Request,
connection: AsyncConnection = Depends(get_connection_dep)
):
async def get_account(user_id: int, request: Request, connection: AsyncConnection = Depends(get_connection_dep)):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_id(connection, user_id)
if user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Account not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")
return user
@api_router.post("")
async def create_account(
user: UserUpdate,
request: Request,
connection: AsyncConnection = Depends(get_connection_dep)
):
async def create_account(user: UserUpdate, request: Request, connection: AsyncConnection = Depends(get_connection_dep)):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
@@ -65,40 +52,29 @@ async def create_account(
user_validation = await get_user_login(connection, user.login)
if user_validation is None:
await create_user(connection,user,authorize_user.id)
await create_user(connection, user, authorize_user.id)
user_new = await get_user_login(connection, user.login)
return user_new
else:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="An account with this information already exists.")
status_code=status.HTTP_400_BAD_REQUEST, detail="An account with this information already exists."
)
@api_router.put("/{user_id}")
async def update_account(
user_id: int,
request: Request,
user_update: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep)
):
user_id: int, request: Request, user_update: UserUpdate, connection: AsyncConnection = Depends(get_connection_dep)
):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_id(connection, user_id)
if user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Account not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")
update_values = update_user_data_changes(user_update,user)
update_values = update_user_data_changes(user_update, user)
if update_values is None:
return user
@@ -107,42 +83,30 @@ async def update_account(
await update_user_id(connection, update_values, user)
user = await get_user_id(connection, user_id)
return user
@api_router.delete("/{user_id}")
async def delete_account(
user_id: int,
request: Request,
connection: AsyncConnection = Depends(get_connection_dep)
):
async def delete_account(user_id: int, request: Request, connection: AsyncConnection = Depends(get_connection_dep)):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_id(connection, user_id)
if user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Account not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")
user_update = UserUpdate(status=Status.DELETED.value)
update_values = update_user_data_changes(user_update,user)
update_values = update_user_data_changes(user_update, user)
if update_values is None:
return user
await update_user_id(connection, update_values, user)
user = await get_user_id(connection, user_id)
return user

73
api/api/endpoints/auth.py
View File

@@ -24,7 +24,7 @@ from api.config import get_settings
from api.db.connection.session import get_connection_dep
from api.services.auth import authenticate_user
from api.db.logic.auth import add_new_refresh_token,upgrade_old_refresh_token
from api.db.logic.auth import add_new_refresh_token, upgrade_old_refresh_token
from api.schemas.endpoints.auth import Auth
@@ -54,12 +54,11 @@ def get_config():
@api_router.post("")
async def login_for_access_token(
user: Auth,
response: Response,
connection: AsyncConnection = Depends(get_connection_dep),
Authorize: AuthJWT = Depends(),
):
user: Auth,
response: Response,
connection: AsyncConnection = Depends(get_connection_dep),
Authorize: AuthJWT = Depends(),
):
"""Авторизирует, выставляет токены в куки."""
user = await authenticate_user(connection, user.login, user.password)
@@ -73,44 +72,33 @@ async def login_for_access_token(
# headers={"WWW-Authenticate": "Bearer"},
)
access_token_expires = timedelta(
minutes=get_settings().ACCESS_TOKEN_EXPIRE_MINUTES)
access_token_expires = timedelta(minutes=get_settings().ACCESS_TOKEN_EXPIRE_MINUTES)
refresh_token_expires = timedelta(
days=get_settings().REFRESH_TOKEN_EXPIRE_DAYS
)
refresh_token_expires = timedelta(days=get_settings().REFRESH_TOKEN_EXPIRE_DAYS)
logger.debug(f"refresh_token_expires {refresh_token_expires}")
access_token = Authorize.create_access_token(
subject=user.login, expires_time=access_token_expires
)
refresh_token = Authorize.create_refresh_token(
subject=user.login, expires_time=refresh_token_expires
)
access_token = Authorize.create_access_token(subject=user.login, expires_time=access_token_expires)
refresh_token = Authorize.create_refresh_token(subject=user.login, expires_time=refresh_token_expires)
refresh_token_expires_time = datetime.now(timezone.utc) + refresh_token_expires
await add_new_refresh_token(connection,refresh_token,refresh_token_expires_time,user)
await add_new_refresh_token(connection, refresh_token, refresh_token_expires_time, user)
Authorize.set_refresh_cookies(refresh_token)
return {
"access_token": access_token,
# "access_token_expires": access_token_expires_time,
# "refresh_token": refresh_token,
# "refresh_token_expires": refresh_token_expires_time
}
"access_token": access_token,
# "access_token_expires": access_token_expires_time,
# "refresh_token": refresh_token,
# "refresh_token_expires": refresh_token_expires_time
}
@api_router.post("/refresh")
async def refresh(
request: Request,
connection: AsyncConnection = Depends(get_connection_dep),
Authorize: AuthJWT = Depends()
):
request: Request, connection: AsyncConnection = Depends(get_connection_dep), Authorize: AuthJWT = Depends()
):
refresh_token = request.cookies.get("refresh_token_cookie")
# print("Refresh Token:", refresh_token)
@@ -118,29 +106,24 @@ async def refresh(
raise HTTPException(status_code=401, detail="Refresh token is missing")
try:
Authorize.jwt_refresh_token_required()
current_user = Authorize.get_jwt_subject()
except Exception as e:
await upgrade_old_refresh_token(connection,current_user,refresh_token)
await upgrade_old_refresh_token(connection, current_user, refresh_token)
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid refresh token",
)
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid refresh token",
)
access_token_expires = timedelta(minutes=get_settings().ACCESS_TOKEN_EXPIRE_MINUTES)
new_access_token = Authorize.create_access_token(
subject=current_user, expires_time=access_token_expires
)
new_access_token = Authorize.create_access_token(subject=current_user, expires_time=access_token_expires)
return {
"access_token": new_access_token,
# "access_token_expires": access_token_expires_time,
# "refresh_token": refresh_token,
# "refresh_token_expires": refresh_token_expires_time
}
"access_token": new_access_token,
# "access_token_expires": access_token_expires_time,
# "refresh_token": refresh_token,
# "refresh_token_expires": refresh_token_expires_time
}

78
api/api/endpoints/keyring.py
View File

@@ -14,7 +14,7 @@ from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.connection.session import get_connection_dep
from api.db.logic.keyring import get_key_id,create_key,update_key_id
from api.db.logic.keyring import get_key_id, create_key, update_key_id
from api.schemas.account.account import Status
@@ -33,12 +33,7 @@ api_router = APIRouter(
@api_router.get("/{user_id}/{key_id}")
async def get_keyring(
key_id: str,
request: Request,
connection: AsyncConnection = Depends(get_connection_dep)
):
async def get_keyring(key_id: str, request: Request, connection: AsyncConnection = Depends(get_connection_dep)):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
@@ -46,22 +41,19 @@ async def get_keyring(
keyring = await get_key_id(connection, key_id)
if keyring is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Key not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Key not found")
return keyring
@api_router.post("/{user_id}/{key_id}")
async def create_keyring(
user_id: int,
key_id: str,
request: Request,
key: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep)
):
user_id: int,
key_id: str,
request: Request,
key: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
@@ -69,82 +61,70 @@ async def create_keyring(
keyring = await get_key_id(connection, key_id)
if keyring is None:
user_new = await create_key(connection,key, key_id, )
user_new = await create_key(
connection,
key,
key_id,
)
return user_new
else:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="An keyring with this information already exists.")
status_code=status.HTTP_400_BAD_REQUEST, detail="An keyring with this information already exists."
)
@api_router.put("/{user_id}/{key_id}")
async def update_keyring(
user_id: int,
key_id: str,
request: Request,
keyring_update: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep)
):
user_id: int,
key_id: str,
request: Request,
keyring_update: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_id(connection, key_id)
if keyring is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="keyring not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="keyring not found")
update_values = update_key_data_changes(keyring_update,keyring)
update_values = update_key_data_changes(keyring_update, keyring)
if update_values is None:
return keyring
keyring_update_data = AccountKeyring.model_validate({**keyring.model_dump(), **update_values})
await update_key_id(connection, update_values, keyring)
keyring = await get_key_id(connection, key_id)
return keyring
@api_router.delete("/{user_id}/{key_id}")
async def delete_keyring(
user_id: int,
key_id: str,
request: Request,
connection: AsyncConnection = Depends(get_connection_dep)
):
user_id: int, key_id: str, request: Request, connection: AsyncConnection = Depends(get_connection_dep)
):
current_user = request.state.current_user
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_id(connection, key_id)
if keyring is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="keyring not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="keyring not found")
keyring_update = AccountKeyringUpdate(status=Status.DELETED.value)
update_values = update_key_data_changes(keyring_update,keyring)
update_values = update_key_data_changes(keyring_update, keyring)
if update_values is None:
return keyring
await update_key_id(connection, update_values, keyring)
keyring = await get_key_id(connection, key_id)
return keyring

47
api/api/endpoints/profile.py
View File

@@ -13,13 +13,12 @@ from fastapi import (
from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.connection.session import get_connection_dep
from api.db.logic.account import get_user_id, update_user_id,get_user_login
from api.db.logic.account import get_user_id, update_user_id, get_user_login
from api.services.update_data_validation import update_user_data_changes
from api.schemas.endpoints.account import UserUpdate
api_router = APIRouter(
prefix="/profile",
tags=["User accountModel"],
@@ -28,50 +27,42 @@ api_router = APIRouter(
@api_router.get("")
async def get_profile(
request: Request,
connection: AsyncConnection = Depends(get_connection_dep),
):
request: Request,
connection: AsyncConnection = Depends(get_connection_dep),
):
# Извлекаем текущего пользователя из request.state
current_user = request.state.current_user
user = await get_user_login(connection, current_user)
if user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Account not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")
return user
@api_router.put("")
async def update_profile(
request: Request,
user_updata: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
):
request: Request,
user_updata: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
):
current_user = request.state.current_user
user = await get_user_login(connection, current_user)
if user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Account not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")
if user_updata.role == None and user_updata.login == None:
update_values = update_user_data_changes(user_updata,user)
if update_values is None:
return user
await update_user_id(connection, update_values, user)
user = await get_user_id(connection, user.id)
update_values = update_user_data_changes(user_updata, user)
if update_values is None:
return user
await update_user_id(connection, update_values, user)
user = await get_user_id(connection, user.id)
return user
else:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY ,
detail="Bad body")
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Bad body")

19
api/api/schemas/account/account.py
View File

@@ -6,17 +6,20 @@ from pydantic import BaseModel, EmailStr, Field
# Модель для хранения информации из запроса
class Role(Enum):
OWNER = 'OWNER'
ADMIN = 'ADMIN'
EDITOR = 'EDITOR'
VIEWER = 'VIEWER'
OWNER = "OWNER"
ADMIN = "ADMIN"
EDITOR = "EDITOR"
VIEWER = "VIEWER"
class Status(Enum):
ACTIVE = 'ACTIVE'
DISABLED = 'DISABLED'
BLOCKED = 'BLOCKED'
DELETED = 'DELETED'
ACTIVE = "ACTIVE"
DISABLED = "DISABLED"
BLOCKED = "BLOCKED"
DELETED = "DELETED"
class User(BaseModel):
id: Optional[int] = None

2
api/api/schemas/account/account_keyring.py
View File

@@ -6,12 +6,14 @@ from datetime import datetime
# Модель для хранения информации из запроса
class TypeKey(Enum):
PASSWORD = "PASSWORD"
ACCESS_TOKEN = "ACCESS_TOKEN"
REFRESH_TOKEN = "REFRESH_TOKEN"
API_KEY = "API_KEY"
class StatusKey(Enum):
ACTIVE = "ACTIVE"
EXPIRED = "EXPIRED"

19
api/api/schemas/endpoints/account.py
View File

@@ -5,17 +5,20 @@ from pydantic import BaseModel, EmailStr, Field
# Таблица для получения информации из запроса
class Role(Enum):
OWNER = 'OWNER'
ADMIN = 'ADMIN'
EDITOR = 'EDITOR'
VIEWER = 'VIEWER'
OWNER = "OWNER"
ADMIN = "ADMIN"
EDITOR = "EDITOR"
VIEWER = "VIEWER"
class Status(Enum):
ACTIVE = 'ACTIVE'
DISABLED = 'DISABLED'
BLOCKED = 'BLOCKED'
DELETED = 'DELETED'
ACTIVE = "ACTIVE"
DISABLED = "DISABLED"
BLOCKED = "BLOCKED"
DELETED = "DELETED"
class UserUpdate(BaseModel):
id: Optional[int] = None

2
api/api/schemas/endpoints/account_keyring.py
View File

@@ -6,12 +6,14 @@ from datetime import datetime
# Таблица для получения информации из запроса
class TypeKey(Enum):
PASSWORD = "PASSWORD"
ACCESS_TOKEN = "ACCESS_TOKEN"
REFRESH_TOKEN = "REFRESH_TOKEN"
API_KEY = "API_KEY"
class StatusKey(Enum):
ACTIVE = "ACTIVE"
EXPIRED = "EXPIRED"

1
api/api/schemas/endpoints/auth.py
View File

@@ -2,6 +2,7 @@ from pydantic import BaseModel
# Таблица для получения информации из запроса
class Auth(BaseModel):
login: str
password: str

1
api/api/schemas/events/list_events.py
View File

@@ -14,6 +14,7 @@ class Status(Enum):
DISABLED = "Disabled"
DELETED = "Deleted"
class ListEvent(BaseModel):
id: int
name: str = Field(..., max_length=40)

2
api/api/schemas/process/node_link.py
View File

@@ -3,12 +3,14 @@ from typing import Dict, Any
from datetime import datetime
from enum import Enum
class Status(Enum):
ACTIVE = "Active"
STOPPING = "Stopping"
STOPPED = "Stopped"
DELETED = "Deleted"
class MyModel(BaseModel):
id: int
link_name: str = Field(..., max_length=20)

2
api/api/schemas/process/process_schema.py
View File

@@ -3,12 +3,14 @@ from typing import Dict, Any
from datetime import datetime
from enum import Enum
class Status(Enum):
ACTIVE = "Active"
STOPPING = "Stopping"
STOPPED = "Stopped"
DELETED = "Deleted"
class ProcessSchema(BaseModel):
id: int
title: str = Field(..., max_length=100)

1
api/api/schemas/process/process_version_archive.py
View File

@@ -2,6 +2,7 @@ from pydantic import BaseModel, Field
from typing import Dict, Any
from datetime import datetime
class ProcessStatusSchema(BaseModel):
id: int
version: int

3
api/api/schemas/process/ps_node.py
View File

@@ -5,14 +5,15 @@ from enum import Enum
class NodeType(Enum):
pass
class Status(Enum):
ACTIVE = "Active"
DISABLED = "Disabled"
DELETED = "Deleted"
class Ps_Node(BaseModel):
id: int
ps_id: int

16
api/api/services/auth.py
View File

@@ -1,21 +1,17 @@
from typing import Optional
from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.logic.auth import get_user
# # from backend.schemas.users.token import TokenData
from api.schemas.account.account import User,Status
from api.schemas.account.account import User, Status
from api.utils.hasher import Hasher
async def authenticate_user(connection: AsyncConnection, username: str, password: str) -> Optional[User]:
sql_user, sql_password = await get_user(connection, username)
async def authenticate_user(
connection: AsyncConnection, username: str, password: str
) -> Optional[User]:
sql_user,sql_password = await get_user(connection, username)
if not sql_user or sql_user.status != Status.ACTIVE :
return None
if not sql_user or sql_user.status != Status.ACTIVE:
return None
hasher = Hasher()
if not hasher.verify_data(password, sql_password.key_value):
return None

35
api/api/services/middleware.py
View File

@@ -14,52 +14,43 @@ from re import escape
from fastapi_jwt_auth import AuthJWT
class MiddlewareAccessTokenValidadtion(BaseHTTPMiddleware):
def __init__(self, app):
super().__init__(app)
self.prefix = escape(get_settings().PATH_PREFIX)
self.excluded_routes = [
re.compile(r'^' + re.escape(self.prefix) + r'/auth/refresh/?$'),
re.compile(r'^' + re.escape(self.prefix) + r'/auth/?$')
re.compile(r"^" + re.escape(self.prefix) + r"/auth/refresh/?$"),
re.compile(r"^" + re.escape(self.prefix) + r"/auth/?$"),
]
async def dispatch(self,
request: Request,
call_next):
async def dispatch(self, request: Request, call_next):
if request.method in ["GET", "POST", "PUT", "DELETE"]:
if any(pattern.match(request.url.path) for pattern in self.excluded_routes):
return await call_next(request)
else:
auth_header = request.headers.get("Authorization")
if not auth_header:
return JSONResponse(
status_code=status.HTTP_401_UNAUTHORIZED,
content={"detail": "Missing authorization header."},
headers={"WWW-Authenticate": "Bearer"}
)
return JSONResponse(
status_code=status.HTTP_401_UNAUTHORIZED,
content={"detail": "Missing authorization header."},
headers={"WWW-Authenticate": "Bearer"},
)
token = auth_header.split(" ")[1]
Authorize = AuthJWT(request)
try:
current_user = Authorize.get_jwt_subject()
current_user = Authorize.get_jwt_subject()
request.state.current_user = current_user
return await call_next(request)
except Exception:
return JSONResponse(
status_code=status.HTTP_401_UNAUTHORIZED,
content={"detail": "The access token is invalid or expired."},
headers={"WWW-Authenticate": "Bearer"}
)
status_code=status.HTTP_401_UNAUTHORIZED,
content={"detail": "The access token is invalid or expired."},
headers={"WWW-Authenticate": "Bearer"},
)
# async with get_connection() as connection:
# authorize_user = await get_user_login(connection, current_user)

2
api/api/services/update_data_validation.py
View File

@@ -3,6 +3,7 @@ from typing import Optional
from api.schemas.endpoints.account import UserUpdate, Role, Status
from api.schemas.endpoints.account_keyring import AccountKeyringUpdate, StatusKey, TypeKey
def update_user_data_changes(update_data: UserUpdate, user) -> Optional[dict]:
"""
Сравнивает данные для обновления с текущими значениями пользователя.
@@ -36,6 +37,7 @@ def update_user_data_changes(update_data: UserUpdate, user) -> Optional[dict]:
return changes if changes else None
def update_key_data_changes(update_data: AccountKeyringUpdate, key) -> Optional[dict]:
"""
Сравнивает данные для обновления с текущими значениями пользователя.

8
api/api/services/user_role_validation.py
View File

@@ -3,13 +3,11 @@ from fastapi import (
status,
)
from api.db.logic.account import get_user_login
from api.schemas.account.account import Role,Status
from api.schemas.account.account import Role, Status
async def db_user_role_validation(connection, current_user):
authorize_user = await get_user_login(connection, current_user)
if authorize_user.role not in {Role.OWNER, Role.ADMIN}:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="You do not have enough permissions")
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not have enough permissions")
return authorize_user

1
api/api/utils/hasher.py
View File

@@ -2,6 +2,7 @@ import hashlib
# Хешер для работы с паролем.
class Hasher:
def __init__(self):
pass

1
api/api/utils/key_id_gen.py
View File

@@ -3,6 +3,7 @@ from datetime import datetime
# Генератор key_id для таблицы account_keyring
def KeyIdGenerator():
random_number = random.randint(1000, 9999)
result = f"{datetime.now().strftime('%Y-%m-%d')}-{random_number}"