Major update

app/api/routes/routes.py

@@ -10,8 +10,9 @@ from app.api.services import (
     TokenValidationService,
     LienCheckService,
     NewTransactionCheckService,
-    RepaymentService,  # Added RepaymentService
+    RepaymentService,
-    StatusCallService,  # Added StatusCallService
+    StatusCallService,
+    LoanStatusService
 )
 from app.utils.logger import logger
 from app.api.middlewares import require_api_key, require_app_id, enforce_json
@@ -59,6 +60,16 @@ def disbursement():
     response = DisbursementService.process_request(data)
     return response
 
+# LoanStatus Endpoint
+@api.route('/LoanStatus', methods=['POST'])
+@require_api_key
+@require_app_id
+def loan_status():
+    data = request.get_json()
+    # logger.info(f"LoanStatus request received: {data}")
+    response = LoanStatusService.process_request(data)
+    return response
+
 # CollectLoan Endpoint
 @api.route('/CollectLoan', methods=['POST'])
 @require_api_key

app/api/schemas/bulk_sms.py

@@ -0,0 +1,18 @@
+from marshmallow import Schema, fields
+
+# Individual SMS item schema for BulkSMS
+class BulkSMSItemSchema(Schema):
+    text = fields.Str(required=True, description="Message to send to customer")
+    dest = fields.Str(required=True, description="Phone Number in international format")
+    unicode = fields.Bool(required=True, description="Character encoding standard (set as True for bulk SMS)")
+
+# BulkSMS Request Schema (list of SMS items)
+class BulkSMSSchema(Schema):
+    _schema = fields.List(fields.Nested(BulkSMSItemSchema), required=True)
+
+# BulkSMS Response Schema
+class BulkSMSResponseSchema(Schema):
+    data = fields.Str(required=True, description="Any additional data in response")
+    statusCode = fields.Int(required=True, description="Result code of executed process (200 = Success)")
+    IsSuccessful = fields.Bool(required=True, description="An Indicator that the process was successful or not")
+    errorMessage = fields.Str(required=True, allow_none=True, description="Description of status code if process is failed, null if successful")

app/api/schemas/collect_loan.py

@@ -1,16 +1,32 @@
-from marshmallow import Schema, fields
+from marshmallow import Schema, fields, validate
 
-# Collect Loan Schema
+# CollectLoan Request Schema
 class CollectLoanSchema(Schema):
-    transactionId = fields.Str(required=True)
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
-    fbnTransactionId = fields.Str(required=True)
+    fbnTransactionId = fields.Str(required=True, description="Unique id of the transaction received from FBN in Eligibility or Provision requests")
-    debtId = fields.Str(required=True)
+    debtId = fields.Str(required=True, description="Unique identifier of a loan in Simbrella system that is going to be collected (it correlates with provision request)")
-    customerId = fields.Str(required=True)
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
-    accountId = fields.Str(required=True)
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
-    productId = fields.Str(required=True)
+    productId = fields.Str(required=True, description="Identifier of a product for which collection to be made")
-    collectAmount = fields.Float(required=True)
+    collectAmount = fields.Float(required=True, description="Amount to be collected from user's account (penalCharge is not included)")
-    penalCharge = fields.Float(required=False)  # Optional 
+    penalCharge = fields.Float(required=False, description="Amount of penalty to be collected from user's account. If there is no penalty, amount is '0'")
-    collectionMethod = fields.Int(required=True)
+    collectionMethod = fields.Int(required=True, description="1 - on deposit of salary; 2 - on due date; 3 - initiated by user",
-    lienAmount = fields.Float(required=True)
+                                 validate=validate.OneOf([1, 2, 3]))
-    countryId = fields.Str(required=True) 
+    lienAmount = fields.Float(required=True, description="Aggregated (summed up) lien amount")
-    comment = fields.Str(required=False)  # Optional
+    countryId = fields.Str(required=True, description="Set to static value '01'")
+    comment = fields.Str(required=False, description="Any additional comment for provided loan operation")
+
+# CollectLoan Response Schema
+class CollectLoanResponseSchema(Schema):
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
+    debtId = fields.Str(required=True, description="Unique identifier of a loan in Simbrella system that is going to be collected (it correlates with provision request)")
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    productId = fields.Str(required=True, description="Identifier of a product for which collection to be made")
+    collectAmount = fields.Float(required=True, description="Amount collected from user's account (penalCharge is not included)")
+    penalCharge = fields.Float(required=True, description="Amount of penalty collected from user's account. If there is no penalty, amount is '0'")
+    lienAmount = fields.Float(required=True, description="Aggregated (summed up) lien amount")
+    countryId = fields.Str(required=False, description="Set to static value '01'")
+    comment = fields.Str(required=False, description="Any additional comment for provided loan operation")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/lien_check.py

@@ -1,8 +1,13 @@
 from marshmallow import Schema, fields
 
-# Lien Check Schema
+# LienCheck Request Schema
 class LienCheckSchema(Schema):
-    transactionId = fields.Str(required=True)
+    transactionId = fields.Str(required=True, description="Unique Identifier in Simbrella system")
-    customerId = fields.Str(required=True)
+    customerId = fields.Str(required=True, description="Unique identifier of customer")
-    accountId = fields.Str(required=True)
+    accountId = fields.Str(required=True, description="Unique identifier of account")
-    countryId = fields.Str(required=True)
+
+# LienCheck Response Schema
+class LienCheckResponseSchema(Schema):
+    lienAmount = fields.Float(required=True, description="Lien amount applied to the account")
+    resultCode = fields.Str(required=True, description="Result code of response")
+    resultDescription = fields.Str(required=True, description="Response description")

