inbox/resolvers/chats.py

import json
import uuid
from datetime import datetime, timezone

from services.auth import login_required
from services.redis import redis
from services.schema import mutation


@mutation.field("updateChat")
@login_required
async def update_chat(_, info, chat_new):
    """
    updating chat
    requires info["request"].user.slug to be in chat["admins"]

    :param info: GraphQLInfo with request
    :param chat_new: dict with chat data
    :return: Result { error chat }
    """
    author_id = info.context["author_id"]
    chat_id = chat_new["id"]
    chat = await redis.execute("GET", f"chats/{chat_id}")
    if not chat:
        return {"error": "chat not exist"}
    chat = dict(json.loads(chat))

    if author_id in chat["admins"]:
        chat.update(
            {
                "title": chat_new.get("title", chat["title"]),
                "description": chat_new.get("description", chat["description"]),
                "updatedAt": int(datetime.now(tz=timezone.utc).timestamp()),
                "admins": chat_new.get("admins", chat.get("admins") or []),
                "users": chat_new.get("users", chat["users"]),
            }
        )
    await redis.execute("SET", f"chats/{chat['id']}", json.dumps(chat))
    await redis.execute("COMMIT")

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


@mutation.field("createChat")
@login_required
async def create_chat(_, info, title="", members=None):
    if members is None:
        members = []
    chat = None
    author_id = info.context["author_id"]
    print("create_chat members: %r" % members)
    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 = set(
            (await redis.execute("SMEMBERS", f"chats_by_author/{members[0]}")) or []
        )
        chatset2 = set(
            (await redis.execute("SMEMBERS", f"chats_by_author/{members[1]}")) or []
        )
        for c in chatset1.intersection(chatset2):
            chat = await redis.execute("GET", f"chats/{c.decode('utf-8')}")
            if chat:
                chat = json.loads(chat)
                if chat["title"] == "":
                    print("[inbox] createChat found old chat")
                    print(chat)
                    break
        if chat:
            return {"chat": chat, "error": "existed"}

    chat_id = str(uuid.uuid4())
    chat = {
        "id": chat_id,
        "members": members,
        "title": title,
        "createdBy": author_id,
        "createdAt": int(datetime.now(tz=timezone.utc).timestamp()),
        "updatedAt": int(datetime.now(tz=timezone.utc).timestamp()),
        "admins": members if (len(members) == 2 and title == "") else [],
    }

    for m in members:
        await redis.execute("SADD", f"chats_by_author/{m}", chat_id)
    await redis.execute("SET", f"chats/{chat_id}", json.dumps(chat))
    await redis.execute("SET", f"chats/{chat_id}/next_message_id", str(0))
    await redis.execute("COMMIT")
    return {"error": None, "chat": chat}


@mutation.field("deleteChat")
@login_required
async def delete_chat(_, info, chat_id: str):
    author_id = info.context["author_id"]

    chat = await redis.execute("GET", f"/chats/{chat_id}")
    if chat:
        chat = dict(json.loads(chat))
        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)
            await redis.execute("COMMIT")
    else:
        return {"error": "chat not exist"}


chats_resolvers = {
    "Mutation": {
        "deleteChat": delete_chat,
        "createChat": create_chat,
        "updateChat": update_chat,
    },
}