fix(repository): Debugging fastapi package methods

Author: IhorSotnyk

monobank_api_client/drf_mono/views.py

@@ -17,29 +17,35 @@ class MonoView(GenericAPIView):
 
     def post(self, request) -> Dict:
         serializer = self.serializer_class(data=request.data)
-        serializer.is_valid(raise_exception=True)
+        serializer.is_valid()
         _ = serializer.validated_data
-        mono_obj = Mono.objects.filter(user=self.request.user)
-        mono_obj.create(mono_token=_["mono_token"], user=request.user)
+        mono = Mono.objects.filter(user=self.request.user)
         mng = SyncMonoManager()
-        response = mng.create_success()
+        if mono.first() is not None:
+            response = mng.exists_exception()
+        else:
+            mono.create(mono_token=_["mono_token"], user=request.user)
+            response = mng.create_success()
         return Response(response)
 
     def put(self, request) -> Dict:
         serializer = self.serializer_class(data=request.data)
         serializer.is_valid(raise_exception=True)
         _ = serializer.validated_data
-        mono_obj = Mono.objects.filter(user=request.user)
-        mono_obj.update(mono_token=_["mono_token"])
+        mono = Mono.objects.filter(user=request.user)
         mng = SyncMonoManager()
-        response = mng.update_success()
+        if mono.first() is not None:
+            mono.update(mono_token=_["mono_token"])
+            response = mng.update_success()
+        else:
+            response = mng.does_not_exsists_exception()
         return Response(response)
 
     def delete(self, request) -> Dict:
         mng = SyncMonoManager()
-        mono_obj = Mono.objects.filter(user=request.user)
-        if mono_obj.first() is not None:
-            mono_obj.delete()
+        mono = Mono.objects.filter(user=request.user)
+        if mono.first() is not None:
+            mono.delete()
             response = mng.delete_success()
         else:
             response = mng.does_not_exsists_exception()

monobank_api_client/fastapi_mono/crud.py

@@ -12,59 +12,51 @@ async def create_mono(schema: MonoSchema, session: AsyncSession) -> Dict:
         query = await session.execute(select(mdl).where(mdl.user_id == schema.user_id))
         if query.first() is not None:
             return mng.exists_exception()
-        else:
-            new_obj = insert(mdl).values(**schema.model_dump())
-            await session.execute(new_obj)
-            await session.commit()
-            response = mng.create_success()
-        return response
+        new_obj = insert(mdl).values(**schema.model_dump())
+        await session.execute(new_obj)
+        await session.commit()
+        return mng.create_success()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
-async def read_mono(user: str, session: AsyncSession) -> Dict:
+async def read_mono(user_id: str, session: AsyncSession) -> Dict:
     try:
-        query = await session.execute(select(mdl).where(mdl.user_id == user))
-        token = query.first()[0].mono_token
-        response = {"token": token}
-        return response
+        query = await session.execute(select(mdl).where(mdl.user_id == user_id))
+        return query.first()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
 async def update_mono(
-    user: str, schema: MonoSchemaUpdate, session: AsyncSession
+    user_id: str, schema: MonoSchemaUpdate, session: AsyncSession
 ) -> Dict:
     try:
         mng = AsyncMonoManager()
-        query = await session.execute(select(mdl).where(mdl.user_id == user))
+        query = await session.execute(select(mdl).where(mdl.user_id == user_id))
         if query.first() is not None:
             query = await session.execute(
-                update(mdl).values(**schema.model_dump()).where(mdl.user_id == user)
+                update(mdl).values(**schema.model_dump()).where(mdl.user_id == user_id)
             )
             await session.commit()
-            response = mng.update_success()
-        else:
-            return mng.does_not_exsists_exception()
-        return response
+            return mng.update_success()
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
-async def delete_mono(user: str, session: AsyncSession) -> Dict:
+async def delete_mono(user_id: str, session: AsyncSession) -> Dict:
     try:
         mng = AsyncMonoManager()
-        query = await session.execute(select(mdl).where(mdl.user_id == user))
+        query = await session.execute(select(mdl).where(mdl.user_id == user_id))
         if query.first() is not None:
-            query = await session.execute(delete(mdl).where(mdl.user_id == user))
+            query = await session.execute(delete(mdl).where(mdl.user_id == user_id))
             await session.commit()
