restructured,inbox-removed

resolvers/__init__.py

@@ -8,62 +8,36 @@ from resolvers.auth import (
     get_current_user,
 )
 
-from resolvers.create.migrate import markdown_body
-from resolvers.create.editor import create_shout, delete_shout, update_shout
-
-from resolvers.zine.profile import (
+from resolvers.migrate import markdown_body
+from resolvers.editor import create_shout, delete_shout, update_shout
+from resolvers.profile import (
     load_authors_by,
     rate_user,
     update_profile,
-    get_authors_all
+    get_authors_all,
 )
 
-from resolvers.zine.reactions import (
+from resolvers.topics import (
+    topics_all,
+    topics_by_community,
+    topics_by_author,
+    topic_follow,
+    topic_unfollow,
+    get_topic,
+)
+
+from resolvers.reactions import (
     create_reaction,
     delete_reaction,
     update_reaction,
     reactions_unfollow,
     reactions_follow,
-    load_reactions_by
-)
-from resolvers.zine.topics import (
-    topic_follow,
-    topic_unfollow,
-    topics_by_author,
-    topics_by_community,
-    topics_all,
-    get_topic
+    load_reactions_by,
 )
 
-from resolvers.zine.following import (
-    follow,
-    unfollow
-)
+from resolvers.following import follow, unfollow
 
-from resolvers.zine.load import (
-    load_shout,
-    load_shouts_by
-)
-
-from resolvers.inbox.chats import (
-    create_chat,
-    delete_chat,
-    update_chat
-
-)
-from resolvers.inbox.messages import (
-    create_message,
-    delete_message,
-    update_message,
-    message_generator,
-    mark_as_read
-)
-from resolvers.inbox.load import (
-    load_chats,
-    load_messages_by,
-    load_recipients
-)
-from resolvers.inbox.search import search_recipients
+from resolvers.load import load_shout, load_shouts_by
 
 __all__ = [
     # auth
@@ -74,12 +48,12 @@ __all__ = [
     "auth_send_link",
     "sign_out",
     "get_current_user",
-    # zine.profile
+    # profile
     "load_authors_by",
     "rate_user",
     "update_profile",
     "get_authors_all",
-    # zine.load
+    # load
     "load_shout",
     "load_shouts_by",
     # zine.following
@@ -90,7 +64,7 @@ __all__ = [
     "update_shout",
     "delete_shout",
     "markdown_body",
-    # zine.topics
+    # topics
     "topics_all",
     "topics_by_community",
     "topics_by_author",
@@ -104,17 +78,4 @@ __all__ = [
     "update_reaction",
     "delete_reaction",
     "load_reactions_by",
-    # inbox
-    "load_chats",
-    "load_messages_by",
-    "create_chat",
-    "delete_chat",
-    "update_chat",
-    "create_message",
-    "delete_message",
-    "update_message",
-    "message_generator",
-    "mark_as_read",
-    "load_recipients",
-    "search_recipients"
 ]

resolvers/auth.py

@@ -13,10 +13,15 @@ from auth.email import send_auth_email
 from auth.identity import Identity, Password
 from auth.jwtcodec import JWTCodec
 from auth.tokenstorage import TokenStorage
-from base.exceptions import (BaseHttpException, InvalidPassword, InvalidToken,
-                             ObjectNotExist, Unauthorized)
-from base.orm import local_session
-from base.resolvers import mutation, query
+from services.exceptions import (
+    BaseHttpException,
+    InvalidPassword,
+    InvalidToken,
+    ObjectNotExist,
+    Unauthorized,
+)
+from services.db import local_session
+from services.schema import mutation, query
 from orm import Role, User
 from resolvers.zine.profile import user_subscriptions
 from settings import SESSION_TOKEN_HEADER, FRONTEND_URL
@@ -44,7 +49,7 @@ async def get_current_user(_, info):
 async def confirm_email(_, info, token):
     """confirm owning email address"""
     try:
-        print('[resolvers.auth] confirm email by token')
+        print("[resolvers.auth] confirm email by token")
         payload = JWTCodec.decode(token)
         user_id = payload.user_id
         await TokenStorage.get(f"{user_id}-{payload.username}-{token}")
@@ -58,7 +63,7 @@ async def confirm_email(_, info, token):
             return {
                 "token": session_token,
                 "user": user,
-                "news": await user_subscriptions(user.id)
+                "news": await user_subscriptions(user.id),
             }
     except InvalidToken as e:
         raise InvalidToken(e.message)
@@ -71,9 +76,9 @@ async def confirm_email_handler(request):
     token = request.path_params["token"]  # one time
     request.session["token"] = token
     res = await confirm_email(None, {}, token)
-    print('[resolvers.auth] confirm_email request: %r' % request)
+    print("[resolvers.auth] confirm_email request: %r" % request)
     if "error" in res:
-        raise BaseHttpException(res['error'])
+        raise BaseHttpException(res["error"])
     else:
         response = RedirectResponse(url=FRONTEND_URL)
         response.set_cookie("token", res["token"])  # session token
@@ -90,22 +95,22 @@ def create_user(user_dict):
 
 
 def generate_unique_slug(src):
-    print('[resolvers.auth] generating slug from: ' + src)
+    print("[resolvers.auth] generating slug from: " + src)
     slug = translit(src, "ru", reversed=True).replace(".", "-").lower()
-    slug = re.sub('[^0-9a-zA-Z]+', '-', slug)
+    slug = re.sub("[^0-9a-zA-Z]+", "-", slug)
     if slug != src:
-        print('[resolvers.auth] translited name: ' + slug)
+        print("[resolvers.auth] translited name: " + slug)
     c = 1
     with local_session() as session:
         user = session.query(User).where(User.slug == slug).first()
         while user:
             user = session.query(User).where(User.slug == slug).first()
-            slug = slug + '-' + str(c)
+            slug = slug + "-" + str(c)
             c += 1
         if not user:
             unique_slug = slug
-            print('[resolvers.auth] ' + unique_slug)
-            return quote_plus(unique_slug.replace('\'', '')).replace('+', '-')
+            print("[resolvers.auth] " + unique_slug)
+            return quote_plus(unique_slug.replace("'", "")).replace("+", "-")
 
 
 @mutation.field("registerUser")
@@ -120,12 +125,12 @@ async def register_by_email(_, _info, email: str, password: str = "", name: str
         slug = generate_unique_slug(name)
         user = session.query(User).where(User.slug == slug).first()
         if user:
-            slug = generate_unique_slug(email.split('@')[0])
+            slug = generate_unique_slug(email.split("@")[0])
         user_dict = {
             "email": email,
             "username": email,  # will be used to store phone number or some messenger network id
             "name": name,
-            "slug": slug
+            "slug": slug,
         }
         if password:
             user_dict["password"] = Password.encode(password)
@@ -182,7 +187,9 @@ async def login(_, info, email: str, password: str = "", lang: str = "ru"):
                     }
                 except InvalidPassword:
                     print(f"[auth] {email}: invalid password")
-                    raise InvalidPassword("invalid password")  # contains webserver status
+                    raise InvalidPassword(
+                        "invalid password"
+                    )  # contains webserver status
                     # return {"error": "invalid password"}
 
 

resolvers/editor.py

@@ -5,8 +5,8 @@ from sqlalchemy.orm import joinedload
 
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
-from base.orm import local_session
-from base.resolvers import mutation
+from services.db import local_session
+from services.schema import mutation
 from orm.shout import Shout, ShoutAuthor, ShoutTopic
 from orm.topic import Topic
 from resolvers.zine.reactions import reactions_follow, reactions_unfollow
@@ -18,21 +18,25 @@ async def create_shout(_, info, inp):
     auth: AuthCredentials = info.context["request"].auth
 
     with local_session() as session:
-        topics = session.query(Topic).filter(Topic.slug.in_(inp.get('topics', []))).all()
+        topics = (
+            session.query(Topic).filter(Topic.slug.in_(inp.get("topics", []))).all()
+        )
 
-        new_shout = Shout.create(**{
-            "title": inp.get("title"),
-            "subtitle": inp.get('subtitle'),
-            "lead": inp.get('lead'),
-            "description": inp.get('description'),
-            "body": inp.get("body", ''),
-            "layout": inp.get("layout"),
-            "authors": inp.get("authors", []),
-            "slug": inp.get("slug"),
-            "mainTopic": inp.get("mainTopic"),
-            "visibility": "owner",
-            "createdBy": auth.user_id
-        })
+        new_shout = Shout.create(
+            **{
+                "title": inp.get("title"),
+                "subtitle": inp.get("subtitle"),
+                "lead": inp.get("lead"),
+                "description": inp.get("description"),
+                "body": inp.get("body", ""),
+                "layout": inp.get("layout"),
+                "authors": inp.get("authors", []),
+                "slug": inp.get("slug"),
+                "mainTopic": inp.get("mainTopic"),
+                "visibility": "owner",
+                "createdBy": auth.user_id,
+            }
+        )
 
         for topic in topics:
             t = ShoutTopic.create(topic=topic.id, shout=new_shout.id)
@@ -64,10 +68,15 @@ async def update_shout(_, info, shout_id, shout_input=None, publish=False):
     auth: AuthCredentials = info.context["request"].auth
 
     with local_session() as session:
-        shout = session.query(Shout).options(
-            joinedload(Shout.authors),
-            joinedload(Shout.topics),
-        ).filter(Shout.id == shout_id).first()
+        shout = (
+            session.query(Shout)
+            .options(
+                joinedload(Shout.authors),
+                joinedload(Shout.topics),
+            )
+            .filter(Shout.id == shout_id)
+            .first()
+        )
 
         if not shout:
             return {"error": "shout not found"}
@@ -82,7 +91,9 @@ async def update_shout(_, info, shout_id, shout_input=None, publish=False):
             del shout_input["topics"]
 
             new_topics_to_link = []
-            new_topics = [topic_input for topic_input in topics_input if topic_input["id"] < 0]
+            new_topics = [
+                topic_input for topic_input in topics_input if topic_input["id"] < 0
+            ]
 
             for new_topic in new_topics:
                 del new_topic["id"]
@@ -94,24 +105,40 @@ async def update_shout(_, info, shout_id, shout_input=None, publish=False):
                 session.commit()
 
             for new_topic_to_link in new_topics_to_link:
-                created_unlinked_topic = ShoutTopic.create(shout=shout.id, topic=new_topic_to_link.id)
+                created_unlinked_topic = ShoutTopic.create(
+                    shout=shout.id, topic=new_topic_to_link.id
+                )
                 session.add(created_unlinked_topic)
 
-            existing_topics_input = [topic_input for topic_input in topics_input if topic_input.get("id", 0) > 0]
-            existing_topic_to_link_ids = [existing_topic_input["id"] for existing_topic_input in existing_topics_input
-                                          if existing_topic_input["id"] not in [topic.id for topic in shout.topics]]
+            existing_topics_input = [
+                topic_input
+                for topic_input in topics_input
+                if topic_input.get("id", 0) > 0
+            ]
+            existing_topic_to_link_ids = [
+                existing_topic_input["id"]
+                for existing_topic_input in existing_topics_input
+                if existing_topic_input["id"]
+                not in [topic.id for topic in shout.topics]
+            ]
 
             for existing_topic_to_link_id in existing_topic_to_link_ids:
-                created_unlinked_topic = ShoutTopic.create(shout=shout.id, topic=existing_topic_to_link_id)
+                created_unlinked_topic = ShoutTopic.create(
+                    shout=shout.id, topic=existing_topic_to_link_id
+                )
                 session.add(created_unlinked_topic)
 
-            topic_to_unlink_ids = [topic.id for topic in shout.topics
-                                   if topic.id not in [topic_input["id"] for topic_input in existing_topics_input]]
+            topic_to_unlink_ids = [
+                topic.id
+                for topic in shout.topics
+                if topic.id
+                not in [topic_input["id"] for topic_input in existing_topics_input]
+            ]
 
             shout_topics_to_remove = session.query(ShoutTopic).filter(
                 and_(
                     ShoutTopic.shout == shout.id,
-                    ShoutTopic.topic.in_(topic_to_unlink_ids)
+                    ShoutTopic.topic.in_(topic_to_unlink_ids),
                 )
             )
 
@@ -120,13 +147,13 @@ async def update_shout(_, info, shout_id, shout_input=None, publish=False):
 
             shout_input["mainTopic"] = shout_input["mainTopic"]["slug"]
 
-            if shout_input["mainTopic"] == '':
+            if shout_input["mainTopic"] == "":
                 del shout_input["mainTopic"]
 
             shout.update(shout_input)
             updated = True
 
-        if publish and shout.visibility == 'owner':
+        if publish and shout.visibility == "owner":
             shout.visibility = "community"
             shout.publishedAt = datetime.now(tz=timezone.utc)
             updated = True

resolvers/following.py

@@ -1,8 +1,9 @@
 import asyncio
-from base.orm import local_session
-from base.resolvers import mutation, subscription
+from services.db import local_session
+from services.schema import mutation, subscription
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
+
 # from resolvers.community import community_follow, community_unfollow
 from orm.user import AuthorFollower
 from orm.topic import TopicFollower
@@ -22,20 +23,20 @@ async def follow(_, info, what, slug):
     try:
         if what == "AUTHOR":
             if author_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'author', slug)
-                await FollowingManager.push('author', result)
+                result = FollowingResult("NEW", "author", slug)
+                await FollowingManager.push("author", result)
         elif what == "TOPIC":
             if topic_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'topic', slug)
-                await FollowingManager.push('topic', result)
+                result = FollowingResult("NEW", "topic", slug)
+                await FollowingManager.push("topic", result)
         elif what == "COMMUNITY":
             if False:  # TODO: use community_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'community', slug)
-                await FollowingManager.push('community', result)
+                result = FollowingResult("NEW", "community", slug)
+                await FollowingManager.push("community", result)
         elif what == "REACTIONS":
             if reactions_follow(auth.user_id, slug):
-                result = FollowingResult("NEW", 'shout', slug)
-                await FollowingManager.push('shout', result)
+                result = FollowingResult("NEW", "shout", slug)
+                await FollowingManager.push("shout", result)
     except Exception as e:
         print(Exception(e))
         return {"error": str(e)}
@@ -51,20 +52,20 @@ async def unfollow(_, info, what, slug):
     try:
         if what == "AUTHOR":
             if author_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'author', slug)
-                await FollowingManager.push('author', result)
+                result = FollowingResult("DELETED", "author", slug)
+                await FollowingManager.push("author", result)
         elif what == "TOPIC":
             if topic_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'topic', slug)
-                await FollowingManager.push('topic', result)
+                result = FollowingResult("DELETED", "topic", slug)
+                await FollowingManager.push("topic", result)
         elif what == "COMMUNITY":
             if False:  # TODO: use community_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'community', slug)
-                await FollowingManager.push('community', result)
+                result = FollowingResult("DELETED", "community", slug)
+                await FollowingManager.push("community", result)
         elif what == "REACTIONS":
             if reactions_unfollow(auth.user_id, slug):
-                result = FollowingResult("DELETED", 'shout', slug)
-                await FollowingManager.push('shout', result)
+                result = FollowingResult("DELETED", "shout", slug)
+                await FollowingManager.push("shout", result)
     except Exception as e:
         return {"error": str(e)}
 
@@ -82,23 +83,29 @@ async def shout_generator(_, info: GraphQLResolveInfo):
         tasks = []
 
         with local_session() as session:
-
             # notify new shout by followed authors
-            following_topics = session.query(TopicFollower).where(TopicFollower.follower == user_id).all()
+            following_topics = (
+                session.query(TopicFollower)
+                .where(TopicFollower.follower == user_id)
+                .all()
+            )
 
             for topic_id in following_topics:
-                following_topic = Following('topic', topic_id)
-                await FollowingManager.register('topic', following_topic)
+                following_topic = Following("topic", topic_id)
+                await FollowingManager.register("topic", following_topic)
                 following_topic_task = following_topic.queue.get()
                 tasks.append(following_topic_task)
 
             # by followed topics
-            following_authors = session.query(AuthorFollower).where(
-                AuthorFollower.follower == user_id).all()
+            following_authors = (
+                session.query(AuthorFollower)
+                .where(AuthorFollower.follower == user_id)
+                .all()
+            )
 
             for author_id in following_authors:
-                following_author = Following('author', author_id)
-                await FollowingManager.register('author', following_author)
+                following_author = Following("author", author_id)
+                await FollowingManager.register("author", following_author)
                 following_author_task = following_author.queue.get()
                 tasks.append(following_author_task)
 
@@ -128,15 +135,18 @@ async def reaction_generator(_, info):
     user_id = auth.user_id
     try:
         with local_session() as session:
-            followings = session.query(ShoutReactionsFollower.shout).where(
-                ShoutReactionsFollower.follower == user_id).unique()
+            followings = (
+                session.query(ShoutReactionsFollower.shout)
+                .where(ShoutReactionsFollower.follower == user_id)
+                .unique()
+            )
 
             # notify new reaction
 
             tasks = []
             for shout_id in followings:
-                following_shout = Following('shout', shout_id)
-                await FollowingManager.register('shout', following_shout)
+                following_shout = Following("shout", shout_id)
+                await FollowingManager.register("shout", following_shout)
                 following_author_task = following_shout.queue.get()
                 tasks.append(following_author_task)
 

resolvers/inbox/chats.py

@@ -1,124 +0,0 @@
-import json
-import uuid
-from datetime import datetime, timezone
-
-from auth.authenticate import login_required
-from auth.credentials import AuthCredentials
-from base.redis import redis
-from base.resolvers import mutation
-from validations.inbox import Chat
-
-
-@mutation.field("updateChat")
-@login_required
-async def update_chat(_, info, chat_new: Chat):
-    """
-    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 }
-    """
-    auth: AuthCredentials = info.context["request"].auth
-    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))
-
-    # TODO
-    if auth.user_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=[]):
-    auth: AuthCredentials = info.context["request"].auth
-    chat = {}
-    print('create_chat members: %r' % members)
-    if auth.user_id not in members:
-        members.append(int(auth.user_id))
-
-    # reuse chat craeted before if exists
-    if len(members) == 2 and title == "":
-        chat = None
-        print(members)
-        chatset1 = await redis.execute("SMEMBERS", f"chats_by_user/{members[0]}")
-        if not chatset1:
-            chatset1 = set([])
-        print(chatset1)
-        chatset2 = await redis.execute("SMEMBERS", f"chats_by_user/{members[1]}")
-        if not chatset2:
-            chatset2 = set([])
-        print(chatset2)
-        chatset = chatset1.intersection(chatset2)
-        print(chatset)
-        for c in chatset:
-            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,
-        "users": members,
-        "title": title,
-        "createdBy": auth.user_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_user/{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):
-    auth: AuthCredentials = info.context["request"].auth
-
-    chat = await redis.execute("GET", f"/chats/{chat_id}")
-    if chat:
-        chat = dict(json.loads(chat))
-        if auth.user_id in chat['admins']:
-            await redis.execute("DEL", f"chats/{chat_id}")
-            await redis.execute("SREM", "chats_by_user/" + str(auth.user_id), chat_id)
-            await redis.execute("COMMIT")
-    else:
-        return {
-            "error": "chat not exist"
-        }

