isolated

resolvers/load.py

@@ -0,0 +1,133 @@
+import json
+
+from services.db import local_session
+from services.redis import redis
+from resolvers import query
+from orm.author import Author
+from services.auth import login_required
+from .chats import create_chat
+from .unread import get_unread_counter
+
+
+# NOTE: not an API handler
+async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
+    """load :limit messages for :chat_id with :offset"""
+    messages = []
+    try:
+        message_ids = [] + ids
+        if limit:
+            mids = await redis.lrange(
+                f"chats/{chat_id}/message_ids", offset, offset + limit
+            )
+            mids = [mid.decode("utf-8") for mid in mids]
+            message_ids += mids
+        if message_ids:
+            message_keys = [f"chats/{chat_id}/messages/{mid}" for mid in message_ids]
+            messages = await redis.mget(*message_keys)
+            messages = [json.loads(msg.decode("utf-8")) for msg in messages]
+            replies = []
+            for m in messages:
+                rt = m.get("replyTo")
+                if rt:
+                    rt = int(rt)
+                    if rt not in message_ids:
+                        replies.append(rt)
+            if replies:
+                messages += await load_messages(redis, chat_id, limit=0, ids=replies)
+    except Exception as e:
+        print(e)
+    return messages
+
+
+@query.field("loadChats")
+@login_required
+async def load_chats(_, info, limit: int = 50, offset: int = 0):
+    """load :limit chats of current user with :offset"""
+    author_id = info.context["author_id"]
+    cids = list(
+        (await redis.execute("SMEMBERS", f"chats_by_author/{author_id}")) or []
+    )[offset : offset + limit]
+    members_online = (await redis.execute("SMEMBERS", "authors-online")) or []
+    chats = []
+    if len(cids) == 0:
+        r = await create_chat(None, info, members=[1, int(author_id)])
+        cids.append(r["chat"]["id"])
+    with local_session() as session:
+        for cid in cids:
+            cid = cid.decode("utf-8")
+            c = await redis.execute("GET", "chats/" + cid)
+            if c:
+                c = dict(json.loads(c))
+                c["messages"] = await load_messages(cid, 5, 0)
+                c["unread"] = await get_unread_counter(cid, author_id)
+                member_ids = c["members"].copy()
+                c["members"] = []
+                for member_id in member_ids:
+                    a = session.query(Author).where(Author.id == member_id).first()
+                    if a:
+                        c["members"].append(
+                            {
+                                "id": a.id,
+                                "slug": a.slug,
+                                "userpic": a.userpic,
+                                "name": a.name,
+                                "lastSeen": a.lastSeen,
+                                "online": a.id in members_online,
+                            }
+                        )
+                chats.append(c)
+    return {"chats": chats, "error": None}
+
+
+@query.field("loadMessagesBy")
+@login_required
+async def load_messages_by(_, info, by, limit: int = 10, offset: int = 0):
+    """load :limit messages of :chat_id with :offset"""
+    author_id = info.context["author_id"]
+    user_chats = await redis.execute("SMEMBERS", "chats_by_author/" + str(author_id))
+    user_chats = [c.decode("utf-8") for c in user_chats]
+    if user_chats:
+        messages = []
+        by_chat = by.get("chat")
+        if by_chat in user_chats:
+            chat = await redis.execute("GET", f"chats/{by_chat}")
+            if not chat:
+                return {"messages": [], "error": "chat not exist"}
+            # everyone's messages in filtered chat
+            messages = await load_messages(by_chat, limit, offset)
+        return {
+            "messages": sorted(list(messages), key=lambda m: m["createdAt"]),
+            "error": None,
+        }
+    else:
+        return {"error": "Cannot access messages of this chat"}
+
+
+@query.field("loadRecipients")
+async def load_recipients(_, _info, limit=50, offset=0):
+    """load possible chat participants"""
+    onliners = (await redis.execute("SMEMBERS", "authors-online")) or []
+    members = []
+    with local_session() as session:
+        all_authors = session.query(Author).limit(limit).offset(offset)
+        for a in all_authors:
+            members.append(
+                {
+                    "id": a.id,
+                    "slug": a.slug,
+                    "userpic": a.userpic,
+                    "name": a.name,
+                    "lastSeen": a.lastSeen,
+                    "online": a.id in onliners,
+                }
+            )
+    return {"members": members, "error": None}
+
+
+load_resolvers = {
+    "Query": {
+        "loadRecipients": load_recipients,
+        "loadMessagesBy": load_messages_by,
+        "loadChats": load_chats,
+    }
+}