ipulse-shared-core-ftredge 7.1.1__py3-none-any.whl → 8.1.1__py3-none-any.whl

ipulse_shared_core_ftredge/models/user_status.py

@@ -1,35 +1,56 @@
 """ User Status model for tracking user subscription and access rights. """
-from datetime import datetime
-from typing import Set, Optional, Dict, List, ClassVar
-from pydantic import Field, ConfigDict, field_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings, Subject
+from datetime import datetime, timezone
+from dateutil.relativedelta import relativedelta  # Add missing import
+from typing import Set, Optional, Dict, List, ClassVar, Any, Union
+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 .subscription import Subscription
 from .base_data_model import BaseDataModel
 
 # ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
+class IAMUnitRefAssignment(BaseModel):
+    """
+    Represents an IAM assignment (for groups, roles, or permissions) with expiration tracking.
+    """
+    # Identity of the IAM unit reference
+    iam_unit_ref: str = Field(
+        ...,
+        description="Reference name of the IAM unit (e.g., 'base_subscription_group')"
+    )
+
+    # Expiration tracking
+    expires_at: Optional[datetime] = Field(
+        default=None,
+        description="When this assignment expires (null for permanent)"
+    )
+
+    source: str = Field(
+        ...,
+        description="Source of this assignment (subscription plan ID, 'system_default', etc.)"
+    )
+
+    def is_valid(self) -> bool:
+        """Check if the assignment is currently valid (not expired)."""
+        if self.expires_at is None:
+            return True
+        return datetime.now(timezone.utc) <= self.expires_at
+
 ############################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! #################################
 class UserStatus(BaseDataModel):
     """
     User Status model for tracking user subscription and access rights.
     """
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    # Set frozen=False to allow modification of attributes
+    model_config = ConfigDict(frozen=False, extra="forbid")
 
     # Class constants
-    VERSION: ClassVar[float] = 4.1
+    VERSION: ClassVar[float] = 5.0  # Incremented version for primary_user_type addition
     DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.USER.name))
     OBJ_REF: ClassVar[str] = "userstatus"
 
-    # Default values as class variables
-    DEFAULT_IAM_GROUPS: ClassVar[Dict[str, List[str]]] = {"pulseroot": ["full_open_read"]}
-    DEFAULT_SUBSCRIPTION_PLAN: ClassVar[str] = "subscription_free"
-    DEFAULT_SUBSCRIPTION_STATUS: ClassVar[str] = "active"
-    DEFAULT_SUBSCRIPTION_INSIGHT_CREDITS: ClassVar[int] = 10
-    DEFAULT_VOTING_CREDITS: ClassVar[int] = 0
-    DEFAULT_EXTRA_INSIGHT_CREDITS: ClassVar[int] = 0
-
-
     # System-managed fields
     schema_version: float = Field(
         default=VERSION,
@@ -37,9 +58,9 @@ class UserStatus(BaseDataModel):
         description="Version of this Class == version of DB Schema"
     )
 
