Format Error/Response main

index.py

@@ -17,6 +17,7 @@
 from src.services.commonServices.queueService.queueService import queue_obj
 from src.services.utils.logger import logger
 from src.routes.bridge_version_routes import router as bridge_version
+from src.middlewares.response_middleware import ResponseMiddleware
 
 async def consume_messages_in_executor():
     await queue_obj.consume_messages()
@@ -56,6 +57,8 @@ async def lifespan(app: FastAPI):
     allow_headers=["*"],
     max_age=86400
 )
+# Add middleware
+app.add_middleware(ResponseMiddleware)
 
 # Healthcheck route
 @app.get("/healthcheck")

src/controllers/apiCallController.py

@@ -1,21 +1,13 @@
 from fastapi import HTTPException, status
-from fastapi.responses import JSONResponse
 from src.db_services.apiCallDbService import get_all_api_calls_by_org_id
 from src.db_services.apiCallDbService import update_api_call_by_function_id
 from src.db_services.apiCallDbService import get_function_by_id
 
 async def get_all_apicalls_controller(request):
-    try:
         org_id = request.state.profile['org']['id']
         functions = await get_all_api_calls_by_org_id(org_id=org_id)
-        return JSONResponse(status_code=200, content={
-                "success": True,
-                "message": "Get all functions of a org successfully",
-                "data" : functions,
-                "org_id": org_id # [?] is it really needed
-            })
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e,)
+        response_data = {"functions": functions,"org_id": org_id}
+        return response_data
 
 
 async def validate_data_to_update(data_to_update: dict,  db_data: dict) -> bool: 
@@ -39,7 +31,6 @@ def recursive_check(data, expected, path=''):
 
 
 async def update_apicalls_controller(request, function_id):
-    try:
         org_id = request.state.profile['org']['id']
         body = await request.json()  
         data_to_update = body.get('dataToSend')  
@@ -61,12 +52,5 @@ async def update_apicalls_controller(request, function_id):
         updated_function = await update_api_call_by_function_id(
             org_id=org_id, function_id=function_id, data_to_update=data_to_update
         )
-
-        return JSONResponse(status_code=200, content={
-            "success": True,
-            "data": updated_function
-        })
-
-    except Exception as e:
-        print(f"Error updating function: {e}")
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+        response_data = {updated_function}
+        return response_data

src/controllers/apicallControllerV2.py

@@ -1,5 +1,4 @@
 from fastapi import Request, HTTPException
-from fastapi.responses import JSONResponse
 from src.db_services.ConfigurationServices import get_bridges, update_bridge, get_bridges_with_tools
 from src.services.utils.helper import Helper
 from src.services.utils.apicallUtills import  get_api_data, save_api, delete_api
@@ -8,7 +7,6 @@
 
 
 async def creates_api(request: Request):
-    try:
         body = await request.json()
         org_id = request.state.profile.get("org",{}).get("id","")
         function_name = body.get('id')
@@ -46,36 +44,24 @@ async def creates_api(request: Request):
                 raise HTTPException(status_code=400, detail="Something went wrong!")
 
             if result.get('success'):
-                return JSONResponse(status_code=200, content={
-                    "message": "API saved successfully",
-                    "success": True,
-                    "activated": True,
-                    "data": result['api_data']
-                })
+                response_data = {"activated": True,"data": result['api_data']}
+                return response_data
             else:
                 raise HTTPException(status_code=400, detail=result)
 
         elif status in ["delete", "paused"]:
             result = await delete_api(function_name, org_id)
             if result:
-                return JSONResponse(status_code=200, content={
-                    "message": "API deleted successfully",
-                    "success": True,
-                    "deleted": True,
-                    "data": result
-                })
+                response_data = {"deleted": True,"data": result}
+                return response_data
             else:
                 raise HTTPException(status_code=400, detail=result)
 
         raise HTTPException(status_code=400, detail="Something went wrong!")
 
-    except Exception as error:
-        print(f"error in viasocket embed get api=> {error}")
-        raise HTTPException(status_code=400, detail=str(error))
 
 
 async def updates_api(request: Request, bridge_id: str):
-    try:
         body = await request.json()
         version_id = body.get('version_id')
         org_id = request.state.org_id if hasattr(request.state, 'org_id') else None