app/api/schemas/loan_status.py

@@ -0,0 +1,29 @@
+from marshmallow import Schema, fields, validate
+
+# Schema for the loan item in the response
+class LoanItemSchema(Schema):
+    debtId = fields.Str(required=True, description="Unique identifier of a debt of a user")
+    loanDate = fields.Str(required=True, description="Date and time of provided loan")
+    dueDate = fields.Str(required=True, description="Due date of provided loan")
+    currentLoanAmount = fields.Float(required=True, description="Outstanding debt amount of the user")
+    initialLoanAmount = fields.Float(required=True, description="Initial loan amount")
+    defaultPenaltyFee = fields.Float(required=True, description="Penalty fee amount")
+    continuousFee = fields.Float(required=True, description="Interest fee charged continuously. First occurs when payment is delayed")
+    productId = fields.Str(required=True, description="Identifier of a provided product to a user")
+
+# LoanStatus Request Schema
+class LoanStatusSchema(Schema):
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
+    customerId = fields.Str(required=True, description="Unique identifier of a customer")
+    msisdn = fields.Str(required=False, description="User's mobile number in an international format")
+    channel = fields.Str(required=True, description="Request channel: USSD, MobileApp, or Web",
+                        validate=validate.OneOf(["USSD", "MobileApp", "Web", "100", "101", "102", "103"]))  # Added numeric channel codes
+
+# LoanStatus Response Schema
+class LoanStatusResponseSchema(Schema):
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
+    loans = fields.List(fields.Nested(LoanItemSchema), required=True, description="Array of loan entities. If customer doesn't have a loan, this array will be empty")
+    totalDebtAmount = fields.Float(required=False, description="Sum amount of all existing debts of a user")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/penal_charge.py

@@ -1,14 +1,17 @@
 from marshmallow import Schema, fields
 
-
+# PenalCharge Request Schema
-# Penal Charge Schema
 class PenalChargeSchema(Schema):
-    transactionId = fields.Str(required=True)
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
-    fbnTransactionId = fields.Str(required=True)
+    fbnTransactionId = fields.Str(required=True, description="Unique id of the transaction received from FBN in Eligibility or Provision requests")
-    debtId = fields.Str(required=True)
+    debtId = fields.Str(required=True, description="Unique identifier of providing loan in Simbrella system")
-    customerId = fields.Str(required=True)
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
-    accountId = fields.Str(required=True)
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
-    penalCharge = fields.Decimal(required=True)
+    penalCharge = fields.Float(required=True, description="Penalty amount that needs to be collected from user's account")
-    lienAmount = fields.Decimal(required=True)
+    lienAmount = fields.Float(required=True, description="Aggregated (summed up) lien amount")
-    countryId = fields.Str(required=True)
+    comment = fields.Str(required=False, description="Any additional comment for provided loan operation")
-    comment = fields.Str(required=False)
+
+# PenalCharge Response Schema
+class PenalChargeResponseSchema(Schema):
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/provide_loan.py

@@ -0,0 +1,26 @@
+from marshmallow import Schema, fields, validate
+
+# ProvideLoan Request Schema
+class ProvideLoanSchema(Schema):
+    requestId = fields.Str(required=False, description="Unique identifier of request")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
+    customerId = fields.Str(required=True, description="Unique identifier of a customer")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    msisdn = fields.Str(required=False, description="User's mobile number in an international format")
+    productId = fields.Str(required=True, description="Identifier of a product chosen by user")
+    requestedAmount = fields.Float(required=True, description="Amount of loan that requested by user")
+    collectionType = fields.Int(required=True, description="Type of collection that user is preferred. 0 – as soon as salary inflow occurs; 1- as soon as any new inflow occurs, 1 – collection after XX days.",
+                               validate=validate.OneOf([0, 1]))
+    offerId = fields.Int(required=True, description="Offer ID of the loan selected by Customer")
+    channel = fields.Str(required=True, description="Request channel: 'USSD' or 'MobileApp' or 'Web' - Reference Channel types",
+                        validate=validate.OneOf(["USSD", "MobileApp", "Web", "100", "101", "102", "103"]))  # Added numeric channel codes
+
+# ProvideLoan Response Schema
+class ProvideLoanResponseSchema(Schema):
+    requestId = fields.Str(required=True, description="Unique identifier of request")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
+    customerId = fields.Str(required=True, description="Unique identifier of a customer")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    msisdn = fields.Str(required=False, description="User's mobile number in an international format")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/rac_check.py

@@ -1,23 +1,32 @@
 from marshmallow import Schema, fields
 
-class RACItemSchema(Schema):
+# RACResponse Schema
-    salaryAccount = fields.Bool(required=True)
+class RACResponseSchema(Schema):
-    bvn = fields.Str(required=True)
+    Salary_account = fields.Str(data_key="Salary account", required=True, description="Has Salary account or Not (1 = Yes, 0 = No)")
-    crc = fields.Bool(required=True)
+    BVN = fields.Str(required=False, description="BVN Ok (1 = Yes, 0 = No)")
-    crms = fields.Bool(required=True)
+    BVNAttachedToAccount = fields.Str(required=True, description="BVN attached to account (1 = Yes, 0 = No)")
-    accountStatus = fields.Str(required=True)
+    CRMS = fields.Str(required=True, description="No Delinquent loan in CRMS (1 = Yes, 0 = No)")
-    lien = fields.Bool(required=True)
+    CRC = fields.Str(required=True, description="No Delinquent loan in CRC (1 = Yes, 0 = No)")
-    noBouncedCheck = fields.Bool(required=True)
+    AccountStatus = fields.Str(required=True, description="Has 'Regular' account status (1 = Yes, 0 = No)")
-    existingLoan = fields.Bool(required=True)
+    Lien = fields.Str(required=True, description="No Lien on account (1 = Yes, 0 = No)")
-    whitelist = fields.Bool(required=True)
+    NoBouncedCheck = fields.Str(required=True, description="No Bounced Check (1 = Yes, 0 = No)")
-    noPastDueSalaryLoan = fields.Bool(required=True)
+    Whitelist = fields.Str(required=True, description="Not blacklisted (1 = Yes, 0 = No)")
-    noPastDueOtherLoans = fields.Bool(required=True)
+    NoPastDueSalaryLoan = fields.Str(required=True, description="No Past Due Salary Loan (1 = Yes, 0 = No)")
+    NoPastDueOtherLoan = fields.Str(required=True, description="No Past Due Other Loans (1 = Yes, 0 = No)")
 