-    id : str = Field(
-        ...,
-        description="User ID, format: {OBJ_REF}_{user_uid}"
+    id: str = Field(
+        ...,  # Still required, but will be auto-generated by model_validator if not provided
+        description=f"User ID, format: {OBJ_REF}_user_uid"
     )
 
     user_uid: str = Field(
@@ -47,60 +68,508 @@ class UserStatus(BaseDataModel):
         description="User UID from Firebase Auth"
     )
 
-    # IAM and subscription fields
-    iam_groups: Dict[str, List[str]] = Field(
-        default_factory=lambda: UserStatus.DEFAULT_IAM_GROUPS,
-        description="User's Groups, with a default one for all authenticated Pulse users"
+    # Added primary_user_type field for main role categorization
+    primary_user_type: str = Field(
+        ...,
+        description="Primary user type (e.g., customer, internal, admin, superadmin)"
     )
 
-    # Subscription Management
-    subscriptions: Dict[str, Subscription] = Field(
-        default_factory=dict,
-        description="Dictionary of user's active and past subscriptions, keyed by plan name"
+    # Renamed user_types to secondary_user_types
+    secondary_user_types: List[str] = Field(
+        default_factory=list,
+        description="List of secondary user types/roles"
     )
 
-    # Credits management
+    # Added organizations field for consistency with UserProfile
+    organizations_uids: Set[str] = Field(
+        default_factory=set,
+        description="Organization UIDs the user belongs to"
+    )
+
+    # Enhanced IAM permissions structure with expiration - update to use string for enum keys
+    iam_domain_permissions: Dict[str, Dict[str, Dict[str, IAMUnitRefAssignment]]] = Field(
+        ...,
+        description="Domain -> IAM unit type (groups/roles/permissions) -> unit reference name -> assignment details (with expiration)"
+    )
+
+    # 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"
+    )
+
+    # Changed from dictionary to single Optional subscription
+    active_subscription: Optional[Subscription] = Field(
+        default=None,
+        description="The user's currently active subscription, if any"
+    )
+
+    # Credit management fields
     sbscrptn_based_insight_credits: int = Field(
-        default_factory=lambda: UserStatus.DEFAULT_SUBSCRIPTION_INSIGHT_CREDITS,
-        description="Subscription-based insight credits"
+        ...,
+        description="Subscription-based insight credits (expire with subscription)"
     )
+
     sbscrptn_based_insight_credits_updtd_on: datetime = Field(
-        default_factory=datetime.now,
+        default_factory=lambda: datetime.now(timezone.utc),
         description="Last update timestamp for subscription credits"
     )
+
     extra_insight_credits: int = Field(
-        default_factory=lambda: UserStatus.DEFAULT_EXTRA_INSIGHT_CREDITS,
+        ...,
         description="Additional purchased insight credits (non-expiring)"
     )
 
     extra_insight_credits_updtd_on: datetime = Field(
-        default_factory=datetime.now,
+        default_factory=lambda: datetime.now(timezone.utc),
         description="Last update timestamp for extra credits"
     )
 
     voting_credits: int = Field(
-        default_factory=lambda: UserStatus.DEFAULT_VOTING_CREDITS,  # Changed default to default_factory
+        ...,
         description="Voting credits for user"
     )
 
-    # Optional fields
-    payment_refs_uids: Optional[Set[str]] = None
+    voting_credits_updtd_on: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="Last update timestamp for voting credits"
+    )
 
-    # Remove audit fields as they're inherited from BaseDataModel
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional metadata for the user status"
+    )
 
-    @field_validator('id', mode='before')
+    @model_validator(mode='before')
     @classmethod
