[add]: eco endpoints and dummy responses

app/eco/services/__init__.py

@@ -0,0 +1,5 @@
+from .authorization import AuthorizationService
+from .disbursement import DisbursementService
+from .debt_closure_notification import DebtClosureNotificationService
+from .send_sms import SendSMSService
+from .collect_loan import CollectLoanService

app/eco/services/authorization.py

@@ -0,0 +1,102 @@
+from flask import request, jsonify
+from marshmallow import ValidationError
+from app.eco.services.base_service import BaseService
+from app.utils.logger import logger
+from app.eco.schemas.authorization import AuthorizeRequestSchema
+from app.eco.helpers.response_helper import ResponseHelper
+from flask_jwt_extended import (
+    JWTManager,
+    jwt_required,
+    create_access_token,
+    create_refresh_token,
+    get_jwt_identity,
+)
+from app.config import Config
+
+USERNAME = Config.BASIC_AUTH_USERNAME
+PASSWORD = Config.BASIC_AUTH_PASSWORD
+
+
+class AuthorizationService(BaseService):
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the Authorization request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing Authorization request")
+
+            if not data:
+                return ResponseHelper.bad_request(result_description="Missing JSON in request")
+
+            # Validate input data using the Authorization schema
+            schema = AuthorizeRequestSchema()
+            validated_data = schema.load(data)  # Raises ValidationError if invalid
+
+            if (
+                validated_data["username"] != USERNAME
+                or validated_data["password"] != PASSWORD
+            ):
+                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"])
+
+            # Simulated processing logic
+            response_data = {
+                "access_token": access_token,
+                "refresh_token": refresh_token,
+            }
+
+            return ResponseHelper.success(
+                data={"data": response_data}, result_description="Authorization processed successfully"
+            )
+
+        except ValidationError as e:
+            logger.error(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(
+                result_description=f"Error processing Authorization request: {e}"
+            )
+
+    @staticmethod
+    def process_refresh_request():
+        """
+        Process the RefreshToken request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            logger.info("Processing RefreshToken request")
+
+            identity = get_jwt_identity()
+            access_token = create_access_token(identity=identity)
+
+            # Simulated processing logic
+            response_data = {
+                "access_token": access_token,
+            }
+
+            return ResponseHelper.success(
+                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(
+                result_description=f"Error processing RefreshToken request: {e}"
+            )

app/eco/services/base_service.py

@@ -0,0 +1,32 @@
+from app.eco.enums import TransactionType
+from flask import jsonify
+from marshmallow import ValidationError
+import logging
+
+logger = logging.getLogger(__name__)
+
+class BaseService:
+    TRANSACTION_TYPE = None
+
+    @classmethod
+    def validate_data(cls, data, schema):
+        """
+        Validate input data based on the provided schema.
+        """
+        logger.info(f"Processing {cls.TRANSACTION_TYPE} request")
+        return schema.load(data)
+
+    # @classmethod
+    # def log_session(cls, validated_data):
+    #     """
+    #     Create a new session.
+    #     """
+    #     channel = "USSD" if validated_data.get("channel") is None else validated_data.get("channel")
+
+    #     return Session.create_session(
+    #         session_id = validated_data.get("transactionId"),
+    #         customer_id =  validated_data.get('customerId', None),
+    #         account_id = validated_data.get("accountId", None),  
+    #         type = cls.TRANSACTION_TYPE,
+    #         channel = channel,
+    #     )

app/eco/services/collect_loan.py

@@ -0,0 +1,33 @@
+from app.eco.enums.transaction_type import TransactionType
+from app.eco.services.base_service import BaseService
+from app.eco.schemas.collect_loan import CollectLoanSchema
+from marshmallow import ValidationError
+from app.eco.helpers.response_helper import ResponseHelper
+
+class CollectLoanService(BaseService):
+    TRANSACTION_TYPE = TransactionType.COLLECT_LOAN
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the loan collection request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            validated_data = CollectLoanService.validate_data(data, CollectLoanSchema())
+
+            response_data = {
+                "transactionId": "01135062",
+                "amountCollected": 900.0,
+            }
+
+            return ResponseHelper.success(data=response_data)
+        except ValidationError as err:
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+        except Exception as e:
+            return ResponseHelper.internal_server_error()

app/eco/services/debt_closure_notification.py

@@ -0,0 +1,27 @@
+from app.eco.enums.transaction_type import TransactionType
+from app.eco.services.base_service import BaseService
+from app.eco.schemas.debt_closure_notification import DebtClosureNotificationSchema
+from marshmallow import ValidationError
+from app.eco.helpers.response_helper import ResponseHelper
+
+class DebtClosureNotificationService(BaseService):
+    TRANSACTION_TYPE = TransactionType.DEBT_CLOSURE_NOTIFICATION
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the debt closure notification request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            validated_data = DebtClosureNotificationService.validate_data(data, DebtClosureNotificationSchema())
+            return ResponseHelper.success()
+        except ValidationError as err:
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+        except Exception as e:
+            return ResponseHelper.internal_server_error()

app/eco/services/disbursement.py

@@ -0,0 +1,32 @@
+from app.eco.enums.transaction_type import TransactionType
+from app.eco.services.base_service import BaseService
+from app.eco.schemas.disbursement import DisbursementSchema
+from marshmallow import ValidationError
+from app.eco.helpers.response_helper import ResponseHelper
+
+class DisbursementService(BaseService):
+    TRANSACTION_TYPE = TransactionType.DISBURSEMENT
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the disbursement request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            validated_data = DisbursementService.validate_data(data, DisbursementSchema())
+            response_data = {
+                "transactionId": "SIM01135042",
+            }
+        
+            return ResponseHelper.success(data=response_data)
+
+        except ValidationError as err:
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+        except Exception as e:
+            return ResponseHelper.internal_server_error()

app/eco/services/send_sms.py

@@ -0,0 +1,31 @@
+from app.eco.enums.transaction_type import TransactionType
+from app.eco.services.base_service import BaseService
+from app.eco.schemas.send_sms import SendSmsSchema
+from marshmallow import ValidationError
+from app.eco.helpers.response_helper import ResponseHelper
+
+class SendSMSService(BaseService):
+    TRANSACTION_TYPE = TransactionType.SEND_SMS
+
+    @staticmethod
+    def process_request(data):
+        """
+        Process the SMS sending request.
+
+        Args:
+            data (dict): The request data.
+
+        Returns:
+            dict: A standardized response.
+        """
+        try:
+            validated_data = SendSMSService.validate_data(data, SendSmsSchema())
+
+            response_data = {
+                "undelivered": []
+            }
+            return ResponseHelper.success(data=response_data)
+        except ValidationError as err:
+            return ResponseHelper.unprocessable_entity(result_description="Validation exception")
+        except Exception as e:
+            return ResponseHelper.internal_server_error()