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

refactor: refactor api project with ruff

Browse Source
This commit is contained in:
Vladislav Syrochkin 2025-06-09 12:12:48 +05:00
parent 2e4e9d1113
commit 787dc0e8f8
15 changed files with 100 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,17 +18,19 @@ async def get_user_accaunt_page(connection: AsyncConnection, page, limit) -> Opt
Получает список ползовелей заданных значениями page, limit.
"""
first_user = page*limit-(limit)
first_user = page * limit - (limit)
query = (
select(account_table.c.id,
account_table.c.name,
account_table.c.login,
account_table.c.email,
account_table.c.bind_tenant_id,
account_table.c.role,
account_table.c.created_at,
account_table.c.status)
select(
account_table.c.id,
account_table.c.name,
account_table.c.login,
account_table.c.email,
account_table.c.bind_tenant_id,
account_table.c.role,
account_table.c.created_at,
account_table.c.status,
)
.order_by(account_table.c.id)
.offset(first_user)
.limit(limit)
@ -45,11 +47,7 @@ async def get_user_accaunt_page(connection: AsyncConnection, page, limit) -> Opt
validated_users = all_user_adapter.validate_python(users_data)
return AllUserResponse(
users=validated_users,
amount_count=total_count,
amount_pages=total_pages
)
return AllUserResponse(users=validated_users, amount_count=total_count, amount_pages=total_pages)
async def get_user_by_id(connection: AsyncConnection, id: int) -> Optional[User]:

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

@ -10,8 +10,6 @@ from api.db.tables.account import account_keyring_table
from api.schemas.account.account_keyring import AccountKeyring
async def get_key_by_id(connection: AsyncConnection, key_id: str) -> Optional[AccountKeyring]:
"""
Получает key по key_id.

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

