### 🔄 Изменения - **SQLAlchemy KeyError** - исправление ошибки `KeyError: Reaction` при инициализации - **Исправлена ошибка SQLAlchemy**: Устранена проблема `InvalidRequestError: When initializing mapper Mapper[Shout(shout)], expression Reaction failed to locate a name (Reaction)` ### 🧪 Тестирование - **Исправление тестов** - адаптация к новой структуре моделей - **RBAC инициализация** - добавление `rbac.initialize_rbac()` в `conftest.py` - **Создан тест для getSession**: Добавлен комплексный тест `test_getSession_cookies.py` с проверкой всех сценариев - **Покрытие edge cases**: Тесты проверяют работу с валидными/невалидными токенами, отсутствующими пользователями - **Мокирование зависимостей**: Использование unittest.mock для изоляции тестируемого кода ### 🔧 Рефакторинг - **Упрощена архитектура**: Убраны сложные конструкции с отложенными импортами, заменены на чистую архитектуру - **Перемещение моделей** - `Author` и связанные модели перенесены в `orm/author.py`: Вынесены базовые модели пользователей (`Author`, `AuthorFollower`, `AuthorBookmark`, `AuthorRating`) из `orm.author` в отдельный модуль - **Устранены циклические импорты**: Разорван цикл между `auth.core` → `orm.community` → `orm.author` через реструктуризацию архитектуры - **Создан модуль `utils/password.py`**: Класс `Password` вынесен в utils для избежания циклических зависимостей - **Оптимизированы импорты моделей**: Убран прямой импорт `Shout` из `orm/community.py`, заменен на строковые ссылки ### 🔧 Авторизация с cookies - **getSession теперь работает с cookies**: Мутация `getSession` теперь может получать токен из httpOnly cookies даже без заголовка Authorization - **Убрано требование авторизации**: `getSession` больше не требует декоратор `@login_required`, работает автономно - **Поддержка dual-авторизации**: Токен может быть получен как из заголовка Authorization, так и из cookie `session_token` - **Автоматическая установка cookies**: Middleware автоматически устанавливает httpOnly cookies при успешном `getSession` - **Обновлена GraphQL схема**: `SessionInfo` теперь содержит поля `success`, `error` и опциональные `token`, `author` - **Единообразная обработка токенов**: Все модули теперь используют централизованные функции для работы с токенами - **Улучшена обработка ошибок**: Добавлена детальная валидация токенов и пользователей в `getSession` - **Логирование операций**: Добавлены подробные логи для отслеживания процесса авторизации ### 📝 Документация - **Обновлена схема GraphQL**: `SessionInfo` тип теперь соответствует новому формату ответа - Обновлена документация RBAC - Обновлена документация авторизации с cookies
This commit is contained in:
@@ -1,19 +1,18 @@
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import JSONResponse, RedirectResponse, Response
|
||||
|
||||
# Импорт базовых функций из реструктурированных модулей
|
||||
from auth.core import verify_internal_auth
|
||||
from auth.orm import Author
|
||||
from auth.tokens.storage import TokenStorage
|
||||
from storage.db import local_session
|
||||
from auth.utils import extract_token_from_request
|
||||
from orm.author import Author
|
||||
from settings import (
|
||||
SESSION_COOKIE_HTTPONLY,
|
||||
SESSION_COOKIE_MAX_AGE,
|
||||
SESSION_COOKIE_NAME,
|
||||
SESSION_COOKIE_SAMESITE,
|
||||
SESSION_COOKIE_SECURE,
|
||||
SESSION_TOKEN_HEADER,
|
||||
)
|
||||
from storage.db import local_session
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
|
||||
@@ -25,30 +24,7 @@ async def logout(request: Request) -> Response:
|
||||
1. HTTP-only cookie
|
||||
2. Заголовка Authorization
|
||||
"""
|
||||
token = None
|
||||
# Получаем токен из cookie
|
||||
if SESSION_COOKIE_NAME in request.cookies:
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
logger.debug(f"[auth] logout: Получен токен из cookie {SESSION_COOKIE_NAME}")
|
||||
|
||||
# Если токен не найден в cookie, проверяем заголовок
|
||||
if not token:
|
||||
# Сначала проверяем основной заголовок авторизации
|
||||
auth_header = request.headers.get(SESSION_TOKEN_HEADER)
|
||||
if auth_header:
|
||||
if auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:].strip()
|
||||
logger.debug(f"[auth] logout: Получен Bearer токен из заголовка {SESSION_TOKEN_HEADER}")
|
||||
else:
|
||||
token = auth_header.strip()
|
||||
logger.debug(f"[auth] logout: Получен прямой токен из заголовка {SESSION_TOKEN_HEADER}")
|
||||
|
||||
# Если токен не найден в основном заголовке, проверяем стандартный Authorization
|
||||
if not token and "Authorization" in request.headers:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:].strip()
|
||||
logger.debug("[auth] logout: Получен Bearer токен из заголовка Authorization")
|
||||
token = await extract_token_from_request(request)
|
||||
|
||||
# Если токен найден, отзываем его
|
||||
if token:
|
||||
@@ -91,36 +67,7 @@ async def refresh_token(request: Request) -> JSONResponse:
|
||||
|
||||
Возвращает новый токен как в HTTP-only cookie, так и в теле ответа.
|
||||
"""
|
||||
token = None
|
||||
source = None
|
||||
|
||||
# Получаем текущий токен из cookie
|
||||
if SESSION_COOKIE_NAME in request.cookies:
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
source = "cookie"
|
||||
logger.debug(f"[auth] refresh_token: Токен получен из cookie {SESSION_COOKIE_NAME}")
|
||||
|
||||
# Если токен не найден в cookie, проверяем заголовок авторизации
|
||||
if not token:
|
||||
# Проверяем основной заголовок авторизации
|
||||
auth_header = request.headers.get(SESSION_TOKEN_HEADER)
|
||||
if auth_header:
|
||||
if auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:].strip()
|
||||
source = "header"
|
||||
logger.debug(f"[auth] refresh_token: Токен получен из заголовка {SESSION_TOKEN_HEADER} (Bearer)")
|
||||
else:
|
||||
token = auth_header.strip()
|
||||
source = "header"
|
||||
logger.debug(f"[auth] refresh_token: Токен получен из заголовка {SESSION_TOKEN_HEADER} (прямой)")
|
||||
|
||||
# Если токен не найден в основном заголовке, проверяем стандартный Authorization
|
||||
if not token and "Authorization" in request.headers:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:].strip()
|
||||
source = "header"
|
||||
logger.debug("[auth] refresh_token: Токен получен из заголовка Authorization")
|
||||
token = await extract_token_from_request(request)
|
||||
|
||||
if not token:
|
||||
logger.warning("[auth] refresh_token: Токен не найден в запросе")
|
||||
@@ -152,6 +99,8 @@ async def refresh_token(request: Request) -> JSONResponse:
|
||||
logger.error(f"[auth] refresh_token: Не удалось обновить токен для пользователя {user_id}")
|
||||
return JSONResponse({"success": False, "error": "Не удалось обновить токен"}, status_code=500)
|
||||
|
||||
source = "cookie" if token.startswith("Bearer ") else "header"
|
||||
|
||||
# Создаем ответ
|
||||
response = JSONResponse(
|
||||
{
|
||||
|
||||
@@ -7,12 +7,12 @@ import time
|
||||
|
||||
from sqlalchemy.orm.exc import NoResultFound
|
||||
|
||||
from auth.orm import Author
|
||||
from auth.state import AuthState
|
||||
from auth.tokens.storage import TokenStorage as TokenManager
|
||||
from orm.author import Author
|
||||
from orm.community import CommunityAuthor
|
||||
from storage.db import local_session
|
||||
from settings import ADMIN_EMAILS as ADMIN_EMAILS_LIST
|
||||
from storage.db import local_session
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
ADMIN_EMAILS = ADMIN_EMAILS_LIST.split(",")
|
||||
|
||||
@@ -9,11 +9,11 @@ from sqlalchemy import exc
|
||||
from auth.core import authenticate
|
||||
from auth.credentials import AuthCredentials
|
||||
from auth.exceptions import OperationNotAllowedError
|
||||
from auth.orm import Author
|
||||
from auth.utils import get_auth_token, get_safe_headers
|
||||
from orm.author import Author
|
||||
from orm.community import CommunityAuthor
|
||||
from storage.db import local_session
|
||||
from settings import ADMIN_EMAILS as ADMIN_EMAILS_LIST
|
||||
from storage.db import local_session
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
ADMIN_EMAILS = ADMIN_EMAILS_LIST.split(",")
|
||||
|
||||
@@ -2,11 +2,11 @@ from typing import Any, TypeVar
|
||||
|
||||
from auth.exceptions import ExpiredTokenError, InvalidPasswordError, InvalidTokenError
|
||||
from auth.jwtcodec import JWTCodec
|
||||
from auth.orm import Author
|
||||
from auth.password import Password
|
||||
from orm.author import Author
|
||||
from storage.db import local_session
|
||||
from storage.redis import redis
|
||||
from utils.logger import root_logger as logger
|
||||
from utils.password import Password
|
||||
|
||||
AuthorType = TypeVar("AuthorType", bound=Author)
|
||||
|
||||
|
||||
@@ -15,10 +15,8 @@ from starlette.responses import JSONResponse, Response
|
||||
from starlette.types import ASGIApp
|
||||
|
||||
from auth.credentials import AuthCredentials
|
||||
from auth.orm import Author
|
||||
from auth.tokens.storage import TokenStorage as TokenManager
|
||||
from storage.db import local_session
|
||||
from storage.redis import redis as redis_adapter
|
||||
from orm.author import Author
|
||||
from settings import (
|
||||
ADMIN_EMAILS as ADMIN_EMAILS_LIST,
|
||||
)
|
||||
@@ -30,6 +28,8 @@ from settings import (
|
||||
SESSION_COOKIE_SECURE,
|
||||
SESSION_TOKEN_HEADER,
|
||||
)
|
||||
from storage.db import local_session
|
||||
from storage.redis import redis as redis_adapter
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
ADMIN_EMAILS = ADMIN_EMAILS_LIST.split(",")
|
||||
@@ -498,6 +498,31 @@ class AuthMiddleware:
|
||||
f"[graphql_handler] Установлена cookie {SESSION_COOKIE_NAME} для операции {op_name}"
|
||||
)
|
||||
|
||||
# Если это операция getSession и в ответе есть токен, устанавливаем cookie
|
||||
elif op_name == "getsession":
|
||||
token = None
|
||||
# Пытаемся извлечь токен из данных ответа
|
||||
if result_data and isinstance(result_data, dict):
|
||||
data_obj = result_data.get("data", {})
|
||||
if isinstance(data_obj, dict) and "getSession" in data_obj:
|
||||
op_result = data_obj.get("getSession", {})
|
||||
if isinstance(op_result, dict) and "token" in op_result and op_result.get("success"):
|
||||
token = op_result.get("token")
|
||||
|
||||
if token:
|
||||
# Устанавливаем cookie с токеном для поддержания сессии
|
||||
response.set_cookie(
|
||||
key=SESSION_COOKIE_NAME,
|
||||
value=token,
|
||||
httponly=SESSION_COOKIE_HTTPONLY,
|
||||
secure=SESSION_COOKIE_SECURE,
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
logger.debug(
|
||||
f"[graphql_handler] Установлена cookie {SESSION_COOKIE_NAME} для операции {op_name}"
|
||||
)
|
||||
|
||||
# Если это операция logout, удаляем cookie
|
||||
elif op_name == "logout":
|
||||
response.delete_cookie(
|
||||
|
||||
@@ -10,11 +10,9 @@ from sqlalchemy.orm import Session
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import JSONResponse, RedirectResponse
|
||||
|
||||
from auth.orm import Author
|
||||
from auth.tokens.storage import TokenStorage
|
||||
from orm.author import Author
|
||||
from orm.community import Community, CommunityAuthor, CommunityFollower
|
||||
from storage.db import local_session
|
||||
from storage.redis import redis
|
||||
from settings import (
|
||||
FRONTEND_URL,
|
||||
OAUTH_CLIENTS,
|
||||
@@ -24,6 +22,8 @@ from settings import (
|
||||
SESSION_COOKIE_SAMESITE,
|
||||
SESSION_COOKIE_SECURE,
|
||||
)
|
||||
from storage.db import local_session
|
||||
from storage.redis import redis
|
||||
from utils.generate_slug import generate_unique_slug
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
|
||||
282
auth/orm.py
282
auth/orm.py
@@ -1,282 +0,0 @@
|
||||
import time
|
||||
from typing import Any, Dict, Optional
|
||||
|
||||
from sqlalchemy import (
|
||||
JSON,
|
||||
Boolean,
|
||||
ForeignKey,
|
||||
Index,
|
||||
Integer,
|
||||
PrimaryKeyConstraint,
|
||||
String,
|
||||
)
|
||||
from sqlalchemy.orm import Mapped, Session, mapped_column
|
||||
|
||||
from auth.password import Password
|
||||
from orm.base import BaseModel as Base
|
||||
|
||||
# Общие table_args для всех моделей
|
||||
DEFAULT_TABLE_ARGS = {"extend_existing": True}
|
||||
|
||||
PROTECTED_FIELDS = ["email", "password", "provider_access_token", "provider_refresh_token"]
|
||||
|
||||
|
||||
class Author(Base):
|
||||
"""
|
||||
Расширенная модель автора с функциями аутентификации и авторизации
|
||||
"""
|
||||
|
||||
__tablename__ = "author"
|
||||
__table_args__ = (
|
||||
Index("idx_author_slug", "slug"),
|
||||
Index("idx_author_email", "email"),
|
||||
Index("idx_author_phone", "phone"),
|
||||
{"extend_existing": True},
|
||||
)
|
||||
|
||||
# Базовые поля автора
|
||||
id: Mapped[int] = mapped_column(Integer, primary_key=True)
|
||||
name: Mapped[str | None] = mapped_column(String, nullable=True, comment="Display name")
|
||||
slug: Mapped[str] = mapped_column(String, unique=True, comment="Author's slug")
|
||||
bio: Mapped[str | None] = mapped_column(String, nullable=True, comment="Bio") # короткое описание
|
||||
about: Mapped[str | None] = mapped_column(
|
||||
String, nullable=True, comment="About"
|
||||
) # длинное форматированное описание
|
||||
pic: Mapped[str | None] = mapped_column(String, nullable=True, comment="Picture")
|
||||
links: Mapped[dict[str, Any] | None] = mapped_column(JSON, nullable=True, comment="Links")
|
||||
|
||||
# OAuth аккаунты - JSON с данными всех провайдеров
|
||||
# Формат: {"google": {"id": "123", "email": "user@gmail.com"}, "github": {"id": "456"}}
|
||||
oauth: Mapped[dict[str, Any] | None] = mapped_column(
|
||||
JSON, nullable=True, default=dict, comment="OAuth accounts data"
|
||||
)
|
||||
|
||||
# Поля аутентификации
|
||||
email: Mapped[str | None] = mapped_column(String, unique=True, nullable=True, comment="Email")
|
||||
phone: Mapped[str | None] = mapped_column(String, unique=True, nullable=True, comment="Phone")
|
||||
password: Mapped[str | None] = mapped_column(String, nullable=True, comment="Password hash")
|
||||
email_verified: Mapped[bool] = mapped_column(Boolean, default=False)
|
||||
phone_verified: Mapped[bool] = mapped_column(Boolean, default=False)
|
||||
failed_login_attempts: Mapped[int] = mapped_column(Integer, default=0)
|
||||
account_locked_until: Mapped[int | None] = mapped_column(Integer, nullable=True)
|
||||
|
||||
# Временные метки
|
||||
created_at: Mapped[int] = mapped_column(Integer, nullable=False, default=lambda: int(time.time()))
|
||||
updated_at: Mapped[int] = mapped_column(Integer, nullable=False, default=lambda: int(time.time()))
|
||||
last_seen: Mapped[int] = mapped_column(Integer, nullable=False, default=lambda: int(time.time()))
|
||||
deleted_at: Mapped[int | None] = mapped_column(Integer, nullable=True)
|
||||
|
||||
oid: Mapped[str | None] = mapped_column(String, nullable=True)
|
||||
|
||||
@property
|
||||
def protected_fields(self) -> list[str]:
|
||||
return PROTECTED_FIELDS
|
||||
|
||||
@property
|
||||
def is_authenticated(self) -> bool:
|
||||
"""Проверяет, аутентифицирован ли пользователь"""
|
||||
return self.id is not None
|
||||
|
||||
def verify_password(self, password: str) -> bool:
|
||||
"""Проверяет пароль пользователя"""
|
||||
return Password.verify(password, str(self.password)) if self.password else False
|
||||
|
||||
def set_password(self, password: str):
|
||||
"""Устанавливает пароль пользователя"""
|
||||
self.password = Password.encode(password) # type: ignore[assignment]
|
||||
|
||||
def increment_failed_login(self):
|
||||
"""Увеличивает счетчик неудачных попыток входа"""
|
||||
self.failed_login_attempts += 1 # type: ignore[assignment]
|
||||
if self.failed_login_attempts >= 5:
|
||||
self.account_locked_until = int(time.time()) + 300 # type: ignore[assignment] # 5 минут
|
||||
|
||||
def reset_failed_login(self):
|
||||
"""Сбрасывает счетчик неудачных попыток входа"""
|
||||
self.failed_login_attempts = 0 # type: ignore[assignment]
|
||||
self.account_locked_until = None # type: ignore[assignment]
|
||||
|
||||
def is_locked(self) -> bool:
|
||||
"""Проверяет, заблокирован ли аккаунт"""
|
||||
if not self.account_locked_until:
|
||||
return False
|
||||
return bool(self.account_locked_until > int(time.time()))
|
||||
|
||||
@property
|
||||
def username(self) -> str:
|
||||
"""
|
||||
Возвращает имя пользователя для использования в токенах.
|
||||
Необходимо для совместимости с TokenStorage и JWTCodec.
|
||||
|
||||
Returns:
|
||||
str: slug, email или phone пользователя
|
||||
"""
|
||||
return str(self.slug or self.email or self.phone or "")
|
||||
|
||||
def dict(self, access: bool = False) -> Dict[str, Any]:
|
||||
"""
|
||||
Сериализует объект автора в словарь.
|
||||
|
||||
Args:
|
||||
access: Если True, включает защищенные поля
|
||||
|
||||
Returns:
|
||||
Dict: Словарь с данными автора
|
||||
"""
|
||||
result: Dict[str, Any] = {
|
||||
"id": self.id,
|
||||
"name": self.name,
|
||||
"slug": self.slug,
|
||||
"bio": self.bio,
|
||||
"about": self.about,
|
||||
"pic": self.pic,
|
||||
"links": self.links,
|
||||
"created_at": self.created_at,
|
||||
"updated_at": self.updated_at,
|
||||
"last_seen": self.last_seen,
|
||||
"deleted_at": self.deleted_at,
|
||||
"email_verified": self.email_verified,
|
||||
}
|
||||
|
||||
# Добавляем защищенные поля только если запрошен полный доступ
|
||||
if access:
|
||||
result.update({"email": self.email, "phone": self.phone, "oauth": self.oauth})
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def find_by_oauth(cls, provider: str, provider_id: str, session: Session) -> Optional["Author"]:
|
||||
"""
|
||||
Находит автора по OAuth провайдеру и ID
|
||||
|
||||
Args:
|
||||
provider (str): Имя OAuth провайдера (google, github и т.д.)
|
||||
provider_id (str): ID пользователя у провайдера
|
||||
session: Сессия базы данных
|
||||
|
||||
Returns:
|
||||
Author или None: Найденный автор или None если не найден
|
||||
"""
|
||||
# Ищем авторов, у которых есть данный провайдер с данным ID
|
||||
authors = session.query(cls).where(cls.oauth.isnot(None)).all()
|
||||
for author in authors:
|
||||
if author.oauth and provider in author.oauth:
|
||||
oauth_data = author.oauth[provider] # type: ignore[index]
|
||||
if isinstance(oauth_data, dict) and oauth_data.get("id") == provider_id:
|
||||
return author
|
||||
return None
|
||||
|
||||
def set_oauth_account(self, provider: str, provider_id: str, email: str | None = None) -> None:
|
||||
"""
|
||||
Устанавливает OAuth аккаунт для автора
|
||||
|
||||
Args:
|
||||
provider (str): Имя OAuth провайдера (google, github и т.д.)
|
||||
provider_id (str): ID пользователя у провайдера
|
||||
email (Optional[str]): Email от провайдера
|
||||
"""
|
||||
if not self.oauth:
|
||||
self.oauth = {} # type: ignore[assignment]
|
||||
|
||||
oauth_data: Dict[str, str] = {"id": provider_id}
|
||||
if email:
|
||||
oauth_data["email"] = email
|
||||
|
||||
self.oauth[provider] = oauth_data # type: ignore[index]
|
||||
|
||||
def get_oauth_account(self, provider: str) -> Dict[str, Any] | None:
|
||||
"""
|
||||
Получает OAuth аккаунт провайдера
|
||||
|
||||
Args:
|
||||
provider (str): Имя OAuth провайдера
|
||||
|
||||
Returns:
|
||||
dict или None: Данные OAuth аккаунта или None если не найден
|
||||
"""
|
||||
oauth_data = getattr(self, "oauth", None)
|
||||
if not oauth_data:
|
||||
return None
|
||||
if isinstance(oauth_data, dict):
|
||||
return oauth_data.get(provider)
|
||||
return None
|
||||
|
||||
def remove_oauth_account(self, provider: str):
|
||||
"""
|
||||
Удаляет OAuth аккаунт провайдера
|
||||
|
||||
Args:
|
||||
provider (str): Имя OAuth провайдера
|
||||
"""
|
||||
if self.oauth and provider in self.oauth:
|
||||
del self.oauth[provider]
|
||||
|
||||
|
||||
class AuthorBookmark(Base):
|
||||
"""
|
||||
Закладка автора на публикацию.
|
||||
|
||||
Attributes:
|
||||
author (int): ID автора
|
||||
shout (int): ID публикации
|
||||
"""
|
||||
|
||||
__tablename__ = "author_bookmark"
|
||||
author: Mapped[int] = mapped_column(ForeignKey(Author.id))
|
||||
shout: Mapped[int] = mapped_column(ForeignKey("shout.id"))
|
||||
created_at: Mapped[int] = mapped_column(Integer, nullable=False, default=lambda: int(time.time()))
|
||||
|
||||
__table_args__ = (
|
||||
PrimaryKeyConstraint(author, shout),
|
||||
Index("idx_author_bookmark_author", "author"),
|
||||
Index("idx_author_bookmark_shout", "shout"),
|
||||
{"extend_existing": True},
|
||||
)
|
||||
|
||||
|
||||
class AuthorRating(Base):
|
||||
"""
|
||||
Рейтинг автора от другого автора.
|
||||
|
||||
Attributes:
|
||||
rater (int): ID оценивающего автора
|
||||
author (int): ID оцениваемого автора
|
||||
plus (bool): Положительная/отрицательная оценка
|
||||
"""
|
||||
|
||||
__tablename__ = "author_rating"
|
||||
rater: Mapped[int] = mapped_column(ForeignKey(Author.id))
|
||||
author: Mapped[int] = mapped_column(ForeignKey(Author.id))
|
||||
plus: Mapped[bool] = mapped_column(Boolean)
|
||||
|
||||
__table_args__ = (
|
||||
PrimaryKeyConstraint(rater, author),
|
||||
Index("idx_author_rating_author", "author"),
|
||||
Index("idx_author_rating_rater", "rater"),
|
||||
{"extend_existing": True},
|
||||
)
|
||||
|
||||
|
||||
class AuthorFollower(Base):
|
||||
"""
|
||||
Подписка одного автора на другого.
|
||||
|
||||
Attributes:
|
||||
follower (int): ID подписчика
|
||||
author (int): ID автора, на которого подписываются
|
||||
created_at (int): Время создания подписки
|
||||
auto (bool): Признак автоматической подписки
|
||||
"""
|
||||
|
||||
__tablename__ = "author_follower"
|
||||
follower: Mapped[int] = mapped_column(ForeignKey(Author.id))
|
||||
author: Mapped[int] = mapped_column(ForeignKey(Author.id))
|
||||
created_at: Mapped[int] = mapped_column(Integer, nullable=False, default=lambda: int(time.time()))
|
||||
auto: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
|
||||
|
||||
__table_args__ = (
|
||||
PrimaryKeyConstraint(follower, author),
|
||||
Index("idx_author_follower_author", "author"),
|
||||
Index("idx_author_follower_follower", "follower"),
|
||||
{"extend_existing": True},
|
||||
)
|
||||
@@ -1,57 +0,0 @@
|
||||
"""
|
||||
Модуль для работы с паролями
|
||||
Отдельный модуль для избежания циклических импортов
|
||||
"""
|
||||
|
||||
from binascii import hexlify
|
||||
from hashlib import sha256
|
||||
|
||||
import bcrypt
|
||||
|
||||
|
||||
class Password:
|
||||
@staticmethod
|
||||
def _to_bytes(data: str) -> bytes:
|
||||
return bytes(data.encode())
|
||||
|
||||
@classmethod
|
||||
def _get_sha256(cls, password: str) -> bytes:
|
||||
bytes_password = cls._to_bytes(password)
|
||||
return hexlify(sha256(bytes_password).digest())
|
||||
|
||||
@staticmethod
|
||||
def encode(password: str) -> str:
|
||||
"""
|
||||
Кодирует пароль пользователя
|
||||
|
||||
Args:
|
||||
password (str): Пароль пользователя
|
||||
|
||||
Returns:
|
||||
str: Закодированный пароль
|
||||
"""
|
||||
password_sha256 = Password._get_sha256(password)
|
||||
salt = bcrypt.gensalt(rounds=10)
|
||||
return bcrypt.hashpw(password_sha256, salt).decode("utf-8")
|
||||
|
||||
@staticmethod
|
||||
def verify(password: str, hashed: str) -> bool:
|
||||
r"""
|
||||
Verify that password hash is equal to specified hash. Hash format:
|
||||
|
||||
$2a$10$Ro0CUfOqk6cXEKf3dyaM7OhSCvnwM9s4wIX9JeLapehKK5YdLxKcm
|
||||
\__/\/ \____________________/\_____________________________/
|
||||
| | Salt Hash
|
||||
| Cost
|
||||
Version
|
||||
|
||||
More info: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.bcrypt.html
|
||||
|
||||
:param password: clear text password
|
||||
:param hashed: hash of the password
|
||||
:return: True if clear text password matches specified hash
|
||||
"""
|
||||
hashed_bytes = Password._to_bytes(hashed)
|
||||
password_sha256 = Password._get_sha256(password)
|
||||
|
||||
return bcrypt.checkpw(password_sha256, hashed_bytes)
|
||||
118
auth/utils.py
118
auth/utils.py
@@ -3,7 +3,7 @@
|
||||
Содержит функции для работы с токенами, заголовками и запросами
|
||||
"""
|
||||
|
||||
from typing import Any
|
||||
from typing import Any, Tuple
|
||||
|
||||
from settings import SESSION_COOKIE_NAME, SESSION_TOKEN_HEADER
|
||||
from utils.logger import root_logger as logger
|
||||
@@ -56,6 +56,122 @@ def get_safe_headers(request: Any) -> dict[str, str]:
|
||||
return headers
|
||||
|
||||
|
||||
async def extract_token_from_request(request) -> str | None:
|
||||
"""
|
||||
DRY функция для извлечения токена из request.
|
||||
Проверяет cookies и заголовок Authorization.
|
||||
|
||||
Args:
|
||||
request: Request объект
|
||||
|
||||
Returns:
|
||||
Optional[str]: Токен или None
|
||||
"""
|
||||
if not request:
|
||||
return None
|
||||
|
||||
# 1. Проверяем cookies
|
||||
if hasattr(request, "cookies") and request.cookies:
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
if token:
|
||||
logger.debug(f"[utils] Токен получен из cookie {SESSION_COOKIE_NAME}")
|
||||
return token
|
||||
|
||||
# 2. Проверяем заголовок Authorization
|
||||
headers = get_safe_headers(request)
|
||||
auth_header = headers.get("authorization", "")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:].strip()
|
||||
logger.debug("[utils] Токен получен из заголовка Authorization")
|
||||
return token
|
||||
|
||||
logger.debug("[utils] Токен не найден ни в cookies, ни в заголовке")
|
||||
return None
|
||||
|
||||
|
||||
async def get_user_data_by_token(token: str) -> Tuple[bool, dict | None, str | None]:
|
||||
"""
|
||||
Получает данные пользователя по токену.
|
||||
|
||||
Args:
|
||||
token: Токен авторизации
|
||||
|
||||
Returns:
|
||||
Tuple[bool, Optional[dict], Optional[str]]: (success, user_data, error_message)
|
||||
"""
|
||||
try:
|
||||
from auth.tokens.storage import TokenStorage as TokenManager
|
||||
from orm.author import Author
|
||||
from storage.db import local_session
|
||||
|
||||
# Проверяем сессию через TokenManager
|
||||
payload = await TokenManager.verify_session(token)
|
||||
|
||||
if not payload:
|
||||
return False, None, "Сессия не найдена"
|
||||
|
||||
# Получаем user_id из payload
|
||||
user_id = payload.user_id if hasattr(payload, "user_id") else payload.get("user_id")
|
||||
|
||||
if not user_id:
|
||||
return False, None, "Токен не содержит user_id"
|
||||
|
||||
# Получаем данные пользователя
|
||||
with local_session() as session:
|
||||
author_obj = session.query(Author).where(Author.id == int(user_id)).first()
|
||||
if not author_obj:
|
||||
return False, None, f"Пользователь с ID {user_id} не найден в БД"
|
||||
|
||||
try:
|
||||
user_data = author_obj.dict()
|
||||
except Exception:
|
||||
user_data = {
|
||||
"id": author_obj.id,
|
||||
"email": author_obj.email,
|
||||
"name": getattr(author_obj, "name", ""),
|
||||
"slug": getattr(author_obj, "slug", ""),
|
||||
"username": getattr(author_obj, "username", ""),
|
||||
}
|
||||
|
||||
logger.debug(f"[utils] Данные пользователя получены для ID {user_id}")
|
||||
return True, user_data, None
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[utils] Ошибка при получении данных пользователя: {e}")
|
||||
return False, None, f"Ошибка получения данных: {e!s}"
|
||||
|
||||
|
||||
async def get_auth_token_from_context(info: Any) -> str | None:
|
||||
"""
|
||||
Извлекает токен авторизации из GraphQL контекста.
|
||||
Порядок проверки:
|
||||
1. Проверяет заголовок Authorization
|
||||
2. Проверяет cookie session_token
|
||||
3. Переиспользует логику get_auth_token для request
|
||||
|
||||
Args:
|
||||
info: GraphQLResolveInfo объект
|
||||
|
||||
Returns:
|
||||
Optional[str]: Токен авторизации или None
|
||||
"""
|
||||
try:
|
||||
context = getattr(info, "context", {})
|
||||
request = context.get("request")
|
||||
|
||||
if request:
|
||||
# Переиспользуем существующую логику для request
|
||||
return await get_auth_token(request)
|
||||
|
||||
# Если request отсутствует, возвращаем None
|
||||
logger.debug("[utils] Request отсутствует в GraphQL контексте")
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[utils] Ошибка при извлечении токена из GraphQL контекста: {e}")
|
||||
return None
|
||||
|
||||
|
||||
async def get_auth_token(request: Any) -> str | None:
|
||||
"""
|
||||
Извлекает токен авторизации из запроса.
|
||||
|
||||
Reference in New Issue
Block a user