-
+# RACCheck Request Schema
-# RAC Check Schema
 class RACCheckSchema(Schema):
-    transactionId = fields.Str(required=True)
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
-    fbnTransactionId = fields.Str(required=True)
+    fbnTransactionId = fields.Str(required=True, description="Unique id of the transaction received from FBN in Eligibility or Provision requests")
-    customerId = fields.Str(required=True)
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
-    accountId = fields.Str(required=True)
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
-    RAC_Array = fields.List(fields.Nested(RACItemSchema), required=True)
+    RAC_Array = fields.List(fields.Str(), required=True, description="Array of RAC items to check (BVN, CRC, CRMS, Salary account, lien, whitelist, lien, account status, no bounced check and existing loan)")
+
+# RACCheck Response Schema
+class RACCheckResponseSchema(Schema):
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    RACResponse = fields.Nested(RACResponseSchema, required=True, description="Object containing binary responses for each RAC check")
+    resultCode = fields.Str(required=False, description="Result code of executed transaction")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/repayment.py

@@ -0,0 +1,33 @@
+from marshmallow import Schema, fields, validate
+
+# Repayment Request Schema
+class RepaymentSchema(Schema):
+    requestId = fields.Str(required=True, description="Unique identifier of request")
+    countryCode = fields.Str(required=True, description="Unique country code. Please refer to Country Codes table")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
+    debtId = fields.Str(required=True, description="Unique identifier of a loan in Simbrella system that is going to be collected (it correlates with provision request)")
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    productId = fields.Str(required=True, description="Identifier of a product for which collection to be made")
+    collectedAmount = fields.Float(required=True, description="Amount to be collected from user's account (penalCharge is not included)")
+    penalCharge = fields.Float(required=False, description="Amount of penalty to be collected from user's account. If there is no penalty, amount is '0'")
+    collectionMethod = fields.Int(required=True, description="1 - on deposit of salary, 2 - on due date, 3 - initiated by user",
+                                 validate=validate.OneOf([1, 2, 3]))
+    lienAmount = fields.Float(required=True, description="Aggregated (summed up) lien amount")
+    comment = fields.Str(required=False, description="Any additional comment for provided loan operation")
+
+# Repayment Response Schema
+class RepaymentResponseSchema(Schema):
+    requestId = fields.Str(required=True, description="Unique identifier of request")
+    countryCode = fields.Str(required=True, description="Unique country code. Please refer to Country Codes table")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
+    debtId = fields.Str(required=True, description="Unique identifier of a loan in Simbrella system that is going to be collected (it correlates with provision request)")
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    productId = fields.Str(required=True, description="Identifier of a product for which collection to be made")
+    collectedAmount = fields.Float(required=True, description="Amount to be collected from user's account (penalCharge is not included)")
+    penalCharge = fields.Float(required=False, description="Amount of penalty to be collected from user's account. If there is no penalty, amount is '0'")
+    lienAmount = fields.Float(required=True, description="Aggregated (summed up) lien amount")
+    comment = fields.Str(required=False, description="Any additional comment for provided loan operation")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/sms.py

@@ -0,0 +1,14 @@
+from marshmallow import Schema, fields
+
+# SMS Request Schema
+class SMSSchema(Schema):
+    text = fields.Str(required=True, description="Message to send to customer")
+    dest = fields.Str(required=True, description="Phone Number in international format")
+    unicode = fields.Bool(required=True, description="Character encoding standard (set as False for single SMS)")
+
+# SMS Response Schema
+class SMSResponseSchema(Schema):
+    data = fields.Str(required=True, description="Any additional data in response")
+    statusCode = fields.Int(required=True, description="Result code of executed process (200 = Success)")
+    IsSuccessful = fields.Bool(required=True, description="An Indicator that the process was successful or not")
+    errorMessage = fields.Str(required=True, allow_none=True, description="Description of status code if process is failed, null if successful")

app/api/schemas/status_call.py