@@ -95,19 +81,9 @@ async def updates_api(request: Request, bridge_id: str):
 
         result = await get_bridges_with_tools(bridge_id, org_id, version_id)
 
-        if result.get("success"):
-            return Helper.response_middleware_for_bridge({
-                "success": True,
-                "message": "Bridge Updated successfully",
-                "bridge" : result.get('bridges')
-
-            })
-        else:
-            return JSONResponse(status_code=400, content=result)
-
-    except Exception as error:
-        print(f"error in viasocket embed get api => {error}")
-        raise HTTPException(status_code=400, detail=str(error))
+        return Helper.response_middleware_for_bridge({
+            "bridge" : result.get('bridges')
+        })
 
 
 def traverse_body(body, path=None, paths=None, fields=None, required_params=None):

src/controllers/bridge_version_controller.py

@@ -1,33 +1,23 @@
 import json
 from fastapi import HTTPException, status
-from fastapi.responses import JSONResponse
 from ..db_services.bridge_version_services import create_bridge_version, update_bridges, get_version_with_tools, publish
 from src.services.utils.helper import Helper
 from ..db_services.ConfigurationServices import get_bridges_with_tools, update_bridge, get_bridges_without_tools
 from bson import ObjectId
 async def create_version(request):
-    try:
        body = await request.json()
        version_id = body.get('version_id')
        org_id = request.state.profile['org']['id']
        bridge_data = await get_bridges_without_tools(org_id=org_id, version_id= version_id)
-       if bridge_data is None:
-           return JSONResponse({"success": False, "message": "no version found"})
        parent_id = bridge_data.get('bridges').get('parent_id')
        create_new_version = await create_bridge_version(bridge_data.get('bridges'), parent_id=parent_id)
        update_fields = {'versions' : [create_new_version]}
        await update_bridges(parent_id, update_fields)
        return {
-           "success": True,
-           "message" : "version created successfully",
            "version_id" : create_new_version
        }
 
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e)
-
 async def get_version(request, version_id: str):
-    try:
         org_id = request.state.profile.get("org",{}).get("id","")
         bridge = await get_version_with_tools(version_id, org_id)
         prompt = bridge.get('bridges').get('configuration',{}).get('prompt')
@@ -43,20 +33,16 @@ async def get_version(request, version_id: str):
                 path_variables.append(vars_dict)
         all_variables = variables + path_variables
         bridge.get('bridges')['all_varaibles'] = all_variables
-        return Helper.response_middleware_for_bridge({"succcess": True,"message": "bridge get successfully","bridge":bridge.get("bridges", {})})
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e,)
+        return Helper.response_middleware_for_bridge({"bridge":bridge.get("bridges", {})})
 
 
 async def publish_version(request, version_id):
-    try:
         org_id = request.state.profile['org']['id']
         result = await publish(org_id, version_id)
         if result['success']:
-            return JSONResponse({"success": True, "message": "version published successfully", "version_id": version_id})
+           response_data = {"version_id": version_id}
+           return response_data
         return result
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e)
 
 
 async def discard_version(request, version_id):
@@ -73,8 +59,10 @@ async def discard_version(request, version_id):
     function_ids = bridge_data['bridges'].get('function_ids', [])
     bridge_data['bridges']['function_ids'] = [ObjectId(fid) for fid in function_ids]
     result = await update_bridge(version_id=version_id, update_fields=bridge_data['bridges'])
-    if 'success' in result:
-        return JSONResponse({"success": True, "message": "version changes discarded successfully", "version_id": version_id})
+    if 'result' in result and result['result']:
+        response_data = {"version_id": version_id}
+        return response_data
     return result
+
 
 

src/controllers/configController.py

@@ -1,5 +1,4 @@
 from fastapi import HTTPException, status
-from fastapi.responses import JSONResponse
 from pydantic import ValidationError
 from src.db_services.ConfigurationServices import create_bridge, get_bridge_by_id, get_all_bridges_in_org, update_bridge, update_bridge_ids_in_api_calls, get_bridges_with_tools, get_apikey_creds
 from src.configs.modelConfiguration import ModelsConfig as model_configuration
@@ -13,7 +12,6 @@
 from src.services.utils.getDefaultValue import get_default_values_controller
 from src.db_services.bridge_version_services import create_bridge_version
 async def create_bridges_controller(request):
