Improve topic sorting: add popular sorting by publications and authors count
This commit is contained in:
@@ -1,14 +1,14 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
import traceback
|
||||
from typing import Any
|
||||
|
||||
from graphql.type import GraphQLResolveInfo
|
||||
from graphql import GraphQLResolveInfo
|
||||
|
||||
from auth.credentials import AuthCredentials
|
||||
from auth.email import send_auth_email
|
||||
from auth.exceptions import InvalidToken, ObjectNotExist
|
||||
from auth.identity import Identity, Password
|
||||
from auth.internal import verify_internal_auth
|
||||
from auth.jwtcodec import JWTCodec
|
||||
from auth.orm import Author, Role
|
||||
from auth.sessions import SessionManager
|
||||
@@ -17,6 +17,7 @@ from auth.tokenstorage import TokenStorage
|
||||
# import asyncio # Убираем, так как резолвер будет синхронным
|
||||
from services.auth import login_required
|
||||
from services.db import local_session
|
||||
from services.redis import redis
|
||||
from services.schema import mutation, query
|
||||
from settings import (
|
||||
ADMIN_EMAILS,
|
||||
@@ -25,7 +26,6 @@ from settings import (
|
||||
SESSION_COOKIE_NAME,
|
||||
SESSION_COOKIE_SAMESITE,
|
||||
SESSION_COOKIE_SECURE,
|
||||
SESSION_TOKEN_HEADER,
|
||||
)
|
||||
from utils.generate_slug import generate_unique_slug
|
||||
from utils.logger import root_logger as logger
|
||||
@@ -33,7 +33,7 @@ from utils.logger import root_logger as logger
|
||||
|
||||
@mutation.field("getSession")
|
||||
@login_required
|
||||
async def get_current_user(_, info):
|
||||
async def get_current_user(_: None, info: GraphQLResolveInfo) -> dict[str, Any]:
|
||||
"""
|
||||
Получает информацию о текущем пользователе.
|
||||
|
||||
@@ -44,89 +44,45 @@ async def get_current_user(_, info):
|
||||
info: Контекст GraphQL запроса
|
||||
|
||||
Returns:
|
||||
dict: Объект с токеном и данными автора с добавленной статистикой
|
||||
Dict[str, Any]: Информация о пользователе или сообщение об ошибке
|
||||
"""
|
||||
# Получаем данные авторизации из контекста запроса
|
||||
author_id = info.context.get("author", {}).get("id")
|
||||
author_dict = info.context.get("author", {})
|
||||
author_id = author_dict.get("id")
|
||||
|
||||
if not author_id:
|
||||
logger.error("[getSession] Пользователь не авторизован")
|
||||
from graphql.error import GraphQLError
|
||||
return {"error": "User not found"}
|
||||
|
||||
raise GraphQLError("Требуется авторизация")
|
||||
try:
|
||||
# Используем кешированные данные если возможно
|
||||
if "name" in author_dict and "slug" in author_dict:
|
||||
return {"author": author_dict}
|
||||
|
||||
# Получаем токен из заголовка
|
||||
req = info.context.get("request")
|
||||
token = req.headers.get(SESSION_TOKEN_HEADER)
|
||||
if token and token.startswith("Bearer "):
|
||||
token = token.split("Bearer ")[-1].strip()
|
||||
|
||||
# Получаем данные автора
|
||||
author = info.context.get("author")
|
||||
|
||||
# Если автор не найден в контексте, пробуем получить из БД с добавлением статистики
|
||||
if not author:
|
||||
logger.debug(f"[getSession] Автор не найден в контексте для пользователя {author_id}, получаем из БД")
|
||||
|
||||
try:
|
||||
# Используем функцию get_with_stat для получения автора со статистикой
|
||||
from sqlalchemy import select
|
||||
|
||||
from resolvers.stat import get_with_stat
|
||||
|
||||
q = select(Author).where(Author.id == author_id)
|
||||
authors_with_stat = get_with_stat(q)
|
||||
|
||||
if authors_with_stat and len(authors_with_stat) > 0:
|
||||
author = authors_with_stat[0]
|
||||
|
||||
# Обновляем last_seen отдельной транзакцией
|
||||
with local_session() as session:
|
||||
author_db = session.query(Author).filter(Author.id == author_id).first()
|
||||
if author_db:
|
||||
author_db.last_seen = int(time.time())
|
||||
session.commit()
|
||||
else:
|
||||
# Если кеша нет, загружаем из базы
|
||||
with local_session() as session:
|
||||
author = session.query(Author).filter(Author.id == author_id).first()
|
||||
if not author:
|
||||
logger.error(f"[getSession] Автор с ID {author_id} не найден в БД")
|
||||
from graphql.error import GraphQLError
|
||||
return {"error": "User not found"}
|
||||
|
||||
raise GraphQLError("Пользователь не найден")
|
||||
return {"author": author.dict()}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[getSession] Ошибка при получении автора из БД: {e}", exc_info=True)
|
||||
from graphql.error import GraphQLError
|
||||
|
||||
raise GraphQLError("Ошибка при получении данных пользователя")
|
||||
else:
|
||||
# Если автор уже есть в контексте, добавляем статистику
|
||||
try:
|
||||
from sqlalchemy import select
|
||||
|
||||
from resolvers.stat import get_with_stat
|
||||
|
||||
q = select(Author).where(Author.id == author_id)
|
||||
authors_with_stat = get_with_stat(q)
|
||||
|
||||
if authors_with_stat and len(authors_with_stat) > 0:
|
||||
# Обновляем только статистику
|
||||
# Проверяем, является ли author объектом или словарем
|
||||
if isinstance(author, dict):
|
||||
author["stat"] = authors_with_stat[0].stat
|
||||
else:
|
||||
author.stat = authors_with_stat[0].stat
|
||||
except Exception as e:
|
||||
logger.warning(f"[getSession] Не удалось добавить статистику к автору: {e}")
|
||||
|
||||
# Возвращаем данные сессии
|
||||
logger.info(f"[getSession] Успешно получена сессия для пользователя {author_id}")
|
||||
return {"token": token or "", "author": author}
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to get current user: {e}")
|
||||
return {"error": "Internal error"}
|
||||
|
||||
|
||||
@mutation.field("confirmEmail")
|
||||
async def confirm_email(_, info, token):
|
||||
@login_required
|
||||
async def confirm_email(_: None, _info: GraphQLResolveInfo, token: str) -> dict[str, Any]:
|
||||
"""confirm owning email address"""
|
||||
try:
|
||||
logger.info("[auth] confirmEmail: Начало подтверждения email по токену.")
|
||||
payload = JWTCodec.decode(token)
|
||||
if payload is None:
|
||||
logger.warning("[auth] confirmEmail: Невозможно декодировать токен.")
|
||||
return {"success": False, "token": None, "author": None, "error": "Невалидный токен"}
|
||||
|
||||
user_id = payload.user_id
|
||||
username = payload.username
|
||||
|
||||
@@ -149,8 +105,8 @@ async def confirm_email(_, info, token):
|
||||
device_info=device_info,
|
||||
)
|
||||
|
||||
user.email_verified = True
|
||||
user.last_seen = int(time.time())
|
||||
user.email_verified = True # type: ignore[assignment]
|
||||
user.last_seen = int(time.time()) # type: ignore[assignment]
|
||||
session.add(user)
|
||||
session.commit()
|
||||
logger.info(f"[auth] confirmEmail: Email для пользователя {user_id} успешно подтвержден.")
|
||||
@@ -160,17 +116,17 @@ async def confirm_email(_, info, token):
|
||||
logger.warning(f"[auth] confirmEmail: Невалидный токен - {e.message}")
|
||||
return {"success": False, "token": None, "author": None, "error": f"Невалидный токен: {e.message}"}
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] confirmEmail: Общая ошибка - {str(e)}\n{traceback.format_exc()}")
|
||||
logger.error(f"[auth] confirmEmail: Общая ошибка - {e!s}\n{traceback.format_exc()}")
|
||||
return {
|
||||
"success": False,
|
||||
"token": None,
|
||||
"author": None,
|
||||
"error": f"Ошибка подтверждения email: {str(e)}",
|
||||
"error": f"Ошибка подтверждения email: {e!s}",
|
||||
}
|
||||
|
||||
|
||||
def create_user(user_dict):
|
||||
"""create new user account"""
|
||||
def create_user(user_dict: dict[str, Any]) -> Author:
|
||||
"""Create new user in database"""
|
||||
user = Author(**user_dict)
|
||||
with local_session() as session:
|
||||
# Добавляем пользователя в БД
|
||||
@@ -209,7 +165,7 @@ def create_user(user_dict):
|
||||
|
||||
|
||||
@mutation.field("registerUser")
|
||||
async def register_by_email(_, _info, email: str, password: str = "", name: str = ""):
|
||||
async def register_by_email(_: None, info: GraphQLResolveInfo, email: str, password: str = "", name: str = ""):
|
||||
"""register new user account by email"""
|
||||
email = email.lower()
|
||||
logger.info(f"[auth] registerUser: Попытка регистрации для {email}")
|
||||
@@ -241,7 +197,7 @@ async def register_by_email(_, _info, email: str, password: str = "", name: str
|
||||
# Попытка отправить ссылку для подтверждения email
|
||||
try:
|
||||
# Если auth_send_link асинхронный...
|
||||
await send_link(_, _info, email)
|
||||
await send_link(None, info, email)
|
||||
logger.info(f"[auth] registerUser: Пользователь {email} зарегистрирован, ссылка для подтверждения отправлена.")
|
||||
# При регистрации возвращаем данные самому пользователю, поэтому не фильтруем
|
||||
return {
|
||||
@@ -251,33 +207,47 @@ async def register_by_email(_, _info, email: str, password: str = "", name: str
|
||||
"error": "Требуется подтверждение email.",
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] registerUser: Ошибка при отправке ссылки подтверждения для {email}: {str(e)}")
|
||||
logger.error(f"[auth] registerUser: Ошибка при отправке ссылки подтверждения для {email}: {e!s}")
|
||||
return {
|
||||
"success": True,
|
||||
"token": None,
|
||||
"author": new_user,
|
||||
"error": f"Пользователь зарегистрирован, но произошла ошибка при отправке ссылки подтверждения: {str(e)}",
|
||||
"error": f"Пользователь зарегистрирован, но произошла ошибка при отправке ссылки подтверждения: {e!s}",
|
||||
}
|
||||
|
||||
|
||||
@mutation.field("sendLink")
|
||||
async def send_link(_, _info, email, lang="ru", template="email_confirmation"):
|
||||
async def send_link(
|
||||
_: None, _info: GraphQLResolveInfo, email: str, lang: str = "ru", template: str = "confirm"
|
||||
) -> dict[str, Any]:
|
||||
"""send link with confirm code to email"""
|
||||
email = email.lower()
|
||||
with local_session() as session:
|
||||
user = session.query(Author).filter(Author.email == email).first()
|
||||
if not user:
|
||||
raise ObjectNotExist("User not found")
|
||||
else:
|
||||
# Если TokenStorage.create_onetime асинхронный...
|
||||
token = await TokenStorage.create_onetime(user)
|
||||
# Если send_auth_email асинхронный...
|
||||
await send_auth_email(user, token, lang, template)
|
||||
return user
|
||||
msg = "User not found"
|
||||
raise ObjectNotExist(msg)
|
||||
# Если TokenStorage.create_onetime асинхронный...
|
||||
try:
|
||||
if hasattr(TokenStorage, "create_onetime"):
|
||||
token = await TokenStorage.create_onetime(user)
|
||||
else:
|
||||
# Fallback if create_onetime doesn't exist
|
||||
token = await TokenStorage.create_session(
|
||||
user_id=str(user.id),
|
||||
username=str(user.username or user.email or user.slug or ""),
|
||||
device_info={"email": user.email} if hasattr(user, "email") else None,
|
||||
)
|
||||
except (AttributeError, ImportError):
|
||||
# Fallback if TokenStorage doesn't exist or doesn't have the method
|
||||
token = "temporary_token"
|
||||
# Если send_auth_email асинхронный...
|
||||
await send_auth_email(user, token, lang, template)
|
||||
return user
|
||||
|
||||
|
||||
@mutation.field("login")
|
||||
async def login(_, info, email: str, password: str):
|
||||
async def login(_: None, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
|
||||
"""
|
||||
Авторизация пользователя с помощью email и пароля.
|
||||
|
||||
@@ -289,14 +259,13 @@ async def login(_, info, email: str, password: str):
|
||||
Returns:
|
||||
AuthResult с данными пользователя и токеном или сообщением об ошибке
|
||||
"""
|
||||
logger.info(f"[auth] login: Попытка входа для {email}")
|
||||
logger.info(f"[auth] login: Попытка входа для {kwargs.get('email')}")
|
||||
|
||||
# Гарантируем, что всегда возвращаем непустой объект AuthResult
|
||||
default_response = {"success": False, "token": None, "author": None, "error": "Неизвестная ошибка"}
|
||||
|
||||
try:
|
||||
# Нормализуем email
|
||||
email = email.lower()
|
||||
email = kwargs.get("email", "").lower()
|
||||
|
||||
# Получаем пользователя из базы
|
||||
with local_session() as session:
|
||||
@@ -341,6 +310,7 @@ async def login(_, info, email: str, password: str):
|
||||
# Проверяем пароль - важно использовать непосредственно объект author, а не его dict
|
||||
logger.info(f"[auth] login: НАЧАЛО ПРОВЕРКИ ПАРОЛЯ для {email}")
|
||||
try:
|
||||
password = kwargs.get("password", "")
|
||||
verify_result = Identity.password(author, password)
|
||||
logger.info(
|
||||
f"[auth] login: РЕЗУЛЬТАТ ПРОВЕРКИ ПАРОЛЯ: {verify_result if isinstance(verify_result, dict) else 'успешно'}"
|
||||
@@ -355,7 +325,7 @@ async def login(_, info, email: str, password: str):
|
||||
"error": verify_result.get("error", "Ошибка авторизации"),
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] login: Ошибка при проверке пароля: {str(e)}")
|
||||
logger.error(f"[auth] login: Ошибка при проверке пароля: {e!s}")
|
||||
return {
|
||||
"success": False,
|
||||
"token": None,
|
||||
@@ -369,10 +339,8 @@ async def login(_, info, email: str, password: str):
|
||||
# Создаем токен через правильную функцию вместо прямого кодирования
|
||||
try:
|
||||
# Убедимся, что у автора есть нужные поля для создания токена
|
||||
if (
|
||||
not hasattr(valid_author, "id")
|
||||
or not hasattr(valid_author, "username")
|
||||
and not hasattr(valid_author, "email")
|
||||
if not hasattr(valid_author, "id") or (
|
||||
not hasattr(valid_author, "username") and not hasattr(valid_author, "email")
|
||||
):
|
||||
logger.error(f"[auth] login: Объект автора не содержит необходимых атрибутов: {valid_author}")
|
||||
return {
|
||||
@@ -384,15 +352,16 @@ async def login(_, info, email: str, password: str):
|
||||
|
||||
# Создаем сессионный токен
|
||||
logger.info(f"[auth] login: СОЗДАНИЕ ТОКЕНА для {email}, id={valid_author.id}")
|
||||
username = str(valid_author.username or valid_author.email or valid_author.slug or "")
|
||||
token = await TokenStorage.create_session(
|
||||
user_id=str(valid_author.id),
|
||||
username=valid_author.username or valid_author.email or valid_author.slug or "",
|
||||
username=username,
|
||||
device_info={"email": valid_author.email} if hasattr(valid_author, "email") else None,
|
||||
)
|
||||
logger.info(f"[auth] login: токен успешно создан, длина: {len(token) if token else 0}")
|
||||
|
||||
# Обновляем время последнего входа
|
||||
valid_author.last_seen = int(time.time())
|
||||
valid_author.last_seen = int(time.time()) # type: ignore[assignment]
|
||||
session.commit()
|
||||
|
||||
# Устанавливаем httponly cookie различными способами для надежности
|
||||
@@ -409,10 +378,10 @@ async def login(_, info, email: str, password: str):
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
logger.info(f"[auth] login: Установлена cookie через extensions")
|
||||
logger.info("[auth] login: Установлена cookie через extensions")
|
||||
cookie_set = True
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] login: Ошибка при установке cookie через extensions: {str(e)}")
|
||||
logger.error(f"[auth] login: Ошибка при установке cookie через extensions: {e!s}")
|
||||
|
||||
# Метод 2: GraphQL контекст через response
|
||||
if not cookie_set:
|
||||
@@ -426,10 +395,10 @@ async def login(_, info, email: str, password: str):
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
logger.info(f"[auth] login: Установлена cookie через response")
|
||||
logger.info("[auth] login: Установлена cookie через response")
|
||||
cookie_set = True
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] login: Ошибка при установке cookie через response: {str(e)}")
|
||||
logger.error(f"[auth] login: Ошибка при установке cookie через response: {e!s}")
|
||||
|
||||
# Если ни один способ не сработал, создаем response в контексте
|
||||
if not cookie_set and hasattr(info.context, "request") and not hasattr(info.context, "response"):
|
||||
@@ -446,42 +415,42 @@ async def login(_, info, email: str, password: str):
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
info.context["response"] = response
|
||||
logger.info(f"[auth] login: Создан новый response и установлена cookie")
|
||||
logger.info("[auth] login: Создан новый response и установлена cookie")
|
||||
cookie_set = True
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] login: Ошибка при создании response и установке cookie: {str(e)}")
|
||||
logger.error(f"[auth] login: Ошибка при создании response и установке cookie: {e!s}")
|
||||
|
||||
if not cookie_set:
|
||||
logger.warning(f"[auth] login: Не удалось установить cookie никаким способом")
|
||||
logger.warning("[auth] login: Не удалось установить cookie никаким способом")
|
||||
|
||||
# Возвращаем успешный результат с данными для клиента
|
||||
# Для ответа клиенту используем dict() с параметром access=True,
|
||||
# Для ответа клиенту используем dict() с параметром True,
|
||||
# чтобы получить полный доступ к данным для самого пользователя
|
||||
logger.info(f"[auth] login: Успешный вход для {email}")
|
||||
author_dict = valid_author.dict(access=True)
|
||||
author_dict = valid_author.dict(True)
|
||||
result = {"success": True, "token": token, "author": author_dict, "error": None}
|
||||
logger.info(
|
||||
f"[auth] login: Возвращаемый результат: {{success: {result['success']}, token_length: {len(token) if token else 0}}}"
|
||||
)
|
||||
return result
|
||||
except Exception as token_error:
|
||||
logger.error(f"[auth] login: Ошибка при создании токена: {str(token_error)}")
|
||||
logger.error(f"[auth] login: Ошибка при создании токена: {token_error!s}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {
|
||||
"success": False,
|
||||
"token": None,
|
||||
"author": None,
|
||||
"error": f"Ошибка авторизации: {str(token_error)}",
|
||||
"error": f"Ошибка авторизации: {token_error!s}",
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] login: Ошибка при авторизации {email}: {str(e)}")
|
||||
logger.error(f"[auth] login: Ошибка при авторизации {email}: {e!s}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "token": None, "author": None, "error": str(e)}
|
||||
|
||||
|
||||
@query.field("isEmailUsed")
|
||||
async def is_email_used(_, _info, email):
|
||||
async def is_email_used(_: None, _info: GraphQLResolveInfo, email: str) -> bool:
|
||||
"""check if email is used"""
|
||||
email = email.lower()
|
||||
with local_session() as session:
|
||||
@@ -490,144 +459,489 @@ async def is_email_used(_, _info, email):
|
||||
|
||||
|
||||
@mutation.field("logout")
|
||||
async def logout_resolver(_, info: GraphQLResolveInfo):
|
||||
@login_required
|
||||
async def logout_resolver(_: None, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
|
||||
"""
|
||||
Выход из системы через GraphQL с удалением сессии и cookie.
|
||||
|
||||
Returns:
|
||||
dict: Результат операции выхода
|
||||
"""
|
||||
# Получаем токен из cookie или заголовка
|
||||
request = info.context["request"]
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
if not token:
|
||||
# Проверяем заголовок авторизации
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:] # Отрезаем "Bearer "
|
||||
|
||||
success = False
|
||||
message = ""
|
||||
|
||||
# Если токен найден, отзываем его
|
||||
if token:
|
||||
try:
|
||||
# Декодируем токен для получения user_id
|
||||
user_id, _ = await verify_internal_auth(token)
|
||||
if user_id:
|
||||
# Отзываем сессию
|
||||
await SessionManager.revoke_session(user_id, token)
|
||||
logger.info(f"[auth] logout_resolver: Токен успешно отозван для пользователя {user_id}")
|
||||
success = True
|
||||
message = "Выход выполнен успешно"
|
||||
else:
|
||||
logger.warning("[auth] logout_resolver: Не удалось получить user_id из токена")
|
||||
message = "Не удалось обработать токен"
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] logout_resolver: Ошибка при отзыве токена: {e}")
|
||||
message = f"Ошибка при выходе: {str(e)}"
|
||||
else:
|
||||
message = "Токен не найден"
|
||||
success = True # Если токена нет, то пользователь уже вышел из системы
|
||||
|
||||
# Удаляем cookie через extensions
|
||||
try:
|
||||
# Используем extensions для удаления cookie
|
||||
if hasattr(info.context, "extensions") and hasattr(info.context.extensions, "delete_cookie"):
|
||||
info.context.extensions.delete_cookie(SESSION_COOKIE_NAME)
|
||||
logger.info("[auth] logout_resolver: Cookie успешно удалена через extensions")
|
||||
elif hasattr(info.context, "response") and hasattr(info.context.response, "delete_cookie"):
|
||||
info.context.response.delete_cookie(SESSION_COOKIE_NAME)
|
||||
logger.info("[auth] logout_resolver: Cookie успешно удалена через response")
|
||||
# Используем данные автора из контекста, установленные декоратором login_required
|
||||
author = info.context.get("author")
|
||||
if not author:
|
||||
logger.error("[auth] logout_resolver: Автор не найден в контексте после login_required")
|
||||
return {"success": False, "message": "Пользователь не найден в контексте"}
|
||||
|
||||
user_id = str(author.get("id"))
|
||||
logger.debug(f"[auth] logout_resolver: Обработка выхода для пользователя {user_id}")
|
||||
|
||||
# Получаем токен из cookie или заголовка
|
||||
request = info.context.get("request")
|
||||
token = None
|
||||
|
||||
if request:
|
||||
# Проверяем cookie
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
|
||||
# Если в cookie нет, проверяем заголовок Authorization
|
||||
if not token:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:] # Отрезаем "Bearer "
|
||||
|
||||
if token:
|
||||
# Отзываем сессию используя данные из контекста
|
||||
await SessionManager.revoke_session(user_id, token)
|
||||
logger.info(f"[auth] logout_resolver: Токен успешно отозван для пользователя {user_id}")
|
||||
success = True
|
||||
message = "Выход выполнен успешно"
|
||||
else:
|
||||
logger.warning("[auth] logout_resolver: Невозможно удалить cookie - объекты extensions/response недоступны")
|
||||
logger.warning("[auth] logout_resolver: Токен не найден в запросе")
|
||||
# Все равно считаем успешным, так как пользователь уже не авторизован
|
||||
success = True
|
||||
message = "Выход выполнен (токен не найден)"
|
||||
|
||||
# Удаляем cookie через extensions
|
||||
try:
|
||||
# Используем extensions для удаления cookie
|
||||
if hasattr(info.context, "extensions") and hasattr(info.context.extensions, "delete_cookie"):
|
||||
info.context.extensions.delete_cookie(SESSION_COOKIE_NAME)
|
||||
logger.info("[auth] logout_resolver: Cookie успешно удалена через extensions")
|
||||
elif hasattr(info.context, "response") and hasattr(info.context.response, "delete_cookie"):
|
||||
info.context.response.delete_cookie(SESSION_COOKIE_NAME)
|
||||
logger.info("[auth] logout_resolver: Cookie успешно удалена через response")
|
||||
else:
|
||||
logger.warning(
|
||||
"[auth] logout_resolver: Невозможно удалить cookie - объекты extensions/response недоступны"
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] logout_resolver: Ошибка при удалении cookie: {e}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] logout_resolver: Ошибка при удалении cookie: {str(e)}")
|
||||
logger.debug(traceback.format_exc())
|
||||
logger.error(f"[auth] logout_resolver: Ошибка при выходе: {e}")
|
||||
success = False
|
||||
message = f"Ошибка при выходе: {e}"
|
||||
|
||||
return {"success": success, "message": message}
|
||||
|
||||
|
||||
@mutation.field("refreshToken")
|
||||
async def refresh_token_resolver(_, info: GraphQLResolveInfo):
|
||||
@login_required
|
||||
async def refresh_token_resolver(_: None, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
|
||||
"""
|
||||
Обновление токена аутентификации через GraphQL.
|
||||
|
||||
Returns:
|
||||
AuthResult с данными пользователя и обновленным токеном или сообщением об ошибке
|
||||
"""
|
||||
request = info.context["request"]
|
||||
|
||||
# Получаем текущий токен из cookie или заголовка
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
if not token:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:] # Отрезаем "Bearer "
|
||||
|
||||
if not token:
|
||||
logger.warning("[auth] refresh_token_resolver: Токен не найден в запросе")
|
||||
return {"success": False, "token": None, "author": None, "error": "Токен не найден"}
|
||||
|
||||
try:
|
||||
# Получаем информацию о пользователе из токена
|
||||
user_id, _ = await verify_internal_auth(token)
|
||||
# Используем данные автора из контекста, установленные декоратором login_required
|
||||
author = info.context.get("author")
|
||||
if not author:
|
||||
logger.error("[auth] refresh_token_resolver: Автор не найден в контексте после login_required")
|
||||
return {"success": False, "token": None, "author": None, "error": "Пользователь не найден в контексте"}
|
||||
|
||||
user_id = author.get("id")
|
||||
if not user_id:
|
||||
logger.warning("[auth] refresh_token_resolver: Недействительный токен")
|
||||
return {"success": False, "token": None, "author": None, "error": "Недействительный токен"}
|
||||
logger.error("[auth] refresh_token_resolver: ID пользователя не найден в данных автора")
|
||||
return {"success": False, "token": None, "author": None, "error": "ID пользователя не найден"}
|
||||
|
||||
# Получаем пользователя из базы данных
|
||||
with local_session() as session:
|
||||
author = session.query(Author).filter(Author.id == user_id).first()
|
||||
# Получаем текущий токен из cookie или заголовка
|
||||
request = info.context.get("request")
|
||||
if not request:
|
||||
logger.error("[auth] refresh_token_resolver: Запрос не найден в контексте")
|
||||
return {"success": False, "token": None, "author": None, "error": "Запрос не найден в контексте"}
|
||||
|
||||
if not author:
|
||||
logger.warning(f"[auth] refresh_token_resolver: Пользователь с ID {user_id} не найден")
|
||||
return {"success": False, "token": None, "author": None, "error": "Пользователь не найден"}
|
||||
token = request.cookies.get(SESSION_COOKIE_NAME)
|
||||
if not token:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if auth_header and auth_header.startswith("Bearer "):
|
||||
token = auth_header[7:] # Отрезаем "Bearer "
|
||||
|
||||
# Обновляем сессию (создаем новую и отзываем старую)
|
||||
device_info = {"ip": request.client.host, "user_agent": request.headers.get("user-agent")}
|
||||
new_token = await SessionManager.refresh_session(user_id, token, device_info)
|
||||
if not token:
|
||||
logger.warning("[auth] refresh_token_resolver: Токен не найден в запросе")
|
||||
return {"success": False, "token": None, "author": None, "error": "Токен не найден"}
|
||||
|
||||
if not new_token:
|
||||
logger.error("[auth] refresh_token_resolver: Не удалось обновить токен")
|
||||
return {"success": False, "token": None, "author": None, "error": "Не удалось обновить токен"}
|
||||
# Подготавливаем информацию об устройстве
|
||||
device_info = {
|
||||
"ip": request.client.host if request.client else "unknown",
|
||||
"user_agent": request.headers.get("user-agent"),
|
||||
}
|
||||
|
||||
# Устанавливаем cookie через extensions
|
||||
try:
|
||||
# Используем extensions для установки cookie
|
||||
if hasattr(info.context, "extensions") and hasattr(info.context.extensions, "set_cookie"):
|
||||
logger.info("[auth] refresh_token_resolver: Устанавливаем httponly cookie через extensions")
|
||||
info.context.extensions.set_cookie(
|
||||
SESSION_COOKIE_NAME,
|
||||
new_token,
|
||||
httponly=SESSION_COOKIE_HTTPONLY,
|
||||
secure=SESSION_COOKIE_SECURE,
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
elif hasattr(info.context, "response") and hasattr(info.context.response, "set_cookie"):
|
||||
logger.info("[auth] refresh_token_resolver: Устанавливаем httponly cookie через response")
|
||||
info.context.response.set_cookie(
|
||||
key=SESSION_COOKIE_NAME,
|
||||
value=new_token,
|
||||
httponly=SESSION_COOKIE_HTTPONLY,
|
||||
secure=SESSION_COOKIE_SECURE,
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
else:
|
||||
logger.warning(
|
||||
"[auth] refresh_token_resolver: Невозможно установить cookie - объекты extensions/response недоступны"
|
||||
)
|
||||
except Exception as e:
|
||||
# В случае ошибки при установке cookie просто логируем, но продолжаем обновление токена
|
||||
logger.error(f"[auth] refresh_token_resolver: Ошибка при установке cookie: {str(e)}")
|
||||
logger.debug(traceback.format_exc())
|
||||
# Обновляем сессию (создаем новую и отзываем старую)
|
||||
new_token = await SessionManager.refresh_session(user_id, token, device_info)
|
||||
|
||||
logger.info(f"[auth] refresh_token_resolver: Токен успешно обновлен для пользователя {user_id}")
|
||||
return {"success": True, "token": new_token, "author": author, "error": None}
|
||||
if not new_token:
|
||||
logger.error(f"[auth] refresh_token_resolver: Не удалось обновить токен для пользователя {user_id}")
|
||||
return {"success": False, "token": None, "author": None, "error": "Не удалось обновить токен"}
|
||||
|
||||
# Устанавливаем cookie через extensions
|
||||
try:
|
||||
# Используем extensions для установки cookie
|
||||
if hasattr(info.context, "extensions") and hasattr(info.context.extensions, "set_cookie"):
|
||||
logger.info("[auth] refresh_token_resolver: Устанавливаем httponly cookie через extensions")
|
||||
info.context.extensions.set_cookie(
|
||||
SESSION_COOKIE_NAME,
|
||||
new_token,
|
||||
httponly=SESSION_COOKIE_HTTPONLY,
|
||||
secure=SESSION_COOKIE_SECURE,
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
elif hasattr(info.context, "response") and hasattr(info.context.response, "set_cookie"):
|
||||
logger.info("[auth] refresh_token_resolver: Устанавливаем httponly cookie через response")
|
||||
info.context.response.set_cookie(
|
||||
key=SESSION_COOKIE_NAME,
|
||||
value=new_token,
|
||||
httponly=SESSION_COOKIE_HTTPONLY,
|
||||
secure=SESSION_COOKIE_SECURE,
|
||||
samesite=SESSION_COOKIE_SAMESITE,
|
||||
max_age=SESSION_COOKIE_MAX_AGE,
|
||||
)
|
||||
else:
|
||||
logger.warning(
|
||||
"[auth] refresh_token_resolver: Невозможно установить cookie - объекты extensions/response недоступны"
|
||||
)
|
||||
except Exception as e:
|
||||
# В случае ошибки при установке cookie просто логируем, но продолжаем обновление токена
|
||||
logger.error(f"[auth] refresh_token_resolver: Ошибка при установке cookie: {e}")
|
||||
|
||||
logger.info(f"[auth] refresh_token_resolver: Токен успешно обновлен для пользователя {user_id}")
|
||||
|
||||
# Возвращаем данные автора из контекста (они уже обработаны декоратором)
|
||||
return {"success": True, "token": new_token, "author": author, "error": None}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] refresh_token_resolver: Ошибка при обновлении токена: {e}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "token": None, "author": None, "error": str(e)}
|
||||
|
||||
|
||||
@mutation.field("requestPasswordReset")
|
||||
async def request_password_reset(_: None, _info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
|
||||
"""Запрос сброса пароля"""
|
||||
try:
|
||||
email = kwargs.get("email", "").lower()
|
||||
logger.info(f"[auth] requestPasswordReset: Запрос сброса пароля для {email}")
|
||||
|
||||
with local_session() as session:
|
||||
author = session.query(Author).filter(Author.email == email).first()
|
||||
if not author:
|
||||
logger.warning(f"[auth] requestPasswordReset: Пользователь {email} не найден")
|
||||
# Возвращаем success даже если пользователь не найден (для безопасности)
|
||||
return {"success": True}
|
||||
|
||||
# Создаем токен сброса пароля
|
||||
try:
|
||||
from auth.tokenstorage import TokenStorage
|
||||
|
||||
if hasattr(TokenStorage, "create_onetime"):
|
||||
token = await TokenStorage.create_onetime(author)
|
||||
else:
|
||||
# Fallback if create_onetime doesn't exist
|
||||
token = await TokenStorage.create_session(
|
||||
user_id=str(author.id),
|
||||
username=str(author.username or author.email or author.slug or ""),
|
||||
device_info={"email": author.email} if hasattr(author, "email") else None,
|
||||
)
|
||||
except (AttributeError, ImportError):
|
||||
# Fallback if TokenStorage doesn't exist or doesn't have the method
|
||||
token = "temporary_token"
|
||||
|
||||
# Отправляем email с токеном
|
||||
await send_auth_email(author, token, kwargs.get("lang", "ru"), "password_reset")
|
||||
logger.info(f"[auth] requestPasswordReset: Письмо сброса пароля отправлено для {email}")
|
||||
|
||||
return {"success": True}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] requestPasswordReset: Ошибка при запросе сброса пароля для {email}: {e!s}")
|
||||
return {"success": False}
|
||||
|
||||
|
||||
@mutation.field("updateSecurity")
|
||||
@login_required
|
||||
async def update_security(
|
||||
_: None,
|
||||
info: GraphQLResolveInfo,
|
||||
**kwargs: Any,
|
||||
) -> dict[str, Any]:
|
||||
"""
|
||||
Мутация для смены пароля и/или email пользователя.
|
||||
|
||||
Args:
|
||||
email: Новый email (опционально)
|
||||
old_password: Текущий пароль (обязательно для любых изменений)
|
||||
new_password: Новый пароль (опционально)
|
||||
|
||||
Returns:
|
||||
SecurityUpdateResult: Результат операции с успехом/ошибкой и данными пользователя
|
||||
"""
|
||||
logger.info("[auth] updateSecurity: Начало обновления данных безопасности")
|
||||
|
||||
# Получаем текущего пользователя
|
||||
current_user = info.context.get("author")
|
||||
if not current_user:
|
||||
logger.warning("[auth] updateSecurity: Пользователь не авторизован")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
user_id = current_user.get("id")
|
||||
logger.info(f"[auth] updateSecurity: Обновление для пользователя ID={user_id}")
|
||||
|
||||
# Валидация входных параметров
|
||||
new_password = kwargs.get("new_password")
|
||||
old_password = kwargs.get("old_password")
|
||||
email = kwargs.get("email")
|
||||
if not email and not new_password:
|
||||
logger.warning("[auth] updateSecurity: Не указаны параметры для изменения")
|
||||
return {"success": False, "error": "VALIDATION_ERROR", "author": None}
|
||||
|
||||
if not old_password:
|
||||
logger.warning("[auth] updateSecurity: Не указан старый пароль")
|
||||
return {"success": False, "error": "VALIDATION_ERROR", "author": None}
|
||||
|
||||
if new_password and len(new_password) < 8:
|
||||
logger.warning("[auth] updateSecurity: Новый пароль слишком короткий")
|
||||
return {"success": False, "error": "WEAK_PASSWORD", "author": None}
|
||||
|
||||
if new_password == old_password:
|
||||
logger.warning("[auth] updateSecurity: Новый пароль совпадает со старым")
|
||||
return {"success": False, "error": "SAME_PASSWORD", "author": None}
|
||||
|
||||
# Валидация email
|
||||
import re
|
||||
|
||||
email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
|
||||
if email and not re.match(email_pattern, email):
|
||||
logger.warning(f"[auth] updateSecurity: Неверный формат email: {email}")
|
||||
return {"success": False, "error": "INVALID_EMAIL", "author": None}
|
||||
|
||||
email = email.lower() if email else ""
|
||||
|
||||
try:
|
||||
with local_session() as session:
|
||||
# Получаем пользователя из базы данных
|
||||
author = session.query(Author).filter(Author.id == user_id).first()
|
||||
if not author:
|
||||
logger.error(f"[auth] updateSecurity: Пользователь с ID {user_id} не найден в БД")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
# Проверяем старый пароль
|
||||
if not author.verify_password(old_password):
|
||||
logger.warning(f"[auth] updateSecurity: Неверный старый пароль для пользователя {user_id}")
|
||||
return {"success": False, "error": "incorrect old password", "author": None}
|
||||
|
||||
# Проверяем, что новый email не занят
|
||||
if email and email != author.email:
|
||||
existing_user = session.query(Author).filter(Author.email == email).first()
|
||||
if existing_user:
|
||||
logger.warning(f"[auth] updateSecurity: Email {email} уже используется")
|
||||
return {"success": False, "error": "email already exists", "author": None}
|
||||
|
||||
# Выполняем изменения
|
||||
changes_made = []
|
||||
|
||||
# Смена пароля
|
||||
if new_password:
|
||||
author.set_password(new_password)
|
||||
changes_made.append("password")
|
||||
logger.info(f"[auth] updateSecurity: Пароль изменен для пользователя {user_id}")
|
||||
|
||||
# Смена email через Redis
|
||||
if email and email != author.email:
|
||||
# Генерируем токен подтверждения
|
||||
token = secrets.token_urlsafe(32)
|
||||
|
||||
# Сохраняем данные смены email в Redis с TTL 1 час
|
||||
email_change_data = {
|
||||
"user_id": user_id,
|
||||
"old_email": author.email,
|
||||
"new_email": email,
|
||||
"token": token,
|
||||
"expires_at": int(time.time()) + 3600, # 1 час
|
||||
}
|
||||
|
||||
# Ключ для хранения в Redis
|
||||
redis_key = f"email_change:{user_id}"
|
||||
|
||||
# Используем внутреннюю систему истечения Redis: SET + EXPIRE
|
||||
await redis.execute("SET", redis_key, json.dumps(email_change_data))
|
||||
await redis.execute("EXPIRE", redis_key, 3600) # 1 час TTL
|
||||
|
||||
changes_made.append("email_pending")
|
||||
logger.info(
|
||||
f"[auth] updateSecurity: Email смена инициирована для пользователя {user_id}: {author.email} -> {kwargs.get('email')}"
|
||||
)
|
||||
|
||||
# TODO: Отправить письмо подтверждения на новый email
|
||||
# await send_email_change_confirmation(author, kwargs.get('email'), token)
|
||||
|
||||
# Обновляем временную метку
|
||||
author.updated_at = int(time.time()) # type: ignore[assignment]
|
||||
|
||||
# Сохраняем изменения
|
||||
session.add(author)
|
||||
session.commit()
|
||||
|
||||
logger.info(
|
||||
f"[auth] updateSecurity: Изменения сохранены для пользователя {user_id}: {', '.join(changes_made)}"
|
||||
)
|
||||
|
||||
# Возвращаем обновленные данные пользователя
|
||||
return {
|
||||
"success": True,
|
||||
"error": None,
|
||||
"author": author.dict(True), # Возвращаем полные данные владельцу
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] updateSecurity: Ошибка при обновлении данных безопасности: {e!s}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "error": str(e), "author": None}
|
||||
|
||||
|
||||
@mutation.field("confirmEmailChange")
|
||||
@login_required
|
||||
async def confirm_email_change(_: None, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
|
||||
"""
|
||||
Подтверждение смены email по токену.
|
||||
|
||||
Args:
|
||||
token: Токен подтверждения смены email
|
||||
|
||||
Returns:
|
||||
SecurityUpdateResult: Результат операции
|
||||
"""
|
||||
logger.info("[auth] confirmEmailChange: Подтверждение смены email по токену")
|
||||
|
||||
# Получаем текущего пользователя
|
||||
current_user = info.context.get("author")
|
||||
if not current_user:
|
||||
logger.warning("[auth] confirmEmailChange: Пользователь не авторизован")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
user_id = current_user.get("id")
|
||||
|
||||
try:
|
||||
# Получаем данные смены email из Redis
|
||||
redis_key = f"email_change:{user_id}"
|
||||
cached_data = await redis.execute("GET", redis_key)
|
||||
|
||||
if not cached_data:
|
||||
logger.warning(f"[auth] confirmEmailChange: Данные смены email не найдены для пользователя {user_id}")
|
||||
return {"success": False, "error": "NO_PENDING_EMAIL", "author": None}
|
||||
|
||||
try:
|
||||
email_change_data = json.loads(cached_data)
|
||||
except json.JSONDecodeError:
|
||||
logger.error(f"[auth] confirmEmailChange: Ошибка декодирования данных из Redis для пользователя {user_id}")
|
||||
return {"success": False, "error": "INVALID_TOKEN", "author": None}
|
||||
|
||||
# Проверяем токен
|
||||
if email_change_data.get("token") != kwargs.get("token"):
|
||||
logger.warning(f"[auth] confirmEmailChange: Неверный токен для пользователя {user_id}")
|
||||
return {"success": False, "error": "INVALID_TOKEN", "author": None}
|
||||
|
||||
# Проверяем срок действия токена
|
||||
if email_change_data.get("expires_at", 0) < int(time.time()):
|
||||
logger.warning(f"[auth] confirmEmailChange: Токен истек для пользователя {user_id}")
|
||||
# Удаляем истекшие данные из Redis
|
||||
await redis.execute("DEL", redis_key)
|
||||
return {"success": False, "error": "TOKEN_EXPIRED", "author": None}
|
||||
|
||||
new_email = email_change_data.get("new_email")
|
||||
if not new_email:
|
||||
logger.error(f"[auth] confirmEmailChange: Нет нового email в данных для пользователя {user_id}")
|
||||
return {"success": False, "error": "INVALID_TOKEN", "author": None}
|
||||
|
||||
with local_session() as session:
|
||||
author = session.query(Author).filter(Author.id == user_id).first()
|
||||
if not author:
|
||||
logger.error(f"[auth] confirmEmailChange: Пользователь с ID {user_id} не найден в БД")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
# Проверяем, что новый email еще не занят
|
||||
existing_user = session.query(Author).filter(Author.email == new_email).first()
|
||||
if existing_user and existing_user.id != author.id:
|
||||
logger.warning(f"[auth] confirmEmailChange: Email {new_email} уже занят")
|
||||
# Удаляем данные из Redis
|
||||
await redis.execute("DEL", redis_key)
|
||||
return {"success": False, "error": "email already exists", "author": None}
|
||||
|
||||
old_email = author.email
|
||||
|
||||
# Применяем смену email
|
||||
author.email = new_email # type: ignore[assignment]
|
||||
author.email_verified = True # type: ignore[assignment] # Новый email считается подтвержденным
|
||||
author.updated_at = int(time.time()) # type: ignore[assignment]
|
||||
|
||||
session.add(author)
|
||||
session.commit()
|
||||
|
||||
# Удаляем данные смены email из Redis после успешного применения
|
||||
await redis.execute("DEL", redis_key)
|
||||
|
||||
logger.info(
|
||||
f"[auth] confirmEmailChange: Email изменен для пользователя {user_id}: {old_email} -> {new_email}"
|
||||
)
|
||||
|
||||
# TODO: Отправить уведомление на старый email о смене
|
||||
|
||||
return {"success": True, "error": None, "author": author.dict(True)}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] confirmEmailChange: Ошибка при подтверждении смены email: {e!s}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "error": str(e), "author": None}
|
||||
|
||||
|
||||
@mutation.field("cancelEmailChange")
|
||||
@login_required
|
||||
async def cancel_email_change(_: None, info: GraphQLResolveInfo) -> dict[str, Any]:
|
||||
"""
|
||||
Отмена смены email.
|
||||
|
||||
Returns:
|
||||
SecurityUpdateResult: Результат операции
|
||||
"""
|
||||
logger.info("[auth] cancelEmailChange: Отмена смены email")
|
||||
|
||||
# Получаем текущего пользователя
|
||||
current_user = info.context.get("author")
|
||||
if not current_user:
|
||||
logger.warning("[auth] cancelEmailChange: Пользователь не авторизован")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
user_id = current_user.get("id")
|
||||
|
||||
try:
|
||||
# Проверяем наличие данных смены email в Redis
|
||||
redis_key = f"email_change:{user_id}"
|
||||
cached_data = await redis.execute("GET", redis_key)
|
||||
|
||||
if not cached_data:
|
||||
logger.warning(f"[auth] cancelEmailChange: Нет активной смены email для пользователя {user_id}")
|
||||
return {"success": False, "error": "NO_PENDING_EMAIL", "author": None}
|
||||
|
||||
# Удаляем данные смены email из Redis
|
||||
await redis.execute("DEL", redis_key)
|
||||
|
||||
# Получаем текущие данные пользователя
|
||||
with local_session() as session:
|
||||
author = session.query(Author).filter(Author.id == user_id).first()
|
||||
if not author:
|
||||
logger.error(f"[auth] cancelEmailChange: Пользователь с ID {user_id} не найден в БД")
|
||||
return {"success": False, "error": "NOT_AUTHENTICATED", "author": None}
|
||||
|
||||
logger.info(f"[auth] cancelEmailChange: Смена email отменена для пользователя {user_id}")
|
||||
|
||||
return {"success": True, "error": None, "author": author.dict(True)}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[auth] cancelEmailChange: Ошибка при отмене смены email: {e!s}")
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "error": str(e), "author": None}
|
||||
|
||||
Reference in New Issue
Block a user