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

ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py

@@ -0,0 +1,307 @@
+"""
+usertype Catalog Service
+
+This service manages usertype templates stored in Firestore.
+These templates are used to configure default settings for user profiles and statuses.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+from google.cloud.firestore import Client
+from ipulse_shared_base_ftredge import IAMUserType
+from ipulse_shared_base_ftredge.enums.enums_status import ObjectOverallStatus
+from ipulse_shared_core_ftredge.models.catalog.usertype import UserType
+from ipulse_shared_core_ftredge.services.base.base_firestore_service import BaseFirestoreService
+
+class CatalogUserTypeService(BaseFirestoreService[UserType]):
+    """
+    Service for managing usertype catalog configurations.
+
+    This service provides CRUD operations for usertype templates that define
+    the default settings and permissions for different usertypes.
+    """
+
+    def __init__(
+        self,
+        firestore_client: Client,
+        logger: Optional[logging.Logger] = None
+    ):
+        """
+        Initialize the usertype Catalog Service.
+
+        Args:
+            firestore_client: Firestore client instance
+            logger: Logger instance (optional)
+        """
+        super().__init__(
+            db=firestore_client,
+            collection_name="papp_core_catalog_usertypes",
+            resource_type="usertype",
+            model_class=UserType,
+            logger=logger or logging.getLogger(__name__)
+        )
+        self.archive_collection_name = "~archive_papp_core_catalog_usertypes"
+
+    async def create_usertype(
+        self,
+        usertype_id: str,
+        user_type: UserType,
+        creator_uid: str
+    ) -> UserType:
+        """
+        Create a new usertype.
+
+        Args:
+            usertype_id: Unique identifier for the usertype
+            user_type: Usertype data
+            creator_uid: UID of the user creating the usertype
+
+        Returns:
+            Created usertype
+
+        Raises:
+            ServiceError: If creation fails
+            ValidationError: If usertype data is invalid
+        """
+        self.logger.info(f"Creating usertype: {usertype_id}")
+
+        # Create the document
+        created_doc = await self.create_document(
+            doc_id=usertype_id,
+            data=user_type,
+            creator_uid=creator_uid
+        )
+
+        # Convert back to model
+        result = UserType.model_validate(created_doc)
+        self.logger.info(f"Successfully created usertype: {usertype_id}")
+        return result
+
+    async def get_usertype(self, usertype_id: str) -> Optional[UserType]:
+        """
+        Retrieve a usertype by ID.
+
+        Args:
+            usertype_id: Unique identifier for the usertype
+
+        Returns:
+            usertype if found, None otherwise
+
+        Raises:
+            ServiceError: If retrieval fails
+        """
+        self.logger.debug(f"Retrieving usertype: {usertype_id}")
+        doc_data = await self.get_document(usertype_id)
+        if doc_data is None:
+            return None
+        return UserType.model_validate(doc_data) if isinstance(doc_data, dict) else doc_data
+
+    async def update_usertype(
+        self,
+        usertype_id: str,
+        updates: Dict[str, Any],
+        updater_uid: str
+    ) -> UserType:
+        """
+        Update a usertype.
+
+        Args:
+            usertype_id: Unique identifier for the usertype
+            updates: Fields to update
+            updater_uid: UID of the user updating the usertype
+
+        Returns:
+            Updated usertype
+
+        Raises:
+            ServiceError: If update fails
+            ResourceNotFoundError: If usertype not found
+            ValidationError: If update data is invalid
+        """
+        self.logger.info(f"Updating usertype: {usertype_id}")
+
+        updated_doc = await self.update_document(
+            doc_id=usertype_id,
+            update_data=updates,
+            updater_uid=updater_uid
+        )
+
+        result = UserType.model_validate(updated_doc)
+        self.logger.info(f"Successfully updated usertype: {usertype_id}")
+        return result
+
+    async def delete_usertype(
+        self,
+        usertype_id: str,
+        archive: bool = True
+    ) -> bool:
+        """
+        Delete a usertype.
+
+        Args:
+            usertype_id: Unique identifier for the usertype
+            archive: Whether to archive the usertype before deletion
+
+        Returns:
+            True if deletion was successful
+
+        Raises:
+            ServiceError: If deletion fails
+            ResourceNotFoundError: If usertype not found
+        """
+        self.logger.info(f"Deleting usertype: {usertype_id}")
+
+        if archive:
+            # Get the usertype data before deletion for archiving
+            template = await self.get_usertype(usertype_id)
+            if template:
+                await self.archive_document(
+                    document_data=template.model_dump(),
+                    doc_id=usertype_id,
+                    archive_collection=self.archive_collection_name,
+                    archived_by="system"
+                )
+
+        result = await self.delete_document(usertype_id)
+        self.logger.info(f"Successfully deleted usertype: {usertype_id}")
+        return result
+
+    async def list_usertypes(
+        self,
+        primary_usertype: Optional[IAMUserType] = None,
+        pulse_status: Optional[ObjectOverallStatus] = None,
+        latest_version_only: bool = False,
+        limit: Optional[int] = None
+    ) -> List[UserType]:
+        """
+        List usertypes with optional filtering.
+
+        Args:
+            primary_usertype: Filter by specific primary usertype
+            pulse_status: Filter by specific pulse status
+            latest_version_only: Only return the latest version per usertype
+            limit: Maximum number of usertypes to return
+
+        Returns:
+            List of usertypes
+
+        Raises:
+            ServiceError: If listing fails
+        """
+        self.logger.debug(f"Listing usertypes - primary_usertype: {primary_usertype}, pulse_status: {pulse_status}, latest_version_only: {latest_version_only}")
+
+        # Build query filters
+        filters = []
+        if primary_usertype:
+            filters.append(("primary_usertype", "==", primary_usertype.value))
+        if pulse_status:
+            filters.append(("pulse_status", "==", pulse_status.value))
+
+        # If latest_version_only is requested, order by version descending
+        order_by = None
+        if latest_version_only:
+            order_by = "version"
+            # We'll need to group by primary_usertype and take the first from each group
+            # This is more complex, so let's handle it differently
+
+        docs = await self.list_documents(
+            filters=filters,
+            order_by=order_by,
+            limit=limit
+        )
+
+        # Convert to UserType models
+        usertypes = [UserType.model_validate(doc) if isinstance(doc, dict) else doc for doc in docs]
+
+        # If latest_version_only is requested, group by primary_usertype and get highest version
+        if latest_version_only:
+            # Group by primary_usertype
+            usertype_groups = {}
+            for usertype in usertypes:
+                key = usertype.primary_usertype.value
+                if key not in usertype_groups:
+                    usertype_groups[key] = []
+                usertype_groups[key].append(usertype)
+
+            # Get the latest version for each group
+            latest_usertypes = []
+            for group in usertype_groups.values():
+                if group:
+                    # Sort by version descending and take the first
+                    latest = max(group, key=lambda x: x.version)
+                    latest_usertypes.append(latest)
+
+            return latest_usertypes
+
+        return usertypes
+
+    def _get_collection(self):
+        """Get the Firestore collection reference."""
+        return self.db.collection(self.collection_name)
+
+    async def usertype_exists(self, usertype_id: str) -> bool:
+        """
+        Check if a usertype exists.
+
+        Args:
+            usertype_id: Unique identifier for the usertype
+
+        Returns:
+            True if usertype exists, False otherwise
+
+        Raises:
+            ServiceError: If check fails
+        """
+        return await self.document_exists(usertype_id)
+
+    async def validate_usertype_data(self, usertype_data: Dict[str, Any]) -> tuple[bool, List[str]]:
+        """
+        Validate usertype data.
+
+        Args:
+            usertype_data: Usertype data to validate
+
+        Returns:
+            Tuple of (is_valid, list_of_errors)
+        """
+        try:
+            UserType.model_validate(usertype_data)
+            return True, []
+        except Exception as e:
+            return False, [str(e)]
+
+
+    async def get_default_credits_for_usertype(self, primary_usertype: IAMUserType) -> Dict[str, int]:
+        """
+        Get default credit settings for a specific usertype.
+
+        Args:
+            primary_usertype: The primary usertype
+
+        Returns:
+            Dictionary with default credit values
+
+        Raises:
+            ServiceError: If retrieval fails
+        """
+        self.logger.debug(f"Getting default credits for usertype: {primary_usertype}")
+
+        usertypes = await self.list_usertypes(
+            primary_usertype=primary_usertype,
+            pulse_status=ObjectOverallStatus.ACTIVE,
+            latest_version_only=True,
+            limit=1
+        )
+        usertype = usertypes[0] if usertypes else None
+        if not usertype:
+            self.logger.warning(f"No active usertype found for: {primary_usertype}")
+            return {
+                "subscription_based_insight_credits": 0,
+                "extra_insight_credits": 0,
+                "voting_credits": 0
+            }
+
+        return {
+            "extra_insight_credits": usertype.default_extra_insight_credits,
+            "voting_credits": usertype.default_voting_credits
+        }

ipulse_shared_core_ftredge/services/charging_processors.py

@@ -1,7 +1,7 @@
 """Reusable credit checking and charging utilities for services."""
 import os
 from typing import Dict, Any, List, Optional, Callable, Awaitable, TypeVar
-from ipulse_shared_core_ftredge.services.charging_service import ChargingService, ValidationError
+from ipulse_shared_core_ftredge.services.user_charging_service import UserChargingService, ValidationError
 import logging
 
 T = TypeVar('T')
@@ -9,8 +9,8 @@ T = TypeVar('T')
 class ChargingProcessor:
     """Handles credit checking and charging for both single item and batch access."""
 
-    def __init__(self, charging_service: ChargingService, logger: logging.Logger):
-        self.charging_service = charging_service
+    def __init__(self, user_charging_service: UserChargingService, logger: logging.Logger):
+        self.user_charging_service = user_charging_service
         self.logger = logger
 
     async def process_single_item_charging(
@@ -54,9 +54,9 @@ class ChargingProcessor:
                 # For free items, provide current credits if available
                 if pre_fetched_credits:
                     updated_user_credits = pre_fetched_credits
-                elif self.charging_service: # Attempt to get current credits if not pre-fetched
+                elif self.user_charging_service: # Attempt to get current credits if not pre-fetched
                     try:
-                        _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                        _, current_user_credits_from_verify = await self.user_charging_service.verify_credits(user_uid, 0, None)
                         updated_user_credits = current_user_credits_from_verify
                     except Exception: # pylint: disable=broad-except
                         self.logger.warning(f"Could not fetch current credits for user {user_uid} for free item.")
@@ -75,9 +75,9 @@ class ChargingProcessor:
                 # Similar to free items, provide current credits if available
                 if pre_fetched_credits:
                     updated_user_credits = pre_fetched_credits
-                elif self.charging_service:
+                elif self.user_charging_service:
                     try:
-                        _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                        _, current_user_credits_from_verify = await self.user_charging_service.verify_credits(user_uid, 0, None)
                         updated_user_credits = current_user_credits_from_verify
                     except Exception: # pylint: disable=broad-except
                         self.logger.warning(f"Could not fetch current credits for user {user_uid} during debug bypass.")
@@ -90,7 +90,7 @@ class ChargingProcessor:
                 }
 
             # Verify credit service is available
-            if not self.charging_service:
+            if not self.user_charging_service:
                 self.logger.error("ChargingService not initialized.")
                 return {
                     'access_granted': False,
@@ -101,7 +101,7 @@ class ChargingProcessor:
                 }
 
             # Verify user has enough credits
-            has_credits, current_user_credits_from_verify = await self.charging_service.verify_credits(
+            has_credits, current_user_credits_from_verify = await self.user_charging_service.verify_credits(
                 user_uid,
                 credit_cost,
                 pre_fetched_user_credits=pre_fetched_credits
@@ -121,7 +121,7 @@ class ChargingProcessor:
                 }
 
             # Charge the user - this now returns (bool, Optional[Dict])
-            charged, calculated_updated_credits = await self.charging_service.charge_credits_transaction(
+            charged, calculated_updated_credits = await self.user_charging_service.charge_credits_transaction(
                 user_uid,
                 credit_cost,
                 operation_description
@@ -143,9 +143,9 @@ class ChargingProcessor:
         except ValidationError as ve:
             self.logger.error(f"Validation error for item {item_id}, user {user_uid}: {str(ve)}")
             # Try to get current credits to return
-            if self.charging_service:
+            if self.user_charging_service:
                 try:
-                    _, updated_user_credits = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    _, updated_user_credits = await self.user_charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
                 except Exception: # pylint: disable=broad-except
                     pass # Keep updated_user_credits as None
             ve.additional_info = ve.additional_info or {}
@@ -155,9 +155,9 @@ class ChargingProcessor:
             self.logger.error(f"Unexpected error during credit processing for item {item_id}, user {user_uid}: {str(e)}", exc_info=True)
             # Try to get current credits to return
             current_user_credits_on_error = None
-            if self.charging_service:
+            if self.user_charging_service:
                 try:
-                    _, current_user_credits_on_error = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    _, current_user_credits_on_error = await self.user_charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
                 except Exception: # pylint: disable=broad-except
                     pass
             return {
@@ -228,9 +228,9 @@ class ChargingProcessor:
         if not paid_items:
             if pre_fetched_credits:
                 updated_user_credits = pre_fetched_credits
-            elif self.charging_service:
+            elif self.user_charging_service:
                 try:
-                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                    _, current_user_credits_from_verify = await self.user_charging_service.verify_credits(user_uid, 0, None)
                     updated_user_credits = current_user_credits_from_verify
 
                 except Exception: # pylint: disable=broad-except
@@ -250,9 +250,9 @@ class ChargingProcessor:
             self.logger.info(f"Bypassing credit check for {len(paid_items)} paid items due to debug mode")
             if pre_fetched_credits:
                 updated_user_credits = pre_fetched_credits
-            elif self.charging_service:
+            elif self.user_charging_service:
                 try:
-                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                    _, current_user_credits_from_verify = await self.user_charging_service.verify_credits(user_uid, 0, None)
                     updated_user_credits = current_user_credits_from_verify
                 except Exception: # pylint: disable=broad-except
                     self.logger.warning(f"Could not fetch current credits for user {user_uid} during debug bypass for batch.")
@@ -267,7 +267,7 @@ class ChargingProcessor:
             }
 
         # Verify credit service is available
-        if not self.charging_service:
+        if not self.user_charging_service:
             self.logger.error("ChargingService not initialized for batch processing.")
             return {
                 'accessible_items': free_items,
@@ -280,7 +280,7 @@ class ChargingProcessor:
 
         try:
             # Verify user has enough credits for total cost
-            has_credits, current_user_credits_from_verify = await self.charging_service.verify_credits(
+            has_credits, current_user_credits_from_verify = await self.user_charging_service.verify_credits(
                 user_uid,
                 total_cost,
                 pre_fetched_user_credits=pre_fetched_credits
@@ -300,7 +300,7 @@ class ChargingProcessor:
                 }
 
             # Charge the user for all paid items
-            charged, calculated_updated_credits = await self.charging_service.charge_credits_transaction(
+            charged, calculated_updated_credits = await self.user_charging_service.charge_credits_transaction(
                 user_uid,
                 total_cost,
                 f"{operation_description} ({len(paid_items)} items, total cost: {total_cost})"
@@ -322,9 +322,9 @@ class ChargingProcessor:
 
         except ValidationError as ve:
             self.logger.error(f"Validation error during batch credit check for user {user_uid}: {str(ve)}")
-            if self.charging_service:
+            if self.user_charging_service:
                 try:
-                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    _, current_user_credits_from_verify = await self.user_charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
                     updated_user_credits = current_user_credits_from_verify
                 except Exception: # pylint: disable=broad-except
                     pass
@@ -334,9 +334,9 @@ class ChargingProcessor:
         except Exception as e:
             self.logger.error(f"Unexpected error during batch credit check for user {user_uid}: {str(e)}", exc_info=True)
             current_credits_on_error = None
-            if self.charging_service:
+            if self.user_charging_service:
                 try:
-                    _, current_credits_on_error = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    _, current_credits_on_error = await self.user_charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
                     updated_user_credits = current_credits_on_error
                 except Exception: # pylint: disable=broad-except
                     pass

ipulse_shared_core_ftredge/services/user/__init__.py

@@ -10,28 +10,8 @@ This module contains all user-related services organized into specialized operat
 - User-specific exceptions: Specialized exception classes for user operations
 """
 
