fmt

resolvers/reaction.py

@@ -21,16 +21,22 @@ from services.logger import root_logger as logger
 
 def add_stat_columns(q, aliased_reaction):
     q = q.outerjoin(aliased_reaction).add_columns(
-        func.sum(aliased_reaction.id).label('reacted_stat'),
-        func.sum(case((aliased_reaction.kind == ReactionKind.COMMENT.value, 1), else_=0)).label('comments_stat'),
-        func.sum(case((aliased_reaction.kind == ReactionKind.LIKE.value, 1), else_=0)).label('likes_stat'),
-        func.sum(case((aliased_reaction.kind == ReactionKind.DISLIKE.value, 1), else_=0)).label('dislikes_stat'),
+        func.sum(aliased_reaction.id).label("reacted_stat"),
+        func.sum(
+            case((aliased_reaction.kind == ReactionKind.COMMENT.value, 1), else_=0)
+        ).label("comments_stat"),
+        func.sum(
+            case((aliased_reaction.kind == ReactionKind.LIKE.value, 1), else_=0)
+        ).label("likes_stat"),
+        func.sum(
+            case((aliased_reaction.kind == ReactionKind.DISLIKE.value, 1), else_=0)
+        ).label("dislikes_stat"),
         func.max(
             case(
                 (aliased_reaction.kind != ReactionKind.COMMENT.value, None),
                 else_=aliased_reaction.created_at,
             )
-        ).label('last_comment'),
+        ).label("last_comment"),
     )
 
     return q
@@ -54,7 +60,9 @@ def check_to_feature(session, approver_id, reaction):
             approvers = []
             approvers.append(approver_id)
             # now count how many approvers are voted already
-            reacted_readers = session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+            reacted_readers = (
+                session.query(Reaction).where(Reaction.shout == reaction.shout).all()
+            )
             for reacted_reader in reacted_readers:
                 if is_featured_author(session, reacted_reader.id):
                     approvers.append(reacted_reader.id)
@@ -69,12 +77,19 @@ def check_to_unfeature(session, rejecter_id, reaction):
         if is_featured_author(session, rejecter_id):
             reactions = (
                 session.query(Reaction)
-                .where(and_(Reaction.shout == reaction.shout, Reaction.kind.in_(RATING_REACTIONS)))
+                .where(
+                    and_(
+                        Reaction.shout == reaction.shout,
+                        Reaction.kind.in_(RATING_REACTIONS),
+                    )
+                )
                 .all()
             )
             rejects = 0
             for r in reactions:
-                approver = session.query(Author).filter(Author.id == r.created_by).first()
+                approver = (
+                    session.query(Author).filter(Author.id == r.created_by).first()
+                )
                 if is_featured_author(session, approver):
                     if is_negative(r.kind):
                         rejects += 1
