Merge pull request #65 from PSNAppz/1.2.0

Simplify DFSP APIs

Author: venky-ganapathy

openg2p-spar-bene-portal-api/src/openg2p_spar_bene_portal_api/app.py

@@ -15,10 +15,11 @@
     RequestValidation,
 )
 from openg2p_spar_models.models import (
-    DfspProvider,
-    DfspProviderValue,
+    Bank,
+    Branch,
     IdFaMapping,
     Strategy,
+    WalletServiceProvider,
 )
 
 from .controllers import DfspController, MapperController
@@ -45,9 +46,10 @@ def migrate_database(self, args):
 
         async def migrate():
             _logger.info("Migrating database")
+            await Bank.create_migrate()
+            await Branch.create_migrate()
+            await WalletServiceProvider.create_migrate()
             await IdFaMapping.create_migrate()
             await Strategy.create_migrate()
-            await DfspProvider.create_migrate()
-            await DfspProviderValue.create_migrate()
 
         asyncio.run(migrate())

openg2p-spar-bene-portal-api/src/openg2p_spar_bene_portal_api/controllers/dfsp_controller.py

@@ -1,186 +1,95 @@
-import logging
-from typing import List, Optional
-
-from fastapi import Query
 from openg2p_fastapi_common.controller import BaseController
 from openg2p_spar_mapper_core.services import DfspService
 from openg2p_spar_models.schemas import (
-    DfspProviderSchema,
-    DfspProviderValueSchema,
+    BanksRequest,
+    BanksResponse,
+    BranchesRequest,
+    BranchesResponse,
+    WalletServiceProvidersRequest,
+    WalletServiceProvidersResponse,
 )
 
-from ..config import Settings
-
-_config = Settings.get_config()
-_logger = logging.getLogger(_config.logging_default_logger_name)
-
 
 class DfspController(BaseController):
     """
-    Controller for DFSP (Digital Financial Service Provider) endpoints.
+    Controller for Bank, Branch, and WalletServiceProvider endpoints.
 
-    Provides API endpoints for querying provider types and their values.
+    Provides API endpoints for querying bank, branch, and wallet service provider data.
     """
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-        self.router.tags += ["DFSP"]
+        self.router.tags += ["Bank, Branch & Wallet"]
         self.router.prefix = "/dfsp"
         self.service = DfspService.get_component()
 
-        # Provider endpoints
-        self.router.add_api_route(
-            "/providers",
-            self.get_all_providers,
-            responses={200: {"model": List[DfspProviderSchema]}},
-            methods=["GET"],
-            summary="Get all provider types",
-            description="Returns all available provider types (BANK, EMAIL_WALLET, MOBILE_WALLET)",
-        )
-
+        # Bank endpoints
         self.router.add_api_route(
-            "/providers/{provider_type}",
-            self.get_provider_by_type,
-            responses={200: {"model": DfspProviderSchema}},
-            methods=["GET"],
-            summary="Get provider by type",
-            description="Returns a specific provider type configuration",
+            "/fetch-banks",
+            self.fetch_banks,
+            responses={200: {"model": BanksResponse}},
+            methods=["POST"],
+            summary="Fetch all banks",
+            description="Returns all available banks",
         )
 
-        # Provider values endpoints
+        # Branch endpoints
         self.router.add_api_route(
-            "/providers/{provider_type}/values",
-            self.get_provider_values,
-            responses={200: {"model": List[DfspProviderValueSchema]}},
-            methods=["GET"],
-            summary="Get provider values",
-            description="Returns provider values (e.g., banks, branches, wallets) filtered by type and optional parent",
+            "/fetch-branches",
+            self.fetch_branches,
+            responses={200: {"model": BranchesResponse}},
+            methods=["POST"],
+            summary="Fetch all branches",
+            description="Returns all available branches, optionally filtered by bank_id",
         )
 
+        # WalletServiceProvider endpoints
         self.router.add_api_route(
-            "/values/{code}",
-            self.get_provider_value_by_code,
-            responses={200: {"model": DfspProviderValueSchema}},
-            methods=["GET"],
-            summary="Get provider value by code",
-            description="Returns a specific provider value by its code",
+            "/fetch-wallet-service-providers",
+            self.fetch_wallet_service_providers,
+            responses={200: {"model": WalletServiceProvidersResponse}},
+            methods=["POST"],
+            summary="Fetch all wallet service providers",
+            description="Returns all available wallet service providers",
         )
 
