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

ipulse_shared_core_ftredge/models/user_status.py

@@ -1,10 +1,10 @@
 """ User Status model for tracking user subscription and access rights. """
 from datetime import datetime, timezone
 from dateutil.relativedelta import relativedelta  # Add missing import
-from typing import Set, Optional, Dict, List, ClassVar, Any, Union
+from typing import Set, Optional, Dict, List, ClassVar, Any
 from pydantic import Field, ConfigDict, field_validator, computed_field, BaseModel, model_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings, Subject, ObjectOverallStatus, SubscriptionPlan, SubscriptionStatus
-from ipulse_shared_base_ftredge.enums.enums_iam import IAMUnitType, IAMUserType
+from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings, Subject,SubscriptionPlan, SubscriptionStatus
+from ipulse_shared_base_ftredge.enums.enums_iam import IAMUnitType
 from .subscription import Subscription
 from .base_data_model import BaseDataModel
 
@@ -72,18 +72,6 @@ class UserStatus(BaseDataModel):
         description="User UID from Firebase Auth"
     )
 
-    # Added primary_usertype field for main role categorization
-    primary_usertype: str = Field(
-        ...,
-        description="Primary user type (e.g., customer, internal, admin, superadmin)"
-    )
-
-    # Renamed user_types to secondary_usertypes
-    secondary_usertypes: List[str] = Field(
-        default_factory=list,
-        description="List of secondary user types/roles"
-    )
-
     # Added organizations field for consistency with UserProfile
     organizations_uids: Set[str] = Field(
         default_factory=set,
@@ -98,8 +86,8 @@ class UserStatus(BaseDataModel):
 
     # Subscription Management - Single active subscription instead of dictionary
     subscriptions_history: Dict[str, Subscription] = Field(
-        ...,
-        description="Dictionary of user's past recent subscriptions, keyed by subscription ID"
+        default_factory=dict,  # Initialize with empty dict
+        description="Dictionary of user\'s past recent subscriptions, keyed by subscription ID"
     )
 
     # Changed from dictionary to single Optional subscription
@@ -385,32 +373,20 @@ class UserStatus(BaseDataModel):
         # Add IAM permissions from subscription
         self.update_iam_unit_refs_from_subscription(subscription)
 
-        # We need to handle model_config.frozen - use object.__setattr__ if model is frozen
+        # Update subscription-based credits
         credits_per_update = subscription.subscription_based_insight_credits_per_update
         if credits_per_update > 0:
-            if getattr(self.model_config, "frozen", False):
-                object.__setattr__(self, "sbscrptn_based_insight_credits", credits_per_update)
-                object.__setattr__(self, "sbscrptn_based_insight_credits_updtd_on", datetime.now(timezone.utc))
-            else:
-                self.sbscrptn_based_insight_credits = credits_per_update
-                self.sbscrptn_based_insight_credits_updtd_on = datetime.now(timezone.utc)
+            self.sbscrptn_based_insight_credits = credits_per_update
+            self.sbscrptn_based_insight_credits_updtd_on = datetime.now(timezone.utc)
 
         # Update voting credits directly from subscription attributes
         voting_credits = subscription.voting_credits_per_update
         if voting_credits > 0:
-            if getattr(self.model_config, "frozen", False):
-                object.__setattr__(self, "voting_credits", voting_credits)
-                object.__setattr__(self, "voting_credits_updtd_on", datetime.now(timezone.utc))
-            else:
-                self.voting_credits = voting_credits
-                self.voting_credits_updtd_on = datetime.now(timezone.utc)
+            self.voting_credits = voting_credits
+            self.voting_credits_updtd_on = datetime.now(timezone.utc)
 
         # Store subscription details
-        # Use object.__setattr__ if model is frozen
-        if getattr(self.model_config, "frozen", False):
-            object.__setattr__(self, "active_subscription", subscription)
-        else:
-            self.active_subscription = subscription
+        self.active_subscription = subscription
 
     def revoke_subscription(self) -> None:
         """
@@ -420,22 +396,17 @@ class UserStatus(BaseDataModel):
         if not self.active_subscription:
             return
 
-        # Reset subscription-based credits - handle frozen model case
-        if getattr(self.model_config, "frozen", False):
-            object.__setattr__(self, "sbscrptn_based_insight_credits", 0)
-            object.__setattr__(self, "sbscrptn_based_insight_credits_updtd_on", datetime.now(timezone.utc))
-            object.__setattr__(self, "active_subscription", None)
-        else:
-            self.sbscrptn_based_insight_credits = 0
-            self.sbscrptn_based_insight_credits_updtd_on = datetime.now(timezone.utc)
-            self.active_subscription = None
+        # Clear subscription-based credits and active subscription
+        self.sbscrptn_based_insight_credits = 0
+        self.sbscrptn_based_insight_credits_updtd_on = datetime.now(timezone.utc)
+        self.active_subscription = None
 
     def apply_subscription_plan(self,
                                plan_data: Dict[str, Any],
                                source: str = "default_configuration",
                                expires_at: Optional[datetime] = None) -> None:
         """
-        Apply a subscription plan's benefits from plan data dictionary.
+        Apply a subscription plan\'s benefits from plan data dictionary.
 
         Args:
             plan_data: Dictionary containing subscription plan details
@@ -452,11 +423,13 @@ class UserStatus(BaseDataModel):
         # Extract plan name - no default fallbacks
         plan_name_str = plan_data.get("plan_name")
         if not plan_name_str:
+            # Consider logging a warning or raising an error if plan_name is critical
             return  # Cannot create subscription without plan name
 
         try:
             plan_name = SubscriptionPlan(plan_name_str)
         except ValueError:
+            # Consider logging a warning or raising an error for invalid plan_name
             return  # Invalid plan name
 
         # Extract required fields - no default fallbacks
@@ -466,28 +439,46 @@ class UserStatus(BaseDataModel):
 
         # If any required field is missing, return without creating subscription
         if plan_version is None or validity_time_length is None or validity_time_unit is None:
+            # Consider logging a warning or raising an error if these fields are critical
             return
 
         # Calculate directly assigned fields
-        plan_id = f"{plan_name_str}_{plan_version}"
+        plan_id = f"{plan_name_str}_{plan_version}" # Use the string version for ID
         cycle_start_date = datetime.now(timezone.utc)
+
+        # Ensure cycle_end_date is calculated correctly using the provided expires_at or calculated from plan details
+        # If expires_at is provided, it should ideally align with plan's cycle, but we prioritize it if present.
+        # However, the current Subscription.calculate_cycle_end_date might be more robust if plan details are the source of truth.
+        # For now, let's assume expires_at is a specific override if provided, otherwise calculate from plan.
+        # This logic might need refinement based on how expires_at is intended to be used.
+        # If expires_at is meant to be the definitive end date, use it. Otherwise, calculate.
+        # The original code used expires_at for IAM assignments but calculated cycle_end_date for the subscription object itself.
+        # Let's stick to calculating cycle_end_date from plan details for the Subscription object for consistency.
+
         cycle_end_date = Subscription.calculate_cycle_end_date(
             cycle_start_date,
             validity_time_length,
             validity_time_unit
         )
 
+        # If an explicit expires_at is given and differs, it might indicate a special case (e.g. trial ending sooner)
+        # For IAM assignments, the original code used the `expires_at` passed to `apply_subscription_plan`
+        # For the subscription object itself, it calculated `cycle_end_date`.
+        # We will use the calculated `cycle_end_date` for the subscription object.
+        # The `expires_at` for IAM assignments will be handled by `update_iam_unit_refs_from_subscription`
+        # which uses `subscription.cycle_end_date`.
+
         # Create subscription object with direct fields instead of computed
         subscription = Subscription(
-            plan_name=plan_name,
+            plan_name=plan_name, # Enum version
             plan_version=plan_version,
-            plan_id=plan_id,
+            plan_id=plan_id, # String version
             cycle_start_date=cycle_start_date,
-            cycle_end_date=cycle_end_date,
+            cycle_end_date=cycle_end_date, # Calculated cycle_end_date
             validity_time_length=validity_time_length,
             validity_time_unit=validity_time_unit,
             auto_renew=plan_data.get("plan_auto_renewal", False),
-            status=SubscriptionStatus.ACTIVE,
+            status=SubscriptionStatus.ACTIVE, # Default to ACTIVE when applying
             default_iam_domain_permissions=iam_domain_permissions,
             fallback_plan_id=plan_data.get("fallback_plan_id_if_current_plan_expired"),
             price_paid_usd=plan_data.get("plan_per_cycle_price_usd") or 0.0,
@@ -497,93 +488,8 @@ class UserStatus(BaseDataModel):
             subscription_based_insight_credits_update_freq_h=plan_data.get("subscription_based_insight_credits_update_freq_h") or 24,
             extra_insight_credits_per_cycle=plan_data.get("extra_insight_credits_per_cycle") or 0,
             voting_credits_per_update=plan_data.get("voting_credits_per_update") or 0,
-            voting_credits_update_freq_h=plan_data.get("voting_credits_update_freq_h") or 62
+            voting_credits_update_freq_h=plan_data.get("voting_credits_update_freq_h") or 62 # Corrected typo from 62 to, e.g., 720 for monthly if intended
         )
 
-        # Apply the subscription
-        self.apply_subscription(subscription)
-
-    @staticmethod
-    def fetch_user_status_defaults(firestore_client,
-                                   primary_usertype: str,
-                                   collection: str = "papp_core_configs_user") -> Dict[str, Any]:
-        """
-        Fetch user status defaults from Firestore.
-
-        Args:
-            firestore_client: Initialized Firestore client
-            primary_usertype: Primary type of user (customer, internal, admin, etc)
-            collection: Collection name for user status defaults
-
-        Returns:
-            Dictionary containing user status defaults, or empty dict if not found
-        """
-        try:
-            # Get the consolidated document containing all defaults
-            doc_ref = firestore_client.collection(collection).document("all_users_defaults")
-            doc = doc_ref.get()
-
-            if not doc.exists:
-                return {}
-
-            # Get the data
-            data = doc.to_dict()
-
-            # Find the latest version of defaults for the specified user type
-            latest_key = None
-            latest_version = -1
-
-            # Look for defaults with format "{user_type}_defaults_{version}"
-            for key in data.keys():
-                if key.startswith(f"{primary_usertype}_defaults_"):
-                    try:
-                        version = int(key.split("_")[-1])
-                        if version > latest_version:
-                            latest_version = version
-                            latest_key = key
-                    except ValueError:
-                        continue
-
-            # Return the defaults if found
-            if latest_key and latest_key in data:
-                return data[latest_key]
-
-            return {}
-        except Exception:
-            # Return empty dict on error
-            return {}
-
-    @staticmethod
-    def fetch_subscription_plan(firestore_client,
-                               plan_id: str,
-                               collection: str = "papp_core_configs_subscriptionplans") -> Dict[str, Any]:
-        """
-        Fetch subscription plan details from Firestore.
-
-        Args:
-            firestore_client: Initialized Firestore client
-            plan_id: ID of the plan to fetch
-            collection: Collection name for subscription plans
-
-        Returns:
-            Dictionary containing subscription plan details, or empty dict if not found
-        """
-        try:
-            # Get the consolidated document containing all plans
-            doc_ref = firestore_client.collection(collection).document("all_subscriptionplans_defaults")
-            doc = doc_ref.get()
-
-            if not doc.exists:
-                return {}
-
-            # Get the data
-            data = doc.to_dict()
-
-            # Return the plan if found
-            if plan_id in data:
-                return data[plan_id]
-
-            return {}
-        except Exception:
-            # Return empty dict on error
-            return {}
+        # Apply this new subscription
+        self.apply_subscription(subscription)

ipulse_shared_core_ftredge/monitoring/__init__.py

@@ -0,0 +1,5 @@
+from .microservmon import Microservmon
+
+__all__ = [
+    'Microservmon',
+]