inbox/resolvers/chats.py

import json
import logging
import time
import uuid

from models.chat import Chat, ChatUpdate
from services.auth import login_required
from services.presence import notify_chat
from services.rediscache import redis
from services.schema import mutation

logger = logging.getLogger("[resolvers.chats] ")
logger.setLevel(logging.DEBUG)


@mutation.field("update_chat")
@login_required
async def update_chat(_, info, chat_new: ChatUpdate):
    """
    updating chat
    requires info.context["author_id"] to be in chat["admins"]
    :param _: not used
    :param info: GraphQLInfo with request
    :param chat_new: dict with chat data
    :return: Result { error chat }
    """
    logger.info("update_chat")
    author_id = info.context["author_id"]
    chat_id = chat_new["id"]
    chat_str = await redis.execute("GET", f"chats/{chat_id}")
    if not chat_str:
        return {"error": "chat not exist"}
    elif isinstance(chat_str, str):
        chat: Chat = json.loads(chat_str)
        if author_id in chat["admins"]:
            chat.update(
                {
                    "title": chat_new.get("title", chat["title"]),
                    "description": chat_new.get("description", chat["description"]),
                    "updated_at": int(time.time()),
                    "admins": chat_new.get("admins", chat.get("admins") or []),
                    "members": chat_new.get("members", chat["members"]),
                }
            )

            await redis.execute("SET", f"chats/{chat['id']}", json.dumps(chat))
            for member_id in chat["members"]:
                await notify_chat(chat, member_id, "update")

        return {"error": None, "chat": chat}


@mutation.field("create_chat")
@login_required
async def create_chat(_, info, title="", members=None):
    logger.info("create_chat")
    members = members or []
    author_id = info.context["author_id"]
    chat: Chat
    if author_id:
        if author_id not in members:
            members.append(int(author_id))

        # NOTE: private chats has no title
        # reuse private chat created before if exists
        if len(members) == 2 and title == "":
            chatset1 = await redis.execute("SMEMBERS", f"chats_by_author/{members[0]}")
            chatset2 = await redis.execute("SMEMBERS", f"chats_by_author/{members[1]}")
            if isinstance(chatset1, set) and isinstance(chatset2, set):
                for c in chatset1.intersection(chatset2):
                    chat_result = await redis.execute("GET", f"chats/{c}")
                    if chat_result:
                        chat = json.loads(chat_result)
                        if chat["title"] == "":
                            logger.info("[inbox] createChat found old chat")
                            return {"chat": chat, "error": "existed"}

        chat_id = str(uuid.uuid4())
        chat: Chat = {
            "id": chat_id,
            "members": members,
            "title": title,
            "description": "",
            "created_by": author_id,
            "created_at": int(time.time()),
            "updated_at": int(time.time()),
            "admins": members if (len(members) == 2 and title == "") else [],
        }

        for member_id in members:
            await redis.execute("SADD", f"chats_by_author/{member_id}", chat_id)
            await notify_chat(chat, member_id, "create")

        print(f"\n\n[resolvers.chats] creating: {chat}\n\n")

        await redis.execute("SET", f"chats/{chat_id}", json.dumps(chat))
        await redis.execute("SET", f"chats/{chat_id}/next_message_id", str(0))

        return {"error": None, "chat": chat}
    return {"error": "no chat was created"}


@mutation.field("delete_chat")
@login_required
async def delete_chat(_, info, chat_id: str):
    logger.info("delete_chat")
    author_id = info.context["author_id"]
    chat_str = await redis.execute("GET", f"chats/{chat_id}")
    if isinstance(chat_str, str):
        chat: Chat = json.loads(chat_str)
        if author_id in chat["admins"]:
            await redis.execute("DEL", f"chats/{chat_id}")
            await redis.execute("SREM", f"chats_by_author/{author_id}", chat_id)
            for member_id in chat["members"]:
                await notify_chat(chat, member_id, "delete")
    return {"error": "chat not exist"}