ipulse-shared-core-ftredge 22.1.1__py3-none-any.whl → 23.1.1__py3-none-any.whl

ipulse_shared_core_ftredge/services/user/user_subscription_operations.py

@@ -2,7 +2,7 @@
 Subscription Management Operations - Handle user subscriptions and related operations
 """
 import logging
-from typing import Optional
+from typing import Optional, Dict, Any
 from datetime import datetime, timezone
 from google.cloud import firestore
 from google.cloud.exceptions import GoogleCloudError
@@ -32,12 +32,12 @@ class UsersubscriptionOperations:
         self.logger = logger or logging.getLogger(__name__)
         self.timeout = timeout
 
-    def _create_subscription_from_subscriptionplan(
+    def create_subscription_from_subscriptionplan(
         self,
         plan: SubscriptionPlan,
         source: str,
         granted_at: Optional[datetime] = None,
-        auto_renewal: Optional[bool] = None
+        auto_renewal_end: Optional[datetime] = None
     ) -> UserSubscription:
         """
         Common helper function to create a UserSubscription from a SubscriptionPlan.
@@ -68,10 +68,8 @@ class UsersubscriptionOperations:
             plan.plan_validity_cycle_unit
         )
 
-        # Use provided auto_renewal or default from plan
-        effective_auto_renewal = auto_renewal if auto_renewal is not None else (
-            plan.plan_default_auto_renewal if plan.plan_default_auto_renewal is not None else False
-        )
+        # Use provided auto_renewal_end or default from plan
+        effective_auto_renewal_end = auto_renewal_end if auto_renewal_end is not None else plan.plan_default_auto_renewal_end
 
         try:
             # Validate plan name
@@ -89,10 +87,10 @@ class UsersubscriptionOperations:
             plan_version=plan.plan_version,
             plan_id=plan.id or f"{plan.plan_name}_{plan.plan_version}",
             cycle_start_date=start_date,
-            cycle_end_date=end_date,
+            cycle_end_datetime=end_date,
             validity_time_length=plan.plan_validity_cycle_length,
             validity_time_unit=plan.plan_validity_cycle_unit,
-            auto_renew=effective_auto_renewal,
+            auto_renew_end_datetime=effective_auto_renewal_end,
             status=SubscriptionStatus.ACTIVE,
             granted_iam_permissions=plan.granted_iam_permissions or [],
             fallback_plan_id=plan.fallback_plan_id_if_current_plan_expired,
@@ -113,7 +111,7 @@ class UsersubscriptionOperations:
         updater_uid: str,
         source: str = "system_default_config",
         granted_at: Optional[datetime] = None,
-        auto_renewal: Optional[bool] = None
+        auto_renewal_end: Optional[datetime] = None
     ) -> UserSubscription:
         """
         Fetch a subscription plan from catalog service and apply to user.
@@ -124,7 +122,7 @@ class UsersubscriptionOperations:
             updater_uid: Who is applying the subscription
             source: Source identifier
             granted_at: Optional granted timestamp (overrides plan defaults)
-            auto_renewal: Optional auto-renewal setting (overrides plan defaults)
+            auto_renewal_end: Optional auto-renewal end date (overrides plan defaults)
 
         Returns:
             Applied UserSubscription
@@ -158,7 +156,7 @@ class UsersubscriptionOperations:
                 updater_uid=updater_uid,
                 source=source,
                 granted_at=granted_at,
-                auto_renewal=auto_renewal,
+                auto_renewal_end=auto_renewal_end,
                 add_associated_permissions=True
             )
 
@@ -182,7 +180,7 @@ class UsersubscriptionOperations:
         updater_uid: str,
         source: str = "system_default_config",
         granted_at: Optional[datetime] = None,
-        auto_renewal: Optional[bool] = None,
+        auto_renewal_end: Optional[datetime] = None,
         add_associated_permissions: bool = True
     ) -> UserSubscription:
         """
@@ -213,18 +211,18 @@ class UsersubscriptionOperations:
 
         try:
             # Create subscription from plan using helper
