fmt

resolvers/editor.py

@@ -18,20 +18,17 @@ from services.search import search_service
 from services.logger import root_logger as logger
 
 
-@query.field("get_shouts_drafts")
+@query.field('get_shouts_drafts')
 @login_required
 async def get_shouts_drafts(_, info):
-    user_id = info.context["user_id"]
+    user_id = info.context['user_id']
     shouts = []
     with local_session() as session:
         author = session.query(Author).filter(Author.user == user_id).first()
         if author:
             q = (
                 select(Shout)
-                .options(
-                    joinedload(Shout.authors),
-                    joinedload(Shout.topics),
-                )
+                .options(joinedload(Shout.authors), joinedload(Shout.topics))
                 .filter(and_(Shout.deleted_at.is_(None), Shout.created_by == author.id))
                 .filter(Shout.published_at.is_(None))
                 .group_by(Shout.id)
@@ -40,28 +37,28 @@ async def get_shouts_drafts(_, info):
     return shouts
 
 
-@mutation.field("create_shout")
+@mutation.field('create_shout')
 @login_required
 async def create_shout(_, info, inp):
-    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 isinstance(author, Author):
             current_time = int(time.time())
-            slug = inp.get("slug") or f"draft-{current_time}"
+            slug = inp.get('slug') or f'draft-{current_time}'
             shout_dict = {
-                "title": inp.get("title", ""),
-                "subtitle": inp.get("subtitle", ""),
-                "lead": inp.get("lead", ""),
-                "description": inp.get("description", ""),
-                "body": inp.get("body", ""),
-                "layout": inp.get("layout", "article"),
-                "created_by": author.id,
-                "authors": [],
-                "slug": slug,
-                "topics": inp.get("topics", []),
-                "published_at": None,
-                "created_at": current_time,  # Set created_at as Unix timestamp
+                'title': inp.get('title', ''),
+                'subtitle': inp.get('subtitle', ''),
+                'lead': inp.get('lead', ''),
+                'description': inp.get('description', ''),
+                'body': inp.get('body', ''),
+                'layout': inp.get('layout', 'article'),
+                'created_by': author.id,
+                'authors': [],
+                'slug': slug,
+                'topics': inp.get('topics', []),
+                'published_at': None,
+                'created_at': current_time,  # Set created_at as Unix timestamp
             }
 
             new_shout = Shout(**shout_dict)
@@ -77,7 +74,7 @@ async def create_shout(_, info, inp):
 
                 topics = (
                     session.query(Topic)
-                    .filter(Topic.slug.in_(inp.get("topics", [])))
+                    .filter(Topic.slug.in_(inp.get('topics', [])))
                     .all()
                 )
                 for topic in topics:
@@ -89,20 +86,15 @@ async def create_shout(_, info, inp):
                 # notifier
                 # await notify_shout(shout_dict, 'create')
 
-                return {"shout": shout.dict()}
+                return {'shout': shout.dict()}
 
-    return {"error": "cant create shout"}
+    return {'error': 'cant create shout'}
 
 
 def patch_main_topic(session, main_topic, shout):
     old_main_topic = (
         session.query(ShoutTopic)
-        .filter(
-            and_(
-                ShoutTopic.shout == shout.id,
-                ShoutTopic.main.is_(True),
-            )
-        )
+        .filter(and_(ShoutTopic.shout == shout.id, ShoutTopic.main.is_(True)))
         .first()
     )
 
@@ -112,25 +104,22 @@ def patch_main_topic(session, main_topic, shout):
         new_main_topic = (
             session.query(ShoutTopic)
             .filter(
-                and_(
-                    ShoutTopic.shout == shout.id,
-                    ShoutTopic.topic == main_topic.id,
-                )
+                and_(ShoutTopic.shout == shout.id, ShoutTopic.topic == main_topic.id)
             )
             .first()
         )
 
         if old_main_topic and new_main_topic and old_main_topic is not new_main_topic:
-            ShoutTopic.update(old_main_topic, {"main": False})
+            ShoutTopic.update(old_main_topic, {'main': False})
             session.add(old_main_topic)
 
-            ShoutTopic.update(new_main_topic, {"main": True})
+            ShoutTopic.update(new_main_topic, {'main': True})
             session.add(new_main_topic)
 
 
 def patch_topics(session, shout, topics_input):
     new_topics_to_link = [
-        Topic(**new_topic) for new_topic in topics_input if new_topic["id"] < 0
+        Topic(**new_topic) for new_topic in topics_input if new_topic['id'] < 0
     ]
     if new_topics_to_link:
         session.add_all(new_topics_to_link)
@@ -141,12 +130,12 @@ def patch_topics(session, shout, topics_input):
         session.add(created_unlinked_topic)
 
     existing_topics_input = [
-        topic_input for topic_input in topics_input if topic_input.get("id", 0) > 0
+        topic_input for topic_input in topics_input if topic_input.get('id', 0) > 0
     ]
     existing_topic_to_link_ids = [
-        existing_topic_input["id"]
+        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]
+        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:
@@ -158,60 +147,54 @@ def patch_topics(session, shout, 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]
+        if topic.id not in [topic_input['id'] for topic_input in existing_topics_input]
     ]
 
     session.query(ShoutTopic).filter(
-        and_(
-            ShoutTopic.shout == shout.id,
-            ShoutTopic.topic.in_(topic_to_unlink_ids),
-        )
+        and_(ShoutTopic.shout == shout.id, ShoutTopic.topic.in_(topic_to_unlink_ids))
     ).delete(synchronize_session=False)
 
 