-        self.router.add_api_route(
-            "/values/{parent_id}/children",
-            self.get_children,
-            responses={200: {"model": List[DfspProviderValueSchema]}},
-            methods=["GET"],
-            summary="Get children of a provider value",
-            description="Returns direct children of a provider value (e.g., branches of a bank)",
-        )
-
-    async def get_all_providers(self) -> List[DfspProviderSchema]:
+    async def fetch_banks(self, banks_request: BanksRequest) -> BanksResponse:
         """
-        Get all provider types.
-
-        Returns:
-            List of all provider types
-        """
-        try:
-            _logger.debug("Fetching all provider types")
-            providers = await self.service.get_all_providers()
-            _logger.debug(f"Found {len(providers)} provider types")
-            return providers
-        except Exception as e:
-            _logger.error(f"Error fetching providers: {str(e)}")
-            raise
-
-    async def get_provider_by_type(self, provider_type: str) -> DfspProviderSchema:
-        """
-        Get a provider by type.
+        Fetch all banks.
 
         Args:
-            provider_type: The provider type (BANK, EMAIL_WALLET, MOBILE_WALLET)
+            banks_request: The banks request
 
         Returns:
-            DfspProviderSchema for the requested type
+            BanksResponse with list of banks
         """
-        try:
-            _logger.debug(f"Fetching provider type: {provider_type}")
-            provider = await self.service.get_provider_by_type(provider_type)
-            if not provider:
-                _logger.warning(f"Provider type not found: {provider_type}")
-                return {"error": f"Provider type '{provider_type}' not found"}
-            return provider
-        except Exception as e:
-            _logger.error(f"Error fetching provider type {provider_type}: {str(e)}")
-            raise
-
-    async def get_provider_values(
-        self,
-        provider_type: str,
-        parent_id: Optional[int] = Query(
-            None, description="Optional parent ID for filtering"
-        ),
-    ) -> List[DfspProviderValueSchema]:
-        """
-        Get provider values filtered by type and optional parent.
+        return await self.service.fetch_banks(banks_request)
 
-        Args:
-            provider_type: The provider type (BANK, EMAIL_WALLET, MOBILE_WALLET)
-            parent_id: Optional parent ID (for branches under a bank)
-
-        Returns:
-            List of provider values matching the criteria
+    async def fetch_branches(
+        self, branches_request: BranchesRequest
+    ) -> BranchesResponse:
         """
-        try:
-            _logger.debug(
-                f"Fetching provider values for type: {provider_type}, parent_id: {parent_id}"
-            )
-            values = await self.service.get_provider_values(
-                provider_type=provider_type, parent_id=parent_id
-            )
-            _logger.debug(f"Found {len(values)} provider values")
-            return values
-        except Exception as e:
-            _logger.error(
-                f"Error fetching provider values for {provider_type}: {str(e)}"
-            )
-            raise
-
-    async def get_provider_value_by_code(self, code: str) -> DfspProviderValueSchema:
-        """
-        Get a provider value by code.
+        Fetch all branches, optionally filtered by bank_id.
 
         Args:
-            code: The provider value code
+            branches_request: The branches request
 
         Returns:
-            DfspProviderValueSchema for the requested code
+            BranchesResponse with list of branches
         """
-        try:
-            _logger.debug(f"Fetching provider value by code: {code}")
-            value = await self.service.get_provider_value_by_code(code)
-            if not value:
-                _logger.warning(f"Provider value not found: {code}")
-                return {"error": f"Provider value '{code}' not found"}
-            return value
-        except Exception as e:
-            _logger.error(f"Error fetching provider value {code}: {str(e)}")
-            raise
-
-    async def get_children(self, parent_id: int) -> List[DfspProviderValueSchema]:
+        return await self.service.fetch_branches(branches_request)
+
+    async def fetch_wallet_service_providers(
+        self, wsp_request: WalletServiceProvidersRequest
+    ) -> WalletServiceProvidersResponse:
         """
-        Get direct children of a provider value.
+        Fetch all wallet service providers.
 
         Args:
-            parent_id: Parent provider value ID
+            wsp_request: The wallet service providers request
 
         Returns:
-            List of child provider values
+            WalletServiceProvidersResponse with list of wallet service providers
         """
-        try:
-            _logger.debug(f"Fetching children for parent_id: {parent_id}")
-            children = await self.service.get_children(parent_id)
-            _logger.debug(f"Found {len(children)} children")
-            return children
-        except Exception as e:
-            _logger.error(f"Error fetching children for {parent_id}: {str(e)}")
-            raise
+        return await self.service.fetch_wallet_service_providers(wsp_request)