Valid HTML
") + >>> is_valid + True + >>> error + '' + >>> is_valid, error = validate_html_content("Invalid < HTML") + >>> is_valid + False + >>> 'Invalid HTML' in error + True + """ + if not html_content or not html_content.strip(): + return False, "Content is empty" + + try: + html_content = wrap_html_fragment(html_content) + extracted = trafilatura.extract(html_content) + if not extracted: + return False, "Invalid HTML structure or empty content" + return True, "" + except Exception as e: + logger.error(f"HTML validation error: {e}", exc_info=True) + return False, f"Invalid HTML content: {str(e)}" + + @mutation.field("publish_draft") @login_required async def publish_draft(_, info, draft_id: int): - user_id = info.context.get("user_id") - author_dict = info.context.get("author", {}) - author_id = author_dict.get("id") - if not user_id or not author_id: - return {"error": "User ID and author ID are required"} - - with local_session() as session: - draft = session.query(Draft).filter(Draft.id == draft_id).first() - if not draft: - return {"error": "Draft not found"} - shout = create_shout_from_draft(session, draft, author_id) - session.add(shout) - session.commit() - return {"shout": shout, "draft": draft} - - -@mutation.field("unpublish_draft") -@login_required -async def unpublish_draft(_, info, draft_id: int): - user_id = info.context.get("user_id") - author_dict = info.context.get("author", {}) - author_id = author_dict.get("id") - if not user_id or not author_id: - return {"error": "User ID and author ID are required"} - - with local_session() as session: - draft = session.query(Draft).filter(Draft.id == draft_id).first() - if not draft: - return {"error": "Draft not found"} - shout = session.query(Shout).filter(Shout.draft == draft.id).first() - if shout: - shout.published_at = None - session.commit() - return {"shout": shout, "draft": draft} - return {"error": "Failed to unpublish draft"} - - -@mutation.field("publish_shout") -@login_required -async def publish_shout(_, info, shout_id: int): - """Publish draft as a shout or update existing shout. - + """ + Публикует черновик, создавая новый Shout или обновляя существующий. + Args: - shout_id: ID существующей публикации или 0 для новой - draft: Объект черновика (опционально) + draft_id (int): ID черновика для публикации + + Returns: + dict: Результат публикации с shout или сообщением об ошибке """ user_id = info.context.get("user_id") author_dict = info.context.get("author", {}) author_id = author_dict.get("id") - now = int(time.time()) + if not user_id or not author_id: - return {"error": "User ID and author ID are required"} + return {"error": "Author ID is required"} try: with local_session() as session: - shout = session.query(Shout).filter(Shout.id == shout_id).first() - if not shout: - return {"error": "Shout not found"} - was_published = shout.published_at is not None - draft = session.query(Draft).where(Draft.id == shout.draft).first() + # Загружаем черновик со всеми связями + draft = ( + session.query(Draft) + .options( + joinedload(Draft.topics), + joinedload(Draft.authors), + joinedload(Draft.publication) + ) + .filter(Draft.id == draft_id) + .first() + ) + if not draft: return {"error": "Draft not found"} - # Находим черновик если не передан - if not shout: - shout = create_shout_from_draft(session, draft, author_id) - else: + # Проверка валидности HTML в body + is_valid, error = validate_html_content(draft.body) + if not is_valid: + return {"error": f"Cannot publish draft: {error}"} + + # Проверяем, есть ли уже публикация для этого черновика + if draft.publication: + shout = draft.publication # Обновляем существующую публикацию - shout.draft = draft.id - shout.created_by = author_id - shout.title = draft.title - shout.subtitle = draft.subtitle - shout.body = draft.body - shout.cover = draft.cover - shout.cover_caption = draft.cover_caption - shout.lead = draft.lead - shout.layout = draft.layout - shout.media = draft.media - shout.lang = draft.lang - shout.seo = draft.seo + for field in ["body", "title", "subtitle", "lead", "cover", "cover_caption", "media", "lang", "seo"]: + if hasattr(draft, field): + setattr(shout, field, getattr(draft, field)) + shout.updated_at = int(time.time()) + shout.updated_by = author_id + else: + # Создаем новую публикацию + shout = create_shout_from_draft(session, draft, author_id) + now = int(time.time()) + shout.created_at = now + shout.published_at = now + session.add(shout) + session.flush() # Получаем ID нового шаута - draft.updated_at = now - shout.updated_at = now + # Очищаем существующие связи + session.query(ShoutAuthor).filter(ShoutAuthor.shout == shout.id).delete() + session.query(ShoutTopic).filter(ShoutTopic.shout == shout.id).delete() - # Устанавливаем published_at только если была ранее снята с публикации - if not was_published: - shout.published_at = now - - # Обрабатываем связи с авторами - if ( - not session.query(ShoutAuthor) - .filter(and_(ShoutAuthor.shout == shout.id, ShoutAuthor.author == author_id)) - .first() - ): - sa = ShoutAuthor(shout=shout.id, author=author_id) + # Добавляем авторов + for author in (draft.authors or []): + sa = ShoutAuthor(shout=shout.id, author=author.id) session.add(sa) - # Обрабатываем темы - if draft.topics: - for topic in draft.topics: - st = ShoutTopic( - topic=topic.id, shout=shout.id, main=topic.main if hasattr(topic, "main") else False - ) - session.add(st) - - session.add(shout) - session.add(draft) - session.flush() - - # Инвалидируем кэш только если это новая публикация или была снята с публикации - if not was_published: - cache_keys = ["feed", f"author_{author_id}", "random_top", "unrated"] - - # Добавляем ключи для тем - for topic in shout.topics: - cache_keys.append(f"topic_{topic.id}") - cache_keys.append(f"topic_shouts_{topic.id}") - await cache_by_id(Topic, topic.id, cache_topic) - - # Инвалидируем кэш - await invalidate_shouts_cache(cache_keys) - await invalidate_shout_related_cache(shout, author_id) - - # Обновляем кэш авторов - for author in shout.authors: - await cache_by_id(Author, author.id, cache_author) - - # Отправляем уведомление о публикации - await notify_shout(shout.dict(), "published") - - # Обновляем поисковый индекс - search_service.index(shout) - else: - # Для уже опубликованных материалов просто отправляем уведомление об обновлении - await notify_shout(shout.dict(), "update") + # Добавляем темы + for topic in (draft.topics or []): + st = ShoutTopic( + topic=topic.id, + shout=shout.id, + main=topic.main if hasattr(topic, "main") else False + ) + session.add(st) session.commit() + + # Инвалидируем кеш + invalidate_shouts_cache() + invalidate_shout_related_cache(shout.id) + + # Уведомляем о публикации + await notify_shout(shout.id) + + # Обновляем поисковый индекс + search_service.index_shout(shout) + + logger.info(f"Successfully published shout #{shout.id} from draft #{draft_id}") + logger.debug(f"Shout data: {shout.dict()}") + return {"shout": shout} except Exception as e: - logger.error(f"Failed to publish shout: {e}", exc_info=True) - if "session" in locals(): - session.rollback() - return {"error": f"Failed to publish shout: {str(e)}"} - - -@mutation.field("unpublish_shout") -@login_required -async def unpublish_shout(_, info, shout_id: int): - """Unpublish a shout. - - Args: - shout_id: The ID of the shout to unpublish - - Returns: - dict: The unpublished shout or an error message - """ - author_dict = info.context.get("author", {}) - author_id = author_dict.get("id") - if not author_id: - return {"error": "Author ID is required"} - - shout = None - with local_session() as session: - try: - shout = session.query(Shout).filter(Shout.id == shout_id).first() - shout.published_at = None - session.commit() - invalidate_shout_related_cache(shout) - invalidate_shouts_cache() - - except Exception: - session.rollback() - return {"error": "Failed to unpublish shout"} - - return {"shout": shout} + logger.error(f"Failed to publish draft {draft_id}: {e}", exc_info=True) + return {"error": f"Failed to publish draft: {str(e)}"} diff --git a/resolvers/editor.py b/resolvers/editor.py index 6d0b396f..0fd67c6e 100644 --- a/resolvers/editor.py +++ b/resolvers/editor.py @@ -3,7 +3,7 @@ import time import orjson import trafilatura from sqlalchemy import and_, desc, select -from sqlalchemy.orm import joinedload +from sqlalchemy.orm import joinedload, selectinload from sqlalchemy.sql.functions import coalesce from cache.cache import ( @@ -13,6 +13,7 @@ from cache.cache import ( invalidate_shouts_cache, ) from orm.author import Author +from orm.draft import Draft from orm.shout import Shout, ShoutAuthor, ShoutTopic from orm.topic import Topic from resolvers.follower import follow, unfollow @@ -20,8 +21,9 @@ from resolvers.stat import get_with_stat from services.auth import login_required from services.db import local_session from services.notify import notify_shout -from services.schema import query +from services.schema import mutation, query from services.search import search_service +from utils.html_wrapper import wrap_html_fragment from utils.logger import root_logger as logger @@ -179,9 +181,11 @@ async def create_shout(_, info, inp): # Создаем публикацию без topics body = inp.get("body", "") lead = inp.get("lead", "") - body_text = trafilatura.extract(body) - lead_text = trafilatura.extract(lead) - seo = inp.get("seo", lead_text or body_text[:300].split(". ")[:-1].join(". ")) + body_html = wrap_html_fragment(body) + lead_html = wrap_html_fragment(lead) + body_text = trafilatura.extract(body_html) + lead_text = trafilatura.extract(lead_html) + seo = inp.get("seo", lead_text.strip() or body_text.strip()[:300].split(". ")[:-1].join(". ")) new_shout = Shout( slug=slug, body=body, @@ -645,39 +649,178 @@ def get_main_topic(topics): """Get the main topic from a list of ShoutTopic objects.""" logger.info(f"Starting get_main_topic with {len(topics) if topics else 0} topics") logger.debug( - f"Topics data: {[(t.topic.slug if t.topic else 'no-topic', t.main) for t in topics] if topics else []}" + f"Topics data: {[(t.slug, getattr(t, 'main', False)) for t in topics] if topics else []}" ) if not topics: logger.warning("No topics provided to get_main_topic") return {"id": 0, "title": "no topic", "slug": "notopic", "is_main": True} - # Find first main topic in original order - main_topic_rel = next((st for st in topics if st.main), None) - logger.debug( - f"Found main topic relation: {main_topic_rel.topic.slug if main_topic_rel and main_topic_rel.topic else None}" - ) + # Проверяем, является ли topics списком объектов ShoutTopic или Topic + if hasattr(topics[0], 'topic') and topics[0].topic: + # Для ShoutTopic объектов (старый формат) + # Find first main topic in original order + main_topic_rel = next((st for st in topics if getattr(st, 'main', False)), None) + logger.debug( + f"Found main topic relation: {main_topic_rel.topic.slug if main_topic_rel and main_topic_rel.topic else None}" + ) - if main_topic_rel and main_topic_rel.topic: - result = { - "slug": main_topic_rel.topic.slug, - "title": main_topic_rel.topic.title, - "id": main_topic_rel.topic.id, - "is_main": True, - } - logger.info(f"Returning main topic: {result}") - return result + if main_topic_rel and main_topic_rel.topic: + result = { + "slug": main_topic_rel.topic.slug, + "title": main_topic_rel.topic.title, + "id": main_topic_rel.topic.id, + "is_main": True, + } + logger.info(f"Returning main topic: {result}") + return result - # If no main found but topics exist, return first - if topics and topics[0].topic: - logger.info(f"No main topic found, using first topic: {topics[0].topic.slug}") - result = { - "slug": topics[0].topic.slug, - "title": topics[0].topic.title, - "id": topics[0].topic.id, - "is_main": True, - } - return result + # If no main found but topics exist, return first + if topics and topics[0].topic: + logger.info(f"No main topic found, using first topic: {topics[0].topic.slug}") + result = { + "slug": topics[0].topic.slug, + "title": topics[0].topic.title, + "id": topics[0].topic.id, + "is_main": True, + } + return result + else: + # Для Topic объектов (новый формат из selectinload) + # После смены на selectinload у нас просто список Topic объектов + if topics: + logger.info(f"Using first topic as main: {topics[0].slug}") + result = { + "slug": topics[0].slug, + "title": topics[0].title, + "id": topics[0].id, + "is_main": True, + } + return result logger.warning("No valid topics found, returning default") return {"slug": "notopic", "title": "no topic", "id": 0, "is_main": True} + +@mutation.field("unpublish_shout") +@login_required +async def unpublish_shout(_, info, shout_id: int): + """Снимает публикацию (shout) с публикации. + + Предзагружает связанный черновик (draft) и его авторов/темы, чтобы избежать + ошибок при последующем доступе к ним в GraphQL. + + Args: + shout_id: ID публикации для снятия с публикации + + Returns: + dict: Снятая с публикации публикация или сообщение об ошибке + """ + author_dict = info.context.get("author", {}) + author_id = author_dict.get("id") + if not author_id: + # В идеале нужна проверка прав, имеет ли автор право снимать публикацию + return {"error": "Author ID is required"} + + shout = None + with local_session() as session: + try: + # Загружаем Shout со всеми связями для правильного формирования ответа + shout = ( + session.query(Shout) + .options( + joinedload(Shout.authors), + selectinload(Shout.topics) + ) + .filter(Shout.id == shout_id) + .first() + ) + + if not shout: + logger.warning(f"Shout not found for unpublish: ID {shout_id}") + return {"error": "Shout not found"} + + # Если у публикации есть связанный черновик, загружаем его с relationships + if shout.draft: + # Отдельно загружаем черновик с его связями + draft = ( + session.query(Draft) + .options( + selectinload(Draft.authors), + selectinload(Draft.topics) + ) + .filter(Draft.id == shout.draft) + .first() + ) + + # Связываем черновик с публикацией вручную для доступа через API + if draft: + shout.draft_obj = draft + + # TODO: Добавить проверку прав доступа, если необходимо + # if author_id not in [a.id for a in shout.authors]: # Требует selectinload(Shout.authors) выше + # logger.warning(f"Author {author_id} denied unpublishing shout {shout_id}") + # return {"error": "Access denied"} + + # Запоминаем старый slug и id для формирования поля publication + shout_slug = shout.slug + shout_id_for_publication = shout.id + + # Снимаем с публикации (устанавливаем published_at в None) + shout.published_at = None + session.commit() + + # Формируем полноценный словарь для ответа + shout_dict = shout.dict() + + # Добавляем связанные данные + shout_dict["topics"] = ( + [ + {"id": topic.id, "slug": topic.slug, "title": topic.title} + for topic in shout.topics + ] + if shout.topics + else [] + ) + + # Добавляем main_topic + shout_dict["main_topic"] = get_main_topic(shout.topics) + + # Добавляем авторов + shout_dict["authors"] = ( + [ + {"id": author.id, "name": author.name, "slug": author.slug} + for author in shout.authors + ] + if shout.authors + else [] + ) + + # Важно! Обновляем поле publication, отражая состояние "снят с публикации" + shout_dict["publication"] = { + "id": shout_id_for_publication, + "slug": shout_slug, + "published_at": None # Ключевое изменение - устанавливаем published_at в None + } + + # Инвалидация кэша + try: + cache_keys = [ + "feed", # лента + f"author_{author_id}", # публикации автора + "random_top", # случайные топовые + "unrated", # неоцененные + ] + await invalidate_shout_related_cache(shout, author_id) + await invalidate_shouts_cache(cache_keys) + logger.info(f"Cache invalidated after unpublishing shout {shout_id}") + except Exception as cache_err: + logger.error(f"Failed to invalidate cache for unpublish shout {shout_id}: {cache_err}") + + except Exception as e: + session.rollback() + logger.error(f"Failed to unpublish shout {shout_id}: {e}", exc_info=True) + return {"error": f"Failed to unpublish shout: {str(e)}"} + + # Возвращаем сформированный словарь вместо объекта + logger.info(f"Shout {shout_id} unpublished successfully by author {author_id}") + return {"shout": shout_dict} \ No newline at end of file diff --git a/resolvers/reaction.py b/resolvers/reaction.py index 4a3fe56a..b10de0bf 100644 --- a/resolvers/reaction.py +++ b/resolvers/reaction.py @@ -487,12 +487,16 @@ def apply_reaction_filters(by, q): shout_slug = by.get("shout") if shout_slug: q = q.filter(Shout.slug == shout_slug) + + shout_id = by.get("shout_id") + if shout_id: + q = q.filter(Shout.id == shout_id) shouts = by.get("shouts") if shouts: q = q.filter(Shout.slug.in_(shouts)) - created_by = by.get("created_by") + created_by = by.get("created_by", by.get("author_id")) if created_by: q = q.filter(Author.id == created_by) diff --git a/resolvers/topic.py b/resolvers/topic.py index 4ecf241b..000f6d07 100644 --- a/resolvers/topic.py +++ b/resolvers/topic.py @@ -10,6 +10,7 @@ from cache.cache import ( ) from orm.author import Author from orm.topic import Topic +from orm.reaction import ReactionKind from resolvers.stat import get_with_stat from services.auth import login_required from services.db import local_session @@ -112,7 +113,7 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None) shouts_stats_query = f""" SELECT st.topic, COUNT(DISTINCT s.id) as shouts_count FROM shout_topic st - JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL + JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL WHERE st.topic IN ({",".join(map(str, topic_ids))}) GROUP BY st.topic """ @@ -121,7 +122,7 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None) # Запрос на получение статистики по подписчикам для выбранных тем followers_stats_query = f""" SELECT topic, COUNT(DISTINCT follower) as followers_count - FROM topic_followers + FROM topic_followers tf WHERE topic IN ({",".join(map(str, topic_ids))}) GROUP BY topic """ @@ -143,7 +144,8 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None) SELECT st.topic, COUNT(DISTINCT r.id) as comments_count FROM shout_topic st JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL - JOIN reaction r ON r.shout = s.id + JOIN reaction r ON r.shout = s.id AND r.kind = '{ReactionKind.COMMENT.value}' AND r.deleted_at IS NULL + JOIN author a ON r.created_by = a.id AND a.deleted_at IS NULL WHERE st.topic IN ({",".join(map(str, topic_ids))}) GROUP BY st.topic """ diff --git a/schema/input.graphql b/schema/input.graphql index c1637723..fba7b144 100644 --- a/schema/input.graphql +++ b/schema/input.graphql @@ -92,12 +92,14 @@ input LoadShoutsOptions { input ReactionBy { shout: String + shout_id: Int shouts: [String] search: String kinds: [ReactionKind] reply_to: Int # filter topic: String created_by: Int + author_id: Int author: String after: Int sort: ReactionSort # sort diff --git a/schema/type.graphql b/schema/type.graphql index eb8e2770..87df242b 100644 --- a/schema/type.graphql +++ b/schema/type.graphql @@ -107,6 +107,12 @@ type Shout { score: Float } +type PublicationInfo { + id: Int! + slug: String! + published_at: Int +} + type Draft { id: Int! created_at: Int! @@ -129,9 +135,9 @@ type Draft { deleted_at: Int updated_by: Author deleted_by: Author - authors: [Author] - topics: [Topic] - + authors: [Author]! + topics: [Topic]! + publication: PublicationInfo } type Stat { diff --git a/services/notify.py b/services/notify.py index 911bd6ec..91896f68 100644 --- a/services/notify.py +++ b/services/notify.py @@ -53,3 +53,66 @@ async def notify_follower(follower: dict, author_id: int, action: str = "follow" except Exception as e: # Log the error and re-raise it logger.error(f"Failed to publish to channel {channel_name}: {e}") + + +async def notify_draft(draft_data, action: str = "publish"): + """ + Отправляет уведомление о публикации или обновлении черновика. + + Функция гарантирует, что данные черновика сериализуются корректно, включая + связанные атрибуты (topics, authors). + + Args: + draft_data (dict): Словарь с данными черновика. Должен содержать минимум id и title + action (str, optional): Действие ("publish", "update"). По умолчанию "publish" + + Returns: + None + + Examples: + >>> draft = {"id": 1, "title": "Тестовый черновик", "slug": "test-draft"} + >>> await notify_draft(draft, "publish") + """ + channel_name = "draft" + try: + # Убеждаемся, что все необходимые данные присутствуют + # и объект не требует доступа к отсоединенным атрибутам + if isinstance(draft_data, dict): + draft_payload = draft_data + else: + # Если это ORM объект, преобразуем его в словарь с нужными атрибутами + draft_payload = { + "id": getattr(draft_data, "id", None), + "slug": getattr(draft_data, "slug", None), + "title": getattr(draft_data, "title", None), + "subtitle": getattr(draft_data, "subtitle", None), + "media": getattr(draft_data, "media", None), + "created_at": getattr(draft_data, "created_at", None), + "updated_at": getattr(draft_data, "updated_at", None) + } + + # Если переданы связанные атрибуты, добавим их + if hasattr(draft_data, "topics") and draft_data.topics is not None: + draft_payload["topics"] = [ + {"id": t.id, "name": t.name, "slug": t.slug} + for t in draft_data.topics + ] + + if hasattr(draft_data, "authors") and draft_data.authors is not None: + draft_payload["authors"] = [ + {"id": a.id, "name": a.name, "slug": a.slug, "pic": getattr(a, "pic", None)} + for a in draft_data.authors + ] + + data = {"payload": draft_payload, "action": action} + + # Сохраняем уведомление + save_notification(action, channel_name, data.get("payload")) + + # Публикуем в Redis + json_data = orjson.dumps(data) + if json_data: + await redis.publish(channel_name, json_data) + + except Exception as e: + logger.error(f"Failed to publish to channel {channel_name}: {e}") diff --git a/services/schema.py b/services/schema.py index b8098575..8137bd64 100644 --- a/services/schema.py +++ b/services/schema.py @@ -1,14 +1,15 @@ from asyncio.log import logger import httpx -from ariadne import MutationType, QueryType +from ariadne import MutationType, ObjectType, QueryType from services.db import create_table_if_not_exists, local_session from settings import AUTH_URL query = QueryType() mutation = MutationType() -resolvers = [query, mutation] +type_draft = ObjectType("Draft") +resolvers = [query, mutation, type_draft] async def request_graphql_data(gql, url=AUTH_URL, headers=None): diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 00000000..0519ecba --- /dev/null +++ b/utils/__init__.py @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/utils/html_wrapper.py b/utils/html_wrapper.py new file mode 100644 index 00000000..fb9e4ba4 --- /dev/null +++ b/utils/html_wrapper.py @@ -0,0 +1,38 @@ +""" +Модуль для обработки HTML-фрагментов +""" + +def wrap_html_fragment(fragment: str) -> str: + """ + Оборачивает HTML-фрагмент в полную HTML-структуру для корректной обработки. + + Args: + fragment: HTML-фрагмент для обработки + + Returns: + str: Полный HTML-документ + + Example: + >>> wrap_html_fragment("Текст параграфа
") + 'Текст параграфа
' + """ + if not fragment or not fragment.strip(): + return fragment + + # Проверяем, является ли контент полным HTML-документом + is_full_html = fragment.strip().startswith(' + + + +