-    def validate_or_generate_id(cls, v: Optional[str], info) -> str:
+    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.
+        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
+
+        # 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']}"
+
+        return data
+
+    # Utility methods for subscription management - updated for single subscription
+
+    def get_active_subscription(self) -> Optional[Subscription]:
+        """Get the currently active subscription if it exists."""
+        return self.active_subscription
+
+    def get_subscription_plan_name(self) -> Optional[SubscriptionPlan]:
+        """Get the current subscription plan name."""
+        if self.active_subscription:
+            return self.active_subscription.plan_name
+        return None
+
+    def has_valid_permission_type_for_domain(self, domain: str, iam_unit_type: IAMUnitType = IAMUnitType.GROUPS) -> bool:
+        """Check if the user has any valid IAM permissions of specified type for the domain."""
+        if domain not in self.iam_domain_permissions:
+            return False
+
+        # Update to use string value from enum
+        domain_permissions = self.iam_domain_permissions[domain].get(iam_unit_type.value, {})
+        return any(assignment.is_valid() for assignment in domain_permissions.values())
+
+    def has_valid_groups_for_domain(self, domain: str) -> bool:
+        """Check if the user has any valid IAM groups for the specified domain (legacy method)."""
+        return self.has_valid_permission_type_for_domain(domain, IAMUnitType.GROUPS)
+
+    def get_valid_permissions_for_domain(self, domain: str, iam_unit_type: IAMUnitType = IAMUnitType.GROUPS) -> List[str]:
+        """Get a list of valid (non-expired) permission names of specified type for the domain."""
+        if domain not in self.iam_domain_permissions:
+            return []
+
+        # Update to use string value from enum
+        domain_permissions = self.iam_domain_permissions[domain].get(iam_unit_type.value, {})
+        return [
+            iam_unit_ref
+            for iam_unit_ref, assignment in domain_permissions.items()
+            if assignment.is_valid()
+        ]
+
+    def get_valid_groups_for_domain(self, domain: str) -> List[str]:
+        """Get a list of valid (non-expired) group names for the domain (legacy method)."""
+        return self.get_valid_permissions_for_domain(domain, IAMUnitType.GROUPS)
+
+    def add_iam_unit_ref_assignment(
+        self,
+        domain: str,
+        iam_unit_ref: str,
+        iam_unit_type: IAMUnitType,
+        source: str,
+        expires_at: Optional[datetime] = None
+    ) -> None:
+        """
+        Add a permission assignment to the user's IAM domain permissions.
+
+        Args:
+            domain: The domain for the permission (e.g., 'papp')
+            iam_unit_ref: The name/identifier of the permission to add
+            iam_unit_type: Type of IAM assignment (GROUP, ROLE, PERMISSION)
+            source: Source identifier for this assignment (e.g., subscription ID)
+            expires_at: Optional expiration date
+        """
+        # Ensure domain exists
+        if domain not in self.iam_domain_permissions:
+            self.iam_domain_permissions[domain] = {}
+
+        # Ensure permission type section exists - use string value from enum
+        if iam_unit_type.value not in self.iam_domain_permissions[domain]:
+            self.iam_domain_permissions[domain][iam_unit_type.value] = {}
+
+        # Create new assignment
+        assignment = IAMUnitRefAssignment(
+            iam_unit_ref=iam_unit_ref,
+            source=source,
+            expires_at=expires_at
+        )
+
+        # Add the permission - use string value from enum
+        self.iam_domain_permissions[domain][iam_unit_type.value][iam_unit_ref] = assignment
+
+    def add_group_assignment(
+        self,
+        domain: str,
+        group_name: str,
+        source: str,
+        expires_at: Optional[datetime] = None
+    ) -> None:
+        """
+        Add a group assignment to the user's IAM groups (legacy method).
+
+        Args:
+            domain: The domain for the group (e.g., 'papp')
+            group_name: The name of the group to add
+            source: Source identifier for this assignment (e.g., subscription ID)
+            expires_at: Optional expiration date
+        """
+        self.add_iam_unit_ref_assignment(domain, group_name, IAMUnitType.GROUPS, source, expires_at)
+
+    def remove_expired_iam_unit_refs(self, iam_unit_type: Optional[IAMUnitType] = None) -> int:
+        """
+        Remove all expired permission assignments of a specific type or all types.
+
+        Args:
+            iam_unit_type: If provided, only remove this type of permissions
+
+        Returns:
+            Number of removed permission assignments
+        """
+        now = datetime.now(timezone.utc)
+        removed_count = 0
+
+        # Create a deep copy of domains to avoid modification during iteration
+        domains = list(self.iam_domain_permissions.keys())
+
+        for domain in domains:
+            # If iam_unit_type is specified, only check that type
+            if iam_unit_type:
+                unit_type_value = iam_unit_type.value
+                if unit_type_value not in self.iam_domain_permissions[domain]:
+                    continue
+
+                iam_unit_types_to_check = [unit_type_value]
+            else:
+                # Check all permission types
+                iam_unit_types_to_check = list(self.iam_domain_permissions[domain].keys())
+
+            # Process each permission type
+            for perm_type in iam_unit_types_to_check:
+                # Create a list of permissions to remove
+                permissions_to_remove = [
+                    iam_unit_ref
+                    for iam_unit_ref, assignment in self.iam_domain_permissions[domain][perm_type].items()
+                    if assignment.expires_at and assignment.expires_at < now
+                ]
+
+                # Remove expired permissions
+                for iam_unit_ref in permissions_to_remove:
+                    del self.iam_domain_permissions[domain][perm_type][iam_unit_ref]
+                    removed_count += 1
+
+        return removed_count
+
+    def remove_expired_groups(self) -> int:
+        """
+        Remove all expired group assignments (legacy method).
+
+        Returns:
+            Number of removed group assignments
+        """
+        return self.remove_expired_iam_unit_refs(IAMUnitType.GROUPS)
+
+    def update_iam_unit_refs_from_subscription(self, subscription: Subscription) -> int:
+        """
+        Update IAM permissions based on a subscription.
+
+        Args:
+            subscription: Subscription to apply
+
+        Returns:
+            Number of permission assignments added
+        """
+        added_count = 0
+
+        for domain, permissions_by_type in subscription.iam_domain_permissions.items():
+            for iam_unit_type_str, iam_unit_refs in permissions_by_type.items():
+                # Convert string to enum if needed for internal processing
+                try:
+                    iam_unit_type = IAMUnitType(iam_unit_type_str)
+                    for iam_unit_ref in iam_unit_refs:
+                        self.add_iam_unit_ref_assignment(
+                            domain=domain,
+                            iam_unit_ref=iam_unit_ref,
+                            iam_unit_type=iam_unit_type,
+                            source=f"{subscription.plan_name.value}_v{subscription.plan_version}",
+                            expires_at=subscription.cycle_end_date
+                        )
+                        added_count += 1
+                except ValueError:
+                    # Skip invalid unit types
+                    continue
+
+        return added_count
+
+    def update_groups_from_subscription(self, subscription: Subscription) -> int:
+        """
+        Update IAM groups based on a subscription (legacy method).
+
+        Args:
+            subscription: Subscription to apply
+
+        Returns:
+            Number of group assignments added
+        """
+        return self.update_iam_unit_refs_from_subscription(subscription)
+
+    @computed_field
+    def is_subscription_active(self) -> bool:
+        """Check if the user has an active subscription."""
+        if self.active_subscription:
+            return self.active_subscription.is_active()
+        return False
+
+    @computed_field
+    def subscription_expires_in_days(self) -> Optional[int]:
+        """Get days until subscription expiration."""
+        if self.active_subscription and self.active_subscription.is_active():
+            return self.active_subscription.days_remaining()
+        return None
+
+    def apply_subscription(self, subscription: Subscription) -> None:
+        """
+        Apply a subscription's benefits to the user status.
+        This updates credits, permissions, and sets the active subscription.
+
+        Args:
+            subscription: The subscription to apply
+        """
+        if not subscription:
+            return
+
+        # 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
+        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)
+
+        # 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)
+
+        # 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
+
+    def revoke_subscription(self) -> None:
+        """
+        Revoke the current subscription benefits.
+        This clears subscription-based credits and removes the active subscription.
+        """
+        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
+
+    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.
+
+        Args:
+            plan_data: Dictionary containing subscription plan details
+            source: Source identifier for this application
+            expires_at: Optional expiration date for the subscription
+        """
+        # Default expiration date (1 month from now) if not provided
+        if not expires_at:
+            expires_at = datetime.now(timezone.utc) + relativedelta(months=1)
+
+        # Extract IAM permissions
+        iam_domain_permissions = plan_data.get("default_iam_domain_permissions", {})
+
+        # Extract plan name - no default fallbacks
+        plan_name_str = plan_data.get("plan_name")
+        if not plan_name_str:
+            return  # Cannot create subscription without plan name
+
+        try:
+            plan_name = SubscriptionPlan(plan_name_str)
+        except ValueError:
+            return  # Invalid plan name
+
+        # Extract required fields - no default fallbacks
+        plan_version = plan_data.get("plan_version")
+        validity_time_length = plan_data.get("plan_validity_cycle_length")
+        validity_time_unit = plan_data.get("plan_validity_cycle_unit")
+
+        # 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:
+            return
+
+        # Create temporary subscription object with direct attributes instead of metadata
+        subscription = Subscription(
+            plan_name=plan_name,
+            plan_version=plan_version,
+            cycle_start_date=datetime.now(timezone.utc),
+            validity_time_length=validity_time_length,
+            validity_time_unit=validity_time_unit,
+            auto_renew=plan_data.get("plan_auto_renewal", False),  # Default only for boolean fields
+            status=SubscriptionStatus.ACTIVE,
+            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,
+            created_by=source,
+            updated_by=source,
+            # Direct attributes for credit-related fields
+            subscription_based_insight_credits_per_update=plan_data.get("subscription_based_insight_credits_per_update") or 0,
+            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
+        )
+
+        # Apply the subscription
+        self.apply_subscription(subscription)
+
+    @staticmethod
+    def fetch_user_status_defaults(firestore_client,
+                                   primary_user_type: str,
+                                   collection: str = "papp_core_configs_user") -> Dict[str, Any]:
         """
