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

ipulse_shared_core_ftredge/models/{subscription.py → user/user_subscription.py}

@@ -1,20 +1,20 @@
 from datetime import datetime, timezone
 from dateutil.relativedelta import relativedelta
 import uuid
-from typing import Set, Optional, ClassVar, Dict, Any, List, Union
-from pydantic import Field, ConfigDict
-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 .base_data_model import BaseDataModel
+from typing import Optional, ClassVar, Dict, Any, List
+from pydantic import Field, ConfigDict, model_validator
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, SubscriptionPlanName, SubscriptionStatus
+from ..base_data_model import BaseDataModel
+from .user_permissions import UserPermission
 # ORIGINAL AUTHOR ="russlan.ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
 
-DEFAULT_SUBSCRIPTION_PLAN = SubscriptionPlan.FREE
+DEFAULT_SUBSCRIPTION_PLAN = SubscriptionPlanName.FREE_SUBSCRIPTION
 DEFAULT_SUBSCRIPTION_STATUS = SubscriptionStatus.ACTIVE
 
 ############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! ############################################
-class Subscription(BaseDataModel):
+class UserSubscription(BaseDataModel):
     """
     Represents a single subscription cycle with enhanced flexibility and tracking.
     """
@@ -22,7 +22,7 @@ class Subscription(BaseDataModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     VERSION: ClassVar[float] = 3.0  # Incremented version for direct fields instead of computed
-    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.SUBSCRIPTION.name))
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.SUBSCRIPTION))
     OBJ_REF: ClassVar[str] = "subscription"
 
     # System-managed fields (read-only)
@@ -33,13 +33,13 @@ class Subscription(BaseDataModel):
     )
 
     # Unique identifier for this specific subscription instance - now auto-generated