-            response = mng.delete_success()
-        else:
-            return mng.does_not_exsists_exception()
-        return response
+            return mng.delete_success()
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception

monobank_api_client/fastapi_mono/router.py

@@ -72,68 +72,61 @@ async def currency(ccy_pair: str) -> Dict:
 
 @router.get("/client_info")
 async def client_info(
-    user: str, session: AsyncSession = Depends(async_session)
+    user_id: str, session: AsyncSession = Depends(async_session)
 ) -> Dict:
     try:
         mng = AsyncMonoManager()
-        mono = await crud.read_mono(user, session)
-        token = mono.get("token")
-        if token is not None:
-            mng.token = token
-            response = await mng.get_client_info()
-        else:
-            response = mng.does_not_exsists_exception()
-        return response
+        payload = await crud.read_mono(user_id, session)
+        if payload is not None:
+            mng.token = payload[0].mono_token
+            return await mng.get_client_info()
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
 @router.get("/balance")
-async def balance(user: str, session: AsyncSession = Depends(async_session)) -> Dict:
+async def balance(user_id: str, session: AsyncSession = Depends(async_session)) -> Dict:
     try:
         mng = AsyncMonoManager()
-        mono = await crud.read_mono(user, session)
-        token = mono.get("token")
-        if token is not None:
-            mng.token = token
-            response = await mng.get_balance()
-        else:
-            response = mng.does_not_exsists_exception()
-        return response
+        payload = await crud.read_mono(user_id, session)
+        if payload is not None:
+            mng.token = payload[0].mono_token
+            return await mng.get_balance()
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
 @router.get("/statement")
 async def statement(
-    user: str, period: int, session: AsyncSession = Depends(async_session)
+    user_id: str, period: int, session: AsyncSession = Depends(async_session)
 ) -> Dict:
     try:
         mng = AsyncMonoManager()
-        mono = await crud.read_mono(user, session)
-        token = mono.get("token")
-        if token is not None:
-            mng.token = token
-            response = await mng.get_statement(period)
-        else:
-            response = mng.does_not_exsists_exception()
-        return response
+        payload = await crud.read_mono(user_id, session)
+        if payload is not None:
+            mng.token = payload[0].mono_token
+            return await mng.get_statement(period)
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
 
 
 @router.post("/webhook")
 async def webhook(
-    user: str, webhook: str, session: AsyncSession = Depends(async_session)
+    user_id: str, webhook: str, session: AsyncSession = Depends(async_session)
 ) -> Dict:
     try:
-        mono = await crud.read_mono(user, session)
-        mng = AsyncMonoManager(mono.get("token"))
-        response = await mng.create_webhook(webhook)
-        return response
+        mng = AsyncMonoManager()
+        payload = await crud.read_mono(user_id, session)
+        if payload is not None:
+            mng.token = payload[0].mono_token
+            return await mng.create_webhook(webhook)
+        return mng.does_not_exsists_exception()
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception

monobank_api_client/mono_config/config.py

@@ -131,13 +131,13 @@
 }
 
 MONO_CREATE_SUCCESS_CODE = 201
-MONO_CREATE_SUCCESS_DETAIL = "Mono-token added successfully."
+MONO_CREATE_SUCCESS_DETAIL = "Mono added successfully."
 
 MONO_UPDATE_SUCCESS_CODE = 200
-MONO_UPDATE_SUCCESS_DETAIL = "Mono-token chanched successfully."
+MONO_UPDATE_SUCCESS_DETAIL = "Mono chanched successfully."
 
 MONO_DELETE_SUCCESS_CODE = 204
-MONO_DELETE_SUCCESS_DETAIL = "Mono-token deleted successfully."
+MONO_DELETE_SUCCESS_DETAIL = "Mono deleted successfully."
 
 MONO_CURRENCY_EXCEPTION_CODE = 400
 MONO_CURRENCY_EXCEPTION_DETAIL = "Incorrect currency pair."

setup.py

@@ -8,7 +8,7 @@ def readme():
 
 setup(
     name="monobank_api_client",
-    version="1.1.5",
+    version="1.1.8",
     author="ihor.sotnyk",
     author_email="ihor.sotnyk@onix-systems.com",
     description="This module is designed for quick interaction with the monobank API.",