merged

resolvers/load.py

@@ -137,7 +137,7 @@ async def load_shouts_by(_, info, options):
     """
     :param options: {
         filters: {
-            layout: 'audio',
+            layout: 'music',
             excludeLayout: 'article',
             visibility: "public",
             author: 'discours',
@@ -208,6 +208,7 @@ async def load_shouts_by(_, info, options):
 
 
 @query.field("loadDrafts")
+@login_required
 async def get_drafts(_, info):
     auth: AuthCredentials = info.context["request"].auth
     user_id = auth.user_id

resolvers/notifications.py

@@ -0,0 +1,84 @@
+from sqlalchemy import select, desc, and_, update
+
+from auth.credentials import AuthCredentials
+from base.resolvers import query, mutation
+from auth.authenticate import login_required
+from base.orm import local_session
+from orm import Notification
+
+
+@query.field("loadNotifications")
+@login_required
+async def load_notifications(_, info, params=None):
+    if params is None:
+        params = {}
+
+    auth: AuthCredentials = info.context["request"].auth
+    user_id = auth.user_id
+
+    limit = params.get('limit', 50)
+    offset = params.get('offset', 0)
+
+    q = select(Notification).where(
+        Notification.user == user_id
+    ).order_by(desc(Notification.createdAt)).limit(limit).offset(offset)
+
+    with local_session() as session:
+        total_count = session.query(Notification).where(
+            Notification.user == user_id
+        ).count()
+
+        total_unread_count = session.query(Notification).where(
+            and_(
+                Notification.user == user_id,
+                Notification.seen is False
+            )
+        ).count()
+
+        notifications = session.execute(q).fetchall()
+
+    return {
+        "notifications": notifications,
+        "totalCount": total_count,
+        "totalUnreadCount": total_unread_count
+    }
+
+
+@mutation.field("markNotificationAsRead")
+@login_required
+async def mark_notification_as_read(_, info, notification_id: int):
+    auth: AuthCredentials = info.context["request"].auth
+    user_id = auth.user_id
+
+    with local_session() as session:
+        notification = session.query(Notification).where(
+            and_(Notification.id == notification_id, Notification.user == user_id)
+        ).one()
+        notification.seen = True
+        session.commit()
+
+    return {}
+
+
+@mutation.field("markAllNotificationsAsRead")
+@login_required
+async def mark_all_notifications_as_read(_, info):
+    auth: AuthCredentials = info.context["request"].auth
+    user_id = auth.user_id
+
+    statement = update(Notification).where(
+        and_(
+            Notification.user == user_id,
+            Notification.seen == False
+        )
+    ).values(seen=True)
+
+    with local_session() as session:
+        try:
+            session.execute(statement)
+            session.commit()
+        except Exception as e:
+            session.rollback()
+            print(f"[mark_all_notifications_as_read] error: {str(e)}")
+
+    return {}

resolvers/profile.py

@@ -266,10 +266,20 @@ async def get_authors_all(_, _info):
 @query.field("getAuthor")
 async def get_author(_, _info, slug):
     q = select(User).where(User.slug == slug)
-    q = add_author_stat_columns(q, True)
+    q = add_author_stat_columns(q)
 
-    authors = get_authors_from_query(q)
-    return authors[0]
+    [author] = get_authors_from_query(q)
+
+    with local_session() as session:
+        comments_count = session.query(Reaction).where(
+            and_(
+                Reaction.createdBy == author.id,
+                Reaction.kind == ReactionKind.COMMENT
+            )
+        ).count()
+        author.stat["commented"] = comments_count
+
+    return author
 
 
 @query.field("loadAuthorsBy")

resolvers/reactions.py

@@ -10,6 +10,7 @@ from services.schema import mutation, query
 from orm.reaction import Reaction, ReactionKind
 from orm.shout import Shout, ShoutReactionsFollower
 from orm.user import User
+from services.notifications.notification_service import notification_service
 
 
 def add_reaction_stat_columns(q):
@@ -217,6 +218,8 @@ async def create_reaction(_, info, reaction):
         r = Reaction.create(**reaction)
 
         # Proposal accepting logix
+        # FIXME: will break if there will be 2 proposals
+        # FIXME: will break if shout will be changed
         if (
             r.replyTo is not None
             and r.kind == ReactionKind.ACCEPT
@@ -237,12 +240,14 @@ async def create_reaction(_, info, reaction):
 
         session.add(r)
         session.commit()
+
+        await notification_service.handle_new_reaction(r.id)
+
         rdict = r.dict()
         rdict["shout"] = shout.dict()
         rdict["createdBy"] = author.dict()
 
         # self-regulation mechanics
-
         if check_to_hide(session, auth.user_id, r):
             set_hidden(session, r.shout)
         elif check_to_publish(session, auth.user_id, r):