-        Validate or generate the id field based on user_uid.
+        Fetch user status defaults from Firestore.
+
+        Args:
+            firestore_client: Initialized Firestore client
+            primary_user_type: 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_user_type}_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
         """
-        # If id is already provided (Firebase Auth case), return it
-        if v:
-            return v
+        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]
 
-        # Fallback: generate from user_uid if needed
-        values = info.data
-        user_uid = values.get('user_uid')
-        if not user_uid:
-            raise ValueError("Either id or user_uid must be provided")
-        return f"{cls.OBJ_REF}_{user_uid}"
+            return {}
+        except Exception:
+            # Return empty dict on error
+            return {}

ipulse_shared_core_ftredge/services/base_firestore_service.py

@@ -25,10 +25,10 @@ class BaseFirestoreService(Generic[T]):
 
             # Add audit fields
             doc_data.update({
-                'creat_date': current_time.isoformat(),
-                'creat_by_user': creator_uid,
-                'updt_date': current_time.isoformat(),
-                'updt_by_user': creator_uid
+                'created_at': current_time.isoformat(),
+                'created_by': creator_uid,
+                'updated_at': current_time.isoformat(),
+                'updated_by': creator_uid
             })
 
             doc_ref = self.db.collection(self.collection_name).document(doc_id)
@@ -56,10 +56,10 @@ class BaseFirestoreService(Generic[T]):
             for doc in documents:
                 doc_data = doc.model_dump(mode='json')
                 doc_data.update({
-                    'creat_date': current_time.isoformat(),
-                    'creat_by_user': creator_uid,
-                    'updt_date': current_time.isoformat(),
-                    'updt_by_user': creator_uid
+                    'created_at': current_time.isoformat(),
+                    'created_by': creator_uid,
+                    'updated_at': current_time.isoformat(),
+                    'updated_by': creator_uid
                 })
 
                 doc_ref = self.db.collection(self.collection_name).document(doc_data.get('id'))
@@ -109,8 +109,8 @@ class BaseFirestoreService(Generic[T]):
 
             # Add audit fields
             valid_fields.update({
-                'updt_date': datetime.now(timezone.utc).isoformat(),
-                'updt_by_user': updater_uid
+                'updated_at': datetime.now(timezone.utc).isoformat(),
+                'updated_by': updater_uid
             })
 
             doc_ref.update(valid_fields)

{ipulse_shared_core_ftredge-7.1.1.dist-info → ipulse_shared_core_ftredge-8.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 7.1.1
+Version: 8.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
@@ -17,6 +17,7 @@ Requires-Dist: ipulse_shared_base_ftredge>=5.7.1
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary