bw-essentials-core 0.1.5__py3-none-any.whl → 0.1.33__py3-none-any.whl

bw_essentials/services/notification.py

@@ -32,7 +32,7 @@ class NotificationService(ApiClient):
             "email": "email"
         }
 
-    def _whatsapp(self, title, template, platform, params, to, user_id) -> None:
+    def _whatsapp(self, title, template, platform, params, to, user_id) -> dict:
         """
         Sends a WhatsApp notification.
 
@@ -46,7 +46,7 @@ class NotificationService(ApiClient):
         - params: Parameters for the notification message.
 
         Returns:
-        None
+            returns the response data from the notification service.
         """
         logger.info(f"In - whatsapp {user_id =}, {to =}, "
                     f"{title =}, {template =}, {platform =}, {params =}")
@@ -66,8 +66,9 @@ class NotificationService(ApiClient):
         self.set_headers(headers)
         resp_data = self._post(url=self.base_url, endpoint=self.urls.get('whatsapp'), data=payload)
         logger.info(f"Whatsapp response {resp_data =}")
+        return resp_data
 
-    def send_whatsapp(self, template, title, params, to, user_id) -> None:
+    def send_whatsapp(self, template, title, params, to, user_id) -> dict:
         """
 
         Args:
@@ -78,17 +79,18 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user receiving the notification.
 
         Returns:
-            None
+            Returns the response of calling function
         """
         logger.info(f"In - send_whatsapp_notification {user_id =} {title = } {params = } {to = }")
