[add]: timestamp fix

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)
+        return ResponseHelper.build_response(result_code, result_description, data)

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({
-                            "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
+            return ResponseHelper.internal_server_error()

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
+            db.session.rollback()
+            return ResponseHelper.internal_server_error()

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
+            return ResponseHelper.internal_server_error()

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()

app/api/services/offer_analysis.py

@@ -83,7 +83,7 @@ class OfferAnalysis:
                     "offerId": public_offer_id,
                     "product_id": original_transaction_offer.product_id,
                     "min_amount": original_transaction_offer.min_amount,
-                    "max_amount": real_eligible_amount,
+                    "max_amount": round(real_eligible_amount, 2),
                     "tenor": original_loan.tenor
                 })
                 return eligible_offers

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,53 +149,37 @@ 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
                     }
 
-
                 # KafkaIntegration.send_loan_request(loan_data = response_data, request_id = request_id)
                 # Call Kafka in a background thread
                 thread = Thread(target=ProvideLoanService.async_send_to_kafka, args=(response_data, request_id, "PROCESS_PAYMENT"))
                 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()

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()

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()
         

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")

app/models/account.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone
 from sqlalchemy.orm import relationship
 from app.extensions import db
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy.sql import func
 
 class Account(db.Model):
     __tablename__ = 'accounts'