@@ -0,0 +1,27 @@
+from marshmallow import Schema, fields, validate
+
+# Nested data schema for StatusCallResponse
+class StatusCallDataSchema(Schema):
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system that was sent for transaction check")
+    providedAmount = fields.Float(required=True, description="Amount collected from user's account within disbursement operation. Amount should always be equal to zero if operation is of any type other than Disbursement")
+    collectedAmount = fields.Float(required=True, description="Amount collected from user's account. In case of Disbursement this value will be equal to 0. In case of Collection this value will represent amount successfully collected from customers account. In case of Penal charge this value will represent penalty amount collected from customer's account.")
+    resultCode = fields.Str(required=True, description="Result code of the operation one sent for transaction check, e.g. (00 – Success etc.)")
+    resultDescription = fields.Str(required=True, description="Description of provided result code that was sent for transaction check")
+
+# StatusCall Request Schema
+class StatusCallSchema(Schema):
+    requestId = fields.Str(required=True, description="RequestId for transaction sent by Simbrella within initial request to Firstbank API")
+    countryCode = fields.Str(required=True, description="Unique country code.")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction. This transaction Id must be consistent across all platforms")
+    debtId = fields.Str(required=True, description="Unique identifier of provided loan in Simbrella system")
+    transactionType = fields.Str(required=True,
+                               description="Type of Transaction Simbrella is sending Transaction Check for",
+                               validate=validate.OneOf(["Disbursement", "Collection", "PenalCharge"]))
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+
+# StatusCall Response Schema
+class StatusCallResponseSchema(Schema):
+    transactionId = fields.Str(required=True, description="Unique identifier of request in Simbrella system")
+    data = fields.Nested(StatusCallDataSchema, required=True, description="Object containing details of transaction Simbrella querying")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.)")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/schemas/transaction_verify.py

@@ -1,12 +1,27 @@
-from marshmallow import Schema, fields
+from marshmallow import Schema, fields, validate
 
-
+# TransactionVerify Request Schema
-# Transaction Verify Schema
 class TransactionVerifySchema(Schema):
-    counter = fields.Str(required=True)
+    requestId = fields.Str(required=True, description="Unique identifier of request")
-    transactionId = fields.Str(required=True)
+    countryCode = fields.Str(required=True, description="Unique country code. Please refer to Country Codes table")
-    requestID = fields.Str(required=True)
+    counter = fields.Str(required=True, description="Unique counter for number of attempts of the API call. Original attempt is 1")
-    customerId = fields.Str(required=True)
+    transactionId = fields.Str(required=True, description="Id of the transaction we are checking")
-    accountId = fields.Str(required=True)
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
-    countryId = fields.Str(required=True)  # Static value “01”
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
-    transactionType = fields.Str(required=True)
+    transactionType = fields.Str(required=True,
+                               description="To check state of loan disbursal transaction, value must be 'Disbursement', to check state of loan collection transaction, value must be 'Collection', to check state of penalty charge transaction, value must be 'Penalty'",
+                               validate=validate.OneOf(["Disbursement", "Collection", "Penalty"]))
+
+# TransactionVerify Response Schema
+class TransactionVerifyResponseSchema(Schema):
+    requestId = fields.Str(required=True, description="Unique identifier of request")
+    countryCode = fields.Str(required=True, description="Unique country code. Please refer to Country Codes table")
+    transactionId = fields.Str(required=True, description="Unique identifier of transaction in Simbrella system")
+    transactionType = fields.Str(required=True, description="Type of transaction: Disbursement, Collection, or Penalty",
+                               validate=validate.OneOf(["Disbursement", "Collection", "Penalty"]))
+    customerId = fields.Str(required=True, description="Unique identifier of a user")
+    accountId = fields.Str(required=True, description="Specific identifier of a user's account")
+    providedAmount = fields.Float(required=True, description="Amount provided to a user within loan provision operation")
+    collectedAmount = fields.Float(required=True, description="Amount collected from user's account within collection operation")
+    resultCode = fields.Str(required=True, description="Result code of executed transaction, e.g. (00 – Success etc.) see result codes table")
+    resultDescription = fields.Str(required=True, description="Description of provided result code")

app/api/services/__init__.py

@@ -1,12 +1,18 @@
-from app.api.services.rac_check import RACCheckService
 from app.api.services.disbursement import DisbursementService
 from app.api.services.select_offer import SelectOfferService
+from app.api.services.provide_loan import ProvideLoanService
+from app.api.services.loan_status import LoanStatusService
+from app.api.services.repayment import RepaymentService
 from app.api.services.collect_loan import CollectLoanService
+from app.api.services.rac_check import RACCheckService
 from app.api.services.transaction_verify import TransactionVerifyService
 from app.api.services.penal_charge import PenalChargeService
-from app.api.services.revoke_enable_consent import RevokeEnableConsentService
-from app.api.services.token_validation import TokenValidationService
 from app.api.services.lien_check import LienCheckService
-from app.api.services.new_transaction_check import NewTransactionCheckService
+from app.api.services.status_call import StatusCallService
-from app.api.services.repayment import RepaymentService
+from app.api.services.sms import SMSService
-from app.api.services.status_call import StatusCallService
+from app.api.services.bulk_sms import BulkSMSService
+
+# from app.api.services.revoke_enable_consent import RevokeEnableConsentService
+# from app.api.services.token_validation import TokenValidationService
+# from app.api.services.new_transaction_check import NewTransactionCheckService
+# from app.api.services.status_call import StatusCallService

app/api/services/bulk_sms.py

@@ -0,0 +1,78 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.utils.logger import logger
+from app.api.schemas.bulk_sms import BulkSMSSchema, BulkSMSResponseSchema
+
+
+class BulkSMSService:
+    @staticmethod
+    def process_request(data):
+        """
+        Process the BulkSMS request.
+
+        Args:
+            data (list): The request data as a list of SMS items.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing BulkSMS request")
+
+            # Check if the data is a list and not too large
+            if not isinstance(data, list):
+                return jsonify({
+                    "data": "",
+                    "statusCode": 400,
+                    "IsSuccessful": False,
+                    "errorMessage": "Request must be a list of SMS items"
+                }), 400
+
+            if len(data) > 20:
+                return jsonify({
+                    "data": "",
+                    "statusCode": 400,
+                    "IsSuccessful": False,
+                    "errorMessage": "Maximum of 20 SMS items allowed"
+                }), 400
+
+            # Validate each item in the list
+            schema = BulkSMSSchema()
+            # We need to wrap the list in a dictionary with a key that matches the schema field name
+            validated_data = schema.load({"_schema": data})  # Raises ValidationError if invalid
+
+            # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to send bulk SMS messages to customers
+
+            # For demonstration, we'll simulate a successful bulk SMS send
+            response_data = {
+                "data": "",
+                "statusCode": 200,
+                "IsSuccessful": True,
+                "errorMessage": None
+            }
+
+            # Validate the response using the response schema
+            response_schema = BulkSMSResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "data": "",
+                "statusCode": 400,
+                "IsSuccessful": False,
+                "errorMessage": f"Validation error: {err.messages}"
+            }), 400
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            return jsonify({
+                "data": "",
+                "statusCode": 500,
+                "IsSuccessful": False,
+                "errorMessage": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/collect_loan.py

@@ -1,8 +1,8 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.helpers.response_helper import ResponseHelper
+from app.api.schemas.collect_loan import CollectLoanSchema, CollectLoanResponseSchema
-from app.api.schemas.collect_loan import CollectLoanSchema   
+
 
 class CollectLoanService:
     @staticmethod
@@ -21,41 +21,47 @@ class CollectLoanService:
 
             # Validate input data using CollectLoanSchema
             schema = CollectLoanSchema()
-            validated_data = schema.load(data)
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
 
             # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to process the loan collection
+
+            # For demonstration, we'll simulate a partial collection
+            collect_amount = validated_data.get('collectAmount') * 0.75  # 75% of requested amount
+            lien_amount = validated_data.get('lienAmount') * 0.25  # 25% of requested amount as lien
+
             response_data = {
-                "transactionId": "T002",
+                "transactionId": validated_data.get('transactionId'),
-                "debtId": "273194670",
+                "debtId": validated_data.get('debtId'),
-                "customerId": "CN621868",
+                "customerId": validated_data.get('customerId'),
-                "accountId": "2017821799",
+                "accountId": validated_data.get('accountId'),
-                "productId": "101",
+                "productId": validated_data.get('productId'),
-                "collectAmount": 60000.00,
+                "collectAmount": collect_amount,
-                "penalCharge": 0,
+                "penalCharge": validated_data.get('penalCharge', 0),
-                "lienAmount": 20000,
+                "lienAmount": lien_amount,
-                "countryId": "01",
+                "countryId": validated_data.get('countryId'),
-                "comment": "Testing CollectionLoanRequest",
+                "comment": validated_data.get('comment', ""),
                 "resultCode": "00",
                 "resultDescription": "Loan Collection Successful"
             }
 
+            # Validate the response using the response schema
+            response_schema = CollectLoanResponseSchema()
+            validated_response = response_schema.dump(response_data)
 
-            # return ResponseHelper.success(
+            return jsonify(validated_response)
-            #     data=response_data,
-            #     message="Loan collection completed successfully"
-            # )
-            
-            return response_data
 
         except ValidationError as err:
             logger.error(f"Validation Error: {err.messages}")
             return jsonify({
-                "message": "Validation exception"
+                "resultCode": "01",
-                }) , 422
+                "resultDescription": f"Validation error: {err.messages}"
-
+            }), 422
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
-                "message": "Internal Server Error"
+                "resultCode": "08",
-                }) , 500
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/lien_check.py

@@ -1,8 +1,8 @@
+from flask import request, jsonify
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.helpers.response_helper import ResponseHelper
+from app.api.schemas.lien_check import LienCheckSchema, LienCheckResponseSchema
-from app.api.schemas.lien_check import LienCheckSchema 
+
-from flask import request, jsonify
 
 class LienCheckService:
     @staticmethod
@@ -23,29 +23,33 @@ class LienCheckService:
             schema = LienCheckSchema()
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
-            # Simulated lien check logic
+            # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to check the lien amount on the account
+
+            # For demonstration, we'll simulate a lien amount of 20000.0
             response_data = {
                 "lienAmount": 20000.0,
                 "resultCode": "00",
                 "resultDescription": "Successful"
             }
 
+            # Validate the response using the response schema
+            response_schema = LienCheckResponseSchema()
+            validated_response = response_schema.dump(response_data)
 
-            # return ResponseHelper.success(
+            return jsonify(validated_response)
-            #     data=response_data,
-            #     message="Lien check completed successfully"
-            # )
-
-            return response_data
 
         except ValidationError as err:
             logger.error(f"Validation Error: {err.messages}")
             return jsonify({
-                "message": "Validation exception"
+                "resultCode": "01",
-                }) , 422
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
-                "message": "Internal Server Error"
+                "resultCode": "08",
-                }) , 500
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/loan_status.py

@@ -0,0 +1,77 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.utils.logger import logger
+from app.api.schemas.loan_status import LoanStatusSchema, LoanStatusResponseSchema
+from datetime import datetime, timedelta
+
+
+class LoanStatusService:
+    @staticmethod
+    def process_request(data):
+        """
+        Process the LoanStatus request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing LoanStatus request")
+
+            # Validate input data using LoanStatusSchema
+            schema = LoanStatusSchema()
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
+
+            # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to retrieve the customer's loan status
+
+            # For demonstration, we'll create a sample response with one loan
+            # In a real implementation, you would query your database for actual loan data
+            current_date = datetime.now()
+            loan_date = (current_date - timedelta(days=30)).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+            due_date = (current_date + timedelta(days=30)).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+            # Sample loan data
+            loan_data = {
+                "debtId": "123456789",
+                "loanDate": loan_date,
+                "dueDate": due_date,
+                "currentLoanAmount": 8500.0,
+                "initialLoanAmount": 10000.0,
+                "defaultPenaltyFee": 0.0,
+                "continuousFee": 0.0,
+                "productId": "101"
+            }
+
+            # Create response with the loan data
+            response_data = {
+                "customerId": validated_data.get('customerId'),
+                "transactionId": validated_data.get('transactionId'),
+                "loans": [loan_data],  # Array with one loan
+                "totalDebtAmount": 8500.0,  # Same as currentLoanAmount for this example
+                "resultCode": "00",
+                "resultDescription": "Successful"
+            }
+
+            # Validate the response using the response schema
+            response_schema = LoanStatusResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "resultCode": "01",
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            return jsonify({
+                "resultCode": "08",
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/penal_charge.py

@@ -1,8 +1,7 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.helpers.response_helper import ResponseHelper
+from app.api.schemas.penal_charge import PenalChargeSchema, PenalChargeResponseSchema
-from app.api.schemas.penal_charge import PenalChargeSchema   
 
 
 class PenalChargeService:
@@ -25,27 +24,31 @@ class PenalChargeService:
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
             # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to process the penal charge
+
+            # For demonstration, we'll simulate a successful penal charge
             response_data = {
                 "resultCode": "00",
                 "resultDescription": "Penal charge debited successfully"
             }
 
+            # Validate the response using the response schema
+            response_schema = PenalChargeResponseSchema()
+            validated_response = response_schema.dump(response_data)
 
-            # return ResponseHelper.success(
+            return jsonify(validated_response)
-            #     data=response_data,
-            #     message="Penal charge applied successfully"
-            # )
-
-            return response_data
 
         except ValidationError as err:
             logger.error(f"Validation Error: {err.messages}")
             return jsonify({
-                "message": "Validation exception"
+                "resultCode": "01",
-                }) , 422
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
-                "message": "Internal Server Error"
+                "resultCode": "08",
-                }) , 500
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/provide_loan.py