-        self._whatsapp(title=title,
+        response = self._whatsapp(title=title,
                        template=template,
                        platform=self._get_env_var(NotificationService.PLATFORM),
                        params=params,
                        to=to,
                        user_id=user_id)
+        return response
 
-    def _email(self, title: str, content: str, platform: str, to: str, user_id: str) -> None:
+    def _email(self, title: str, content: str, platform: str, to: str, user_id: str) -> dict:
         """
         Sends an email notification using the internal notification service.
 
@@ -100,7 +102,7 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user for tracking or logging purposes.
 
         Returns:
-            None
+            returns the response data from the notification service.
 
         """
         logger.info(f"In - email {user_id =}, {to =}, {title =}, {platform =}, {content =}")
@@ -119,8 +121,9 @@ class NotificationService(ApiClient):
         self.set_headers(headers)
         resp_data = self._post(url=self.base_url, endpoint=self.urls.get('email'), json=payload)
         logger.info(f"Email response {resp_data =}")
+        return resp_data
 
-    def send_email(self, title: str, content: str, to: str, user_id: str) -> None:
+    def send_email(self, title: str, content: str, to: str, user_id: str) -> dict:
         """
         Sends an email notification to the specified recipient.
 
@@ -131,13 +134,14 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user associated with the notification.
 
         Returns:
-            None
+            return the response of calling function
         """
         logger.info(f"In - send_email {user_id =}, {title =}, {to =}")
-        self._email(
-            title=title,
-            content=content,
-            platform=self._get_env_var(NotificationService.PLATFORM),
-            to=to,
-            user_id=user_id
+        response = self._email(
+                title=title,
+                content=content,
+                platform=self._get_env_var(NotificationService.PLATFORM),
+                to=to,
+                user_id=user_id
         )
+        return response

bw_essentials/services/payment.py

@@ -0,0 +1,84 @@
+import logging
+from bw_essentials.services.api_client import ApiClient
+from bw_essentials.constants.services import Services
+
+logger = logging.getLogger(__name__)
+
+
+class Payment(ApiClient):
+
+    def __init__(self, service_user: str):
+        super().__init__(service_user)
+        self.urls = {
+            "get_subscription": "user-subscription",
+            "update_otp_facilitator_code": "order",
+            "update_subscription_facilitator_code": "user-subscription-update-data"
+        }
+        self.name = Services.PAYMENT.value
+        self.base_url = self.get_base_url(Services.PAYMENT.value)
+
+    def get_subscription(self, user_id):
+        """
+        Fetch subscription details for a given user.
+
+        This method constructs the request URL using the configured base URL
+        and the `get_subscription` endpoint. It sends a GET request with
+        the provided `user_id` as a query parameter, logs the process,
+        and returns the subscription data payload.
+
+        Args:
+            user_id (str | int): Unique identifier of the user whose
+                subscription details need to be fetched.
+
+        Returns:
+            dict | None: A dictionary containing the subscription data if
+            available, otherwise `None`.
+        """
+        logger.info(f"Received request to get subscription with {user_id =}")
+        url = f"{self.base_url}"
+        subscription = self._get(url=url, endpoint=self.urls.get('get_subscription'), params={'userId': user_id})
+        logger.info(f"Successfully fetched subscription data. {subscription =}")
+        return subscription.get('data')
+
+    def update_otp_facilitator_code(self, payment_reference_id: str, analyst_id: str, payload: dict):
+        """
+        Updates the facilitator code on the Payment Service for a given payment_reference_id.
+
+        Args:
+            payment_reference_id (str): The payment reference ID (order ID)
+            analyst_id (str): Analyst UUID
+            payload (dict): Body containing facilitatorCode
+
+        Returns:
+            dict: Response data
+        """
+        logger.info(f"In - update_facilitator_code payment_reference_id={payment_reference_id}, "
+                    f""f"analyst_id={analyst_id}, payload={payload}")
+        response = self._put(
+            url=f"{self.base_url}",
+            endpoint=f"{self.urls.get('update_otp_facilitator_code')}/{payment_reference_id}",
+            json=payload,
+            params={"analyst": analyst_id},
+        )
+        logger.info(f"Out - update_facilitator_code response={response}")
+        return response
+
+    def update_subscription_facilitator_code(self, payment_reference_id: str, payload: dict):
+        """
+        Updates the facilitator code on the Payment Service for a given payment_reference_id.
+        Args:
+            payment_reference_id (str): The payment reference ID (subscription ID)
+            payload (dict): Body containing facilitatorCode and userId
+
+        Returns:
+            dict: Response data
+        """
+        logger.info(f"In - update_subscription_facilitator_code payment_reference_id={payment_reference_id}, "
+                    f"payload={payload}")
+        response = self._put(
+            url=f"{self.base_url}",
+            endpoint=f"{self.urls.get('update_subscription_facilitator_code')}/{payment_reference_id}",
+            json=payload
+        )
+        logger.info(f"Out - update_subscription_facilitator_code response={response}")
+        return response

bw_essentials/services/portfolio_catalogue.py

@@ -48,7 +48,7 @@ Example
 import logging
 from typing import Optional, Dict, Any
 
-from bw_essentials.constants.services import Services
+from bw_essentials.constants.services import Services, PortfolioStatus
 from bw_essentials.services.api_client import ApiClient
 
 logger = logging.getLogger(__name__)
@@ -78,6 +78,10 @@ class PortfolioCatalogue(ApiClient):
         self.name = Services.PORTFOLIO_CATALOGUE.value
         self.urls = {
             "rebalance": "rebalance",
+            "get_rebalance": "rebalance",
+            "subscriptions_by_ids": "subscription-plan/list",
+            "otp_subscriptions_by_ids": "one-time-plans/list",
+            "option_recommendations": "options/recommendations"
         }
 
     def create_rebalance(self, json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
@@ -102,3 +106,167 @@ class PortfolioCatalogue(ApiClient):
         )
         logger.info("%s", data)
         return data
+
+    def rebalance(self, portfolio_id, status):
+        """Fetch the latest rebalance record for a portfolio.
+
+        Parameters
+        ----------
+        portfolio_id : str
+            Portfolio identifier.
+        status : str
+            Portfolio status filter.
+
+        Returns
+        -------
+        dict
+            The first record from the service response's 'data' list.
+        """
+        logger.info("In - rebalance portfolio_id=%s status=%s", portfolio_id, status)
+        data = self._get(
+            url=self.base_url,
+            endpoint=self.urls["get_rebalance"],
+            params={'portfolioId': portfolio_id, 'status': status}
+        )
+        logger.info("rebalance response: %s", data)
+        return data.get('data')[0]
+
+    def get_rebalance_due_date(self, portfolio_id, status):
+        """Return the next rebalance date for an active portfolio, else None.
+
+        Parameters
+        ----------
+        portfolio_id : str
+            Portfolio identifier.
+        status : str
+            Portfolio status.
+
+        Returns
+        -------
+        str | None
+            The next rebalance date string if available; otherwise None.
+        """
+        logger.info(
+            "In - get_rebalance_due_date portfolio_id=%s status=%s",
+            portfolio_id,
+            status,
+        )
+        if status in PortfolioStatus.ACTIVE_FOR_SUBSCRIBED_USER.value:
+            rebalance_history = self.rebalance(portfolio_id, status)
+            next_rebalance_date = (
+                rebalance_history.get('nextRebalanceDate') if rebalance_history else None
+            )
+            logger.info("nextRebalanceDate=%s", next_rebalance_date)
+            return next_rebalance_date
+        logger.info("get_rebalance_due_date not applicable for status=%s", status)
+        return None
+
+    def get_subscriptions_by_ids(self, plans_ids: list):
+        """
+        Fetch multiple subscriptions by their plan IDs.
+
+        This method constructs the request URL using the configured base URL
+        and the `subscriptions_by_ids` endpoint. It sends a POST request with
+        the given list of `plans_ids` in the request body, logs the process,
+        and returns the subscription data.
+
+        Args:
+            plans_ids (list[str] | list[int]): A list of subscription plan IDs
+                to fetch details for.
+
+        Returns:
+            list[dict]: A list of subscription data dictionaries if available,
+            otherwise an empty list.
+        """
+        logger.info(f"In get_subscriptions_by_ids {plans_ids =}")
+        url = f"{self.base_url}"
+        payload = {
+            "planId": plans_ids
+        }
+        response = self._post(url=url, endpoint=self.urls.get('subscriptions_by_ids'), json=payload)
+        logger.info(f"Successfully fetched subscriptions by ids data. {response =}")
+        return response.get('data', [])
+
+    def get_otp_subscriptions_by_ids(self, plans_ids: list):
+        """
+        Fetch OTP subscription details for multiple plan IDs.
+
+        This method sends a POST request to the `otp_subscriptions_by_ids`
+        endpoint with the given list of plan IDs in the request body.
+        It logs the request and response flow and returns the extracted
+        subscription data.
+
+        Args:
+            plans_ids (list[str] | list[int]): A list of OTP subscription plan IDs
+                to retrieve details for.
+
+        Returns:
+            list[dict]: A list of OTP subscription data dictionaries if available,
+            otherwise an empty list.
+        """
+        logger.info(f"In get_otp_subscriptions_by_ids {plans_ids =}")
+        url = f"{self.base_url}"
+        payload = {
+            "id": plans_ids
+        }
+        response  = self._post(url=url, endpoint=self.urls.get('otp_subscriptions_by_ids'), json=payload)
+        logger.info(f"Successfully fetched otp subscriptions by ids data. {response =}")
+        return response.get('data', [])
+
+    def get_options_recommendations(self,
+                                    strike_price_gt: float = None,
+                                    segment_in: str = None,
+                                    date_gte: str = None,
+                                    limit: int = None,
+                                    broker: str = None,
+                                    underlying_symbol: str = None,
+                                    status: str = None,
+                                    isin_code: str = None):
+        """
+        Fetch options trading recommendations based on filtering parameters.
+
+        This method sends a GET request to the Portfolio-Catalogue service's
+        `/options/recommendations` endpoint with optional query parameters
+        for filtering by strike price, trading segment, date, broker, and limit.
+
+        Endpoint:
+            GET /options/recommendations
+
+        Args:
+            strike_price_gt (float, optional): Fetch recommendations where strike price > given value.
+            segment_in (str, optional): Trading segment to filter by (e.g., 'fno').
+            date_gte (str, optional): Minimum date (ISO format, e.g., '2025-10-28').
+            limit (int, optional): Limit the number of records returned.
+            broker (str, optional): Broker name to filter recommendations (e.g., 'zerodha').
+            underlying_symbol (str, optional): Trading symbol to filter recommendations (e.g., 'RELIANCE').
+            status (str, optional): Status of the recommendation. (e.g., 'active', 'inactive')
+            isin_code (str, optional): ISIN code to filter recommendations).
+
+        Returns:
+            list[dict]: A list of recommendation records if available, otherwise an empty list.
+        """
+        logger.info(
+            "In - get_options_recommendations strike_price_gt=%s, segment_in=%s, date_gte=%s, limit=%s, "
+            "broker=%s, underlying_symbol=%s, status=%s, isin_code=%s",
+            strike_price_gt, segment_in, date_gte, limit, broker, underlying_symbol, status, isin_code
+        )
+
+        params = {k: v for k, v in {
+            "strike_price__gt": strike_price_gt,
+            "segment__in": segment_in,
+            "date__gte": date_gte,
+            "limit": limit,
+            "broker": broker,
+            "underlying_symbol": underlying_symbol,
+            "status": status,
+            "isin_code": isin_code
+        }.items() if v is not None}
+
+        response = self._get(
+            url=self.base_url,
+            endpoint=self.urls.get('option_recommendations'),
+            params=params
+        )
+
+        logger.info(f"Successfully fetched options recommendations. {response =}")
+        return response.get("data", [])

bw_essentials/services/portfolio_content.py

@@ -43,6 +43,7 @@ class PortfolioContent(ApiClient):
         self.name = Services.PORTFOLIO_CONTENT.value
         self.urls = {
             "portfolio": "portfolio",
+            "portfolio-details": "portfolio-details"
         }
 
     def get_portfolio_details(self, portfolio_id: str) -> Optional[Dict[str, Any]]:
@@ -67,3 +68,26 @@ class PortfolioContent(ApiClient):
         )
         logger.info("%s", data)
         return data
+
+    def get_portfolio_details_by_ids(self, portfolio_ids: list):
+        """
+        Fetch portfolio details from the external service for the given portfolio IDs.
+
+        Args:
+            portfolio_ids (list): A list of portfolio IDs to fetch details for.
+
+        Returns:
+            dict: The response data containing portfolio details from the external service.
+        """
+        logger.info("Fetching portfolio details for %d portfolio IDs: %s", len(portfolio_ids), portfolio_ids)
+
+        payload = {
+            "portfolioIds": portfolio_ids
+        }
+        response = self._post(
+            url=self.base_url,
+            endpoint=self.urls['portfolio-details'],
+            json=payload
+        )
+        logger.info(f"Successfully fetched portfolio details by ids. {response=}")
+        return response.get('data', [])