@@ -86,7 +101,7 @@ def check_to_unfeature(session, rejecter_id, reaction):
 async def set_featured(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
     s.featured_at = int(time.time())
-    Shout.update(s, {'featured_at': int(time.time())})
+    Shout.update(s, {"featured_at": int(time.time())})
     author = session.query(Author).filter(Author.id == s.created_by).first()
     if author:
         await add_user_role(str(author.user))
@@ -96,7 +111,7 @@ async def set_featured(session, shout_id):
 
 def set_unfeatured(session, shout_id):
     s = session.query(Shout).where(Shout.id == shout_id).first()
-    Shout.update(s, {'featured_at': None})
+    Shout.update(s, {"featured_at": None})
     session.add(s)
     session.commit()
 
@@ -108,7 +123,11 @@ async def _create_reaction(session, shout, author, reaction):
     rdict = r.dict()
 
     # collaborative editing
-    if rdict.get('reply_to') and r.kind in RATING_REACTIONS and author.id in shout.authors:
+    if (
+        rdict.get("reply_to")
+        and r.kind in RATING_REACTIONS
+        and author.id in shout.authors
+    ):
         handle_proposing(session, r, shout)
 
     # self-regultaion mechanics
@@ -118,92 +137,95 @@ async def _create_reaction(session, shout, author, reaction):
         await set_featured(session, shout.id)
 
     # reactions auto-following
-    reactions_follow(author.id, reaction['shout'], True)
+    reactions_follow(author.id, reaction["shout"], True)
 
-    rdict['shout'] = shout.dict()
-    rdict['created_by'] = author.dict()
-    rdict['stat'] = {'commented': 0, 'reacted': 0, 'rating': 0}
+    rdict["shout"] = shout.dict()
+    rdict["created_by"] = author.dict()
+    rdict["stat"] = {"commented": 0, "reacted": 0, "rating": 0}
 
     # notifications call
-    await notify_reaction(rdict, 'create')
+    await notify_reaction(rdict, "create")
 
     return rdict
 
 
-@mutation.field('create_reaction')
+@mutation.field("create_reaction")
 @login_required
 async def create_reaction(_, info, reaction):
-    user_id = info.context['user_id']
+    user_id = info.context["user_id"]
 
-    shout_id = reaction.get('shout')
+    shout_id = reaction.get("shout")
 
     if not shout_id:
-        return {'error': 'Shout ID is required to create a reaction.'}
+        return {"error": "Shout ID is required to create a reaction."}
 
     try:
         with local_session() as session:
             shout = session.query(Shout).filter(Shout.id == shout_id).first()
             author = session.query(Author).filter(Author.user == user_id).first()
             if shout and author:
-                reaction['created_by'] = author.id
-                kind = reaction.get('kind')
+                reaction["created_by"] = author.id
+                kind = reaction.get("kind")
                 shout_id = shout.id
 
-                if not kind and isinstance(reaction.get('body'), str):
+                if not kind and isinstance(reaction.get("body"), str):
                     kind = ReactionKind.COMMENT.value
 
                 if not kind:
-                    return {'error': 'cannot create reaction without a kind'}
+                    return {"error": "cannot create reaction without a kind"}
 
                 if kind in RATING_REACTIONS:
-
-                    opposite_kind = ( ReactionKind.DISLIKE.value
+                    opposite_kind = (
+                        ReactionKind.DISLIKE.value
                         if is_positive(kind)
                         else ReactionKind.LIKE.value
                     )
 
-                    q = (
-                        select(Reaction)
-                        .filter(
-                            and_(
-                                Reaction.shout == shout_id,
-                                Reaction.created_by == author.id,
-                                Reaction.kind.in_(RATING_REACTIONS),
-                            )
+                    q = select(Reaction).filter(
+                        and_(
+                            Reaction.shout == shout_id,
+                            Reaction.created_by == author.id,
+                            Reaction.kind.in_(RATING_REACTIONS),
                         )
                     )
-                    reply_to = reaction.get('reply_to')
+                    reply_to = reaction.get("reply_to")
                     if reply_to:
                         q = q.filter(Reaction.reply_to == reply_to)
                     rating_reactions = session.execute(q).all()
-                    same_rating = filter(lambda r: r.created_by == author.id and r.kind == opposite_kind, rating_reactions)
-                    opposite_rating = filter(lambda r: r.created_by == author.id and r.kind == opposite_kind, rating_reactions)
+                    same_rating = filter(
+                        lambda r: r.created_by == author.id and r.kind == opposite_kind,
+                        rating_reactions,
+                    )
+                    opposite_rating = filter(
+                        lambda r: r.created_by == author.id and r.kind == opposite_kind,
+                        rating_reactions,
+                    )
                     if same_rating:
-                        return {'error': "You can't rate the same thing twice"}
+                        return {"error": "You can't rate the same thing twice"}
                     elif opposite_rating:
-                        return {'error': 'Remove opposite vote first'}
+                        return {"error": "Remove opposite vote first"}
                     elif filter(lambda r: r.created_by == author.id, rating_reactions):
-                        return {'error': "You can't rate your own thing"}
+                        return {"error": "You can't rate your own thing"}
 
                 rdict = await _create_reaction(session, shout, author, reaction)
-                return {'reaction': rdict}
+                return {"reaction": rdict}
     except Exception as e:
         import traceback
 
         traceback.print_exc()
-        logger.error(f'{type(e).__name__}: {e}')
+        logger.error(f"{type(e).__name__}: {e}")
 
-    return {'error': 'Cannot create reaction.'}
+    return {"error": "Cannot create reaction."}
 
 
-@mutation.field('update_reaction')
+@mutation.field("update_reaction")
 @login_required
 async def update_reaction(_, info, reaction):
-    user_id = info.context.get('user_id')
-    roles = info.context.get('roles')
-    rid = reaction.get('id')
+    user_id = info.context.get("user_id")
+    roles = info.context.get("roles")
+    rid = reaction.get("id")
     if rid and user_id and roles:
-        del reaction['id']
+        del reaction["id"]
         with local_session() as session:
             reaction_query = select(Reaction).filter(Reaction.id == int(rid))
             aliased_reaction = aliased(Reaction)
@@ -211,22 +233,24 @@ async def update_reaction(_, info, reaction):
             reaction_query = reaction_query.group_by(Reaction.id)
 
             try:
-                [r, reacted_stat, commented_stat, likes_stat, dislikes_stat, _l] = session.execute(reaction_query).unique().first()
+                [r, reacted_stat, commented_stat, likes_stat, dislikes_stat, _l] = (
+                    session.execute(reaction_query).unique().first()
+                )
 
                 if not r:
-                    return {'error': 'invalid reaction id'}
+                    return {"error": "invalid reaction id"}
 
                 author = session.query(Author).filter(Author.user == user_id).first()
                 if author:
-                    if r.created_by != author.id and 'editor' not in roles:
-                        return {'error': 'access denied'}
+                    if r.created_by != author.id and "editor" not in roles:
+                        return {"error": "access denied"}
 
-                    body = reaction.get('body')
+                    body = reaction.get("body")
                     if body:
                         r.body = body
                     r.updated_at = int(time.time())
 
-                    if r.kind != reaction['kind']:
+                    if r.kind != reaction["kind"]:
                         # Определение изменения мнения может быть реализовано здесь
                         pass
 
@@ -235,79 +259,79 @@ async def update_reaction(_, info, reaction):
                     session.commit()
 
                     r.stat = {
-                        'reacted': reacted_stat,
-                        'commented': commented_stat,
-                        'rating': int(likes_stat or 0) - int(dislikes_stat or 0),
+                        "reacted": reacted_stat,
+                        "commented": commented_stat,
+                        "rating": int(likes_stat or 0) - int(dislikes_stat or 0),
                     }
 
-                    await notify_reaction(r.dict(), 'update')
+                    await notify_reaction(r.dict(), "update")
 
-                    return {'reaction': r}
+                    return {"reaction": r}
                 else:
-                    return {'error': 'not authorized'}
+                    return {"error": "not authorized"}
             except Exception:
                 import traceback
 
                 traceback.print_exc()
-    return {'error': 'cannot create reaction'}
+    return {"error": "cannot create reaction"}
 
 
-@mutation.field('delete_reaction')
+@mutation.field("delete_reaction")
 @login_required
 async def delete_reaction(_, info, reaction_id: int):
-    user_id = info.context['user_id']
-    roles = info.context['roles']
+    user_id = info.context["user_id"]
+    roles = info.context["roles"]
     if isinstance(reaction_id, int) and user_id and isinstance(roles, list):
         with local_session() as session:
             try:
                 author = session.query(Author).filter(Author.user == user_id).one()
                 r = session.query(Reaction).filter(Reaction.id == reaction_id).one()
                 if r and author:
-                    if r.created_by is author.id and 'editor' not in roles:
-                        return {'error': 'access denied'}
+                    if r.created_by is author.id and "editor" not in roles:
+                        return {"error": "access denied"}
 
                     if r.kind in [ReactionKind.LIKE.value, ReactionKind.DISLIKE.value]:
                         session.delete(r)
                         session.commit()
-                        await notify_reaction(r.dict(), 'delete')
+                        await notify_reaction(r.dict(), "delete")
             except Exception as exc:
-                return {'error': f'cannot delete reaction: {exc}'}
-    return {'error': 'cannot delete reaction'}
+                return {"error": f"cannot delete reaction: {exc}"}
+    return {"error": "cannot delete reaction"}
 
 
 def apply_reaction_filters(by, q):
-    shout_slug = by.get('shout', None)
+    shout_slug = by.get("shout", None)
     if shout_slug:
         q = q.filter(Shout.slug == shout_slug)
 
-    elif by.get('shouts'):
-        q = q.filter(Shout.slug.in_(by.get('shouts', [])))
+    elif by.get("shouts"):
+        q = q.filter(Shout.slug.in_(by.get("shouts", [])))
 
-    created_by = by.get('created_by', None)
+    created_by = by.get("created_by", None)
     if created_by:
         q = q.filter(Author.id == created_by)
 
-    topic = by.get('topic', None)
+    topic = by.get("topic", None)
     if topic:
         q = q.filter(Shout.topics.contains(topic))
 
-    if by.get('comment', False):
+    if by.get("comment", False):
         q = q.filter(Reaction.kind == ReactionKind.COMMENT.value)
-    if by.get('rating', False):
+    if by.get("rating", False):
         q = q.filter(Reaction.kind.in_(RATING_REACTIONS))
 
-    by_search = by.get('search', '')
+    by_search = by.get("search", "")
     if len(by_search) > 2:
-        q = q.filter(Reaction.body.ilike(f'%{by_search}%'))
+        q = q.filter(Reaction.body.ilike(f"%{by_search}%"))
 
-    after = by.get('after', None)
+    after = by.get("after", None)
     if isinstance(after, int):
         q = q.filter(Reaction.created_at > after)
 
     return q
 
 
-@query.field('load_reactions_by')
+@query.field("load_reactions_by")
 async def load_reactions_by(_, info, by, limit=50, offset=0):
     """
     :param info: graphql meta
@@ -344,7 +368,7 @@ async def load_reactions_by(_, info, by, limit=50, offset=0):
     q = q.group_by(Reaction.id, Author.id, Shout.id, aliased_reaction.id)
 
     # order by
-    q = q.order_by(desc('created_at'))
+    q = q.order_by(desc("created_at"))
 
     # pagination
     q = q.limit(limit).offset(offset)
@@ -365,19 +389,19 @@ async def load_reactions_by(_, info, by, limit=50, offset=0):
             reaction.created_by = author
             reaction.shout = shout
             reaction.stat = {
-                'rating': int(likes_stat or 0) - int(dislikes_stat or 0),
-                'reacted': reacted_stat,
-                'commented': commented_stat,
+                "rating": int(likes_stat or 0) - int(dislikes_stat or 0),
+                "reacted": reacted_stat,
+                "commented": commented_stat,
             }
             reactions.add(reaction)
 
         # sort if by stat is present
-        stat_sort = by.get('stat')
+        stat_sort = by.get("stat")
         if stat_sort:
             reactions = sorted(
                 reactions,
                 key=lambda r: r.stat.get(stat_sort) or r.created_at,
-                reverse=stat_sort.startswith('-'),
+                reverse=stat_sort.startswith("-"),
             )
 
     return reactions
@@ -415,7 +439,9 @@ async def reacted_shouts_updates(follower_id: int, limit=50, offset=0) -> List[S
             q2 = add_stat_columns(q2, aliased(Reaction))
 
             # Sort shouts by the `last_comment` field
-            combined_query = union(q1, q2).order_by(desc('last_comment')).limit(limit).offset(offset)
+            combined_query = (
+                union(q1, q2).order_by(desc("last_comment")).limit(limit).offset(offset)
+            )
             results = session.execute(combined_query).scalars()
             with local_session() as session:
                 for [
@@ -427,26 +453,26 @@ async def reacted_shouts_updates(follower_id: int, limit=50, offset=0) -> List[S
                     last_comment,
                 ] in results:
                     shout.stat = {
-                        'viewed': await ViewedStorage.get_shout(shout.slug),
-                        'rating': int(likes_stat or 0) - int(dislikes_stat or 0),
-                        'reacted': reacted_stat,
-                        'commented': commented_stat,
-                        'last_comment': last_comment,
+                        "viewed": await ViewedStorage.get_shout(shout.slug),
+                        "rating": int(likes_stat or 0) - int(dislikes_stat or 0),
+                        "reacted": reacted_stat,
+                        "commented": commented_stat,
+                        "last_comment": last_comment,
                     }
                     shouts.append(shout)
 
     return shouts
 
 
-@query.field('load_shouts_followed')
+@query.field("load_shouts_followed")
 @login_required
 async def load_shouts_followed(_, info, limit=50, offset=0) -> List[Shout]:
-    user_id = info.context['user_id']
+    user_id = info.context["user_id"]
     with local_session() as session:
         author = session.query(Author).filter(Author.user == user_id).first()
         if author:
             try:
-                author_id: int = author.dict()['id']
+                author_id: int = author.dict()["id"]
                 shouts = await reacted_shouts_updates(author_id, limit, offset)
                 return shouts
             except Exception as error: