diff --git a/app/api/helpers/response_helper.py b/app/api/helpers/response_helper.py index adcc178..d2158f0 100644 --- a/app/api/helpers/response_helper.py +++ b/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, - message: str, - data: Optional[Union[Dict, List, str]] = None, - status_code: int = 200, - error: Optional[Union[Dict, str]] = None, + result_code: str, + result_description: str, + data: Optional[Union[Dict, List, 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, - "statusCode": status_code, - "message": message, - "data": data if data is not None else {}, - "error": error if error is not None else {}, + "resultCode": result_code, + "resultDescription": result_description } - 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, - message: str = "Successful", - status_code: int = 200, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Successful", + result_code: str = "00", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def error( - message: str = "An error occurred", - status_code: int = 400, - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "An error occurred", + result_code: str = "01", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def created( - data: Optional[Union[Dict, List, str]] = None, - message: str = "Resource created successfully", - error: Optional[Union[Dict, str]] = None, + result_description: str = "Resource created successfully", + result_code: str = "00", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def updated( - data: Optional[Union[Dict, List, str]] = None, - message: str = "Resource updated successfully", - error: Optional[Union[Dict, str]] = None, + result_description: str = "Resource updated successfully", + result_code: str = "00", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def internal_server_error( - message: str = "Internal Server Error", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Internal Server Error", + result_code: str = "500", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def unauthorized( - message: str = "Unauthorized", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Unauthorized", + result_code: str = "401", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def forbidden( - message: str = "Forbidden", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Forbidden", + result_code: str = "403", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def not_found( - message: str = "Resource not found", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Resource not found", + result_code: str = "404", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) + return ResponseHelper.build_response(result_code, result_description, data) @staticmethod def unprocessable_entity( - message: str = "Unprocessable entity", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Unprocessable entity", + result_code: str = "422", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - Return a response for an unprocessable entity. + return ResponseHelper.build_response(result_code, result_description, data) - 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", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Method Not Allowed", + result_code: str = "405", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - Return a response for a method not allowed error. + return ResponseHelper.build_response(result_code, result_description, data) - 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", - data: Optional[Union[Dict, List, str]] = None, - error: Optional[Union[Dict, str]] = None, + result_description: str = "Bad Request", + result_code: str = "400", + data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """ - 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) \ No newline at end of file + return ResponseHelper.build_response(result_code, result_description, data) \ No newline at end of file diff --git a/app/api/services/authorization.py b/app/api/services/authorization.py index 39108a9..4374b9f 100644 --- a/app/api/services/authorization.py +++ b/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}" ) diff --git a/app/api/services/customer_consent.py b/app/api/services/customer_consent.py index a6b4f07..e2663d3 100644 --- a/app/api/services/customer_consent.py +++ b/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({ - "message": "Failed to log transaction." - }), 400 + return ResponseHelper.error(result_description="Failed to log transaction.") else: - return jsonify({ - "message": "Invalid Customer or Account" - }), 400 + return ResponseHelper.error(result_description="Invalid Customer or Account") - - # 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 jsonify({ - "message": "Validation exception" - }) , 422 + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") 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() - return jsonify({ - "message": "Internal Server Error" - }) , 500 \ No newline at end of file + return ResponseHelper.internal_server_error() \ No newline at end of file diff --git a/app/api/services/eligibility_check.py b/app/api/services/eligibility_check.py index 263d9cb..c318d8c 100644 --- a/app/api/services/eligibility_check.py +++ b/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({ - "message": "Failed to log transaction." - }), 400 - - else: - return jsonify({ - "message": "Invalid Customer or Account" - }), 400 + return ResponseHelper.error(result_description="Failed to log transaction.") + else: + return ResponseHelper.error(result_description="Invalid Customer or Account") 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({ - "message": "Failed to save RACCheck." - }), 400 + return ResponseHelper.error(result_description="Failed to save RACCheck.") # -----------------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({ - "message": str(ve) - }), 400 + return ResponseHelper.error(result_description= str(ve)) # ----------------------------------------------------------------------- # 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))}") - - return jsonify({ - "message": "Validation exception" - }) , 422 + db.session.rollback() + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") - - return jsonify({ - "message": str(err) - }) , 400 + db.session.rollback() + return ResponseHelper.error(result_description=str(err)) except Exception as e: logger.error(f"An error occurred: {str(e)}", exc_info=True) - return jsonify({ - "message": "Internal Server Error" - }) , 500 \ No newline at end of file + db.session.rollback() + return ResponseHelper.internal_server_error() \ No newline at end of file diff --git a/app/api/services/loan_status.py b/app/api/services/loan_status.py index 55de9b8..ed2b182 100644 --- a/app/api/services/loan_status.py +++ b/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({ - "message": "Failed to log transaction." - }), 400 - else: - return jsonify({ - "message": "Invalid Customer or Account" - }), 400 + return ResponseHelper.error(result_description="Failed to log transaction.") + else: + return ResponseHelper.error(result_description="Invalid Customer or Account") # 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 jsonify({ - "message": "Validation exception" - }) , 422 + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") 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() - return jsonify({ - "message": "Internal Server Error" - }) , 500 \ No newline at end of file + return ResponseHelper.internal_server_error() \ No newline at end of file diff --git a/app/api/services/notification_callback.py b/app/api/services/notification_callback.py index 6257b2b..e8f78fe 100644 --- a/app/api/services/notification_callback.py +++ b/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 - response_data = { - "resultCode": "00", - "resultDescription": "Successful" - } - - - # return ResponseHelper.success( - # data=response_data, - # message="Notification callback processed successfully" - # ) - - return response_data + return ResponseHelper.success() except ValidationError as err: logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}") - - return jsonify({ - "message": "Validation exception" - }) , 422 + db.session.rollback() + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") - - return jsonify({ - "message": str(err) - }) , 400 + db.session.rollback() + return ResponseHelper.error(result_description=str(err)) except Exception as e: logger.error(f"An error occurred: {str(e)}", exc_info=True) - return jsonify({ - "message": "Internal Server Error" - }) , 500 + db.session.rollback() + return ResponseHelper.internal_server_error() diff --git a/app/api/services/provide_loan.py b/app/api/services/provide_loan.py index 88c348f..343b800 100644 --- a/app/api/services/provide_loan.py +++ b/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({ - "message": str(ve) - }), 400 + return ResponseHelper.error(result_description=str(ve)) # 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({ - "message": "Failed to log transaction." - }), 400 + return ResponseHelper.error(result_description="Failed to log transaction.") 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." - }), 400 + + return ResponseHelper.error(result_description="Failed to save loan details.") 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({ - "message": "Failed to generate loan repayment schedule." - }), 400 + return ResponseHelper.error(result_description="Failed to generate loan repayment schedule.") # charges = Charge.get_offer_charges(offer.id) @@ -155,22 +149,15 @@ class ProvideLoanService(BaseService): else: - return jsonify({ - "message": "Invalid Customer or Account" - }), 400 - - padded_loan_id = str(loan_id).zfill(9) - loanRef = f"LID{padded_loan_id}{channel}{current_product_id}" + return ResponseHelper.error(result_description="Invalid Customer or Account") + response_data = { "requestId": request_id, "transactionId": transaction_id, "customerId": customer_id, "accountId": account_id, - "msisdn": customer.msisdn, - "loanRef": loanRef, - "resultCode": "00", - "resultDescription": "Successful" + "msisdn": customer.msisdn } @@ -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() - - return jsonify({ - "message": "Validation exception" - }) , 422 + db.session.rollback() + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") - db.session.rollback() - - return jsonify({ - "message": str(err) - }) , 400 + db.session.rollback() + 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() - return jsonify({ - "message": "Internal Server Error" - }) , 500 \ No newline at end of file + db.session.rollback() + return ResponseHelper.internal_server_error() \ No newline at end of file diff --git a/app/api/services/repayment.py b/app/api/services/repayment.py index 01ebe87..78dda2f 100644 --- a/app/api/services/repayment.py +++ b/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({ - "message": "Failed to save repayment details." - }), 400 + return ResponseHelper.error(result_description="Failed to save repayment details.") #Update Loan status @@ -61,13 +60,9 @@ class RepaymentService(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: - return jsonify({ - "message": "Invalid Customer or Account" - }), 400 + return ResponseHelper.error(result_description="Invalid Customer or Account") @@ -76,43 +71,28 @@ class RepaymentService(BaseService): "transactionId": transaction_id, "customerId": customer_id, "productId": product_id, - "debtId": loan_id, - "resultCode": "00", - "resultDescription": "Successful" + "debtId": loan_id } - # 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() - - return jsonify({ - "message": "Validation exception" - }) , 422 + db.session.rollback() + return ResponseHelper.unprocessable_entity(result_description="Validation exception") except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") - db.session.rollback() - - return jsonify({ - "message": str(err) - }) , 400 + db.session.rollback() + 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() - return jsonify({ - "message": "Internal Server Error" - }) , 500 + db.session.rollback() + return ResponseHelper.internal_server_error() diff --git a/app/api/services/select_offer.py b/app/api/services/select_offer.py index db7a7a6..67c174f 100644 --- a/app/api/services/select_offer.py +++ b/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 - else: - return jsonify({"message": "Invalid Customer or Account"}), 400 + return ResponseHelper.error(result_description="Failed to log transaction.") + else: + 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() - return jsonify({"message": "Validation exception"}), 422 - - except ValueError as err: + db.session.rollback() + return ResponseHelper.unprocessable_entity(result_description="Validation exception") + + except ValueError as err: logger.error(f"{getattr(err, 'messages', str(err))}") - db.session.rollback() - return jsonify({"message": str(err)}), 400 + db.session.rollback() + 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() - return jsonify({"message": "Internal Server Error"}), 500 + db.session.rollback() + return ResponseHelper.internal_server_error() \ No newline at end of file diff --git a/app/errors/handlers.py b/app/errors/handlers.py index 02b665f..567b212 100644 --- a/app/errors/handlers.py +++ b/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")