-    uuid: str = Field(
-        default_factory=lambda: str(uuid.uuid4()),
+    id: Optional[str] = Field(
+        default=None,  # Will be auto-generated using UUID if not provided
         description="Unique identifier for this subscription instance"
     )
 
     # Plan identification
-    plan_name: SubscriptionPlan = Field(
+    plan_name: SubscriptionPlanName = Field(
         ...,  # Required field, no default
         description="Subscription Plan Name"
     )
@@ -61,10 +61,10 @@ class Subscription(BaseDataModel):
         description="Subscription Cycle Start Date"
     )
 
-    # Direct field instead of computed
-    cycle_end_date: datetime = Field(
-        ...,  # Required field, no default
-        description="Subscription Cycle End Date"
+    # Direct field instead of computed - will be auto-calculated
+    cycle_end_date: Optional[datetime] = Field(
+        default=None,
+        description="Subscription Cycle End Date (auto-calculated if not provided)"
     )
 
     # Fields for cycle calculation
@@ -89,14 +89,14 @@ class Subscription(BaseDataModel):
         description="Subscription Status (active, trial, pending_confirmation, etc.)"
     )
 
-    # IAM permissions structure
-    default_iam_domain_permissions: Dict[str, Dict[str, List[str]]] = Field(
-        ...,  # Required field, no default
-        description="IAM domain permissions granted by this subscription (domain -> IAM unit type -> list of unit references)"
+    # IAM permissions structure - simplified flattened list
+    granted_iam_permissions: List[UserPermission] = Field(
+        default_factory=list,
+        description="IAM permissions granted by this subscription"
     )
 
     fallback_plan_id: Optional[str] = Field(
-        ...,  # Required field (can be None), no default
+        default=None,  # Optional field with None default
         description="ID of the plan to fall back to if this subscription expires"
     )
 
@@ -142,6 +142,46 @@ class Subscription(BaseDataModel):
         description="Additional metadata for the subscription"
     )
 
+    @model_validator(mode='before')
+    @classmethod
+    def ensure_id_exists(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Ensures the id field exists by generating it using UUID if needed.
+        """
+        if not isinstance(data, dict):
+            return data
+
+        # If id is already provided and non-empty, leave it alone
+        if data.get('id'):
+            return data
+
+        # Generate a UUID-based id if not provided
+        data['id'] = str(uuid.uuid4())
+        return data
+
+    @model_validator(mode='before')
+    @classmethod
+    def auto_calculate_cycle_end_date(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Auto-calculate cycle_end_date if not provided, based on cycle_start_date,
+        validity_time_length, and validity_time_unit.
+        """
+        if not isinstance(data, dict):
+            return data
+
+        # Only calculate if cycle_end_date is not already provided
+        if 'cycle_end_date' not in data or data['cycle_end_date'] is None:
+            cycle_start_date = data.get('cycle_start_date')
+            validity_time_length = data.get('validity_time_length')
+            validity_time_unit = data.get('validity_time_unit')
+
+            if cycle_start_date and validity_time_length and validity_time_unit:
+                data['cycle_end_date'] = cls.calculate_cycle_end_date(
+                    cycle_start_date, validity_time_length, validity_time_unit
+                )
+
+        return data
+
     # Helper method to calculate cycle end date
     @classmethod
     def calculate_cycle_end_date(cls, start_date: datetime, validity_length: int, validity_unit: str) -> datetime:
@@ -162,6 +202,8 @@ class Subscription(BaseDataModel):
     # Methods for subscription management
     def is_active(self) -> bool:
         """Check if the subscription is currently active."""
+        if not self.cycle_end_date:
+            return False
         now = datetime.now(timezone.utc)
         return (
             self.status == SubscriptionStatus.ACTIVE and
@@ -170,11 +212,15 @@ class Subscription(BaseDataModel):
 
     def is_expired(self) -> bool:
         """Check if the subscription has expired."""
+        if not self.cycle_end_date:
+            return True
         now = datetime.now(timezone.utc)
         return now > self.cycle_end_date
 
     def days_remaining(self) -> int:
         """Calculate the number of days remaining in the subscription."""
+        if not self.cycle_end_date:
+            return 0
         now = datetime.now(timezone.utc)
         if now > self.cycle_end_date:
             return 0

ipulse_shared_core_ftredge/models/{user_auth.py → user/userauth.py}

@@ -1,6 +1,6 @@
 from typing import Optional, Dict, Any, List
 from datetime import datetime
-from pydantic import BaseModel, Field, EmailStr, ConfigDict, field_validator
+from pydantic import BaseModel, Field, EmailStr, ConfigDict, field_validator, model_validator
 
 class UserAuth(BaseModel):
     """Comprehensive authentication model for user credentials and auth operations"""
@@ -8,17 +8,18 @@ class UserAuth(BaseModel):
 
     # Core authentication fields
     email: EmailStr = Field(..., description="User's email address")
+    display_name: Optional[str] = Field(None, description="User's display name")
     password: Optional[str] = Field(None, min_length=6, description="User's password (for creation/update only)")
 
     # Firebase Auth specific fields
-    firebase_uid: Optional[str] = Field(None, description="Firebase Auth UID")
+    firebase_uid: Optional[str] = Field(default=None, description="Firebase Auth UID")
     provider_id: str = Field(default="password", description="Authentication provider ID")
     email_verified: bool = Field(default=False, description="Whether email is verified")
     disabled: bool = Field(default=False, description="Whether user account is disabled")
 
     # Multi-factor authentication
     mfa_enabled: bool = Field(default=False, description="Whether MFA is enabled")
-    phone_number: Optional[str] = Field(None, description="Phone number for SMS MFA")
+    phone_number: Optional[str] = Field(default=None, description="Phone number for SMS MFA")
 
     # Custom claims and metadata
     custom_claims: Dict[str, Any] = Field(default_factory=dict, description="Firebase custom claims")
@@ -28,14 +29,14 @@ class UserAuth(BaseModel):
     provider_data: List[Dict[str, Any]] = Field(default_factory=list, description="Provider-specific data")
 
     # Account management
-    created_at: Optional[datetime] = Field(None, description="Account creation timestamp")
-    last_sign_in: Optional[datetime] = Field(None, description="Last sign-in timestamp")
-    last_refresh: Optional[datetime] = Field(None, description="Last token refresh timestamp")
+    created_at: Optional[datetime] = Field(default=None, description="Account creation timestamp")
+    last_sign_in: Optional[datetime] = Field(default=None, description="Last sign-in timestamp")
+    last_refresh: Optional[datetime] = Field(default=None, description="Last token refresh timestamp")
 
     # Password management
-    password_hash: Optional[str] = Field(None, description="Password hash (internal use only)")
-    password_salt: Optional[str] = Field(None, description="Password salt (internal use only)")
-    valid_since: Optional[datetime] = Field(None, description="Timestamp since when tokens are valid")
+    password_hash: Optional[str] = Field(default=None, description="Password hash (internal use only)")
+    password_salt: Optional[str] = Field(default=None, description="Password salt (internal use only)")
+    valid_since: Optional[datetime] = Field(default=None, description="Timestamp since when tokens are valid")
 
     @field_validator('phone_number')
     @classmethod
@@ -61,4 +62,12 @@ class UserAuth(BaseModel):
             if claim in reserved_claims:
                 raise ValueError(f'Custom claim "{claim}" is reserved by Firebase')
 
-        return v
+        return v
+
+    @model_validator(mode='before')
+    @classmethod
+    def check_password_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Ensure that password and password_hash are not set simultaneously."""
+        if values.get('password') and values.get('password_hash'):
+            raise ValueError('Cannot set both password and password_hash')
+        return values

ipulse_shared_core_ftredge/models/{user_profile.py → user/userprofile.py}

@@ -1,11 +1,10 @@
 """ User Profile model for storing personal information and settings. """
-from datetime import date, datetime, timezone
-from typing import Set, Optional, ClassVar, Dict, Any, List
-from pydantic import EmailStr, Field, ConfigDict, field_validator, model_validator, computed_field
-from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings, Subject
-from .base_data_model import BaseDataModel
+from datetime import date, datetime
 import re  # Add re import
-
+from typing import Set, Optional, ClassVar, Dict, Any, List
+from pydantic import EmailStr, Field, ConfigDict, model_validator, field_validator
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, IAMUserType
+from ..base_data_model import BaseDataModel
 # ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
@@ -18,7 +17,7 @@ class UserProfile(BaseDataModel):
 
     # Class constants
     VERSION: ClassVar[float] = 5.0  # Incremented version for primary_usertype addition
-    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.USER.name))
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.USER))
     OBJ_REF: ClassVar[str] = "userprofile"
 
     schema_version: float = Field(
@@ -27,26 +26,28 @@ class UserProfile(BaseDataModel):
         description="Version of this Class == version of DB Schema"
     )
 
-    id: str = Field(
-        default="",  # Will be auto-generated from user_uid if not provided
+    id: Optional[str] = Field(
+        default=None,  # Will be auto-generated from user_uid if not provided
         description=f"User Profile ID, format: {OBJ_REF}_user_uid"
     )
 
     user_uid: str = Field(
         ...,
-        description="User UID from Firebase Auth"
+        min_length=1,
+        description="User UID from Firebase Auth",
+        frozen=True
     )
 
     # Added primary_usertype field for main role categorization
-    primary_usertype: str = Field(
+    primary_usertype: IAMUserType = Field(
         ...,
-        description="Primary user type (e.g., customer, internal, admin, superadmin)"
+        description="Primary user type from IAMUserType enum"
     )
 
     # Renamed usertypes to secondary_usertypes
-    secondary_usertypes: List[str] = Field(
+    secondary_usertypes: List[IAMUserType] = Field(
         default_factory=list,
-        description="List of secondary user types"
+        description="List of secondary user types from IAMUserType enum"
     )
 
     # Rest of the fields remain the same
@@ -105,24 +106,38 @@ class UserProfile(BaseDataModel):
 
     # Remove audit fields as they're inherited from BaseDataModel
 
+    @field_validator('user_uid')
+    @classmethod
+    def validate_user_uid(cls, v: str) -> str:
+        """Validate that user_uid is not empty string."""
+        if not v or not v.strip():
+            raise ValueError("user_uid cannot be empty or whitespace-only")
+        return v.strip()
+
     @model_validator(mode='before')
     @classmethod
     def ensure_id_exists(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Ensures the id field exists by generating it from user_uid if needed.
+        Ensures the id field exists and matches expected format, or generates it from user_uid.
         This runs BEFORE validation, guaranteeing id will be present for validators.
         """
         if not isinstance(data, dict):
             return data
 
-        # If id is already in the data, leave it alone
-        if 'id' in data and data['id']:
-            return data
+        user_uid = data.get('user_uid')
+        if not user_uid:
+            return data  # Let field validation handle missing user_uid
 
-        # If user_uid exists but id doesn't, generate id from user_uid
-        if 'user_uid' in data and data['user_uid']:
-            data['id'] = f"{cls.OBJ_REF}_{data['user_uid']}"
+        expected_id = f"{cls.OBJ_REF}_{user_uid}"
 
+        # If id is already provided, validate it matches expected format
+        if data.get('id'):
+            if data['id'] != expected_id:
+                raise ValueError(f"Invalid id format. Expected '{expected_id}', got '{data['id']}'")
+            return data
+
+        # If id is not provided, generate it from user_uid
+        data['id'] = expected_id
         return data
 
     @model_validator(mode='before')
@@ -156,4 +171,21 @@ class UserProfile(BaseDataModel):
             # Fallback if no email or username provided
             data['username'] = "user"
 
+        return data
+
+    @model_validator(mode='before')
+    @classmethod
+    def convert_datetime_to_date(cls, data: Any) -> Any:
+        """
+        Convert datetime objects to date objects for date fields.
+        This handles the case where Firestore returns datetime objects
+        but the model expects date objects (e.g., dob field).
+        """
+        if not isinstance(data, dict):
+            return data
+
+        # Handle dob field specifically
+        if 'dob' in data and isinstance(data['dob'], datetime):
+            data['dob'] = data['dob'].date()
+
         return data