resolvers/inbox/load.py

@@ -1,152 +0,0 @@
-import json
-# from datetime import datetime, timedelta, timezone
-
-from auth.authenticate import login_required
-from auth.credentials import AuthCredentials
-from base.redis import redis
-from base.orm import local_session
-from base.resolvers import query
-from orm.user import User
-from resolvers.zine.profile import followed_authors
-from .unread import get_unread_counter
-
-
-async def load_messages(chat_id: str, limit: int = 5, offset: int = 0, ids=[]):
-    ''' load :limit messages for :chat_id with :offset '''
-    messages = []
-    message_ids = []
-    if ids:
-        message_ids += ids
-    try:
-        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
-    except Exception as e:
-        print(e)
-    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(chat_id, limit=0, ids=replies)
-    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 """
-    auth: AuthCredentials = info.context["request"].auth
-
-    cids = await redis.execute("SMEMBERS", "chats_by_user/" + str(auth.user_id))
-    if cids:
-        cids = list(cids)[offset:offset + limit]
-    if not cids:
-        print('[inbox.load] no chats were found')
-        cids = []
-    onliners = await redis.execute("SMEMBERS", "users-online")
-    if not onliners:
-        onliners = []
-    chats = []
-    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, auth.user_id)
-            with local_session() as session:
-                c['members'] = []
-                for uid in c["users"]:
-                    a = session.query(User).where(User.id == uid).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 onliners
-                        })
-                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 '''
-
-    auth: AuthCredentials = info.context["request"].auth
-    userchats = await redis.execute("SMEMBERS", "chats_by_user/" + str(auth.user_id))
-    userchats = [c.decode('utf-8') for c in userchats]
-    # print('[inbox] userchats: %r' % userchats)
-    if userchats:
-        # print('[inbox] loading messages by...')
-        messages = []
-        by_chat = by.get('chat')
-        if by_chat in userchats:
-            chat = await redis.execute("GET", f"chats/{by_chat}")
-            # print(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):
-    chat_users = []
-    auth: AuthCredentials = info.context["request"].auth
-    onliners = await redis.execute("SMEMBERS", "users-online")
-    if not onliners:
-        onliners = []
-    try:
-        chat_users += await followed_authors(auth.user_id)
-        limit = limit - len(chat_users)
-    except Exception:
-        pass
-    with local_session() as session:
-        chat_users += session.query(User).where(User.emailConfirmed).limit(limit).offset(offset)
-        members = []
-        for a in chat_users:
-            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
-    }

resolvers/inbox/messages.py

@@ -1,179 +0,0 @@
-import asyncio
-import json
-from typing import Any
-from datetime import datetime, timezone
-from graphql.type import GraphQLResolveInfo
-from auth.authenticate import login_required
-from auth.credentials import AuthCredentials
-from base.redis import redis
-from base.resolvers import mutation, subscription
-from services.following import FollowingManager, FollowingResult, Following
-from validations.inbox import Message
-
-
-@mutation.field("createMessage")
-@login_required
-async def create_message(_, info, chat: str, body: str, replyTo=None):
-    """ create message with :body for :chat_id replying to :replyTo optionally """
-    auth: AuthCredentials = info.context["request"].auth
-
-    chat = await redis.execute("GET", f"chats/{chat}")
-    if not chat:
-        return {
-            "error": "chat is not exist"
-        }
-    else:
-        chat = dict(json.loads(chat))
-        message_id = await redis.execute("GET", f"chats/{chat['id']}/next_message_id")
-        message_id = int(message_id)
-        new_message = {
-            "chatId": chat['id'],
-            "id": message_id,
-            "author": auth.user_id,
-            "body": body,
-            "createdAt": int(datetime.now(tz=timezone.utc).timestamp())
-        }
-        if replyTo:
-            new_message['replyTo'] = replyTo
-        chat['updatedAt'] = new_message['createdAt']
-        await redis.execute("SET", f"chats/{chat['id']}", json.dumps(chat))
-        print(f"[inbox] creating message {new_message}")
-        await redis.execute(
-            "SET", f"chats/{chat['id']}/messages/{message_id}", json.dumps(new_message)
-        )
-        await redis.execute("LPUSH", f"chats/{chat['id']}/message_ids", str(message_id))
-        await redis.execute("SET", f"chats/{chat['id']}/next_message_id", str(message_id + 1))
-
-        users = chat["users"]
-        for user_slug in users:
-            await redis.execute(
-                "LPUSH", f"chats/{chat['id']}/unread/{user_slug}", str(message_id)
-            )
-
-        result = FollowingResult("NEW", 'chat', new_message)
-        await FollowingManager.push('chat', result)
-
-        return {
-            "message": new_message,
-            "error": None
-        }
-
-
-@mutation.field("updateMessage")
-@login_required
-async def update_message(_, info, chat_id: str, message_id: int, body: str):
-    auth: AuthCredentials = info.context["request"].auth
-
-    chat = await redis.execute("GET", f"chats/{chat_id}")
-    if not chat:
-        return {"error": "chat not exist"}
-
-    message = await redis.execute("GET", f"chats/{chat_id}/messages/{message_id}")
-    if not message:
-        return {"error": "message  not exist"}
-
-    message = json.loads(message)
-    if message["author"] != auth.user_id:
-        return {"error": "access denied"}
-
-    message["body"] = body
-    message["updatedAt"] = int(datetime.now(tz=timezone.utc).timestamp())
-
-    await redis.execute("SET", f"chats/{chat_id}/messages/{message_id}", json.dumps(message))
-
-    result = FollowingResult("UPDATED", 'chat', message)
-    await FollowingManager.push('chat', result)
-
-    return {
-        "message": message,
-        "error": None
-    }
-
-
-@mutation.field("deleteMessage")
-@login_required
-async def delete_message(_, info, chat_id: str, message_id: int):
-    auth: AuthCredentials = info.context["request"].auth
-
-    chat = await redis.execute("GET", f"chats/{chat_id}")
-    if not chat:
-        return {"error": "chat not exist"}
-    chat = json.loads(chat)
-
-    message = await redis.execute("GET", f"chats/{chat_id}/messages/{str(message_id)}")
-    if not message:
-        return {"error": "message  not exist"}
-    message = json.loads(message)
-    if message["author"] != auth.user_id:
-        return {"error": "access denied"}
-
-    await redis.execute("LREM", f"chats/{chat_id}/message_ids", 0, str(message_id))
-    await redis.execute("DEL", f"chats/{chat_id}/messages/{str(message_id)}")
-
-    users = chat["users"]
-    for user_id in users:
-        await redis.execute("LREM", f"chats/{chat_id}/unread/{user_id}", 0, str(message_id))
-
-    result = FollowingResult("DELETED", 'chat', message)
-    await FollowingManager.push(result)
-
-    return {}
-
-
-@mutation.field("markAsRead")
-@login_required
-async def mark_as_read(_, info, chat_id: str, messages: [int]):
-    auth: AuthCredentials = info.context["request"].auth
-
-    chat = await redis.execute("GET", f"chats/{chat_id}")
-    if not chat:
-        return {"error": "chat not exist"}
-
-    chat = json.loads(chat)
-    users = set(chat["users"])
-    if auth.user_id not in users:
-        return {"error": "access denied"}
-
-    for message_id in messages:
-        await redis.execute("LREM", f"chats/{chat_id}/unread/{auth.user_id}", 0, str(message_id))
-
-    return {
-        "error": None
-    }
-
-
-@subscription.source("newMessage")
-async def message_generator(_, info: GraphQLResolveInfo):
-    print(f"[resolvers.messages] generator {info}")
-    auth: AuthCredentials = info.context["request"].auth
-    user_id = auth.user_id
-    try:
-        user_following_chats = await redis.execute("GET", f"chats_by_user/{user_id}")
-        if user_following_chats:
-            user_following_chats = list(json.loads(user_following_chats))  # chat ids
-        else:
-            user_following_chats = []
-        tasks = []
-        updated = {}
-        for chat_id in user_following_chats:
-            chat = await redis.execute("GET", f"chats/{chat_id}")
-            updated[chat_id] = chat['updatedAt']
-        user_following_chats_sorted = sorted(user_following_chats, key=lambda x: updated[x], reverse=True)
-
-        for chat_id in user_following_chats_sorted:
-            following_chat = Following('chat', chat_id)
-            await FollowingManager.register('chat', following_chat)
-            chat_task = following_chat.queue.get()
-            tasks.append(chat_task)
-
-        while True:
-            msg = await asyncio.gather(*tasks)
-            yield msg
-    finally:
-        await FollowingManager.remove('chat', following_chat)
-
-
-@subscription.field("newMessage")
-@login_required
-async def message_resolver(message: Message, info: Any):
-    return message

resolvers/inbox/search.py

@@ -1,95 +0,0 @@
-import json
-from datetime import datetime, timezone, timedelta
-from auth.authenticate import login_required
-from auth.credentials import AuthCredentials
-from base.redis import redis
-from base.resolvers import query
-from base.orm import local_session
-from orm.user import AuthorFollower, User
-from resolvers.inbox.load import load_messages
-
-
-@query.field("searchRecipients")
-@login_required
-async def search_recipients(_, info, query: str, limit: int = 50, offset: int = 0):
-    result = []
-    # TODO: maybe redis scan?
-    auth: AuthCredentials = info.context["request"].auth
-    talk_before = await redis.execute("GET", f"/chats_by_user/{auth.user_id}")
-    if talk_before:
-        talk_before = list(json.loads(talk_before))[offset:offset + limit]
-        for chat_id in talk_before:
-            members = await redis.execute("GET", f"/chats/{chat_id}/users")
-            if members:
-                members = list(json.loads(members))
-                for member in members:
-                    if member.startswith(query):
-                        if member not in result:
-                            result.append(member)
-
-    more_amount = limit - len(result)
-
-    with local_session() as session:
-        # followings
-        result += session.query(AuthorFollower.author).join(
-            User, User.id == AuthorFollower.follower
-        ).where(
-            User.slug.startswith(query)
-        ).offset(offset + len(result)).limit(more_amount)
-
-        more_amount = limit
-        # followers
-        result += session.query(AuthorFollower.follower).join(
-            User, User.id == AuthorFollower.author
-        ).where(
-            User.slug.startswith(query)
-        ).offset(offset + len(result)).limit(offset + len(result) + limit)
-    return {
-        "members": list(result),
-        "error": None
-    }
-
-
-@query.field("searchMessages")
-@login_required
-async def search_user_chats(by, messages, user_id: int, limit, offset):
-    cids = set([])
-    cids.union(set(await redis.execute("SMEMBERS", "chats_by_user/" + str(user_id))))
-    messages = []
-
-    by_author = by.get('author')
-    if by_author:
-        # all author's messages
-        cids.union(set(await redis.execute("SMEMBERS", f"chats_by_user/{by_author}")))
-        # author's messages in filtered chat
-        messages.union(set(filter(lambda m: m["author"] == by_author, list(messages))))
-        for c in cids:
-            c = c.decode('utf-8')
-            messages = await load_messages(c, limit, offset)
-
-    body_like = by.get('body')
-    if body_like:
-        # search in all messages in all user's chats
-        for c in cids:
-            # FIXME: use redis scan here
-            c = c.decode('utf-8')
-            mmm = await load_messages(c, limit, offset)
-            for m in mmm:
-                if body_like in m["body"]:
-                    messages.add(m)
-        else:
-            # search in chat's messages
-            messages.extend(filter(lambda m: body_like in m["body"], list(messages)))
-
-    days = by.get("days")
-    if days:
-        messages.extend(filter(
-            list(messages),
-            key=lambda m: (
-                datetime.now(tz=timezone.utc) - int(m["createdAt"]) < timedelta(days=by["days"])
-            )
-        ))
-    return {
-        "messages": messages,
-        "error": None
-    }

resolvers/inbox/unread.py

@@ -1,22 +0,0 @@
-from base.redis import redis
-import json
-
-
-async def get_unread_counter(chat_id: str, user_id: int):
-    try:
-        unread = await redis.execute("LLEN", f"chats/{chat_id.decode('utf-8')}/unread/{user_id}")
-        if unread:
-            return unread
-    except Exception:
-        return 0
-
-
-async def get_total_unread_counter(user_id: int):
-    chats = await redis.execute("GET", f"chats_by_user/{str(user_id)}")
-    unread = 0
-    if chats:
-        chats = json.loads(chats)
-        for chat_id in chats:
-            n = await get_unread_counter(chat_id.decode('utf-8'), user_id)
-            unread += n
-    return unread

resolvers/load.py

@@ -1,13 +1,13 @@
 from datetime import datetime, timedelta, timezone
 
 from sqlalchemy.orm import joinedload, aliased
-from sqlalchemy.sql.expression import desc, asc, select, func, case, and_, text, nulls_last
+from sqlalchemy.sql.expression import desc, asc, select, func, case, and_, nulls_last
 
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
-from base.exceptions import ObjectNotExist, OperationNotAllowed
-from base.orm import local_session
-from base.resolvers import query
+from services.exceptions import ObjectNotExist
+from services.db import local_session
+from services.schema import query
 from orm import TopicFollower
 from orm.reaction import Reaction, ReactionKind
 from orm.shout import Shout, ShoutAuthor, ShoutTopic
@@ -18,32 +18,32 @@ def add_stat_columns(q):
     aliased_reaction = aliased(Reaction)
 
     q = q.outerjoin(aliased_reaction).add_columns(
+        func.sum(aliased_reaction.id).label("reacted_stat"),
         func.sum(
-            aliased_reaction.id
-        ).label('reacted_stat'),
+            case((aliased_reaction.kind == ReactionKind.COMMENT, 1), else_=0)
+        ).label("commented_stat"),
         func.sum(
             case(
-                (aliased_reaction.kind == ReactionKind.COMMENT, 1),
-                else_=0
+                # do not count comments' reactions
+                (aliased_reaction.replyTo.is_not(None), 0),
+                (aliased_reaction.kind == ReactionKind.AGREE, 1),
+                (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
+                (aliased_reaction.kind == ReactionKind.PROOF, 1),
+                (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
+                (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
+                (aliased_reaction.kind == ReactionKind.REJECT, -1),
+                (aliased_reaction.kind == ReactionKind.LIKE, 1),
+                (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
+                else_=0,
             )
-        ).label('commented_stat'),
-        func.sum(case(
-            # do not count comments' reactions
-            (aliased_reaction.replyTo.is_not(None), 0),
-            (aliased_reaction.kind == ReactionKind.AGREE, 1),
-            (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
-            (aliased_reaction.kind == ReactionKind.PROOF, 1),
-            (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
-            (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
-            (aliased_reaction.kind == ReactionKind.REJECT, -1),
-            (aliased_reaction.kind == ReactionKind.LIKE, 1),
-            (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
-            else_=0)
-        ).label('rating_stat'),
-        func.max(case(
-            (aliased_reaction.kind != ReactionKind.COMMENT, None),
-            else_=aliased_reaction.createdAt
-        )).label('last_comment'))
+        ).label("rating_stat"),
+        func.max(
+            case(
+                (aliased_reaction.kind != ReactionKind.COMMENT, None),
+                else_=aliased_reaction.createdAt,
+            )
+        ).label("last_comment"),
+    )
 
     return q
 
@@ -60,7 +60,7 @@ def apply_filters(q, filters, user_id=None):
 
     if filters.get("layout"):
         q = q.filter(Shout.layout == filters.get("layout"))
-    if filters.get('excludeLayout'):
+    if filters.get("excludeLayout"):
         q = q.filter(Shout.layout != filters.get("excludeLayout"))
     if filters.get("author"):
         q = q.filter(Shout.authors.any(slug=filters.get("author")))
@@ -71,7 +71,9 @@ def apply_filters(q, filters, user_id=None):
     if filters.get("body"):
         q = q.filter(Shout.body.ilike(f'%{filters.get("body")}%s'))
     if filters.get("days"):
-        before = datetime.now(tz=timezone.utc) - timedelta(days=int(filters.get("days")) or 30)
+        before = datetime.now(tz=timezone.utc) - timedelta(
+            days=int(filters.get("days")) or 30
+        )
         q = q.filter(Shout.createdAt > before)
 
     return q
@@ -87,30 +89,32 @@ async def load_shout(_, info, slug=None, shout_id=None):
         q = add_stat_columns(q)
 
         if slug is not None:
-            q = q.filter(
-                Shout.slug == slug
-            )
+            q = q.filter(Shout.slug == slug)
 
         if shout_id is not None:
-            q = q.filter(
-                Shout.id == shout_id
-            )
+            q = q.filter(Shout.id == shout_id)
 
-        q = q.filter(
-            Shout.deletedAt.is_(None)
-        ).group_by(Shout.id)
+        q = q.filter(Shout.deletedAt.is_(None)).group_by(Shout.id)
 
         try:
-            [shout, reacted_stat, commented_stat, rating_stat, last_comment] = session.execute(q).first()
+            [
+                shout,
+                reacted_stat,
+                commented_stat,
+                rating_stat,
+                last_comment,
+            ] = session.execute(q).first()
 
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
 
-            for author_caption in session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug):
+            for author_caption in (
+                session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug)
+            ):
                 for author in shout.authors:
                     if author.id == author_caption.user:
                         author.caption = author_caption.caption
@@ -142,14 +146,13 @@ async def load_shouts_by(_, info, options):
     :return: Shout[]
     """
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(
-            Shout.deletedAt.is_(None),
-            Shout.layout.is_not(None)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
         )
