493 lines
24 KiB
Python
493 lines
24 KiB
Python
from __future__ import annotations
|
||
|
||
from typing import Any
|
||
|
||
from graphql import GraphQLResolveInfo
|
||
from sqlalchemy.sql import and_
|
||
|
||
from cache.cache import (
|
||
cache_author,
|
||
cache_topic,
|
||
get_cached_follower_authors,
|
||
get_cached_follower_topics,
|
||
)
|
||
from orm.author import Author, AuthorFollower
|
||
from orm.community import Community, CommunityFollower
|
||
from orm.shout import Shout, ShoutReactionsFollower
|
||
from orm.topic import Topic, TopicFollower
|
||
from resolvers.author import invalidate_authors_cache
|
||
from services.auth import login_required
|
||
from services.notify import notify_follower
|
||
from storage.db import local_session
|
||
from storage.redis import redis
|
||
from storage.schema import mutation, query
|
||
from utils.logger import root_logger as logger
|
||
|
||
|
||
def get_entity_field_name(entity_type: str) -> str:
|
||
"""
|
||
Возвращает имя поля для связи с сущностью в модели подписчика.
|
||
|
||
Эта функция используется для определения правильного поля в моделях подписчиков
|
||
(AuthorFollower, TopicFollower, CommunityFollower, ShoutReactionsFollower) при создании
|
||
или проверке подписки.
|
||
|
||
Args:
|
||
entity_type: Тип сущности в нижнем регистре ('author', 'topic', 'community', 'shout')
|
||
|
||
Returns:
|
||
str: Имя поля в модели подписчика ('following', 'topic', 'community', 'shout')
|
||
|
||
Raises:
|
||
ValueError: Если передан неизвестный тип сущности
|
||
|
||
Examples:
|
||
>>> get_entity_field_name('author')
|
||
'following'
|
||
>>> get_entity_field_name('topic')
|
||
'topic'
|
||
>>> get_entity_field_name('invalid')
|
||
ValueError: Unknown entity_type: invalid
|
||
"""
|
||
entity_field_mapping = {
|
||
"author": "following", # AuthorFollower.following -> Author
|
||
"topic": "topic", # TopicFollower.topic -> Topic
|
||
"community": "community", # CommunityFollower.community -> Community
|
||
"shout": "shout", # ShoutReactionsFollower.shout -> Shout
|
||
}
|
||
if entity_type not in entity_field_mapping:
|
||
msg = f"Unknown entity_type: {entity_type}"
|
||
raise ValueError(msg)
|
||
return entity_field_mapping[entity_type]
|
||
|
||
|
||
@mutation.field("follow")
|
||
@login_required
|
||
async def follow(
|
||
_: None, info: GraphQLResolveInfo, what: str, slug: str = "", entity_id: int | None = None
|
||
) -> dict[str, Any]:
|
||
"""
|
||
GraphQL мутация для создания подписки на автора, тему, сообщество или публикацию.
|
||
|
||
Эта функция обрабатывает все типы подписок в системе, включая:
|
||
- Подписку на автора (AUTHOR)
|
||
- Подписку на тему (TOPIC)
|
||
- Подписку на сообщество (COMMUNITY)
|
||
- Подписку на публикацию (SHOUT)
|
||
|
||
Args:
|
||
_: None - Стандартный параметр GraphQL (не используется)
|
||
info: GraphQLResolveInfo - Контекст GraphQL запроса, содержит информацию об авторизованном пользователе
|
||
what: str - Тип сущности для подписки ('AUTHOR', 'TOPIC', 'COMMUNITY', 'SHOUT')
|
||
slug: str - Slug сущности (например, 'author-slug' или 'topic-slug')
|
||
entity_id: int | None - ID сущности (альтернатива slug)
|
||
|
||
Returns:
|
||
dict[str, Any] - Результат операции:
|
||
{
|
||
"success": bool, # Успешность операции
|
||
"error": str | None, # Текст ошибки если есть
|
||
"authors": Author[], # Обновленные авторы (для кеширования)
|
||
"topics": Topic[], # Обновленные темы (для кеширования)
|
||
"entity_id": int | None # ID созданной подписки
|
||
}
|
||
|
||
Raises:
|
||
ValueError: При передаче некорректных параметров
|
||
DatabaseError: При проблемах с базой данных
|
||
"""
|
||
logger.debug("Начало выполнения функции 'follow'")
|
||
viewer_id = info.context.get("author", {}).get("id")
|
||
follower_dict = info.context.get("author") or {}
|
||
|
||
# ✅ КРИТИЧНО: Инвалидируем кеш В САМОМ НАЧАЛЕ, если пользователь авторизован
|
||
# чтобы предотвратить чтение старых данных при последующей перезагрузке
|
||
if viewer_id:
|
||
entity_type = what.lower()
|
||
cache_key_pattern = f"author:follows-{entity_type}s:{viewer_id}"
|
||
await redis.execute("DEL", cache_key_pattern)
|
||
await redis.execute("DEL", f"author:id:{viewer_id}")
|
||
logger.debug(f"Инвалидирован кеш подписок follower'а: {cache_key_pattern}")
|
||
|
||
# Проверка авторизации пользователя
|
||
if not viewer_id:
|
||
logger.warning("Попытка подписаться без авторизации")
|
||
return {"error": "Access denied"}
|
||
|
||
logger.debug(f"follower: {follower_dict}")
|
||
|
||
if not viewer_id or not follower_dict:
|
||
logger.warning("Неавторизованный доступ при попытке подписаться")
|
||
return {"error": "UnauthorizedError"}
|
||
|
||
follower_id = follower_dict.get("id")
|
||
logger.debug(f"follower_id: {follower_id}")
|
||
|
||
# Маппинг типов сущностей на их классы и методы кеширования
|
||
entity_classes = {
|
||
"AUTHOR": (Author, AuthorFollower, get_cached_follower_authors, cache_author),
|
||
"TOPIC": (Topic, TopicFollower, get_cached_follower_topics, cache_topic),
|
||
"COMMUNITY": (Community, CommunityFollower, None, None), # Нет методов кэша для сообщества
|
||
"SHOUT": (Shout, ShoutReactionsFollower, None, None), # Нет методов кэша для shout
|
||
}
|
||
|
||
if what not in entity_classes:
|
||
logger.error(f"Неверный тип для следования: {what}")
|
||
return {"error": "invalid follow type"}
|
||
|
||
entity_class, follower_class, get_cached_follows_method, cache_method = entity_classes[what]
|
||
entity_type = what.lower()
|
||
follows: list[dict[str, Any]] = []
|
||
error: str | None = None
|
||
|
||
# ✅ Сохраняем entity_id и error вне сессии для использования после её закрытия
|
||
entity_id_result: int | None = None
|
||
error_result: str | None = None
|
||
|
||
try:
|
||
logger.debug("Попытка получить сущность из базы данных")
|
||
with local_session() as session:
|
||
# Используем query для получения сущности
|
||
entity_query = session.query(entity_class)
|
||
|
||
# Проверяем наличие slug перед фильтрацией
|
||
if hasattr(entity_class, "slug"):
|
||
entity_query = entity_query.where(entity_class.slug == slug)
|
||
|
||
entity = entity_query.first()
|
||
|
||
if not entity:
|
||
logger.warning(f"{what.lower()} не найден по slug: {slug}")
|
||
return {"error": f"{what.lower()} not found"}
|
||
|
||
# Получаем ID сущности
|
||
if entity_id is None:
|
||
entity_id = getattr(entity, "id", None)
|
||
|
||
if not entity_id:
|
||
logger.warning(f"Не удалось получить ID для {what.lower()}")
|
||
return {"error": f"Cannot get ID for {what.lower()}"}
|
||
|
||
# Если это автор, учитываем фильтрацию данных
|
||
entity_dict = entity.dict() if hasattr(entity, "dict") else {}
|
||
|
||
logger.debug(f"entity_id: {entity_id}, entity_dict: {entity_dict}")
|
||
|
||
if entity_id is not None and isinstance(entity_id, int):
|
||
entity_field = get_entity_field_name(entity_type)
|
||
logger.debug(f"entity_type: {entity_type}, entity_field: {entity_field}")
|
||
|
||
existing_sub = (
|
||
session.query(follower_class)
|
||
.where(
|
||
follower_class.follower == follower_id, # type: ignore[attr-defined]
|
||
getattr(follower_class, entity_field) == entity_id, # type: ignore[attr-defined]
|
||
)
|
||
.first()
|
||
)
|
||
|
||
if existing_sub:
|
||
logger.info(f"Пользователь {follower_id} уже подписан на {what.lower()} с ID {entity_id}")
|
||
error_result = "already following"
|
||
# ✅ КРИТИЧНО: Не делаем return - продолжаем для получения списка подписок
|
||
else:
|
||
logger.debug("Добавление новой записи в базу данных")
|
||
sub = follower_class(follower=follower_id, **{entity_field: entity_id})
|
||
logger.debug(f"Создан объект подписки: {sub}")
|
||
session.add(sub)
|
||
session.commit()
|
||
logger.info(f"Пользователь {follower_id} подписался на {what.lower()} с ID {entity_id}")
|
||
|
||
if cache_method:
|
||
logger.debug("Обновление кэша сущности")
|
||
await cache_method(entity_dict)
|
||
|
||
if what == "AUTHOR":
|
||
logger.debug("Отправка уведомления автору о подписке")
|
||
if isinstance(follower_dict, dict) and isinstance(entity_id, int):
|
||
# Получаем ID созданной записи подписки
|
||
subscription_id = getattr(sub, "id", None) if "sub" in locals() else None
|
||
await notify_follower(
|
||
follower=follower_dict,
|
||
author_id=entity_id,
|
||
action="follow",
|
||
subscription_id=subscription_id,
|
||
)
|
||
|
||
# ✅ КРИТИЧНО: Инвалидируем кеш списка подписчиков автора
|
||
# чтобы новый подписчик сразу появился в списке
|
||
await redis.execute("DEL", f"author:followers:{entity_id}")
|
||
logger.debug(f"Инвалидирован кеш подписчиков автора: author:followers:{entity_id}")
|
||
|
||
# Инвалидируем кеш статистики авторов для обновления счетчиков подписчиков
|
||
logger.debug("Инвалидируем кеш статистики авторов")
|
||
await invalidate_authors_cache(entity_id)
|
||
|
||
entity_id_result = entity_id
|
||
|
||
# ✅ Получаем актуальный список подписок для возврата клиенту
|
||
# Кеш уже инвалидирован в начале функции, поэтому get_cached_follows_method
|
||
# вернет свежие данные из БД
|
||
if get_cached_follows_method and isinstance(follower_id, int):
|
||
logger.debug("Получение актуального списка подписок после закрытия сессии")
|
||
existing_follows = await get_cached_follows_method(follower_id)
|
||
logger.debug(
|
||
f"Получено подписок: {len(existing_follows)}, содержит target={entity_id_result in [f.get('id') for f in existing_follows] if existing_follows else False}"
|
||
)
|
||
|
||
# Если это авторы, получаем безопасную версию
|
||
if what == "AUTHOR":
|
||
follows_filtered = []
|
||
|
||
for author_data in existing_follows:
|
||
# Создаем объект автора для использования метода dict
|
||
temp_author = Author()
|
||
for key, value in author_data.items():
|
||
if (
|
||
hasattr(temp_author, key) and key != "username"
|
||
): # username - это свойство, нельзя устанавливать
|
||
setattr(temp_author, key, value)
|
||
# Добавляем отфильтрованную версию
|
||
follows_filtered.append(temp_author.dict())
|
||
|
||
follows = follows_filtered
|
||
else:
|
||
follows = existing_follows
|
||
|
||
logger.debug(f"Актуальный список подписок получен: {len(follows)} элементов")
|
||
|
||
return {f"{entity_type}s": follows, "error": error_result}
|
||
|
||
except Exception as exc:
|
||
logger.exception("Произошла ошибка в функции 'follow'")
|
||
return {"error": str(exc)}
|
||
|
||
|
||
@mutation.field("unfollow")
|
||
@login_required
|
||
async def unfollow(
|
||
_: None, info: GraphQLResolveInfo, what: str, slug: str = "", entity_id: int | None = None
|
||
) -> dict[str, Any]:
|
||
"""
|
||
GraphQL мутация для отмены подписки на автора, тему, сообщество или публикацию.
|
||
|
||
Эта функция обрабатывает отмену всех типов подписок в системе, включая:
|
||
- Отписку от автора (AUTHOR)
|
||
- Отписку от темы (TOPIC)
|
||
- Отписку от сообщества (COMMUNITY)
|
||
- Отписку от публикации (SHOUT)
|
||
|
||
Процесс отмены подписки:
|
||
1. Проверка авторизации пользователя
|
||
2. Поиск существующей подписки в базе данных
|
||
3. Удаление подписки если она найдена
|
||
4. Инвалидация кеша для обновления данных
|
||
5. Отправка уведомлений об отписке
|
||
|
||
Args:
|
||
_: None - Стандартный параметр GraphQL (не используется)
|
||
info: GraphQLResolveInfo - Контекст GraphQL запроса, содержит информацию об авторизованном пользователе
|
||
what: str - Тип сущности для отписки ('AUTHOR', 'TOPIC', 'COMMUNITY', 'SHOUT')
|
||
slug: str - Slug сущности (например, 'author-slug' или 'topic-slug')
|
||
entity_id: int | None - ID сущности (альтернатива slug)
|
||
|
||
Returns:
|
||
dict[str, Any] - Результат операции:
|
||
{
|
||
"success": bool, # Успешность операции
|
||
"error": str | None, # Текст ошибки если есть
|
||
"authors": Author[], # Обновленные авторы (для кеширования)
|
||
"topics": Topic[], # Обновленные темы (для кеширования)
|
||
}
|
||
|
||
Raises:
|
||
ValueError: При передаче некорректных параметров
|
||
DatabaseError: При проблемах с базой данных
|
||
|
||
Examples:
|
||
# Отписка от автора
|
||
mutation {
|
||
unfollow(what: "AUTHOR", slug: "author-slug") {
|
||
success
|
||
error
|
||
}
|
||
}
|
||
|
||
# Отписка от темы
|
||
mutation {
|
||
unfollow(what: "TOPIC", slug: "topic-slug") {
|
||
success
|
||
error
|
||
}
|
||
}
|
||
|
||
# Отписка от сообщества
|
||
mutation {
|
||
unfollow(what: "COMMUNITY", slug: "community-slug") {
|
||
success
|
||
error
|
||
}
|
||
}
|
||
|
||
# Отписка от публикации
|
||
mutation {
|
||
unfollow(what: "SHOUT", entity_id: 123) {
|
||
success
|
||
error
|
||
}
|
||
}
|
||
"""
|
||
logger.debug("Начало выполнения функции 'unfollow'")
|
||
viewer_id = info.context.get("author", {}).get("id")
|
||
follower_dict = info.context.get("author") or {}
|
||
|
||
# ✅ КРИТИЧНО: Инвалидируем кеш В САМОМ НАЧАЛЕ, если пользователь авторизован
|
||
# чтобы предотвратить чтение старых данных при последующей перезагрузке
|
||
if viewer_id:
|
||
entity_type = what.lower()
|
||
cache_key_pattern = f"author:follows-{entity_type}s:{viewer_id}"
|
||
await redis.execute("DEL", cache_key_pattern)
|
||
await redis.execute("DEL", f"author:id:{viewer_id}")
|
||
logger.debug(f"Инвалидирован кеш подписок В НАЧАЛЕ операции unfollow: {cache_key_pattern}")
|
||
|
||
# Проверка авторизации пользователя
|
||
if not viewer_id:
|
||
logger.warning("Попытка отписаться без авторизации")
|
||
return {"error": "Access denied"}
|
||
|
||
logger.debug(f"follower: {follower_dict}")
|
||
|
||
if not viewer_id or not follower_dict:
|
||
logger.warning("Неавторизованный доступ при попытке отписаться")
|
||
return {"error": "UnauthorizedError"}
|
||
|
||
follower_id = follower_dict.get("id")
|
||
logger.debug(f"follower_id: {follower_id}")
|
||
|
||
# Маппинг типов сущностей на их классы и методы кеширования
|
||
entity_classes = {
|
||
"AUTHOR": (Author, AuthorFollower, get_cached_follower_authors, cache_author),
|
||
"TOPIC": (Topic, TopicFollower, get_cached_follower_topics, cache_topic),
|
||
"COMMUNITY": (Community, CommunityFollower, None, None), # Нет методов кэша для сообщества
|
||
"SHOUT": (Shout, ShoutReactionsFollower, None, None), # Нет методов кэша для shout
|
||
}
|
||
|
||
if what not in entity_classes:
|
||
logger.error(f"Неверный тип для отписки: {what}")
|
||
return {"error": "invalid unfollow type"}
|
||
|
||
entity_class, follower_class, get_cached_follows_method, _cache_method = entity_classes[what]
|
||
entity_type = what.lower()
|
||
follows: list[dict[str, Any]] = []
|
||
|
||
try:
|
||
logger.debug("Попытка получить сущность из базы данных")
|
||
with local_session() as session:
|
||
# Используем query для получения сущности
|
||
entity_query = session.query(entity_class)
|
||
if hasattr(entity_class, "slug"):
|
||
entity_query = entity_query.where(entity_class.slug == slug)
|
||
|
||
entity = entity_query.first()
|
||
logger.debug(f"Полученная сущность: {entity}")
|
||
if not entity:
|
||
logger.warning(f"{what.lower()} не найден по slug: {slug}")
|
||
return {"error": f"{what.lower()} not found"}
|
||
|
||
if not entity_id:
|
||
entity_id = getattr(entity, "id", None)
|
||
if not entity_id:
|
||
logger.warning(f"Не удалось получить ID для {what.lower()}")
|
||
return {"error": f"Cannot get ID for {what.lower()}"}
|
||
|
||
logger.debug(f"entity_id: {entity_id}")
|
||
entity_field = get_entity_field_name(entity_type)
|
||
|
||
sub = (
|
||
session.query(follower_class)
|
||
.where(
|
||
and_(
|
||
follower_class.follower == follower_id, # type: ignore[attr-defined]
|
||
getattr(follower_class, entity_field) == entity_id, # type: ignore[attr-defined]
|
||
)
|
||
)
|
||
.first()
|
||
)
|
||
if not sub:
|
||
logger.warning(f"Подписка не найдена для {what.lower()} с ID {entity_id}")
|
||
return {"error": "Not following"}
|
||
|
||
logger.debug(f"Найдена подписка для удаления: {sub}")
|
||
session.delete(sub)
|
||
session.commit()
|
||
logger.info(f"Пользователь {follower_id} отписался от {what.lower()} с ID {entity_id}")
|
||
|
||
# Кеш подписок follower'а уже инвалидирован в начале функции
|
||
if get_cached_follows_method and isinstance(follower_id, int):
|
||
logger.debug("Получение актуального списка подписок из кэша")
|
||
follows = await get_cached_follows_method(follower_id)
|
||
logger.debug(f"Актуальный список подписок получен: {len(follows)} элементов")
|
||
else:
|
||
follows = []
|
||
|
||
if what == "AUTHOR" and isinstance(follower_dict, dict):
|
||
await notify_follower(follower=follower_dict, author_id=entity_id, action="unfollow")
|
||
|
||
# ✅ КРИТИЧНО: Инвалидируем кеш списка подписчиков автора
|
||
# чтобы отписавшийся сразу исчез из списка
|
||
await redis.execute("DEL", f"author:followers:{entity_id}")
|
||
logger.debug(f"Инвалидирован кеш подписчиков автора после unfollow: author:followers:{entity_id}")
|
||
|
||
# Инвалидируем кеш статистики авторов для обновления счетчиков подписчиков
|
||
logger.debug("Инвалидируем кеш статистики авторов после отписки")
|
||
await invalidate_authors_cache(entity_id)
|
||
|
||
return {f"{entity_type}s": follows, "error": None}
|
||
|
||
except Exception as exc:
|
||
logger.exception("Произошла ошибка в функции 'unfollow'")
|
||
return {"error": str(exc)}
|
||
|
||
|
||
@query.field("get_shout_followers")
|
||
def get_shout_followers(
|
||
_: None, _info: GraphQLResolveInfo, slug: str = "", shout_id: int | None = None
|
||
) -> list[dict[str, Any]]:
|
||
"""
|
||
Получает список подписчиков для шаута по slug или ID
|
||
|
||
Args:
|
||
_: GraphQL root
|
||
_info: GraphQL context info
|
||
slug: Slug шаута (опционально)
|
||
shout_id: ID шаута (опционально)
|
||
|
||
Returns:
|
||
Список подписчиков шаута
|
||
"""
|
||
if not slug and not shout_id:
|
||
return []
|
||
|
||
with local_session() as session:
|
||
# Если slug не указан, ищем шаут по ID
|
||
if not slug and shout_id is not None:
|
||
shout = session.query(Shout).where(Shout.id == shout_id).first()
|
||
else:
|
||
# Ищем шаут по slug
|
||
shout = session.query(Shout).where(Shout.slug == slug).first()
|
||
|
||
if not shout:
|
||
return []
|
||
|
||
# Получаем подписчиков шаута
|
||
followers_query = (
|
||
session.query(Author)
|
||
.join(ShoutReactionsFollower, Author.id == ShoutReactionsFollower.follower)
|
||
.where(ShoutReactionsFollower.shout == shout.id)
|
||
)
|
||
|
||
followers = followers_query.all()
|
||
|
||
# Возвращаем безопасную версию данных
|
||
return [follower.dict() for follower in followers]
|