-@mutation.field("update_shout")
+@mutation.field('update_shout')
 @login_required
 async def update_shout(_, info, shout_id, shout_input=None, publish=False):
-    user_id = info.context["user_id"]
-    roles = info.context["roles"]
+    user_id = info.context['user_id']
+    roles = info.context['roles']
     shout_input = shout_input or {}
     with local_session() as session:
         author = session.query(Author).filter(Author.user == user_id).first()
         current_time = int(time.time())
-        shout_id = shout_id or shout_input.get("id")
+        shout_id = shout_id or shout_input.get('id')
         if isinstance(author, Author) and isinstance(shout_id, int):
             shout = (
                 session.query(Shout)
-                .options(
-                    joinedload(Shout.authors),
-                    joinedload(Shout.topics),
-                )
+                .options(joinedload(Shout.authors), joinedload(Shout.topics))
                 .filter(Shout.id == shout_id)
                 .first()
             )
 
             if not shout:
-                return {"error": "shout not found"}
+                return {'error': 'shout not found'}
             if (
                 shout.created_by is not author.id
                 and author.id not in shout.authors
-                and "editor" not in roles
+                and 'editor' not in roles
             ):
-                return {"error": "access denied"}
+                return {'error': 'access denied'}
 
             # topics patch
-            topics_input = shout_input.get("topics")
+            topics_input = shout_input.get('topics')
             if topics_input:
                 patch_topics(session, shout, topics_input)
-                del shout_input["topics"]
+                del shout_input['topics']
 
             # main topic
-            main_topic = shout_input.get("main_topic")
+            main_topic = shout_input.get('main_topic')
             if main_topic:
                 patch_main_topic(session, main_topic, shout)
 
-            shout_input["updated_at"] = current_time
-            shout_input["published_at"] = current_time if publish else None
+            shout_input['updated_at'] = current_time
+            shout_input['published_at'] = current_time if publish else None
             Shout.update(shout, shout_input)
             session.add(shout)
             session.commit()
@@ -219,44 +202,44 @@ async def update_shout(_, info, shout_id, shout_input=None, publish=False):
             shout_dict = shout.dict()
 
             if not publish:
-                await notify_shout(shout_dict, "update")
+                await notify_shout(shout_dict, 'update')
             else:
-                await notify_shout(shout_dict, "published")
+                await notify_shout(shout_dict, 'published')
                 # search service indexing
                 search_service.index(shout)
 
-            return {"shout": shout_dict}
-    logger.debug(f" cannot update with data: {shout_input}")
-    return {"error": "cant update shout"}
+            return {'shout': shout_dict}
+    logger.debug(f' cannot update with data: {shout_input}')
+    return {'error': 'cant update shout'}
 
 
-@mutation.field("delete_shout")
+@mutation.field('delete_shout')
 @login_required
 async def delete_shout(_, info, shout_id):
-    user_id = info.context["user_id"]
-    roles = info.context["roles"]
+    user_id = info.context['user_id']
+    roles = info.context['roles']
     with local_session() as session:
         author = session.query(Author).filter(Author.user == user_id).first()
         shout = session.query(Shout).filter(Shout.id == shout_id).first()
         if not shout:
-            return {"error": "invalid shout id"}
+            return {'error': 'invalid shout id'}
         if author and shout:
             if (
                 shout.created_by is not author.id
                 and author.id not in shout.authors
-                and "editor" not in roles
+                and 'editor' not in roles
             ):
-                return {"error": "access denied"}
+                return {'error': 'access denied'}
 
             for author_id in shout.authors:
                 reactions_unfollow(author_id, shout_id)
 
             shout_dict = shout.dict()
-            shout_dict["deleted_at"] = int(time.time())
+            shout_dict['deleted_at'] = int(time.time())
             Shout.update(shout, shout_dict)
             session.add(shout)
             session.commit()
-            await notify_shout(shout_dict, "delete")
+            await notify_shout(shout_dict, 'delete')
 
     return {}
 
@@ -290,7 +273,7 @@ def handle_proposing(session, r, shout):
                 if proposal.quote:
                     proposal_diff = get_diff(shout.body, proposal.quote)
                     proposal_dict = proposal.dict()
-                    proposal_dict["quote"] = apply_diff(
+                    proposal_dict['quote'] = apply_diff(
                         replied_reaction.quote, proposal_diff
                     )
                     Reaction.update(proposal, proposal_dict)
@@ -298,7 +281,7 @@ def handle_proposing(session, r, shout):
 
             # patch shout's body
             shout_dict = shout.dict()
-            shout_dict["body"] = replied_reaction.quote
+            shout_dict['body'] = replied_reaction.quote
             Shout.update(shout, shout_dict)
             session.add(shout)
             session.commit()