-from .user_account_operations import UserAccountOperations
-from .subscription_management_operations import (
-    SubscriptionManagementOperations,
-    SubscriptionPlanDocument
-)
-from .iam_management_operations import IAMManagementOperations
-from .user_auth_operations import UserAuthOperations
-from .user_holistic_operations import UserHolisticOperations
-from .user_core_service import UserCoreService, UserTypeDefaultsDocument
-
-__all__ = [
-    # Operation classes
-    'UserAccountOperations',
-    'SubscriptionManagementOperations',
-    'IAMManagementOperations',
-    'UserAuthOperations',
-    'UserHolisticOperations',
-
-    # Main orchestrating service
-    'UserCoreService',
-
-    # Supporting models
-    'SubscriptionPlanDocument',
-    'UserTypeDefaultsDocument'
-]
+from .user_subscription_operations import  UsersubscriptionOperations
+from .user_permissions_operations import UserpermissionsOperations
+from .userauth_operations import UserauthOperations
+from .user_multistep_operations import UsermultistepOperations
+from .user_core_service import UserCoreService

ipulse_shared_core_ftredge/services/user/firebase_auth_admin_helpers.py

@@ -0,0 +1,160 @@
+"""
+Firebase Admin Helper Functions
+
+This module provides utility functions for managing Firebase Auth users and permissions.
+These functions are designed for admin operations and testing purposes.
+"""
+
+import os
+import time
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+import firebase_admin
+from firebase_admin import auth
+from ipulse_shared_base_ftredge import log_info, log_warning, log_error, log_debug, LogLevel
+
+
+def get_user_auth_token(
+    email: str, 
+    password: str, 
+    api_key: str, 
+    logger: Optional[logging.Logger] = None, 
+    print_out: bool = False,
+    debug: bool = False
+) -> Optional[str]:
+    """
+    Get a user authentication token using the Firebase REST API.
+    
+    Args:
+        email: User email
+        password: User password
+        api_key: Firebase API key
+        logger: Optional logger instance
+        print_out: Whether to print output
+        debug: Whether to print detailed debug info
+        
+    Returns:
+        ID token or None if failed
+    """
+    import requests  # Import here to keep it optional
+    
+    url = f"https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key={api_key}"
+    payload = {
+        "email": email,
+        "password": password,
+        "returnSecureToken": True
+    }
+    
+    try:
+        if debug:
+            log_info(f"Sending authentication request to: {url}", logger=logger, print_out=print_out)
+            log_info(f"Request payload: {payload}", logger=logger, print_out=print_out)
+            
+        response = requests.post(url, json=payload)
+        
+        # Add detailed error logging
+        if not response.ok:
+            error_details = response.text
+            try:
+                error_json = response.json()
+                if "error" in error_json:
+                    error_details = f"{error_json['error'].get('message', 'Unknown error')}"
+            except Exception:
+                pass
+                
+            log_error(f"Auth error ({response.status_code}): {error_details}", logger=logger, print_out=print_out)
+            
+            # Check for specific error conditions
+            if "EMAIL_NOT_FOUND" in error_details or "INVALID_PASSWORD" in error_details:
+                log_error(f"Authentication failed - invalid credentials for {email}", logger=logger, print_out=print_out)
+            elif "USER_DISABLED" in error_details:
+                log_error(f"User account is disabled: {email}", logger=logger, print_out=print_out)
+            elif "INVALID_EMAIL" in error_details:
+                log_error(f"Invalid email format: {email}", logger=logger, print_out=print_out)
+            
+            return None
+        
+        token = response.json().get("idToken")
+        log_info(f"Successfully obtained auth token for {email}", logger=logger, print_out=print_out)
+        return token
+    except Exception as e:
+        log_error(f"Error getting auth token: {e}", logger=logger, print_out=print_out)
+        return None
+
+def list_users(max_results: int = 1000, logger: Optional[logging.Logger] = None, print_out: bool = False) -> List[Dict[str, Any]]:
+    """
+    List users from Firebase Auth.
+    
+    Args:
+        max_results: Maximum number of users to return
+        logger: Optional logger instance
+        print_out: Whether to print output
+        
+    Returns:
+        List of user dicts
+    """
+    try:
+        users = []
+        page = auth.list_users()
+        for user in page.users:
+            users.append(user._data)
+            if len(users) >= max_results:
+                break
+        
+        log_info(f"Listed {len(users)} users from Firebase Auth", logger=logger, print_out=print_out)
+        return users
+    except Exception as e:
+        log_error(f"Error listing users: {e}", logger=logger, print_out=print_out)
+        return []
+
+def create_custom_token(
+    user_uid: str, 
+    additional_claims: Dict[str, Any] = None, 
+    logger: Optional[logging.Logger] = None, 
+    print_out: bool = False
+) -> str:
+    """
+    Create a custom token for a user.
+    
+    Args:
+        user_uid: User's UID
+        additional_claims: Additional claims to include in the token
+        logger: Optional logger instance
+        print_out: Whether to print output
+        
+    Returns:
+        Custom token
+    """
+    try:
+        token = auth.create_custom_token(user_uid, additional_claims)
+        log_debug(f"Created custom token for user {user_uid}", logger=logger, print_out=print_out)
+        return token
+    except Exception as e:
+        log_error(f"Error creating custom token: {e}", logger=logger, print_out=print_out)
+        raise
+
+def verify_id_token(
+    token: str, 
+    check_revoked: bool = False, 
+    logger: Optional[logging.Logger] = None, 
+    print_out: bool = False
+) -> Dict[str, Any]:
+    """
+    Verify an ID token.
+    
+    Args:
+        token: ID token to verify
+        check_revoked: Whether to check if the token has been revoked
+        logger: Optional logger instance
+        print_out: Whether to print output
+        
+    Returns:
+        Token claims
+    """
+    try:
+        claims = auth.verify_id_token(token, check_revoked=check_revoked)
+        log_debug(f"Verified ID token for user {claims.get('uid')}", logger=logger, print_out=print_out)
+        return claims
+    except Exception as e:
+        log_error(f"Error verifying ID token: {e}", logger=logger, print_out=print_out)
+        raise