+        .where(and_(Shout.deletedAt.is_(None), Shout.layout.is_not(None)))
     )
 
     q = add_stat_columns(q)
@@ -159,23 +162,36 @@ async def load_shouts_by(_, info, options):
 
     order_by = options.get("order_by", Shout.publishedAt)
 
-    query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
+    query_order_by = (
+        desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
+    )
     offset = options.get("offset", 0)
     limit = options.get("limit", 10)
 
-    q = q.group_by(Shout.id).order_by(nulls_last(query_order_by)).limit(limit).offset(offset)
+    q = (
+        q.group_by(Shout.id)
+        .order_by(nulls_last(query_order_by))
+        .limit(limit)
+        .offset(offset)
+    )
 
     shouts = []
     with local_session() as session:
         shouts_map = {}
 
-        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(q).unique():
+        for [
+            shout,
+            reacted_stat,
+            commented_stat,
+            rating_stat,
+            last_comment,
+        ] in session.execute(q).unique():
             shouts.append(shout)
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
             shouts_map[shout.id] = shout
 
@@ -187,11 +203,13 @@ async def get_drafts(_, info):
     auth: AuthCredentials = info.context["request"].auth
     user_id = auth.user_id
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(Shout.deletedAt.is_(None), Shout.createdBy == user_id)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
+        )
+        .where(and_(Shout.deletedAt.is_(None), Shout.createdBy == user_id))
     )
 
     q = q.group_by(Shout.id)