-            subscription = self._create_subscription_from_subscriptionplan(
+            subscription = self.create_subscription_from_subscriptionplan(
                 plan=subscriptionplan,
                 source=f"{source}:{updater_uid}",
                 granted_at=granted_at,
-                auto_renewal=auto_renewal
+                auto_renewal_end=auto_renewal_end
             )
 
             # Apply subscription to user (this will handle removing existing permissions and adding new ones)
             permissions_added = userstatus.apply_subscription(
                 subscription,
                 add_associated_permissions=add_associated_permissions,
-                remove_existing_subscription_permissions=True,
+                remove_previous_subscription_permissions=True,
                 granted_by=f"UsersubscriptionOperations.apply:{source}:{updater_uid}"
             )
 
@@ -442,18 +440,18 @@ class UsersubscriptionOperations:
             current_plan_id = userstatus.active_subscription.plan_id
 
             # Create new subscription from fallback plan with updated granted_at
-            new_subscription = self._create_subscription_from_subscriptionplan(
+            new_subscription = self.create_subscription_from_subscriptionplan(
                 plan=fallback_plan,
                 source=f"downgrade_from_{current_plan_id}:{reason}",
                 granted_at=datetime.now(timezone.utc),  # Set to now for downgrade
-                auto_renewal=fallback_plan.plan_default_auto_renewal
+                auto_renewal_end=fallback_plan.plan_default_auto_renewal_end
             )
 
             # Apply the new subscription to user (this will handle revoking existing permissions and adding new ones)
             permissions_added = userstatus.apply_subscription(
                 new_subscription,
                 add_associated_permissions=True,
-                remove_existing_subscription_permissions=True,
+                remove_previous_subscription_permissions=True,
                 granted_by=f"UsersubscriptionOperations:downgrade:{reason}"
             )
             userstatus.updated_at = datetime.now(timezone.utc)
@@ -481,4 +479,10 @@ class UsersubscriptionOperations:
                 plan_id=fallback_plan_id,
                 operation="downgrade_to_fallback_plan",
                 original_error=e
-            ) from e
+            ) from e
+
+    ######################################################################
+    ######################### Subscription Lifecycle Support Methods #####
+    ######################################################################
+    # Note: The main review method has been moved to UserStatusOperations
+    # as it manages overall user status, not just subscriptions

ipulse_shared_core_ftredge/services/user/userstatus_operations.py

@@ -3,7 +3,7 @@ Userstatus Operations - CRUD operations for Userstatus
 """
 import os
 import logging
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, TYPE_CHECKING
 
 from google.cloud import firestore
 from pydantic import ValidationError as PydanticValidationError
@@ -12,6 +12,11 @@ from ...models import UserStatus
 from ...exceptions import ResourceNotFoundError, UserStatusError
 from ..base import BaseFirestoreService
 
+# Type checking imports to avoid circular dependencies
+if TYPE_CHECKING:
+    from .user_subscription_operations import UsersubscriptionOperations
+    from .user_permissions_operations import UserpermissionsOperations
+
 
 class UserstatusOperations:
     """
@@ -23,12 +28,18 @@ class UserstatusOperations:
         firestore_client: firestore.Client,
         logger: Optional[logging.Logger] = None,
         timeout: float = 10.0,
-        status_collection: Optional[str] = None
+        status_collection: Optional[str] = None,
+        subscription_ops: Optional["UsersubscriptionOperations"] = None,
+        permissions_ops: Optional["UserpermissionsOperations"] = None
     ):
         self.db = firestore_client
         self.logger = logger or logging.getLogger(__name__)
         self.timeout = timeout
 
+        # Optional dependencies for comprehensive operations
+        self.subscription_ops = subscription_ops
+        self.permissions_ops = permissions_ops
+
         self.status_collection_name = status_collection or UserStatus.get_collection_name()
 
         # Archival configuration
