Vorkout/connect
3
0
Fork 0
Code Issues Pull Requests 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

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")