@@ -210,24 +228,26 @@ async def get_my_feed(_, info, options):
     auth: AuthCredentials = info.context["request"].auth
     user_id = auth.user_id
 
-    subquery = select(Shout.id).join(
-        ShoutAuthor
-    ).join(
-        AuthorFollower, AuthorFollower.follower == user_id
-    ).join(
-        ShoutTopic
-    ).join(
-        TopicFollower, TopicFollower.follower == user_id
+    subquery = (
+        select(Shout.id)
+        .join(ShoutAuthor)
+        .join(AuthorFollower, AuthorFollower.follower == user_id)
+        .join(ShoutTopic)
+        .join(TopicFollower, TopicFollower.follower == user_id)
     )
 
-    q = select(Shout).options(
-        joinedload(Shout.authors),
-        joinedload(Shout.topics),
-    ).where(
-        and_(
-            Shout.publishedAt.is_not(None),
-            Shout.deletedAt.is_(None),
-            Shout.id.in_(subquery)
+    q = (
+        select(Shout)
+        .options(
+            joinedload(Shout.authors),
+            joinedload(Shout.topics),
+        )
+        .where(
+            and_(
+                Shout.publishedAt.is_not(None),
+                Shout.deletedAt.is_(None),
+                Shout.id.in_(subquery),
+            )
         )
     )
 
@@ -236,22 +256,35 @@ async def get_my_feed(_, info, options):
 
     order_by = options.get("order_by", Shout.publishedAt)
 
-    query_order_by = desc(order_by) if options.get('order_by_desc', True) else asc(order_by)
+    query_order_by = (
+        desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
+    )
     offset = options.get("offset", 0)
     limit = options.get("limit", 10)
 
-    q = q.group_by(Shout.id).order_by(nulls_last(query_order_by)).limit(limit).offset(offset)
+    q = (
+        q.group_by(Shout.id)
+        .order_by(nulls_last(query_order_by))
+        .limit(limit)
+        .offset(offset)
+    )
 
     shouts = []
     with local_session() as session:
         shouts_map = {}
-        for [shout, reacted_stat, commented_stat, rating_stat, last_comment] in session.execute(q).unique():
+        for [
+            shout,
+            reacted_stat,
+            commented_stat,
+            rating_stat,
+            last_comment,
+        ] in session.execute(q).unique():
             shouts.append(shout)
             shout.stat = {
                 "viewed": shout.views,
                 "reacted": reacted_stat,
                 "commented": commented_stat,
-                "rating": rating_stat
+                "rating": rating_stat,
             }
             shouts_map[shout.id] = shout
 

resolvers/migrate.py

@@ -1,5 +1,4 @@
-
-from base.resolvers import query
+from services.schema import query
 from resolvers.auth import login_required
 from migration.extract import extract_md
 

resolvers/profile.py

@@ -5,8 +5,8 @@ from sqlalchemy.orm import aliased, joinedload
 
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
-from base.orm import local_session
-from base.resolvers import mutation, query
+from services.orm import local_session
+from services.schema import mutation, query
 from orm.reaction import Reaction
 from orm.shout import ShoutAuthor, ShoutTopic
 from orm.topic import Topic
@@ -23,36 +23,31 @@ def add_author_stat_columns(q, include_heavy_stat=False):
     shout_author_aliased = aliased(ShoutAuthor)
 
     q = q.outerjoin(shout_author_aliased).add_columns(
-        func.count(distinct(shout_author_aliased.shout)).label('shouts_stat')
+        func.count(distinct(shout_author_aliased.shout)).label("shouts_stat")
     )
     q = q.outerjoin(author_followers, author_followers.author == User.id).add_columns(
-        func.count(distinct(author_followers.follower)).label('followers_stat')
+        func.count(distinct(author_followers.follower)).label("followers_stat")
     )
 
     q = q.outerjoin(author_following, author_following.follower == User.id).add_columns(
-        func.count(distinct(author_following.author)).label('followings_stat')
+        func.count(distinct(author_following.author)).label("followings_stat")
     )
 
     if include_heavy_stat:
         user_rating_aliased = aliased(UserRating)
-        q = q.outerjoin(user_rating_aliased, user_rating_aliased.user == User.id).add_columns(
-            func.sum(user_rating_aliased.value).label('rating_stat')
-        )
+        q = q.outerjoin(
+            user_rating_aliased, user_rating_aliased.user == User.id
+        ).add_columns(func.sum(user_rating_aliased.value).label("rating_stat"))
 
     else:
-        q = q.add_columns(literal(-1).label('rating_stat'))
+        q = q.add_columns(literal(-1).label("rating_stat"))
 
     if include_heavy_stat:
         q = q.outerjoin(
-            Reaction,
-            and_(
-                Reaction.createdBy == User.id,
-                Reaction.body.is_not(None)
-            )).add_columns(
-            func.count(distinct(Reaction.id)).label('commented_stat')
-        )
+            Reaction, and_(Reaction.createdBy == User.id, Reaction.body.is_not(None))
+        ).add_columns(func.count(distinct(Reaction.id)).label("commented_stat"))
     else:
-        q = q.add_columns(literal(-1).label('commented_stat'))
+        q = q.add_columns(literal(-1).label("commented_stat"))
 
     q = q.group_by(User.id)
 
@@ -60,13 +55,19 @@ def add_author_stat_columns(q, include_heavy_stat=False):
 
 
 def add_stat(author, stat_columns):
-    [shouts_stat, followers_stat, followings_stat, rating_stat, commented_stat] = stat_columns
+    [
+        shouts_stat,
+        followers_stat,
+        followings_stat,
+        rating_stat,
+        commented_stat,
+    ] = stat_columns
     author.stat = {
         "shouts": shouts_stat,
         "followers": followers_stat,
         "followings": followings_stat,
         "rating": rating_stat,
-        "commented": commented_stat
+        "commented": commented_stat,
     }
 
     return author
@@ -84,9 +85,15 @@ def get_authors_from_query(q):
 
 async def user_subscriptions(user_id: int):
     return {
-        "unread": await get_total_unread_counter(user_id),  # unread inbox messages counter
-        "topics": [t.slug for t in await followed_topics(user_id)],  # followed topics slugs
-        "authors": [a.slug for a in await followed_authors(user_id)],  # followed authors slugs
+        "unread": await get_total_unread_counter(
+            user_id
+        ),  # unread inbox messages counter
+        "topics": [
+            t.slug for t in await followed_topics(user_id)
+        ],  # followed topics slugs
+        "authors": [
+            a.slug for a in await followed_authors(user_id)
+        ],  # followed authors slugs
         "reactions": await followed_reactions(user_id)
         # "communities": [c.slug for c in followed_communities(slug)],  # communities
     }
@@ -101,13 +108,12 @@ async def followed_discussions(_, info, user_id) -> List[Topic]:
 async def followed_reactions(user_id):
     with local_session() as session:
         user = session.query(User).where(User.id == user_id).first()
-        return session.query(
-            Reaction.shout
-        ).where(
-            Reaction.createdBy == user.id
-        ).filter(
-            Reaction.createdAt > user.lastSeen
-        ).all()
+        return (
+            session.query(Reaction.shout)
+            .where(Reaction.createdBy == user.id)
+            .filter(Reaction.createdAt > user.lastSeen)
+            .all()
+        )
 
 
 # dufok mod (^*^') :
@@ -158,10 +164,10 @@ async def user_followers(_, _info, slug) -> List[User]:
     q = add_author_stat_columns(q)
 
     aliased_user = aliased(User)
-    q = q.join(AuthorFollower, AuthorFollower.follower == User.id).join(
-        aliased_user, aliased_user.id == AuthorFollower.author
-    ).where(
-        aliased_user.slug == slug
+    q = (
+        q.join(AuthorFollower, AuthorFollower.follower == User.id)
+        .join(aliased_user, aliased_user.id == AuthorFollower.author)
+        .where(aliased_user.slug == slug)
     )
 
     return get_authors_from_query(q)
@@ -189,15 +195,10 @@ async def update_profile(_, info, profile):
     with local_session() as session:
         user = session.query(User).filter(User.id == user_id).one()
         if not user:
-            return {
-                "error": "canoot find user"
-            }
+            return {"error": "canoot find user"}
         user.update(profile)
         session.commit()
-    return {
-        "error": None,
-        "author": user
-    }
+    return {"error": None, "author": user}
 
 
 @mutation.field("rateUser")
@@ -208,7 +209,11 @@ async def rate_user(_, info, rated_userslug, value):
     with local_session() as session:
         rating = (
             session.query(UserRating)
-            .filter(and_(UserRating.rater == auth.user_id, UserRating.user == rated_userslug))
+            .filter(
+                and_(
+                    UserRating.rater == auth.user_id, UserRating.user == rated_userslug
+                )
+            )
             .first()
         )
         if rating:
@@ -239,13 +244,10 @@ def author_follow(user_id, slug):
 def author_unfollow(user_id, slug):
     with local_session() as session:
         flw = (
-            session.query(
-                AuthorFollower
-            ).join(User, User.id == AuthorFollower.author).filter(
-                and_(
-                    AuthorFollower.follower == user_id, User.slug == slug
-                )
-            ).first()
+            session.query(AuthorFollower)
+            .join(User, User.id == AuthorFollower.author)
+            .filter(and_(AuthorFollower.follower == user_id, User.slug == slug))
+            .first()
         )
         if flw:
             session.delete(flw)
@@ -281,7 +283,12 @@ async def load_authors_by(_, info, by, limit, offset):
     elif by.get("name"):
         q = q.filter(User.name.ilike(f"%{by['name']}%"))
     elif by.get("topic"):
-        q = q.join(ShoutAuthor).join(ShoutTopic).join(Topic).where(Topic.slug == by["topic"])
+        q = (
+            q.join(ShoutAuthor)
+            .join(ShoutTopic)
+            .join(Topic)
+            .where(Topic.slug == by["topic"])
+        )
     if by.get("lastSeen"):  # in days
         days_before = datetime.now(tz=timezone.utc) - timedelta(days=by["lastSeen"])
         q = q.filter(User.lastSeen > days_before)
@@ -289,8 +296,6 @@ async def load_authors_by(_, info, by, limit, offset):
         days_before = datetime.now(tz=timezone.utc) - timedelta(days=by["createdAt"])
         q = q.filter(User.createdAt > days_before)
 
-    q = q.order_by(
-        by.get("order", User.createdAt)
-    ).limit(limit).offset(offset)
+    q = q.order_by(by.get("order", User.createdAt)).limit(limit).offset(offset)
 
     return get_authors_from_query(q)

resolvers/reactions.py

@@ -4,9 +4,9 @@ from sqlalchemy.orm import aliased
 
 from auth.authenticate import login_required
 from auth.credentials import AuthCredentials
-from base.exceptions import OperationNotAllowed
-from base.orm import local_session
-from base.resolvers import mutation, query
+from services.exceptions import OperationNotAllowed
+from services.db import local_session
+from services.schema import mutation, query
 from orm.reaction import Reaction, ReactionKind
 from orm.shout import Shout, ShoutReactionsFollower
 from orm.user import User
@@ -15,27 +15,27 @@ from orm.user import User
 def add_reaction_stat_columns(q):
     aliased_reaction = aliased(Reaction)
 
-    q = q.outerjoin(aliased_reaction, Reaction.id == aliased_reaction.replyTo).add_columns(
-        func.sum(
-            aliased_reaction.id
-        ).label('reacted_stat'),
+    q = q.outerjoin(
+        aliased_reaction, Reaction.id == aliased_reaction.replyTo
+    ).add_columns(
+        func.sum(aliased_reaction.id).label("reacted_stat"),
+        func.sum(case((aliased_reaction.body.is_not(None), 1), else_=0)).label(
+            "commented_stat"
+        ),
         func.sum(
             case(
-                (aliased_reaction.body.is_not(None), 1),
-                else_=0
+                (aliased_reaction.kind == ReactionKind.AGREE, 1),
+                (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
+                (aliased_reaction.kind == ReactionKind.PROOF, 1),
+                (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
+                (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
+                (aliased_reaction.kind == ReactionKind.REJECT, -1),
+                (aliased_reaction.kind == ReactionKind.LIKE, 1),
+                (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
+                else_=0,
             )
-        ).label('commented_stat'),
-        func.sum(case(
-            (aliased_reaction.kind == ReactionKind.AGREE, 1),
-            (aliased_reaction.kind == ReactionKind.DISAGREE, -1),
-            (aliased_reaction.kind == ReactionKind.PROOF, 1),
-            (aliased_reaction.kind == ReactionKind.DISPROOF, -1),
-            (aliased_reaction.kind == ReactionKind.ACCEPT, 1),
-            (aliased_reaction.kind == ReactionKind.REJECT, -1),
-            (aliased_reaction.kind == ReactionKind.LIKE, 1),
-            (aliased_reaction.kind == ReactionKind.DISLIKE, -1),
-            else_=0)
-        ).label('rating_stat'))
+        ).label("rating_stat"),
+    )
 
     return q
 
@@ -46,17 +46,19 @@ def reactions_follow(user_id, shout_id: int, auto=False):
             shout = session.query(Shout).where(Shout.id == shout_id).one()
 
             following = (
-                session.query(ShoutReactionsFollower).where(and_(
-                    ShoutReactionsFollower.follower == user_id,
-                    ShoutReactionsFollower.shout == shout.id,
-                )).first()
+                session.query(ShoutReactionsFollower)
+                .where(
+                    and_(
+                        ShoutReactionsFollower.follower == user_id,
+                        ShoutReactionsFollower.shout == shout.id,
+                    )
+                )
+                .first()
             )
 
             if not following:
                 following = ShoutReactionsFollower.create(
-                    follower=user_id,
-                    shout=shout.id,
-                    auto=auto
+                    follower=user_id, shout=shout.id, auto=auto
                 )
                 session.add(following)
                 session.commit()
@@ -71,10 +73,14 @@ def reactions_unfollow(user_id: int, shout_id: int):
             shout = session.query(Shout).where(Shout.id == shout_id).one()
 
             following = (
-                session.query(ShoutReactionsFollower).where(and_(
-                    ShoutReactionsFollower.follower == user_id,
-                    ShoutReactionsFollower.shout == shout.id
-                )).first()
+                session.query(ShoutReactionsFollower)
+                .where(
+                    and_(
+                        ShoutReactionsFollower.follower == user_id,
+                        ShoutReactionsFollower.shout == shout.id,
+                    )
+                )
+                .first()
             )
 
             if following:
@@ -87,30 +93,31 @@ def reactions_unfollow(user_id: int, shout_id: int):
 
 
 def is_published_author(session, user_id):
-    ''' checks if user has at least one publication '''
-    return session.query(
-        Shout
-    ).where(
-        Shout.authors.contains(user_id)
-    ).filter(
-        and_(
-            Shout.publishedAt.is_not(None),
-            Shout.deletedAt.is_(None)
-        )
-    ).count() > 0
+    """checks if user has at least one publication"""
+    return (
+        session.query(Shout)
+        .where(Shout.authors.contains(user_id))
+        .filter(and_(Shout.publishedAt.is_not(None), Shout.deletedAt.is_(None)))
+        .count()
+        > 0
+    )
 
 
 def check_to_publish(session, user_id, reaction):
-    ''' set shout to public if publicated approvers amount > 4 '''
+    """set shout to public if publicated approvers amount > 4"""
     if not reaction.replyTo and reaction.kind in [
         ReactionKind.ACCEPT,
         ReactionKind.LIKE,
-        ReactionKind.PROOF
+        ReactionKind.PROOF,
     ]:
         if is_published_author(user_id):
             # now count how many approvers are voted already
-            approvers_reactions = session.query(Reaction).where(Reaction.shout == reaction.shout).all()
-            approvers = [user_id, ]
+            approvers_reactions = (
+                session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+            )
+            approvers = [
+                user_id,
+            ]
             for ar in approvers_reactions:
                 a = ar.createdBy
                 if is_published_author(session, a):
@@ -121,20 +128,22 @@ def check_to_publish(session, user_id, reaction):
 
 
 def check_to_hide(session, user_id, reaction):
-    ''' hides any shout if 20% of reactions are negative '''
+    """hides any shout if 20% of reactions are negative"""
     if not reaction.replyTo and reaction.kind in [
         ReactionKind.REJECT,
         ReactionKind.DISLIKE,
-        ReactionKind.DISPROOF
+        ReactionKind.DISPROOF,
     ]:
         # if is_published_author(user):
-        approvers_reactions = session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+        approvers_reactions = (
+            session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+        )
         rejects = 0
         for r in approvers_reactions:
             if r.kind in [
                 ReactionKind.REJECT,
                 ReactionKind.DISLIKE,
-                ReactionKind.DISPROOF
+                ReactionKind.DISPROOF,
             ]:
                 rejects += 1
         if len(approvers_reactions) / rejects < 5:
@@ -145,14 +154,14 @@ def check_to_hide(session, user_id, reaction):
 def set_published(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
     s.publishedAt = datetime.now(tz=timezone.utc)
-    s.visibility = text('public')
+    s.visibility = text("public")
     session.add(s)
     session.commit()
 
 
 def set_hidden(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
-    s.visibility = text('community')
+    s.visibility = text("community")
     session.add(s)
     session.commit()
 
@@ -161,37 +170,46 @@ def set_hidden(session, shout_id):
 @login_required
 async def create_reaction(_, info, reaction):
     auth: AuthCredentials = info.context["request"].auth
-    reaction['createdBy'] = auth.user_id
+    reaction["createdBy"] = auth.user_id
     rdict = {}
     with local_session() as session:
         shout = session.query(Shout).where(Shout.id == reaction["shout"]).one()
         author = session.query(User).where(User.id == auth.user_id).one()
 
-        if reaction["kind"] in [
-            ReactionKind.DISLIKE.name,
-            ReactionKind.LIKE.name
-        ]:
-            existing_reaction = session.query(Reaction).where(
-                and_(
-                    Reaction.shout == reaction["shout"],
-                    Reaction.createdBy == auth.user_id,
-                    Reaction.kind == reaction["kind"],
-                    Reaction.replyTo == reaction.get("replyTo")
+        if reaction["kind"] in [ReactionKind.DISLIKE.name, ReactionKind.LIKE.name]:
+            existing_reaction = (
+                session.query(Reaction)
+                .where(
+                    and_(
+                        Reaction.shout == reaction["shout"],
+                        Reaction.createdBy == auth.user_id,
+                        Reaction.kind == reaction["kind"],
+                        Reaction.replyTo == reaction.get("replyTo"),
+                    )
                 )
-            ).first()
+                .first()
+            )
 
             if existing_reaction is not None:
                 raise OperationNotAllowed("You can't vote twice")
 
-            opposite_reaction_kind = ReactionKind.DISLIKE if reaction["kind"] == ReactionKind.LIKE.name else ReactionKind.LIKE
-            opposite_reaction = session.query(Reaction).where(
+            opposite_reaction_kind = (
+                ReactionKind.DISLIKE
+                if reaction["kind"] == ReactionKind.LIKE.name
+                else ReactionKind.LIKE
+            )
+            opposite_reaction = (
+                session.query(Reaction)
+                .where(
                     and_(
                         Reaction.shout == reaction["shout"],
                         Reaction.createdBy == auth.user_id,
                         Reaction.kind == opposite_reaction_kind,
-                        Reaction.replyTo == reaction.get("replyTo")
+                        Reaction.replyTo == reaction.get("replyTo"),
                     )
-                ).first()
+                )
+                .first()
+            )
 
             if opposite_reaction is not None:
                 session.delete(opposite_reaction)
@@ -199,14 +217,18 @@ async def create_reaction(_, info, reaction):
         r = Reaction.create(**reaction)
 
         # Proposal accepting logix
-        if r.replyTo is not None and \
-                r.kind == ReactionKind.ACCEPT and \
-                auth.user_id in shout.dict()['authors']:
-            replied_reaction = session.query(Reaction).where(Reaction.id == r.replyTo).first()
+        if (
+            r.replyTo is not None
+            and r.kind == ReactionKind.ACCEPT
+            and auth.user_id in shout.dict()["authors"]
+        ):
+            replied_reaction = (
+                session.query(Reaction).where(Reaction.id == r.replyTo).first()
+            )
             if replied_reaction and replied_reaction.kind == ReactionKind.PROPOSE:
                 if replied_reaction.range:
                     old_body = shout.body
-                    start, end = replied_reaction.range.split(':')
+                    start, end = replied_reaction.range.split(":")
                     start = int(start)
                     end = int(end)
                     new_body = old_body[:start] + replied_reaction.body + old_body[end:]
@@ -216,8 +238,8 @@ async def create_reaction(_, info, reaction):
         session.add(r)
         session.commit()
         rdict = r.dict()
-        rdict['shout'] = shout.dict()
-        rdict['createdBy'] = author.dict()
+        rdict["shout"] = shout.dict()
+        rdict["createdBy"] = author.dict()
 
         # self-regulation mechanics
 
@@ -231,11 +253,7 @@ async def create_reaction(_, info, reaction):
     except Exception as e:
         print(f"[resolvers.reactions] error on reactions autofollowing: {e}")
 
-    rdict['stat'] = {
-        "commented": 0,
-        "reacted": 0,
-        "rating": 0
-    }
+    rdict["stat"] = {"commented": 0, "reacted": 0, "rating": 0}
     return {"reaction": rdict}
 
 
@@ -250,7 +268,9 @@ async def update_reaction(_, info, id, reaction={}):
         q = add_reaction_stat_columns(q)
         q = q.group_by(Reaction.id)
 
-        [r, reacted_stat, commented_stat, rating_stat] = session.execute(q).unique().one()
+        [r, reacted_stat, commented_stat, rating_stat] = (
+            session.execute(q).unique().one()
+        )
 
         if not r:
             return {"error": "invalid reaction id"}
@@ -268,7 +288,7 @@ async def update_reaction(_, info, id, reaction={}):
         r.stat = {
             "commented": commented_stat,
             "reacted": reacted_stat,
-            "rating": rating_stat
+            "rating": rating_stat,
         }
 
     return {"reaction": r}
@@ -286,17 +306,12 @@ async def delete_reaction(_, info, id):
         if r.createdBy != auth.user_id:
             return {"error": "access denied"}
 
-        if r.kind in [
-            ReactionKind.LIKE,
-            ReactionKind.DISLIKE
-        ]:
+        if r.kind in [ReactionKind.LIKE, ReactionKind.DISLIKE]:
             session.delete(r)
         else:
             r.deletedAt = datetime.now(tz=timezone.utc)
         session.commit()
-        return {
-            "reaction": r
-        }
+        return {"reaction": r}
 
 
 @query.field("loadReactionsBy")
@@ -317,12 +332,10 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     :return: Reaction[]
     """
 
-    q = select(
-        Reaction, User, Shout
-    ).join(
-        User, Reaction.createdBy == User.id
-    ).join(
-        Shout, Reaction.shout == Shout.id
+    q = (
+        select(Reaction, User, Shout)
+        .join(User, Reaction.createdBy == User.id)
+        .join(Shout, Reaction.shout == Shout.id)
     )
 
     if by.get("shout"):
@@ -340,7 +353,7 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     if by.get("comment"):
         q = q.filter(func.length(Reaction.body) > 0)
 
-    if len(by.get('search', '')) > 2:
+    if len(by.get("search", "")) > 2:
         q = q.filter(Reaction.body.ilike(f'%{by["body"]}%'))
 
     if by.get("days"):
@@ -348,13 +361,9 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
         q = q.filter(Reaction.createdAt > after)
 
     order_way = asc if by.get("sort", "").startswith("-") else desc
-    order_field = by.get("sort", "").replace('-', '') or Reaction.createdAt
+    order_field = by.get("sort", "").replace("-", "") or Reaction.createdAt
 
-    q = q.group_by(
-        Reaction.id, User.id, Shout.id
-    ).order_by(
-        order_way(order_field)
-    )
+    q = q.group_by(Reaction.id, User.id, Shout.id).order_by(order_way(order_field))
 
     q = add_reaction_stat_columns(q)
 
@@ -363,13 +372,20 @@ async def load_reactions_by(_, _info, by, limit=50, offset=0):
     reactions = []
 
     with local_session() as session:
-        for [reaction, user, shout, reacted_stat, commented_stat, rating_stat] in session.execute(q):
+        for [
+            reaction,
+            user,
+            shout,
+            reacted_stat,
+            commented_stat,
+            rating_stat,
+        ] in session.execute(q):
             reaction.createdBy = user
             reaction.shout = shout
             reaction.stat = {
                 "rating": rating_stat,
                 "commented": commented_stat,
-                "reacted": reacted_stat
+                "reacted": reacted_stat,
             }
 
             reaction.kind = reaction.kind.name

resolvers/topics.py

@@ -2,8 +2,8 @@ from sqlalchemy import and_, select, distinct, func
 from sqlalchemy.orm import aliased
 
 from auth.authenticate import login_required
-from base.orm import local_session
-from base.resolvers import mutation, query
+from services.db import local_session
+from services.schema import mutation, query
 from orm.shout import ShoutTopic, ShoutAuthor
 from orm.topic import Topic, TopicFollower
 from orm import User
@@ -13,12 +13,19 @@ def add_topic_stat_columns(q):
     aliased_shout_author = aliased(ShoutAuthor)
     aliased_topic_follower = aliased(TopicFollower)
 
-    q = q.outerjoin(ShoutTopic, Topic.id == ShoutTopic.topic).add_columns(
-        func.count(distinct(ShoutTopic.shout)).label('shouts_stat')
-    ).outerjoin(aliased_shout_author, ShoutTopic.shout == aliased_shout_author.shout).add_columns(
-        func.count(distinct(aliased_shout_author.user)).label('authors_stat')
-    ).outerjoin(aliased_topic_follower).add_columns(
-        func.count(distinct(aliased_topic_follower.follower)).label('followers_stat')
+    q = (
+        q.outerjoin(ShoutTopic, Topic.id == ShoutTopic.topic)
+        .add_columns(func.count(distinct(ShoutTopic.shout)).label("shouts_stat"))
+        .outerjoin(aliased_shout_author, ShoutTopic.shout == aliased_shout_author.shout)
+        .add_columns(
+            func.count(distinct(aliased_shout_author.user)).label("authors_stat")
+        )
+        .outerjoin(aliased_topic_follower)
+        .add_columns(
+            func.count(distinct(aliased_topic_follower.follower)).label(
+                "followers_stat"
+            )
+        )
     )
 
     q = q.group_by(Topic.id)
@@ -31,7 +38,7 @@ def add_stat(topic, stat_columns):
     topic.stat = {
         "shouts": shouts_stat,
         "authors": authors_stat,
-        "followers": followers_stat
+        "followers": followers_stat,
     }
 
     return topic
@@ -133,12 +140,10 @@ def topic_unfollow(user_id, slug):
     try:
         with local_session() as session:
             sub = (
-                session.query(TopicFollower).join(Topic).filter(
-                    and_(
-                        TopicFollower.follower == user_id,
-                        Topic.slug == slug
-                    )
-                ).first()
+                session.query(TopicFollower)
+                .join(Topic)
+                .filter(and_(TopicFollower.follower == user_id, Topic.slug == slug))
+                .first()
             )
             if sub:
                 session.delete(sub)