@@ -110,8 +121,8 @@ class UserstatusOperations:
 
         try:
             updated_doc_dict = await self._status_db_service.update_document(
-                userstatus_id,
-                update_data,
+                doc_id=userstatus_id,
+                update_data=update_data,
                 updater_uid=updater_uid
             )
             self.logger.info("Userstatus for %s updated successfully by %s", user_uid, updater_uid)
@@ -210,3 +221,256 @@ class UserstatusOperations:
     async def userstatus_exists(self, user_uid: str) -> bool:
         """Check if a user status exists."""
         return await self._status_db_service.document_exists(f"{UserStatus.OBJ_REF}_{user_uid}")
+
+    ######################################################################
+    ######################### Comprehensive Review Methods #############
+    ######################################################################
+
+    async def review_and_clean_active_subscription_credits_and_permissions(
+        self,
+        user_uid: str,
+        updater_uid: str = "system_review",
+        review_auto_renewal: bool = True,
+        apply_fallback: bool = True,
+        clean_expired_permissions: bool = True,
+        review_credits: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Comprehensive review of user's active subscription, credits, and permissions.
+        This method handles:
+        1. Subscription lifecycle (auto-renewal, fallback, expiration)
+        2. Credit management based on subscription cycle timing
+        3. Permission cleanup and management
+
+        This is designed to be called on every authz request for comprehensive user state management.
+
+        Args:
+            user_uid: User UID to review
+            updater_uid: User ID performing the review
+            account_for_auto_renewal: Whether to auto-renew expired cycles if auto_renew_end_datetime is valid
+            apply_fallback: Whether to apply fallback plans when subscriptions expire
+            clean_expired_permissions: Whether to clean expired permissions
+            review_credits: Whether to review and update subscription-based credits
+
+        Returns:
+            Dict containing detailed results of the review and actions taken
+        """
+        from datetime import datetime, timezone
+        from ipulse_shared_base_ftredge.enums import SubscriptionStatus
+        from ...models import UserSubscription
+
+        self.logger.info("Starting comprehensive subscription, credits, and permissions review for user %s", user_uid)
+
+        result = {
+            'user_uid': user_uid,
+            'timestamp': datetime.now(timezone.utc),
+            'actions_taken': [],
+            'subscription_status': None,
+            'subscription_renewed': False,
+            'fallback_applied': False,
+            'subscription_revoked': False,
+            'permissions_cleaned': 0,
+            'permissions_added': 0,
+            'credits_updated': 0,
+            'error': None,
+            'original_subscription': None,
+            'final_subscription': None,
+            'updated_userstatus': None  # Will be populated with the updated UserStatus
+        }
+
+        try:
+            # Get current user status
+            userstatus = await self.get_userstatus(user_uid)
+            if not userstatus:
+                result['actions_taken'].append('no_userstatus_found')
+                return result
+
+            # Always add the current userstatus to result (will be updated if database changes occur)
+            result['updated_userstatus'] = userstatus
+
+            # Check if there's an active subscription
+            if not userstatus.active_subscription:
+                result['actions_taken'].append('no_active_subscription')
+
+                # Clean expired permissions if requested
+                if clean_expired_permissions:
+                    expired_permissions = userstatus.cleanup_expired_permissions()
+                    if expired_permissions > 0:
+                        result['permissions_cleaned'] = expired_permissions
+                        result['actions_taken'].append('cleaned_expired_permissions')
+
+                        # Save changes and update the result with the updated userstatus
+                        updated_userstatus = await self.update_userstatus(
+                            user_uid=user_uid,
+                            status_data=userstatus.model_dump(exclude_none=True),
+                            updater_uid=f"review:{updater_uid}"
+                        )
+                        result['updated_userstatus'] = updated_userstatus
+
+                return result
+
+            # Store original subscription for comparison
+            result['original_subscription'] = userstatus.active_subscription
+            now = datetime.now(timezone.utc)
+
+            # Use the subscription's is_active() method to check current status
+            if userstatus.active_subscription.is_active():
+                result['subscription_status'] = str(SubscriptionStatus.ACTIVE)
+                result['final_subscription'] = userstatus.active_subscription
+                result['actions_taken'].append('subscription_still_active')
+
+                # Update credits if subscription is active and review_credits is enabled
+                if review_credits:
+                    credits_updated = userstatus.update_subscription_credits()
+                    if credits_updated > 0:
+                        result['credits_updated'] = credits_updated
+                        result['actions_taken'].append('updated_subscription_credits')
+
+                # Clean expired permissions if requested
+                if clean_expired_permissions:
+                    expired_permissions = userstatus.cleanup_expired_permissions()
+                    if expired_permissions > 0:
+                        result['permissions_cleaned'] = expired_permissions
+                        result['actions_taken'].append('cleaned_expired_permissions_only')
+
+                # Save changes if any updates were made
+                if result['credits_updated'] > 0 or result['permissions_cleaned'] > 0:
+                    updated_userstatus = await self.update_userstatus(
+                        user_uid=user_uid,
+                        status_data=userstatus.model_dump(exclude_none=True),
+                        updater_uid=f"review:{updater_uid}"
+                    )
+                    result['updated_userstatus'] = updated_userstatus
+
+                return result
+
+            # Subscription is not active - determine why and what to do
+            subscription = userstatus.active_subscription
+
+            # Check if cycle is expired but auto-renewal is still valid
+            if (review_auto_renewal and
+                subscription.auto_renew_end_datetime and
+                now <= subscription.auto_renew_end_datetime and
+                now > subscription.cycle_end_datetime_safe):
+
+                # Attempt auto-renewal by extending the cycle
+                try:
+                    # Calculate new cycle start date (where the last cycle ended)
+                    new_cycle_start = subscription.cycle_end_datetime_safe
+
+                    # Create new subscription with updated cycle start date
+                    subscription_dict = subscription.model_dump()
+                    subscription_dict.update({
+                        'cycle_start_date': new_cycle_start,
+                        'cycle_end_datetime': None,  # Let the model auto-calculate this
+                        'updated_at': now,
+                        'updated_by': f"UserstatusOperations.auto_renew:{updater_uid}"
+                    })
+
+                    renewed_subscription = UserSubscription(**subscription_dict)
+
+                    # Apply the renewed subscription
+                    userstatus.apply_subscription(
+                        renewed_subscription,
+                        add_associated_permissions=True,
+                        remove_previous_subscription_permissions=True,
+                        granted_by=f"UserstatusOperations.review.auto_renew:{updater_uid}"
+                    )
+
+                    result['subscription_renewed'] = True
+                    result['subscription_status'] = str(userstatus.active_subscription.status)
+                    result['final_subscription'] = renewed_subscription
+                    result['actions_taken'].append('auto_renewed_cycle')
+
+                except (ValueError, UserStatusError) as renewal_error:
+                    self.logger.error("Auto-renewal failed for user %s: %s", user_uid, renewal_error)
+                    result['error'] = f"Auto-renewal failed: {str(renewal_error)}"
+                    result['actions_taken'].append('auto_renewal_failed')
+                    # Continue to fallback logic
+
+            # If auto-renewal didn't happen or failed, check for fallback
+            if not result['subscription_renewed']:
+                if apply_fallback and subscription.fallback_plan_id:
+                    try:
+                        # We need subscription_ops to handle the fallback plan logic
+                        if self.subscription_ops:
+                            # Import the catalog service to get fallback plan
+                            from ...services.catalog.catalog_subscriptionplan_service import CatalogSubscriptionPlanService
+
+                            catalog_service = CatalogSubscriptionPlanService(firestore_client=self.db, logger=self.logger)
+                            fallback_plan = await catalog_service.get_subscriptionplan(subscription.fallback_plan_id)
+
+                            if fallback_plan:
+                                # Create new subscription from fallback plan
+                                fallback_subscription = self.subscription_ops.create_subscription_from_subscriptionplan(
+                                    plan=fallback_plan,
+                                    source=f"fallback_from_{subscription.plan_id}:review:{updater_uid}",
+                                    granted_at=now,
+                                    auto_renewal_end=fallback_plan.plan_default_auto_renewal_end
+                                )
+
+                                # Apply fallback subscription
+                                permissions_added = userstatus.apply_subscription(
+                                    fallback_subscription,
+                                    add_associated_permissions=True,
+                                    remove_previous_subscription_permissions=True,
+                                    granted_by=f"UserstatusOperations.review.fallback:{updater_uid}"
+                                )
+
+                                result['fallback_applied'] = True
+                                result['subscription_status'] = str(userstatus.active_subscription.status)
+                                result['final_subscription'] = fallback_subscription
+                                result['permissions_added'] = permissions_added
+                                result['actions_taken'].append('applied_fallback_plan')
+
+                            else:
+                                self.logger.warning("Fallback plan %s not found for user %s", subscription.fallback_plan_id, user_uid)
+                                result['actions_taken'].append('fallback_plan_not_found')
+                        else:
+                            self.logger.warning("Cannot apply fallback - subscription_ops not available")
+                            result['actions_taken'].append('fallback_unavailable_no_subscription_ops')
+
+                    except (ValueError, UserStatusError) as fallback_error:
+                        self.logger.error("Fallback application failed for user %s: %s", user_uid, fallback_error)
+                        result['error'] = f"Fallback failed: {str(fallback_error)}"
+                        result['actions_taken'].append('fallback_failed')
+                        # Continue to revocation logic
+
+            # If no renewal or fallback happened, revoke the subscription
+            if not result['subscription_renewed'] and not result['fallback_applied']:
+                permissions_cleaned = userstatus.revoke_subscription(remove_associated_permissions=True)
+                result['subscription_revoked'] = True
+                result['subscription_status'] = None
+                result['permissions_cleaned'] = permissions_cleaned
+                result['actions_taken'].append('subscription_revoked')
+
+            # Clean up all expired permissions (not just those associated with the subscription)
+            if clean_expired_permissions:
+                additional_expired = userstatus.cleanup_expired_permissions()
+                if additional_expired > 0:
+                    result['permissions_cleaned'] += additional_expired
+                    result['actions_taken'].append('cleaned_additional_expired_permissions')
+
+            # Save all changes to database
+            updated_userstatus = await self.update_userstatus(
+                user_uid=user_uid,
+                status_data=userstatus.model_dump(exclude_none=False),  # Include None values for proper updates
+                updater_uid=f"review:{updater_uid}"
+            )
+
+            # Add the updated UserStatus to the result
+            result['updated_userstatus'] = updated_userstatus
+
+            self.logger.info(
+                "Completed comprehensive review for user %s. Status: %s, Actions: %s",
+                user_uid, result['subscription_status'], result['actions_taken']
+            )
+
+        except Exception as e:
+            self.logger.error("Comprehensive review failed for user %s: %s", user_uid, e, exc_info=True)
+            result['error'] = str(e)
+            result['actions_taken'].append('review_failed')
+            # Re-raise for proper error handling
+            raise
+
+        return result

{ipulse_shared_core_ftredge-22.1.1.dist-info → ipulse_shared_core_ftredge-23.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 22.1.1
+Version: 23.1.1
 Summary: Shared Core models and Logger util for the Pulse platform project. Using AI for financial advisory and investment management.
 Home-page: https://github.com/TheFutureEdge/ipulse_shared_core
 Author: Russlan Ramdowar

{ipulse_shared_core_ftredge-22.1.1.dist-info → ipulse_shared_core_ftredge-23.1.1.dist-info}/RECORD

@@ -2,50 +2,49 @@ ipulse_shared_core_ftredge/__init__.py,sha256=-KbdF_YW8pgf7pVv9qh_cA1xrNm_B9zigH
 ipulse_shared_core_ftredge/cache/__init__.py,sha256=i2fPojmZiBwAoY5ovnnnME9USl4bi8MRPYkAgEfACfI,136
 ipulse_shared_core_ftredge/cache/shared_cache.py,sha256=BDJtkTsdfmVjKaUkbBXOhJ2Oib7Li0UCsPjWX7FLIPU,12940
 ipulse_shared_core_ftredge/dependencies/__init__.py,sha256=HGsR8HUguKTfjz_BorCILS4izX8CAjG-apE0kIPE0Yo,68
-ipulse_shared_core_ftredge/dependencies/auth_firebase_token_validation.py,sha256=EFWyhoVOI0tGYOWqN5St4JNIy4cMwpxeBhKdjOwEfbg,1888
+ipulse_shared_core_ftredge/dependencies/auth_firebase_token_validation.py,sha256=iwNqOEFHEF0qK7vfRPRXpAexTwF5UOLsfdir1wEo9_E,3646
 ipulse_shared_core_ftredge/dependencies/auth_protected_router.py,sha256=em5D5tE7OkgZmuCtYCKuUAnIZCgRJhCF8Ye5QmtGWlk,1807
-ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=TnJ2ubGUZRxRa6v-OLC2uCLzaoCuX1GkXSaFJMaYg0s,15793
+ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=t2hz1wAVxCT0lCDVf6gmcYeLuUCR7mIXYsThKg0cIlM,14992
 ipulse_shared_core_ftredge/dependencies/firestore_client.py,sha256=VbTb121nsc9EZPd1RDEsHBLW5pIiVw6Wdo2JFL4afMg,714
 ipulse_shared_core_ftredge/exceptions/__init__.py,sha256=Cb_RsIie4DbT_NLwFVwjw4riDKsNNRQEuAvHvYa-Zco,1038
-ipulse_shared_core_ftredge/exceptions/base_exceptions.py,sha256=RuihEpgXdUIR2XEXaP6aJnepePbvZ2RZYQwcKfatGPw,4981
+ipulse_shared_core_ftredge/exceptions/base_exceptions.py,sha256=117YsiCbYLLBu_D0IffYFVSX2yh-pisALMtoSMwj6xI,5338
 ipulse_shared_core_ftredge/exceptions/user_exceptions.py,sha256=I-nm21MKrUYEoybpRODeYNzc184HfgHvRZQm_xux4VY,6824
 ipulse_shared_core_ftredge/models/__init__.py,sha256=oaBL_BZWd7hIDu2K7yxtVKxtkOD9UF9r9_V2ZIPQ8Yk,350
 ipulse_shared_core_ftredge/models/base_api_response.py,sha256=OwuWI2PsMSLDkFt643u35ZhW5AHFEMMAGnGprmUO0fA,2380
 ipulse_shared_core_ftredge/models/base_data_model.py,sha256=GZ7KTT5FanHTgvmaHHTxawzAJtuixkbyb-SuL-mjWys,2193
 ipulse_shared_core_ftredge/models/catalog/__init__.py,sha256=9oKJ74_mTtmj-0iDnRBiPI8m8QJ2J9wvx4ZWaZw3zRk,208
-ipulse_shared_core_ftredge/models/catalog/subscriptionplan.py,sha256=5q1yUwy_755UNt7FZ4Ez-1njF0APSyzmiLbhGP1f2g0,9069
-ipulse_shared_core_ftredge/models/catalog/usertype.py,sha256=W42bis9l6_FL5Q3HY8pqxs1b0gkcIGgGYpLTOU6fYxE,6319
+ipulse_shared_core_ftredge/models/catalog/subscriptionplan.py,sha256=WxKWzTmHJlvFQj6Kq69iWMoFkx_veiPhonFo8dUGzZw,9148
+ipulse_shared_core_ftredge/models/catalog/usertype.py,sha256=E_qQCq7ytiFca6umaX_-_a6TuDh83YwSKtFKdeU4ErM,6584
 ipulse_shared_core_ftredge/models/user/__init__.py,sha256=TheOLldY6v-OK9i-A5mQNIxjHhBFpuOJ43mi-swcN_o,196
 ipulse_shared_core_ftredge/models/user/user_permissions.py,sha256=CUWDBPLPmKN3o43BTZAt0zJvm_ekjJA46iV6rVNp-oc,2411
-ipulse_shared_core_ftredge/models/user/user_subscription.py,sha256=f0EFPtIQU_KKB3LO1MKZYraaxSdJp-FqeZDPKs2VP6E,8587
+ipulse_shared_core_ftredge/models/user/user_subscription.py,sha256=83ncQUHUYF6S19KdZM7-nLEVjD4VPIO88ZRVkXeNnE8,13514
 ipulse_shared_core_ftredge/models/user/userauth.py,sha256=PbS-XSLxDl1feskI0iCziGvmMiLuF8o_ZTspAx1B0j0,3679
 ipulse_shared_core_ftredge/models/user/userprofile.py,sha256=7VbE4qiKpDxZsNTk-IJKA32QxW0JOo8KWPkj8h9J2-Y,6945
-ipulse_shared_core_ftredge/models/user/userstatus.py,sha256=NpSQWlbCnFRQ_Gnx7WLkyt3dKgRDf4-MRrJU5VYF7DA,16748
+ipulse_shared_core_ftredge/models/user/userstatus.py,sha256=9BGaKiKL3JeSNQ8ZRRc0taLgSu0uxtBu5NRVsCbVXW4,18776
 ipulse_shared_core_ftredge/monitoring/__init__.py,sha256=gUoJjT0wj-cQYnMWheWbh1mmRHmaeojmnBZTj7KPNus,61
 ipulse_shared_core_ftredge/monitoring/tracemon.py,sha256=Trku0qrwWvEcvKsBWiYokd_G3fcH-5uP2wRVgcgIz_k,11596
 ipulse_shared_core_ftredge/services/__init__.py,sha256=9AkMLCHNswhuNbQuJZaEVz4zt4F84PxfJLyU_bYk4Js,565
 ipulse_shared_core_ftredge/services/charging_processors.py,sha256=9Re24dyXdjKYbqwx6uNLu3JBzIaw87TAV7Oe__M1QnA,16308
 ipulse_shared_core_ftredge/services/user_charging_service.py,sha256=C3wMfgBXOz4RM1RLc7up2_pIPAnZv8ZYu-lLrkofTmc,14625
 ipulse_shared_core_ftredge/services/base/__init__.py,sha256=zhyrHQMM0cLJr4spk2b6VsgJXuWBy7hUBzhrq_Seg9k,389
-ipulse_shared_core_ftredge/services/base/base_firestore_service.py,sha256=xXmPfDEgBa4trWMJz1UBJRDLPxi8TtG2jDFbo_B28pw,19313
+ipulse_shared_core_ftredge/services/base/base_firestore_service.py,sha256=leZFwxb1ruheypqudpKnuNtRQXtO4KNeoJk6ZACozHc,19512
 ipulse_shared_core_ftredge/services/base/cache_aware_firestore_service.py,sha256=ya5Asff9BQodYnJVAw6M_Pm8WtVRPpEK7izFlZ2MyjA,10016
 ipulse_shared_core_ftredge/services/catalog/__init__.py,sha256=ctc2nDGwsW_Ji4lk9pys3oyNwR_V-gHSbSHawym5fKQ,385
-ipulse_shared_core_ftredge/services/catalog/catalog_subscriptionplan_service.py,sha256=mbwCC1RnIZEav5i5sRGT15nxQJF0qMVA2LT8BAjmJuY,9264
-ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py,sha256=pZdsRt9V96NcYTRremTf76fDL126lAiraxGs936i0aU,9959
+ipulse_shared_core_ftredge/services/catalog/catalog_subscriptionplan_service.py,sha256=X5xAi9sOk_F1ky0ECwPVlwIPPsN2PrZC6bN_pASGDjQ,9702
+ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py,sha256=C_VWxZ5iPcybjsSXdmZHyqS--rI3KY8pp7JDIy_L7S8,12833
 ipulse_shared_core_ftredge/services/user/__init__.py,sha256=jmkD5XzAmaD8QV2UsgB5xynGcfsXliWtRtN2pt6kzbA,884
-ipulse_shared_core_ftredge/services/user/firebase_auth_admin_helpers.py,sha256=7N-MWpCwzWCjIuIFXGv1sIjJJcU9M92nWOfRyMEuHbE,5430
-ipulse_shared_core_ftredge/services/user/user_core_service.py,sha256=9nhFgFVPp188JMiZYINLwyHGtUYqtbHZhIR6cQMhj00,23648
-ipulse_shared_core_ftredge/services/user/user_multistep_operations.py,sha256=hQ1-BygC2Cxin6AUsEVgEWfZg035v5yn__sAoPzy0Us,35543
+ipulse_shared_core_ftredge/services/user/user_core_service.py,sha256=o0trN4yTbyh-BJbXnin9XmS8hW5jOQW6RdegdQ2sRNo,28269
+ipulse_shared_core_ftredge/services/user/user_multistep_operations.py,sha256=0MfMaKLGpVsgfD-Vgaa4s2dKk9nNoH6snWx_skkPy_o,39705
 ipulse_shared_core_ftredge/services/user/user_permissions_operations.py,sha256=FByszIWo-qooLVXFTw0tGLWksIJEqHUPc_ZGwue0_pM,15753
-ipulse_shared_core_ftredge/services/user/user_subscription_operations.py,sha256=h5jz4jvnwocDIwHa5VUX3_u4Qzrkt5A1s06aL5Bafm0,21266
+ipulse_shared_core_ftredge/services/user/user_subscription_operations.py,sha256=z98EO67wHlnDj1V7JK14yq6yaIoTVcX5X5v4-taZFHw,21651
 ipulse_shared_core_ftredge/services/user/userauth_operations.py,sha256=9l2uBAcAxbUnilK8MZ7IlHzaGiaPuqx7nIC51mAyR9w,36120
 ipulse_shared_core_ftredge/services/user/userprofile_operations.py,sha256=_qyIEAQYCTV-subgP-5naMs_26apCpauomE6qmCCVWs,7333
-ipulse_shared_core_ftredge/services/user/userstatus_operations.py,sha256=Gz2P4toJNs3ZMpGBvmN0HfiFqonRv6G3jTKkDz7mjuA,8927
+ipulse_shared_core_ftredge/services/user/userstatus_operations.py,sha256=sW4Q-aMG1mjKvqVKK5AA93-G57FPBCkxO7rPfCkhBd8,22726
 ipulse_shared_core_ftredge/utils/__init__.py,sha256=JnxUb8I2MRjJC7rBPXSrpwBIQDEOku5O9JsiTi3oun8,56
 ipulse_shared_core_ftredge/utils/custom_json_encoder.py,sha256=DblQLD0KOSNDyQ58wQRogBrShIXzPIZUw_oGOBATnJY,1366
 ipulse_shared_core_ftredge/utils/json_encoder.py,sha256=QkcaFneVv3-q-s__Dz4OiUWYnM6jgHDJrDMdPv09RCA,2093
-ipulse_shared_core_ftredge-22.1.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-22.1.1.dist-info/METADATA,sha256=Q-CLpF1xpkRoIMZ5ab17rGskMnkPdA6M04e0qj8yqHI,782
-ipulse_shared_core_ftredge-22.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ipulse_shared_core_ftredge-22.1.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-22.1.1.dist-info/RECORD,,
+ipulse_shared_core_ftredge-23.1.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
+ipulse_shared_core_ftredge-23.1.1.dist-info/METADATA,sha256=keIkjScj_B7Wix1MqoCIY8aR5JRAVkbdJwFd3HWnslg,782
+ipulse_shared_core_ftredge-23.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ipulse_shared_core_ftredge-23.1.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
+ipulse_shared_core_ftredge-23.1.1.dist-info/RECORD,,