@ -7,17 +7,18 @@ from api.db.sql_types import UnsignedInt
from api.db import metadata
class AccountRole(str,Enum):
OWNER = 'OWNER'
ADMIN = 'ADMIN'
EDITOR = 'EDITOR'
VIEWER = 'VIEWER'
class AccountRole(str, Enum):
OWNER = "OWNER"
ADMIN = "ADMIN"
EDITOR = "EDITOR"
VIEWER = "VIEWER"
class AccountStatus(str,Enum):
ACTIVE = 'ACTIVE'
DISABLED = 'DISABLED'
BLOCKED = 'BLOCKED'
DELETED = 'DELETED'
class AccountStatus(str, Enum):
ACTIVE = "ACTIVE"
DISABLED = "DISABLED"
BLOCKED = "BLOCKED"
DELETED = "DELETED"
account_table = Table(
@ -38,13 +39,14 @@ account_table = Table(
)
class KeyType(str,Enum):
class KeyType(str, Enum):
PASSWORD = "PASSWORD"
ACCESS_TOKEN = "ACCESS_TOKEN"
REFRESH_TOKEN = "REFRESH_TOKEN"
API_KEY = "API_KEY"
class KeyStatus(str,Enum):
class KeyStatus(str, Enum):
ACTIVE = "ACTIVE"
EXPIRED = "EXPIRED"
DELETED = "DELETED"

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

@ -10,47 +10,51 @@ from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.connection.session import get_connection_dep
from api.db.logic.account import get_user_by_id, update_user_by_id, create_user,get_user_by_login,get_user_accaunt_page
from api.db.logic.account import (
get_user_by_id,
update_user_by_id,
create_user,
get_user_by_login,
get_user_accaunt_page,
)
from api.schemas.account.account import User
from api.db.tables.account import AccountStatus
from api.schemas.base import bearer_schema
from api.schemas.endpoints.account import UserUpdate,AllUserResponse
from api.schemas.endpoints.account import UserUpdate, AllUserResponse
from api.services.auth import get_current_user
from api.services.user_role_validation import db_user_role_validation
from api.services.update_data_validation import update_user_data_changes
api_router = APIRouter(
prefix="/account",
tags=["User accountModel"],
)
@api_router.get("",dependencies=[Depends(bearer_schema)],response_model=AllUserResponse)
@api_router.get("", dependencies=[Depends(bearer_schema)], response_model=AllUserResponse)
async def get_all_account(
page: int = 1,
limit: int = 10,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
):
page: int = 1,
limit: int = 10,
connection: AsyncConnection = Depends(get_connection_dep),
current_user=Depends(get_current_user),
):
authorize_user = await db_user_role_validation(connection, current_user)
user_list = await get_user_accaunt_page(connection,page,limit)
user_list = await get_user_accaunt_page(connection, page, limit)
if user_list is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Accounts not found")
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Accounts not found")
return user_list
@api_router.get("/{user_id}",dependencies=[Depends(bearer_schema)], response_model=User)
async def get_account(user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)):
@api_router.get("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
async def get_account(
user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
):
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_by_id(connection, user_id)
@ -61,22 +65,16 @@ async def get_account(user_id: int, connection: AsyncConnection = Depends(get_co
return user
@api_router.post("", dependencies=[Depends(bearer_schema)],response_model=User)
@api_router.post("", dependencies=[Depends(bearer_schema)], response_model=User)
async def create_account(
user: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
):
user: UserUpdate, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
):
authorize_user = await db_user_role_validation(connection, current_user)
user_validation = await get_user_by_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_by_login(connection, user.login)
return user_new
@ -86,11 +84,13 @@ async def create_account(
)
@api_router.put("/{user_id}",dependencies=[Depends(bearer_schema)], response_model=User)
@api_router.put("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
async def update_account(
user_id: int, user_update: UserUpdate, connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)
user_id: int,
user_update: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
current_user=Depends(get_current_user),
):
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_by_id(connection, user_id)
@ -106,20 +106,15 @@ async def update_account(
await update_user_by_id(connection, update_values, user)
user = await get_user_by_id(connection, user_id)
return user
@api_router.delete("/{user_id}", dependencies=[Depends(bearer_schema)],response_model=User)
@api_router.delete("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
async def delete_account(
user_id: int,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
):
user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
):
authorize_user = await db_user_role_validation(connection, current_user)
user = await get_user_by_id(connection, user_id)
@ -133,10 +128,8 @@ async def delete_account(
if update_values is None:
return user
await update_user_by_id(connection, update_values, user)
user = await get_user_by_id(connection, user_id)
return user

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

@ -86,8 +86,7 @@ async def login_for_access_token(
return Access(access_token=access_token)
@api_router.post("/refresh",response_model=Access)
@api_router.post("/refresh", response_model=Access)
async def refresh(
request: Request, connection: AsyncConnection = Depends(get_connection_dep), Authorize: AuthJWT = Depends()
):

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

@ -13,8 +13,7 @@ from sqlalchemy.ext.asyncio import AsyncConnection
from api.db.connection.session import get_connection_dep
from api.db.logic.keyring import get_key_by_id,create_key,update_key_by_id
from api.db.logic.keyring import get_key_by_id, create_key, update_key_by_id
from api.db.tables.account import KeyStatus
@ -34,14 +33,10 @@ api_router = APIRouter(
)
@api_router.get("/{user_id}/{key_id}",dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
@api_router.get("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
async def get_keyring(
key_id: str,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
):
key_id: str, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
):
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_by_id(connection, key_id)
@ -58,15 +53,18 @@ async def create_keyring(
key_id: str,
key: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
current_user=Depends(get_current_user),
):
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_by_id(connection, key_id)
if keyring is None:
keyring_new = await create_key(connection,key, key_id, )
keyring_new = await create_key(
connection,
key,
key_id,
)
return keyring_new
else:
@ -75,15 +73,14 @@ async def create_keyring(
)
@api_router.put("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)],response_model=AccountKeyring)
@api_router.put("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
async def update_keyring(
user_id: int,
key_id: str,
keyring_update: AccountKeyringUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
current_user=Depends(get_current_user),
):
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_by_id(connection, key_id)
@ -99,16 +96,18 @@ async def update_keyring(
await update_key_by_id(connection, update_values, keyring)
keyring = await get_key_by_id(connection, key_id)
return keyring
@api_router.delete("/{user_id}/{key_id}",dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
async def delete_keyring(
user_id: int, key_id: str, connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)
):
@api_router.delete("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
async def delete_keyring(
user_id: int,
key_id: str,
connection: AsyncConnection = Depends(get_connection_dep),
current_user=Depends(get_current_user),
):
authorize_user = await db_user_role_validation(connection, current_user)
keyring = await get_key_by_id(connection, key_id)
@ -124,7 +123,6 @@ async def delete_keyring(
await update_key_by_id(connection, update_values, keyring)
keyring = await get_key_by_id(connection, key_id)
return keyring

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

@ -13,7 +13,7 @@ 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_by_id, update_user_by_id,get_user_by_login
from api.db.logic.account import get_user_by_id, update_user_by_id, get_user_by_login
from api.schemas.base import bearer_schema
from api.services.auth import get_current_user
from api.services.update_data_validation import update_user_data_changes
@ -28,12 +28,10 @@ api_router = APIRouter(
)
@api_router.get("",dependencies=[Depends(bearer_schema)],response_model=User)
@api_router.get("", dependencies=[Depends(bearer_schema)], response_model=User)
async def get_profile(
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
):
user = await get_user_by_login(connection, current_user)
if user is None:
@ -42,13 +40,12 @@ async def get_profile(
return user
@api_router.put("", dependencies=[Depends(bearer_schema)],response_model=User)
@api_router.put("", dependencies=[Depends(bearer_schema)], response_model=User)
async def update_profile(
user_updata: UserUpdate,
connection: AsyncConnection = Depends(get_connection_dep),
current_user = Depends(get_current_user)
current_user=Depends(get_current_user),
):
user = await get_user_by_login(connection, current_user)
if user is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")

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

@ -2,10 +2,11 @@ import datetime
from datetime import datetime
from typing import Optional
from pydantic import EmailStr, Field
from api.db.tables.account import AccountRole,AccountStatus
from api.db.tables.account import AccountRole, AccountStatus
from api.schemas.base import Base
class User(Base):
id: Optional[int] = None
name: str = Field(..., max_length=100)

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

@ -2,10 +2,11 @@ import datetime
from typing import Optional
from pydantic import Field
from datetime import datetime
from api.db.tables.account import KeyType,KeyStatus
from api.db.tables.account import KeyType, KeyStatus
from api.schemas.base import Base
class AccountKeyring(Base):
owner_id: int
key_type: KeyType

2
api/api/schemas/base.py
View File

@ -3,7 +3,7 @@ from pydantic import BaseModel, ConfigDict
from pydantic.alias_generators import to_camel
bearer_schema = HTTPBearer() # схема для авторизации в swagger
bearer_schema = HTTPBearer() # схема для авторизации в swagger
class Base(BaseModel):

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

@ -2,7 +2,7 @@ from typing import Optional, List
from datetime import datetime
from pydantic import EmailStr, Field, TypeAdapter
from api.db.tables.account import AccountRole,AccountStatus
from api.db.tables.account import AccountRole, AccountStatus
from api.schemas.base import Base
@ -19,6 +19,7 @@ class UserUpdate(Base):
created_at: Optional[datetime] = None
status: Optional[AccountStatus] = None
class AllUser(Base):
id: int
name: str
@ -35,4 +36,5 @@ class AllUserResponse(Base):
amount_count: int
amount_pages: int
all_user_adapter = TypeAdapter(List[AllUser])

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

@ -2,10 +2,11 @@ import datetime
from typing import Optional
from pydantic import Field
from datetime import datetime
from api.db.tables.account import KeyType,KeyStatus
from api.db.tables.account import KeyType, KeyStatus
from api.schemas.base import Base
class AccountKeyringUpdate(Base):
owner_id: Optional[int] = None
key_type: Optional[KeyType] = None

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

@ -7,8 +7,10 @@ class Auth(Base):
login: str
password: str
class Refresh(Base):
refresh_token: str
class Access(Base):
access_token: str

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

@ -1,9 +1,9 @@
from enum import Enum
from typing import Optional
from api.schemas.endpoints.account import UserUpdate
from api.db.tables.account import KeyType,KeyStatus
from api.db.tables.account import KeyType, KeyStatus
from api.schemas.endpoints.account_keyring import AccountKeyringUpdate
from api.db.tables.account import AccountRole,AccountStatus
from api.db.tables.account import AccountRole, AccountStatus
def update_user_data_changes(update_data: UserUpdate, user) -> Optional[dict]:

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

@ -6,12 +6,8 @@ from api.db.logic.account import get_user_by_login
from api.db.tables.account import AccountRole
async def db_user_role_validation(connection, current_user):
authorize_user = await get_user_by_login(connection, current_user)
if authorize_user.role not in {AccountRole.OWNER, AccountRole.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