load-by pattern, shoutscache removed

resolvers/inbox/chats.py

@@ -4,8 +4,7 @@ from datetime import datetime
 
 from auth.authenticate import login_required
 from base.redis import redis
-from base.resolvers import mutation, query
-from resolvers.inbox.load import load_messages, load_user_chats
+from base.resolvers import mutation
 
 
 async def add_user_to_chat(user_slug: str, chat_id: str, chat=None):
@@ -20,40 +19,6 @@ async def add_user_to_chat(user_slug: str, chat_id: str, chat=None):
         await redis.execute("SET", f"chats_by_user/{member}", json.dumps(chats_ids))
 
 
-@query.field("loadChats")
-@login_required
-async def load_chats(_, info):
-    user = info.context["request"].user
-    return await load_user_chats(user.slug)
-
-
-@mutation.field("enterChat")
-@login_required
-async def enter_chat(_, info, chat_id: str):
-    ''' enter to public chat with :chat_id '''
-    user = info.context["request"].user
-    chat = await redis.execute("GET", f"chats/{chat_id}")
-    if not chat:
-        return {
-            "error": "chat not exist"
-        }
-    else:
-        chat = dict(json.loads(chat))
-        if chat['private']:
-            return {
-                "error": "cannot enter private chat"
-            }
-        if user.slug not in chat["users"]:
-            chat["users"].append(user.slug)
-            await add_user_to_chat(user.slug, chat_id, chat)
-            await redis.execute("SET" f"chats/{chat_id}", json.dumps(chat))
-        chat['messages'] = await load_messages(chat_id)
-        return {
-            "chat": chat,
-            "error": None
-        }
-
-
 @mutation.field("inviteChat")
 async def invite_to_chat(_, info, invited: str, chat_id: str):
     ''' invite user with :slug to chat with :chat_id '''

resolvers/inbox/load.py

@@ -1,6 +1,8 @@
 import json
-
+from datetime import datetime, timedelta
 from base.redis import redis
+from base.resolvers import query
+from auth.authenticate import login_required
 
 
 async def get_unread_counter(chat_id: str, user_slug: str):
@@ -24,23 +26,6 @@ async def get_total_unread_counter(user_slug: str):
     return unread
 
 
-async def load_user_chats(slug, offset: int, amount: int):
-    """ load :amount chats of :slug user with :offset """
-
-    chats = await redis.execute("GET", f"chats_by_user/{slug}")
-    if chats:
-        chats = list(json.loads(chats))[offset:offset + amount]
-    if not chats:
-        chats = []
-    for c in chats:
-        c['messages'] = await load_messages(c['id'])
-        c['unread'] = await get_unread_counter(c['id'], slug)
-    return {
-        "chats": chats,
-        "error": None
-    }
-
-
 async def load_messages(chatId: str, offset: int, amount: int):
     ''' load :amount messages for :chatId with :offset '''
     messages = []
@@ -57,3 +42,61 @@ async def load_messages(chatId: str, offset: int, amount: int):
         "messages": messages,
         "error": None
     }
+
+
+@query.field("loadChats")
+@login_required
+async def load_chats(_, info, offset: int, amount: int):
+    """ load :amount chats of current user with :offset """
+    user = info.context["request"].user
+    chats = await redis.execute("GET", f"chats_by_user/{user.slug}")
+    if chats:
+        chats = list(json.loads(chats))[offset:offset + amount]
+    if not chats:
+        chats = []
+    for c in chats:
+        c['messages'] = await load_messages(c['id'])
+        c['unread'] = await get_unread_counter(c['id'], user.slug)
+    return {
+        "chats": chats,
+        "error": None
+    }
+
+
+@query.field("loadMessagesBy")
+@login_required
+async def load_messages_by(_, info, by, offset: int = 0, amount: int = 50):
+    ''' load :amount messages of :chat_id with :offset '''
+    user = info.context["request"].user
+    my_chats = await redis.execute("GET", f"chats_by_user/{user.slug}")
+    chat_id = by.get('chat')
+    if chat_id:
+        chat = await redis.execute("GET", f"chats/{chat_id}")
+        if not chat:
+            return {
+                "error": "chat not exist"
+            }
+        messages = await load_messages(chat_id, offset, amount)
+    user_id = by.get('author')
+    if user_id:
+        chats = await redis.execute("GET", f"chats_by_user/{user_id}")
+        our_chats = list(set(chats) & set(my_chats))
+        for c in our_chats:
+            messages += await load_messages(c, offset, amount)
+    body_like = by.get('body')
+    if body_like:
+        for c in my_chats:
+            mmm = await load_messages(c, offset, amount)
+            for m in mmm:
+                if body_like in m["body"]:
+                    messages.append(m)
+    days = by.get("days")
+    if days:
+        messages = filter(
+            lambda m: datetime.now() - int(m["createdAt"]) < timedelta(days=by.get("days")),
+            messages
+        )
+    return {
+        "messages": messages,
+        "error": None
+    }

resolvers/inbox/messages.py

@@ -4,25 +4,8 @@ from datetime import datetime
 
 from auth.authenticate import login_required
 from base.redis import redis
-from base.resolvers import mutation, query, subscription
+from base.resolvers import mutation, subscription
 from services.inbox import ChatFollowing, MessageResult, MessagesStorage
-from resolvers.inbox.load import load_messages
-
-
-@query.field("loadMessages")
-@login_required
-async def load_chat_messages(_, info, chat_id: str, offset: int = 0, amount: int = 50):
-    ''' load [amount] chat's messages with [offset] '''
-    chat = await redis.execute("GET", f"chats/{chat_id}")
-    if not chat:
-        return {
-            "error": "chat not exist"
-        }
-    messages = await load_messages(chat_id, offset, amount)
-    return {
-        "messages": messages,
-        "error": None
-    }
 
 
 @mutation.field("createMessage")

resolvers/inbox/search.py

@@ -41,39 +41,3 @@ async def search_users(_, info, query: str, offset: int = 0, amount: int = 50):
         "slugs": list(result),
         "error": None
     }
-
-
-@query.field("searchChats")
-@login_required
-async def search_chats(_, info, query: str, offset: int = 0, amount: int = 50):
-    user = info.context["request"].user
-    my_chats = await redis.execute("GET", f"/chats_by_user/{user.slug}")
-    chats = []
-    for chat_id in my_chats:
-        chat = await redis.execute("GET", f"chats/{chat_id}")
-        if chat:
-            chat = dict(json.loads(chat))
-            chats.append(chat)
-    return {
-        "chats": chats,
-        "error": None
-    }
-
-
-@query.field("searchMessages")
-@login_required
-async def search_messages(_, info, query: str, offset: int = 0, amount: int = 50):
-    user = info.context["request"].user
-    my_chats = await redis.execute("GET", f"/chats_by_user/{user.slug}")
-    chats = []
-    if my_chats:
-        my_chats = list(json.loads(my_chats))
-        for chat_id in my_chats:
-            chat = await redis.execute("GET", f"chats/{chat_id}")
-            if chat:
-                chat = dict(json.loads(chat))
-                chats.append(chat)
-    return {
-        "chats": chats,
-        "error": None
-    }