@@ -0,0 +1,56 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.utils.logger import logger
+from app.api.schemas.provide_loan import ProvideLoanSchema, ProvideLoanResponseSchema
+
+class ProvideLoanService:
+    @staticmethod
+    def process_request(data):
+        """
+        Process the ProvideLoan request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing ProvideLoan request")
+
+            # Validate input data using ProvideLoanSchema
+            schema = ProvideLoanSchema()
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
+
+            # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to process the loan provision request
+            response_data = {
+                "requestId": validated_data.get('requestId', f"REQ-{validated_data.get('transactionId')}"),
+                "transactionId": validated_data.get('transactionId'),
+                "customerId": validated_data.get('customerId'),
+                "accountId": validated_data.get('accountId'),
+                "msisdn": validated_data.get('msisdn', ""),
+                "resultCode": "00",
+                "resultDescription": "Successful"
+            }
+
+            # Validate the response using the response schema
+            response_schema = ProvideLoanResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "resultCode": "01",
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            return jsonify({
+                "resultCode": "08",
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/rac_check.py

@@ -1,8 +1,8 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.helpers.response_helper import ResponseHelper
+from app.api.schemas.rac_check import RACCheckSchema, RACCheckResponseSchema
-from app.api.schemas.rac_check import RACCheckSchema   
+
 
 class RACCheckService:
     @staticmethod
@@ -24,40 +24,49 @@ class RACCheckService:
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
             # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to check the RAC criteria
+
+            # For demonstration, we'll simulate all checks passing
+            rac_response = {
+                "Salary account": "1",
+                "BVN": "1",
+                "BVNAttachedToAccount": "1",
+                "CRMS": "1",
+                "CRC": "1",
+                "AccountStatus": "1",
+                "Lien": "1",
+                "NoBouncedCheck": "1",
+                "Whitelist": "1",
+                "NoPastDueSalaryLoan": "1",
+                "NoPastDueOtherLoan": "1"
+            }
+
             response_data = {
+                "transactionId": validated_data.get('transactionId'),
+                "customerId": validated_data.get('customerId'),
+                "accountId": validated_data.get('accountId'),
+                "RACResponse": rac_response,
                 "resultCode": "00",
-                "RACResponse": {
-                    "SalaryAccount": "1",
-                    "BVN": "1",
-                    "BVNAttachedToAccount": "1",
-                    "CRMS": "1",
-                    "CRC": "1",
-                    "AccountStatus": "1",
-                    "Lien": "1",
-                    "NoBouncedCheck": "1",
-                    "Whitelist": "1",
-                    "NoPastDueSalaryLoan": "1",
-                    "NoPastDueOtherLoan": "1"
-                },
                 "resultDescription": "RAC Check Successful"
             }
 
+            # Validate the response using the response schema
+            response_schema = RACCheckResponseSchema()
+            validated_response = response_schema.dump(response_data)
 
-            # return ResponseHelper.success(
+            return jsonify(validated_response)
-            #     data=response_data,
-            #     message="RAC check completed successfully"
-            # )
-
-            return response_data
 
         except ValidationError as err:
             logger.error(f"Validation Error: {err.messages}")
             return jsonify({
-                "message": "Validation exception"
+                "resultCode": "01",
-                }) , 422
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
-                "message": "Internal Server Error"
+                "resultCode": "08",
-                }) , 500
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/repayment.py

@@ -1,64 +1,68 @@
-from flask import jsonify
+from flask import request, jsonify
+from marshmallow import ValidationError
 from app.utils.logger import logger
+from app.api.schemas.repayment import RepaymentSchema, RepaymentResponseSchema
 
 
 class RepaymentService:
     @staticmethod
     def process_request(data):
         """
-        Process a repayment request from Simbrella to FirstBank
+        Process the Repayment request.
 
         Args:
-            data (dict): The request data containing repayment details
+            data (dict): The request data.
 
         Returns:
-            flask.Response: JSON response with the result of the repayment operation
+            dict: A standardized response.
         """
         try:
-            # Log the incoming request
+            logger.info("Processing Repayment request")
-            logger.info(f"Processing repayment request: {data}")
 
-            # Validate required fields
+            # Validate input data using RepaymentSchema
-            required_fields = [
+            schema = RepaymentSchema()
-                "requestId", "countryCode", "transactionId", "debtId",
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
-                "customerId", "accountId", "productId", "collectAmount",
-                "collectionMethod", "lienAmount"
-            ]
 
-            for field in required_fields:
+            # Simulated processing logic
-                if field not in data:
+            # In a real implementation, this would interact with your business logic
-                    logger.error(f"Missing required field: {field}")
+            # to process the repayment
-                    return jsonify({
-                        "resultCode": "01",
-                        "resultDescription": f"Missing required field: {field}"
-                    }), 400
 
-            # Process the repayment request
+            # For demonstration, we'll simulate a partial repayment
-            # This is where you would implement the actual business logic
+            collected_amount = validated_data.get('collectedAmount') * 0.75  # 75% of requested amount
-            # For now, we'll just return a successful response
+            lien_amount = validated_data.get('lienAmount') * 0.25  # 25% of requested amount as lien
 
-            response = {
+            response_data = {
-                "requestId": data.get("requestId"),
+                "requestId": validated_data.get('requestId'),
-                "countryCode": data.get("countryCode"),
+                "countryCode": validated_data.get('countryCode'),
-                "transactionId": data.get("transactionId"),
+                "transactionId": validated_data.get('transactionId'),
-                "debtId": data.get("debtId"),
+                "debtId": validated_data.get('debtId'),
-                "customerId": data.get("customerId"),
+                "customerId": validated_data.get('customerId'),
-                "accountId": data.get("accountId"),
+                "accountId": validated_data.get('accountId'),
-                "productId": data.get("productId"),
+                "productId": validated_data.get('productId'),
-                "collectAmount": data.get("collectAmount"),
+                "collectedAmount": collected_amount,
-                "penalCharge": data.get("penalCharge", 0),
+                "penalCharge": validated_data.get('penalCharge', 0),
-                "lienAmount": data.get("lienAmount"),
+                "lienAmount": lien_amount,
-                "comment": data.get("comment", ""),
+                "comment": validated_data.get('comment', ""),
                 "resultCode": "00",
                 "resultDescription": "Loan Collection Successful"
             }
 
-            logger.info(f"Repayment response: {response}")
+            # Validate the response using the response schema
-            return jsonify(response)
+            response_schema = RepaymentResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "resultCode": "01",
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
-            logger.error(f"Error processing repayment request: {str(e)}")
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
                 "resultCode": "08",
-                "resultDescription": "Error occurred"
+                "resultDescription": f"Error occurred: {str(e)}"
             }), 500

app/api/services/sms.py

@@ -0,0 +1,60 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.utils.logger import logger
+from app.api.schemas.sms import SMSSchema, SMSResponseSchema
+
+
+class SMSService:
+    @staticmethod
+    def process_request(data):
+        """
+        Process the SMS request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing SMS request")
+
+            # Validate input data using SMSSchema
+            schema = SMSSchema()
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
+
+            # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to send an SMS to the customer
+
+            # For demonstration, we'll simulate a successful SMS send
+            response_data = {
+                "data": "",
+                "statusCode": 200,
+                "IsSuccessful": True,
+                "errorMessage": None
+            }
+
+            # Validate the response using the response schema
+            response_schema = SMSResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "data": "",
+                "statusCode": 400,
+                "IsSuccessful": False,
+                "errorMessage": f"Validation error: {err.messages}"
+            }), 400
+
+        except Exception as e:
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
+            return jsonify({
+                "data": "",
+                "statusCode": 500,
+                "IsSuccessful": False,
+                "errorMessage": f"Error occurred: {str(e)}"
+            }), 500

app/api/services/status_call.py

@@ -1,84 +1,77 @@
-from flask import jsonify
+from flask import request, jsonify
+from marshmallow import ValidationError
 from app.utils.logger import logger
+from app.api.schemas.status_call import StatusCallSchema, StatusCallResponseSchema
 
 
 class StatusCallService:
     @staticmethod
     def process_request(data):
         """
-        Process a status call request to check transaction status
+        Process the StatusCall request.
 
         Args:
-            data (dict): The request data containing transaction details to check
+            data (dict): The request data.
 
         Returns:
-            flask.Response: JSON response with the status of the transaction
+            dict: A standardized response.
         """
         try:
-            # Log the incoming request
+            logger.info("Processing StatusCall request")
-            logger.info(f"Processing status call request: {data}")
 
-            # Validate required fields
+            # Validate input data using StatusCallSchema
-            required_fields = [
+            schema = StatusCallSchema()
-                "transactionId", "transactionType", "customerId"
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
-            ]
 
-            for field in required_fields:
+            # Simulated processing logic
-                if field not in data:
+            # In a real implementation, this would interact with your business logic
-                    logger.error(f"Missing required field: {field}")
+            # to check the status of a transaction
-                    return jsonify({
-                        "resultCode": "01",
-                        "resultDescription": f"Missing required field: {field}"
-                    }), 400
 
-            # Process the status call request based on transaction type
+            # For demonstration, we'll simulate different responses based on transaction type
-            transaction_type = data.get("transactionType")
+            transaction_type = validated_data.get('transactionType')
 
