notifier/resolvers/load.py

import json
import logging
import time
from typing import Dict, List

import strawberry
from sqlalchemy import and_, select
from sqlalchemy.orm import aliased
from sqlalchemy.sql import not_

from orm.notification import (
    Notification,
    NotificationAction,
    NotificationEntity,
    NotificationSeen,
)
from resolvers.model import (
    NotificationAuthor,
    NotificationGroup,
    NotificationReaction,
    NotificationShout,
    NotificationsResult,
)
from services.db import local_session


logger = logging.getLogger('[resolvers.schema] ')
logger.setLevel(logging.DEBUG)


async def get_notifications_grouped(  # noqa: C901
    author_id: int, after: int = 0, limit: int = 10, offset: int = 0
):
    """
    Retrieves notifications for a given author.

    Args:
        author_id (int): The ID of the author for whom notifications are retrieved.
        after (int, optional): If provided, selects only notifications created after this timestamp will be considered.
        limit (int, optional): The maximum number of groupa to retrieve.
        offset (int, optional): Offset for pagination

    Returns:
        Dict[str, NotificationGroup], int, int: A dictionary where keys are thread IDs and values are NotificationGroup objects, unread and total amounts.

    This function queries the database to retrieve notifications for the specified author, considering optional filters.
    The result is a dictionary where each key is a thread ID, and the corresponding value is a NotificationGroup
    containing information about the notifications within that thread.

    NotificationGroup structure:
    {
        entity: str,        # Type of entity (e.g., 'reaction', 'shout', 'follower').
        updated_at: int,    # Timestamp of the latest update in the thread.
        shout: Optional[NotificationShout]
        reactions: List[int],  # List of reaction ids within the thread.
        authors: List[NotificationAuthor],  # List of authors involved in the thread.
    }
    """
    seen_alias = aliased(NotificationSeen)
    query = select(Notification, seen_alias.viewer.label('seen')).outerjoin(
        NotificationSeen,
        and_(
            NotificationSeen.viewer == author_id,
            NotificationSeen.notification == Notification.id,
        ),
    )
    if after:
        query = query.filter(Notification.created_at > after)
    query = query.group_by(NotificationSeen.notification, Notification.created_at)

    groups_amount = 0
    unread = 0
    total = 0
    notifications_by_thread: Dict[str, List[Notification]] = {}
    groups_by_thread: Dict[str, NotificationGroup] = {}
    with local_session() as session:
        total = (
            session.query(Notification)
            .filter(
                and_(
                    Notification.action == NotificationAction.CREATE.value,
                    Notification.created_at > after,
                )
            )
            .count()
        )
        unread = (
            session.query(Notification)
            .filter(
                and_(
                    Notification.action == NotificationAction.CREATE.value,
                    Notification.created_at > after,
                    not_(Notification.seen),
                )
            )
            .count()
        )
        notifications_result = session.execute(query)
        for n, _seen in notifications_result:
            thread_id = ''
            payload = json.loads(n.payload)
            logger.debug(f'[resolvers.schema] {n.action} {n.entity}: {payload}')
            if n.entity == 'shout' and n.action == 'create':
                shout: NotificationShout = payload
                thread_id += f'{shout.id}'
                logger.debug(f'create shout: {shout}')
                group = groups_by_thread.get(thread_id) or NotificationGroup(
                    id=thread_id,
                    entity=n.entity,
                    shout=shout,
                    authors=shout.authors,
                    updated_at=shout.created_at,
                    reactions=[],
                    action='create',
                    seen=author_id in n.seen,
                )
                # store group in result
                groups_by_thread[thread_id] = group
                notifications = notifications_by_thread.get(thread_id, [])
                if n not in notifications:
                    notifications.append(n)
                notifications_by_thread[thread_id] = notifications
                groups_amount += 1
            elif n.entity == NotificationEntity.REACTION.value and n.action == NotificationAction.CREATE.value:
                reaction: NotificationReaction = payload
                shout: NotificationShout = reaction.shout
                thread_id += f'{reaction.shout}'
                if not bool(reaction.reply_to) and (reaction.kind == 'LIKE' or reaction.kind == 'DISLIKE'):
                    # TODO: making published reaction vote announce
                    pass
                elif reaction.kind == 'COMMENT':
                    if reaction.reply_to:
                        thread_id += f"{'::' + str(reaction.reply_to)}"
                    group: NotificationGroup | None = groups_by_thread.get(thread_id)
                    notifications: List[Notification] = notifications_by_thread.get(thread_id, [])
                    if group and notifications:
                        group.seen = False  # any not seen notification make it false
                        group.shout = shout
                        group.authors.append(reaction.created_by)
                        if not group.reactions:
                            group.reactions = []
                        group.reactions.append(reaction.id)
                        # store group in result
                        groups_by_thread[thread_id] = group
                        notifications = notifications_by_thread.get(thread_id, [])
                        if n not in notifications:
                            notifications.append(n)
                        notifications_by_thread[thread_id] = notifications
                        groups_amount += 1
                    else:
                        groups_amount += 1
                        if groups_amount > limit:
                            break
                        else:
                            # init notification group
                            reactions = [
                                reaction.id,
                            ]
                            group = NotificationGroup(
                                id=thread_id,
                                action=n.action,
                                entity=n.entity,
                                updated_at=reaction.created_at,
                                reactions=reactions,
                                shout=shout,
                                authors=[
                                    reaction.created_by,
                                ],
                                seen=author_id in n.seen,
                            )
                            # store group in result
                            groups_by_thread[thread_id] = group
                            notifications = notifications_by_thread.get(thread_id, [])
                            if n not in notifications:
                                notifications.append(n)
                            notifications_by_thread[thread_id] = notifications

            elif n.entity == 'follower':
                thread_id = 'followers'
                follower: NotificationAuthor = payload
                group = groups_by_thread.get(thread_id) or NotificationGroup(
                    id=thread_id,
                    authors=[follower],
                    updated_at=int(time.time()),
                    shout=None,
                    reactions=[],
                    entity='follower',
                    action='follow',
                    seen=author_id in n.seen,
                )
                group.authors = [
                    follower,
                ]
                group.updated_at = int(time.time())
                # store group in result
                groups_by_thread[thread_id] = group
                notifications = notifications_by_thread.get(thread_id, [])
                if n not in notifications:
                    notifications.append(n)
                notifications_by_thread[thread_id] = notifications
                groups_amount += 1

            if groups_amount > limit:
                break

    return groups_by_thread, notifications_by_thread, unread, total


@strawberry.type
class Query:
    @strawberry.field
    async def load_notifications(self, info, after: int, limit: int = 50, offset: int = 0) -> NotificationsResult:
        author_id = info.context.get('author_id')
        groups: Dict[str, NotificationGroup] = {}
        if author_id:
            groups, notifications, total, unread = await get_notifications_grouped(author_id, after, limit, offset)
        notifications = sorted(groups.values(), key=lambda group: group.updated_at, reverse=True)
        return NotificationsResult(notifications=notifications, total=0, unread=0, error=None)