[update]: Resposes

app/api/helpers/response_helper.py

@@ -1,251 +1,112 @@
 from flask import jsonify
-from typing import List, Dict, Union, Optional, Any
+from typing import Optional, Union, Dict, List, Any
 
 
 class ResponseHelper:
     """
-    A helper class for building standardized JSON responses in Flask.
+    A helper class for building standardized JSON responses using resultCode and resultDescription.
     """
 
     @staticmethod
     def build_response(
-        status: bool,
+        result_code: str,
-        message: str,
+        result_description: str,
-        data: Optional[Union[Dict, List, str]] = None,
+        data: Optional[Union[Dict, List, str]] = None
-        status_code: int = 200,
-        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        """
-        Build a standardized JSON response.
-
-        Args:
-            status (bool): Indicates whether the request was successful.
-            message (str): A message describing the result of the request.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            status_code (int): The HTTP status code for the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
         response = {
-            "status": status,
+            "resultCode": result_code,
-            "statusCode": status_code,
+            "resultDescription": result_description
-            "message": message,
-            "data": data if data is not None else {},
-            "error": error if error is not None else {},
         }
-        return jsonify(response), status_code
+
+        if isinstance(data, dict):
+            response.update(data)
+
+        return jsonify(response)
 
     @staticmethod
     def success(
-        data: Optional[Union[Dict, List, str]] = None,
+        result_description: str = "Successful",
-        message: str = "Successful",
+        result_code: str = "00",
-        status_code: int = 200,
+        data: Optional[Dict[str, Any]] = None
-        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a success response.
-
-        Args:
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            message (str): A message describing the result of the request.
-            status_code (int): The HTTP status code for the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(True, message, data, status_code, error)
 
     @staticmethod
     def error(
-        message: str = "An error occurred",
+        result_description: str = "An error occurred",
-        status_code: int = 400,
+        result_code: str = "01",
-        data: Optional[Union[Dict, List, str]] = None,
+        data: Optional[Dict[str, Any]] = None
-        error: Optional[Union[Dict, str]] = None,
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return an error response.
-
-        Args:
-            message (str): A message describing the error.
-            status_code (int): The HTTP status code for the response.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, status_code, error)
 
     @staticmethod
     def created(
-        data: Optional[Union[Dict, List, str]] = None,
+        result_description: str = "Resource created successfully",
-        message: str = "Resource created successfully",
+        result_code: str = "00",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for a created resource.
-
-        Args:
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            message (str): A message describing the result of the request.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(True, message, data, 201, error)
 
     @staticmethod
     def updated(
-        data: Optional[Union[Dict, List, str]] = None,
+        result_description: str = "Resource updated successfully",
-        message: str = "Resource updated successfully",
+        result_code: str = "00",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for an updated resource.
-
-        Args:
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            message (str): A message describing the result of the request.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(True, message, data, 200, error)
 
     @staticmethod
     def internal_server_error(
-        message: str = "Internal Server Error",
+        result_description: str = "Internal Server Error",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "500",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for an internal server error.
-
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 500, error)
 
     @staticmethod
     def unauthorized(
-        message: str = "Unauthorized",
+        result_description: str = "Unauthorized",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "401",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for an unauthorized request.
-
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 401, error)
 
     @staticmethod
     def forbidden(
-        message: str = "Forbidden",
+        result_description: str = "Forbidden",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "403",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for a forbidden request.
-
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 403, error)
 
     @staticmethod
     def not_found(
-        message: str = "Resource not found",
+        result_description: str = "Resource not found",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "404",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for a not found resource.
-
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 404, error)
 
     @staticmethod
     def unprocessable_entity(
-        message: str = "Unprocessable entity",
+        result_description: str = "Unprocessable entity",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "422",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for an unprocessable entity.
 
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 422, error)
-    
     @staticmethod
     def method_not_allowed(
-        message: str = "Method Not Allowed",
+        result_description: str = "Method Not Allowed",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "405",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for a method not allowed error.
 
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 405, error)
-    
     @staticmethod
     def bad_request(
-        message: str = "Bad Request",
+        result_description: str = "Bad Request",
-        data: Optional[Union[Dict, List, str]] = None,
+        result_code: str = "400",
-        error: Optional[Union[Dict, str]] = None,
+        data: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
-        """
+        return ResponseHelper.build_response(result_code, result_description, data)
-        Return a response for a bad request error.
-
-        Args:
-            message (str): A message describing the error.
-            data (Optional[Union[Dict, List, str]]): The data to return in the response.
-            error (Optional[Union[Dict, str]]): Any error details to include in the response.
-
-        Returns:
-            Dict[str, Any]: A dictionary representing the JSON response.
-        """
-        return ResponseHelper.build_response(False, message, data, 400, error)

app/api/services/authorization.py

@@ -34,7 +34,7 @@ class AuthorizationService(BaseService):
             logger.info("Processing Authorization request")
 
             if not data:
-                return ResponseHelper.bad_request(message="Missing JSON in request")
+                return ResponseHelper.bad_request(result_description="Missing JSON in request")
 
             # Validate input data using the Authorization schema
             schema = AuthorizeRequestSchema()
@@ -44,7 +44,7 @@ class AuthorizationService(BaseService):
                 validated_data["username"] != USERNAME
                 or validated_data["password"] != PASSWORD
             ):
-                return ResponseHelper.unauthorized(message="Invalid credentials")
+                return ResponseHelper.unauthorized(result_description="Invalid credentials")
 
             access_token = create_access_token(identity=validated_data["username"])
             refresh_token = create_refresh_token(identity=validated_data["username"])
@@ -56,17 +56,17 @@ class AuthorizationService(BaseService):
             }
 
             return ResponseHelper.success(
-                data=response_data, message="Authorization processed successfully"
+                data={"data": response_data}, result_description="Authorization processed successfully"
             )
 
         except ValidationError as e:
             logger.error(f"Validation error: {e}")
-            return ResponseHelper.bad_request(message=f"Validation error: {e}")
+            return ResponseHelper.bad_request(result_description=f"Validation error: {e}")
 
         except Exception as e:
             logger.error(f"Error processing Authorization request: {e}")
             return ResponseHelper.internal_server_error(
-                message=f"Error processing Authorization request: {e}"
+                result_description=f"Error processing Authorization request: {e}"
             )
 
     @staticmethod
@@ -92,11 +92,11 @@ class AuthorizationService(BaseService):
             }
 
             return ResponseHelper.success(
-                data=response_data, message="RefreshToken processed successfully"
+                data={"data": response_data}, result_description="RefreshToken processed successfully"
             )
 
         except Exception as e:
             logger.error(f"Error processing RefreshToken request: {e}")
             return ResponseHelper.internal_server_error(
-                message=f"Error processing RefreshToken request: {e}"
+                result_description=f"Error processing RefreshToken request: {e}"
             )

app/api/services/customer_consent.py

@@ -1,4 +1,5 @@
 from flask import request, jsonify
+from app.api.helpers.response_helper import ResponseHelper
 from app.api.services.base_service import BaseService
 from marshmallow import ValidationError
 from app.utils.logger import logger
@@ -34,44 +35,26 @@ class CustomerConsentService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                            "message": "Failed to log transaction."
-                        }), 400
                 else:  
-                    return jsonify({
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
-                            "message": "Invalid Customer or Account"
-                        }), 400
 
-                    
-                # Simulated processing logic
-                response_data = {
-                    "resultCode": "00",
-                    "resultDescription": "Request is received"
-                }
 
                 db.session.commit()
-                return response_data
+                return ResponseHelper.success(result_description="Request is received")
             
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
             db.session.rollback()
-
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-            return jsonify({
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
             db.session.rollback()
-
+            return ResponseHelper.error(result_description=str(err))
-            return jsonify({
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             db.session.rollback()
-            return jsonify({
+            return ResponseHelper.internal_server_error()
-                "message": "Internal Server Error"
-                }) , 500

app/api/services/eligibility_check.py

@@ -9,6 +9,7 @@ from app.api.integrations import SimbrellaIntegration
 from app.extensions import db
 from app.models import Offer, RACCheck
 from app.api.services.offer_analysis import OfferAnalysis
+from app.api.helpers.response_helper import ResponseHelper
 
 import random
 
@@ -44,14 +45,9 @@ class EligibilityCheckService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                            "message": "Failed to log transaction."
+                else:  
-                        }), 400
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
-                        
-                else: 
-                    return jsonify({
-                            "message": "Invalid Customer or Account"
-                        }), 400
                 
                 db.session.flush()
                 
@@ -64,7 +60,7 @@ class EligibilityCheckService(BaseService):
 
                 # this chck for error is not valid
                 if response.status_code != 200:
-                   return jsonify({"message": "RACCheck failed"}), 400
+                    return ResponseHelper.error(result_description="RACCheck failed")
                 
                 response = response.json()
                 
@@ -77,9 +73,7 @@ class EligibilityCheckService(BaseService):
                 
                 if not rac_check:
                         logger.error(f"Failed to save RACCheck")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to save RACCheck.")
-                            "message": "Failed to save RACCheck."
-                        }), 400
 # -----------------TIME FOR ANALYSIS TO REGISTER OFFER ----------------------
                 # eligible_offers = []
                 try:
@@ -91,9 +85,7 @@ class EligibilityCheckService(BaseService):
                     )
                 except ValueError as ve:
                     logger.error(str(ve))
-                    return jsonify({
+                    return ResponseHelper.error(result_description= str(ve))
-                        "message": str(ve)
-                    }), 400
 # -----------------------------------------------------------------------
 #                 s = Offer.get_all_offers()
 
@@ -135,30 +127,23 @@ class EligibilityCheckService(BaseService):
                     "countryCode": "NG",
                     "msisdn": msisdn,
                     "eligibleOffers": eligible_offers,
-                    "resultDescription": "Successful",
-                    "resultCode": "00",
                     "accountId": account_id
                     }
 
-                return response_data
+                return ResponseHelper.success(data=response_data)
         
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.error(result_description=str(err))
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
-            return jsonify({
+            db.session.rollback()
-                "message": "Internal Server Error"
+            return ResponseHelper.internal_server_error()
-                }) , 500

app/api/services/loan_status.py

@@ -6,7 +6,8 @@ from app.utils.logger import logger
 from app.api.schemas.loan_status import LoanStatusSchema 
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType   
-from app.extensions import db  
+from app.extensions import db
+from app.api.helpers.response_helper import ResponseHelper
 
 
 class LoanStatusService(BaseService):
@@ -43,13 +44,9 @@ class LoanStatusService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                            "message": "Failed to log transaction."
+                else:  
-                        }), 400
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
-                else: 
-                    return jsonify({
-                            "message": "Invalid Customer or Account"
-                        }), 400
         
 
                 # loans = [
@@ -76,33 +73,23 @@ class LoanStatusService(BaseService):
                     "transactionId": transactionId,
                     "loans": loans,
                     "totalDebtAmount": total_debt_amount,
-                    "resultCode": "00",
-                    "resultDescription": "Successful"
                 }
 
                 db.session.commit()
-                return response_data
+                return ResponseHelper.success(data=response_data)
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
             db.session.rollback()
-
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-            return jsonify({
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
             db.session.rollback()
-
+            return ResponseHelper.error(result_description=str(err))
-            return jsonify({
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             db.session.rollback()
-            return jsonify({
+            return ResponseHelper.internal_server_error()
-                "message": "Internal Server Error"
-                }) , 500

app/api/services/notification_callback.py

@@ -5,6 +5,7 @@ from app.api.enums import TransactionType
 from app.utils.logger import logger
 from app.api.schemas.notification_callback import NotificationCallbackSchema
 from app.extensions import db
+from app.api.helpers.response_helper import ResponseHelper
 
 class NotificationCallbackService(BaseService):
     TRANSACTION_TYPE = TransactionType.NOTIFICATION_CALLBACK 
@@ -27,37 +28,20 @@ class NotificationCallbackService(BaseService):
             schema = NotificationCallbackSchema()
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
-            # Simulated processing logic
+            return ResponseHelper.success()
-            response_data = {
-                "resultCode": "00",
-                "resultDescription": "Successful"
-            }
-
-
-            # return ResponseHelper.success(
-            #     data=response_data,
-            #     message="Notification callback processed successfully"
-            # )
-
-            return response_data
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.error(result_description=str(err))
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
-            return jsonify({
+            db.session.rollback()
-                "message": "Internal Server Error"
+            return ResponseHelper.internal_server_error()
-                }) , 500

app/api/services/provide_loan.py

@@ -15,6 +15,7 @@ from datetime import datetime, timezone
 from dateutil.relativedelta import relativedelta
 from app.models import LoanRepaymentSchedule 
 from app.api.services.offer_analysis import OfferAnalysis
+from app.api.helpers.response_helper import ResponseHelper
 
 class ProvideLoanService(BaseService):
     TRANSACTION_TYPE = TransactionType.PROVIDE_LOAN 
@@ -58,9 +59,7 @@ class ProvideLoanService(BaseService):
                         )
                     except ValueError as ve:
                         logger.error(str(ve))
-                        return jsonify({
+                        return ResponseHelper.error(result_description=str(ve))
-                            "message": str(ve)
-                        }), 400
                     
                     # transaction_offer_id =  int(offer_id[5:]) # The last part is int
 
@@ -87,9 +86,7 @@ class ProvideLoanService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                            "message": "Failed to log transaction."
-                        }), 400
                     
 
                     db.session.flush()
@@ -129,9 +126,8 @@ class ProvideLoanService(BaseService):
 
                     if not loan:
                         logger.error(f"Failed to save loan details")
-                        return jsonify({
+                        
-                            "message": "Failed to save loan details."
+                        return ResponseHelper.error(result_description="Failed to save loan details.")
-                        }), 400
 
                     db.session.flush()
                     current_product_id = offer.product_id
@@ -140,9 +136,7 @@ class ProvideLoanService(BaseService):
 
                     if not schedule:
                         logger.error(f"Failed to create repayment schedule for loan ID {loan.id}")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to generate loan repayment schedule.")
-                            "message": "Failed to generate loan repayment schedule."
-                        }), 400
 
                     # charges = Charge.get_offer_charges(offer.id)
 
@@ -155,22 +149,15 @@ class ProvideLoanService(BaseService):
 
                     
                 else: 
-                    return jsonify({
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
-                            "message": "Invalid Customer or Account"
+            
-                        }), 400
-
-                padded_loan_id = str(loan_id).zfill(9)
-                loanRef =  f"LID{padded_loan_id}{channel}{current_product_id}"
             
                 response_data = {
                     "requestId": request_id,
                     "transactionId": transaction_id,
                     "customerId": customer_id,
                     "accountId": account_id,
-                    "msisdn": customer.msisdn,
+                    "msisdn": customer.msisdn
-                    "loanRef": loanRef,
-                    "resultCode": "00",
-                    "resultDescription": "Successful"
                     }
 
 
@@ -180,28 +167,20 @@ class ProvideLoanService(BaseService):
                 thread.start()
 
                 db.session.commit()
-                return response_data
+                return ResponseHelper.success(data=response_data)
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-            return jsonify({
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-
+            return ResponseHelper.error(result_description=str(err))
-            return jsonify({
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
-            db.session.rollback() 
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.internal_server_error()
-                "message": "Internal Server Error"
-                }) , 500

app/api/services/repayment.py

@@ -1,6 +1,7 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.api.enums.loan_status import LoanStatus
+from app.api.helpers.response_helper import ResponseHelper
 from app.models import Repayment
 from app.models.customer import Customer
 from app.models.loan import Loan
@@ -49,9 +50,7 @@ class RepaymentService(BaseService):
 
                     if not repayment:
                         logger.error(f"Failed to save repayment details")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to save repayment details.")
-                            "message": "Failed to save repayment details."
-                        }), 400
                 
                     
                     #Update Loan status
@@ -61,13 +60,9 @@ class RepaymentService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({
+                        return ResponseHelper.error(result_description="Failed to log transaction.") 
-                            "message": "Failed to log transaction."
-                        }), 400   
                 else: 
-                    return jsonify({
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
-                            "message": "Invalid Customer or Account"
-                        }), 400
         
 
 
@@ -76,43 +71,28 @@ class RepaymentService(BaseService):
                     "transactionId": transaction_id,
                     "customerId": customer_id,
                     "productId": product_id,
-                    "debtId": loan_id,
+                    "debtId": loan_id
-                    "resultCode": "00",
-                    "resultDescription": "Successful"
                 }
 
-                # return ResponseHelper.success(
-                #     data=response_data,
-                #     message="Repayment processed successfully"
-                # )
-
                 # Call Kafka in a background thread
                 thread = Thread(target=RepaymentService.async_send_to_kafka, args=(response_data, request_id, "LOAN_REPAYMENT"))
                 thread.start()
 
                 db.session.commit()
-                return response_data
+                return ResponseHelper.success(data=response_data)
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-            return jsonify({
-                "message": "Validation exception"
-                }) , 422
         
         except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-
+            return ResponseHelper.error(result_description=str(err))
-            return jsonify({
-                "message": str(err)
-                }) , 400
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
-            db.session.rollback() 
+            db.session.rollback()
-            return jsonify({
+            return ResponseHelper.internal_server_error()
-                "message": "Internal Server Error"
-                }) , 500

app/api/services/select_offer.py

@@ -1,5 +1,6 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
+from app.api.helpers.response_helper import ResponseHelper
 from app.api.services.base_service import BaseService
 from app.api.enums import TransactionType
 from app.utils.logger import logger
@@ -49,9 +50,9 @@ class SelectOfferService(BaseService):
 
                     if not transaction:
                         logger.error(f"Failed to log transaction")
-                        return jsonify({"message": "Failed to log transaction."}), 400
+                        return ResponseHelper.error(result_description="Failed to log transaction.")
-                else:
+                else:  
-                    return jsonify({"message": "Invalid Customer or Account"}), 400
+                    return ResponseHelper.error(result_description="Invalid Customer or Account")
 
                 # Get the offer by product ID
                 offer = Offer.get_offer_by_product_id(product_id)
@@ -128,26 +129,24 @@ class SelectOfferService(BaseService):
                     "customerId": customer_id,
                     "accountId": account_id,
                     "loan": offers,
-                    "resultCode": "00",
-                    "resultDescription": "Successful",
                 }
 
                 db.session.commit()
-                return response_data
+                return ResponseHelper.success(data=response_data)
 
         except ValidationError as err:
 
             logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-            return jsonify({"message": "Validation exception"}), 422
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
-
+        
-        except ValueError as err:
+        except  ValueError as err:
             logger.error(f"{getattr(err, 'messages', str(err))}")
-            db.session.rollback() 
+            db.session.rollback()
-            return jsonify({"message": str(err)}), 400
+            return ResponseHelper.error(result_description=str(err))
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
-            db.session.rollback() 
+            db.session.rollback()
-            return jsonify({"message": "Internal Server Error"}), 500
+            return ResponseHelper.internal_server_error()
         

app/errors/handlers.py

@@ -5,20 +5,20 @@ from app.api.helpers.response_helper import ResponseHelper
 def register_error_handlers(app):
     @app.errorhandler(HTTPException)
     def handle_http_exception(e):
-        return jsonify({'error': e.description}), e.code
+        return ResponseHelper.error(result_description=e.description, result_code=e.code )
     
     @app.errorhandler(405)
     def method_not_allowed(error):
-        return jsonify({"message": "Method Not Allowed"}), 405
+        return ResponseHelper.method_not_allowed()
 
     @app.errorhandler(404)
     def not_found(error):
-        return jsonify({"message": "Resource not found"}), 404
+        return ResponseHelper.not_found()
 
     @app.errorhandler(400)
     def bad_request(error):
-        return jsonify({"message": "Bad Request"}), 400
+        return ResponseHelper.bad_request()
 
     @app.errorhandler(415)
     def unsupported_media_type(error):
-        return jsonify({"message": "Unsupported Media Type"}), 415
+        return ResponseHelper.error(result_description="Unsupported Media Type", result_code="415")