-            # Prepare the response based on transaction type
             if transaction_type == "Disbursement":
-                status = {
+                provided_amount = 1000.00
-                    "providedAmount": 1000.00,
+                collected_amount = 0.00
-                    "collectedAmount": 0.00,
+                inner_result_description = "Loan Provision is successful"
-                    "resultCode": "00",
-                    "resultDescription": "Loan Provision is successful"
-                }
             elif transaction_type == "Collection":
-                status = {
+                provided_amount = 0.00
-                    "providedAmount": 0.00,
+                collected_amount = 1050.00
-                    "collectedAmount": 100.00,
+                inner_result_description = "Loan Collection is successful"
-                    "resultCode": "00",
+            else:  # PenalCharge
-                    "resultDescription": "Loan Collection is successful"
+                provided_amount = 0.00
-                }
+                collected_amount = 50.00
-            elif transaction_type == "PenalCharge":
+                inner_result_description = "Penal Charge is successful"
-                status = {
-                    "transactionId": data.get("transactionId"),
-                    "providedAmount": 0.00,
-                    "collectedAmount": 100.00,
-                    "resultCode": "00",
-                    "resultDescription": "Penal Charge is successful"
-                }
-            else:
-                logger.error(f"Invalid transaction type: {transaction_type}")
-                return jsonify({
-                    "resultCode": "01",
-                    "resultDescription": f"Invalid transaction type: {transaction_type}"
-                }), 400
 
-            response = {
+            response_data = {
-                "requestId": data.get("requestId", ""),
+                "transactionId": "24110114545374721",  # This would be generated in a real system
-                "countryCode": data.get("countryCode", "NGR"),
+                "data": {
-                "transactionId": data.get("transactionId"),
+                    "transactionId": validated_data.get('transactionId'),
-                "Status": status,
+                    "providedAmount": provided_amount,
+                    "collectedAmount": collected_amount,
+                    "resultCode": "00",
+                    "resultDescription": inner_result_description
+                },
                 "resultCode": "00",
                 "resultDescription": "SUCCESS"
             }
 
-            logger.info(f"Status call response: {response}")
+            # Validate the response using the response schema
-            return jsonify(response)
+            response_schema = StatusCallResponseSchema()
+            validated_response = response_schema.dump(response_data)
+
+            return jsonify(validated_response)
+
+        except ValidationError as err:
+            logger.error(f"Validation Error: {err.messages}")
+            return jsonify({
+                "resultCode": "01",
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
-            logger.error(f"Error processing status call request: {str(e)}")
+            logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
                 "resultCode": "08",
-                "resultDescription": "Error occurred"
+                "resultDescription": f"Error occurred: {str(e)}"
             }), 500

app/api/services/transaction_verify.py

@@ -1,8 +1,7 @@
 from flask import request, jsonify
 from marshmallow import ValidationError
 from app.utils.logger import logger
-from app.api.helpers.response_helper import ResponseHelper
+from app.api.schemas.transaction_verify import TransactionVerifySchema, TransactionVerifyResponseSchema
-from app.api.schemas.transaction_verify import TransactionVerifySchema   
 
 
 class TransactionVerifyService:
@@ -25,33 +24,54 @@ class TransactionVerifyService:
             validated_data = schema.load(data)  # Raises ValidationError if invalid
 
             # Simulated processing logic
+            # In a real implementation, this would interact with your business logic
+            # to verify the transaction status
+
+            # For demonstration, we'll simulate different responses based on transaction type
+            transaction_type = validated_data.get('transactionType')
+
+            if transaction_type == "Disbursement":
+                provided_amount = 100.0
+                collected_amount = 0.0
+                result_description = "Disbursement Status retrieved successfully."
+            elif transaction_type == "Collection":
+                provided_amount = 0.0
+                collected_amount = 75.0
+                result_description = "Collection Status retrieved successfully."
+            else:  # Penalty
+                provided_amount = 0.0
+                collected_amount = 7.50
+                result_description = "Penalty Status retrieved successfully."
+
             response_data = {
-                "type": "TransactionCheckResponse",
+                "requestId": validated_data.get('requestId'),
-                "nativeId": "FBN20191031104405CN621868",
+                "countryCode": validated_data.get('countryCode'),
-                "customerId": "CN621868",
+                "transactionId": validated_data.get('transactionId'),
-                "accountId": "2017821799",
+                "transactionType": transaction_type,
-                "providedAmount": 0.0,
+                "customerId": validated_data.get('customerId'),
-                "collectedAmount": 7.50,
+                "accountId": validated_data.get('accountId'),
+                "providedAmount": provided_amount,
+                "collectedAmount": collected_amount,
                 "resultCode": "00",
-                "resultDescription": "Collect Status retrieved successfully."
+                "resultDescription": result_description
             }
 
+            # Validate the response using the response schema
+            response_schema = TransactionVerifyResponseSchema()
+            validated_response = response_schema.dump(response_data)
 
-            # return ResponseHelper.success(
+            return jsonify(validated_response)
-            #     data=response_data,
-            #     message="Transaction verification completed successfully"
-            # )
-
-            return response_data
 
         except ValidationError as err:
             logger.error(f"Validation Error: {err.messages}")
             return jsonify({
-                "message": "Validation exception"
+                "resultCode": "01",
-                }) , 422
+                "resultDescription": f"Validation error: {err.messages}"
+            }), 422
 
         except Exception as e:
             logger.error(f"An error occurred: {str(e)}", exc_info=True)
             return jsonify({
-                "message": "Internal Server Error"
+                "resultCode": "08",
-                }) , 500
+                "resultDescription": f"Error occurred: {str(e)}"
+            }), 500