-    try:
         bridges = await request.json()
         type = bridges.get('type')
         org_id = request.state.profile['org']['id']
@@ -61,27 +59,13 @@ async def create_bridges_controller(request):
             "org_id" : org_id,
             "status": status
         })
-        if result.get("success"):
-            create_version = await create_bridge_version(result['bridge'])
-            update_fields = {'versions' : [create_version]}
-            updated_bridge_result = (await update_bridge(str(result['bridge']['_id']), update_fields)).get('result',{})
-            return JSONResponse(status_code=200, content={
-                "success": True,
-                "message": "Bridge created successfully",
-                "bridge" : json.loads(json.dumps(updated_bridge_result, default=str))
-
-            })
-        else:
-            return JSONResponse(status_code=400, content={
-                "success": False,
-                "message": json.loads(json.dumps(result.get('error'), default=str))
-            })
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e)    
+        create_version = await create_bridge_version(result['bridge'])
+        update_fields = {'versions' : [create_version]}
+        updated_bridge_result = (await update_bridge(str(result['bridge']['_id']), update_fields)).get('result',{})
+        response_data = {"bridge" : json.loads(json.dumps(updated_bridge_result, default=str))}
+        return response_data   
 
 async def duplicate_create_bridges(bridges):
-    try:
-
         org_id = bridges.get('org_id')
         service = bridges.get('service') 
         bridgeType = bridges.get('bridgeType')
@@ -118,14 +102,8 @@ async def duplicate_create_bridges(bridges):
 
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=result)
 
-    except HTTPException as e:
-        raise e
-    except Exception as error:
-        print(f"common error=> {error}")
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="An unexpected error occurred while creating the bridge. Please try again later.")
 
 async def get_bridge(request, bridge_id: str):
-    try:
         bridge = await get_bridges_with_tools(bridge_id,request.state.profile['org']['id'])
         if(bridge.get('bridges') is None):
             raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bridge not found")
@@ -142,27 +120,20 @@ async def get_bridge(request, bridge_id: str):
                 path_variables.append(vars_dict)
         all_variables = variables + path_variables
         bridge.get('bridges')['all_varaibles'] = all_variables
-        return Helper.response_middleware_for_bridge({"succcess": True,"message": "bridge get successfully","bridge":bridge.get("bridges", {})})
-    except Exception as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e,)
+        return Helper.response_middleware_for_bridge({"bridge":bridge.get("bridges", {})})
 
 async def get_all_bridges(request):
-    try:
         org_id = request.state.profile['org']['id']
         bridges = await get_all_bridges_in_org(org_id)
         embed_token = Helper.generate_token({ "org_id": Config.ORG_ID, "project_id": Config.PROJECT_ID, "user_id": org_id },Config.Access_key )
-        return JSONResponse(status_code=200, content={
-                "success": True,
-                "message": "Get all bridges successfully",
+        response_data = {
                 "bridge" : bridges,
                 "embed_token": embed_token,
-                "org_id": org_id
+                "org_id": org_id 
+        }
+        return response_data
 
-            })
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
 async def get_all_service_models_controller(service):
-    try:
         service = service.lower()
         def restructure_configuration(config):
             model_field = config.get("configuration", {}).get("model", "")
@@ -261,12 +232,8 @@ def restructure_configuration(config):
             }
 
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
 
 async def update_bridge_controller(request, bridge_id=None, version_id=None):
-    try:
         body  = await request.json()
         org_id = request.state.profile['org']['id']
         slugName = body.get('slugName')
@@ -375,15 +342,6 @@ async def update_bridge_controller(request, bridge_id=None, version_id=None):
         result = await get_bridges_with_tools(bridge_id, org_id, version_id)
         await add_bulk_user_entries(user_history)
 
-        if result.get("success"):
-            return Helper.response_middleware_for_bridge({
-                "success": True,
-                "message": "Bridge Updated successfully",
-                "bridge" : result.get('bridges')
-
-            })
-    except ValidationError as e:
-        raise HTTPException(status_code=400, detail=f"Validation error: {e.json()}")
-    except Exception as e:
-        print(e)
-        raise HTTPException(status_code=400, detail="Invalid request body!")
+        return Helper.response_middleware_for_bridge({
+            "bridge" : result.get('bridges')
+        })