@@ -11,8 +12,8 @@ class Account(db.Model):
     account_type = db.Column(db.String(50))
     status = db.Column(db.String(20), default='active')
     lien_amount = db.Column(db.Float, default=0.0)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
 
     customer = relationship(
         "Customer",

app/models/charge.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone, timedelta
 from app.extensions import db
 from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
 
 
 class Charge(db.Model):
@@ -12,9 +13,8 @@ class Charge(db.Model):
     percent = db.Column(db.Float, default=0.0)
     description = db.Column(db.Text, nullable=True)
     due = db.Column(db.Integer, nullable=False)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     offer = relationship(
         "Offer",
         primaryjoin="Charge.offer_id == Offer.id",

app/models/customer.py

@@ -3,6 +3,7 @@ from sqlalchemy.orm import relationship
 from app.extensions import db
 from app.models.account import Account
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy.sql import func
 
 class Customer(db.Model):
     __tablename__ = 'customers'
@@ -10,9 +11,8 @@ class Customer(db.Model):
     id = db.Column(db.String(50), primary_key=True) 
     msisdn = db.Column(db.String(20), unique=True, nullable=False)
     country_code = db.Column(db.String(3), nullable=False)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     accounts = relationship(
         "Account",
         primaryjoin="Customer.id == Account.customer_id",

app/models/loan.py

@@ -8,6 +8,7 @@ from dateutil.relativedelta import relativedelta
 from datetime import timedelta
 import logging
 from sqlalchemy import and_, or_, not_
+from sqlalchemy.sql import func
 
 logger = logging.getLogger(__name__)
 
@@ -37,8 +38,8 @@ class Loan(db.Model):
     status = db.Column(db.String(20), default='pending')
     tenor = db.Column(db.Integer, nullable=True)
     due_date = db.Column(db.DateTime, nullable=True) 
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     eligible_amount = db.Column(db.Float, nullable=True, default=0.0)
     disburse_date = db.Column(db.DateTime, nullable=True)
     disburse_verify = db.Column(db.DateTime, nullable=True)

app/models/loan_charge.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone, timedelta
 from app.extensions import db
 from sqlalchemy.orm import relationship
 from app.utils.logger import logger
+from sqlalchemy.sql import func
 
 
 class LoanCharge(db.Model):
@@ -16,9 +17,8 @@ class LoanCharge(db.Model):
     description = db.Column(db.Text, nullable=True)
     due = db.Column(db.Integer, nullable=False)
     due_date = db.Column(db.DateTime, nullable=True)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     loan = relationship(
         "Loan",
         primaryjoin="LoanCharge.loan_id == Loan.id",

app/models/loan_repayment_schedule.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone
 from app.extensions import db
 from sqlalchemy.orm import relationship
 from dateutil.relativedelta import relativedelta
+from sqlalchemy.sql import func
 
 class LoanRepaymentSchedule(db.Model):
     __tablename__ = 'loan_repayment_schedules'
@@ -17,9 +18,8 @@ class LoanRepaymentSchedule(db.Model):
     paid = db.Column(db.Boolean, default=False)
     paid_at = db.Column(db.DateTime, nullable=True)
 
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     loan = relationship(
         "Loan",
         primaryjoin="LoanRepaymentSchedule.loan_id == Loan.id",

app/models/offer.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone
 from app.extensions import db
 from app.models.charge import Charge
 from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
 
 class Offer(db.Model):
     __tablename__ = 'offers'
@@ -17,9 +18,8 @@ class Offer(db.Model):
     insurance_rate = db.Column(db.Float, default=1.0)
     vat_rate = db.Column(db.Float, default=7.5)
     list_order = db.Column(db.Integer, nullable=True)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     charges = relationship(
         "Charge",
         primaryjoin="Offer.id == Charge.offer_id",

app/models/rac_checks.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm import relationship
 from sqlalchemy.exc import IntegrityError
 from uuid import uuid4
 from sqlalchemy.types import JSON
+from sqlalchemy.sql import func
 
 class RACCheck(db.Model):
     __tablename__ = 'rac_checks'
@@ -13,9 +14,8 @@ class RACCheck(db.Model):
     customer_id = db.Column(db.String, nullable=False)
     account_id = db.Column(db.String, nullable=False)
     rac_response = db.Column(db.JSON, nullable=False)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     @classmethod
     def add_rac_check(cls, customer_id, account_id, transaction_id, data = None):
     

app/models/repayment.py

@@ -4,6 +4,7 @@ from app.extensions import db
 from app.models.customer import Customer
 from app.models.loan import Loan
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy.sql import func
 
 
 class Repayment(db.Model):
@@ -17,8 +18,8 @@ class Repayment(db.Model):
     loan_id = db.Column(db.String(50), nullable=False)
     customer_id = db.Column(db.String(50), nullable=False)
     product_id = db.Column(db.String(20), nullable=True)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     transaction_id = db.Column(db.String(50), nullable=True)
 
     @classmethod

app/models/transaction.py

@@ -3,6 +3,7 @@ from app.extensions import db
 from app.models import account
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy import and_, or_, not_
+from sqlalchemy.sql import func
 
 class Transaction(db.Model):
     __tablename__ = 'transactions'
@@ -16,9 +17,8 @@ class Transaction(db.Model):
     customer_id = db.Column(db.String(50), nullable=True)
     type = db.Column(db.String(50), nullable=False)
     channel = db.Column(db.String(50), nullable=False)
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     def __repr__(self):
         return f'<Transaction {self.id}>'
 

app/models/transaction_offers.py

@@ -1,6 +1,11 @@
 from datetime import datetime, timezone
 from app.extensions import db
 from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+import logging
+logger = logging.getLogger(__name__)
+
+
 
 class TransactionOffer(db.Model):
     __tablename__ = 'transaction_offers'
@@ -16,9 +21,8 @@ class TransactionOffer(db.Model):
     eligible_amount = db.Column(db.Float, nullable=True)
     tenor = db.Column(db.Integer, nullable=True)  # tenor in months, typically
 
-    created_at = db.Column(db.DateTime, default=datetime.now(timezone.utc))
-    updated_at = db.Column(db.DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
-
+    created_at = db.Column(db.DateTime(timezone=True), server_default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
     customer = relationship(
         "Customer",
         primaryjoin="Customer.id == TransactionOffer.customer_id",

migrations/versions/2eee4157505f_.py

@@ -0,0 +1,250 @@
+"""empty message
+
+Revision ID: 2eee4157505f
+Revises: 565bc3d0ba6e
+Create Date: 2025-05-16 13:24:41.914400
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '2eee4157505f'
+down_revision = '565bc3d0ba6e'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('accounts', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('charges', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('customers', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loan_charges', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loan_repayment_schedules', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loans', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('offers', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('rac_checks', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('repayments', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True)
+
+    with op.batch_alter_table('transactions', schema=None) as batch_op:
+        batch_op.alter_column('created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True,
+               existing_server_default=sa.text('now()'))
+        batch_op.alter_column('updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               type_=sa.DateTime(timezone=True),
+               existing_nullable=True,
+               existing_server_default=sa.text('now()'))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('transactions', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True,
+               existing_server_default=sa.text('now()'))
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True,
+               existing_server_default=sa.text('now()'))
+
+    with op.batch_alter_table('transaction_offers', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('repayments', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('rac_checks', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('offers', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loans', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loan_repayment_schedules', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('loan_charges', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('customers', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('charges', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    with op.batch_alter_table('accounts', schema=None) as batch_op:
+        batch_op.alter_column('updated_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+        batch_op.alter_column('created_at',
+               existing_type=sa.DateTime(timezone=True),
+               type_=postgresql.TIMESTAMP(),
+               existing_nullable=True)
+
+    # ### end Alembic commands ###