gooddata-pipelines 1.47.1.dev1__py3-none-any.whl

gooddata_pipelines/provisioning/entities/users/user_groups.py

@@ -0,0 +1,212 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for provisioning user groups in GoodData workspaces."""
+
+from typing import Sequence, TypeAlias
+
+from gooddata_sdk.catalog.user.entity_model.user_group import CatalogUserGroup
+
+from gooddata_pipelines.provisioning.entities.users.models.user_groups import (
+    UserGroupFullLoad,
+    UserGroupIncrementalLoad,
+)
+from gooddata_pipelines.provisioning.provisioning import Provisioning
+
+UserGroupModel: TypeAlias = UserGroupFullLoad | UserGroupIncrementalLoad
+
+
+class UserGroupProvisioner(
+    Provisioning[UserGroupFullLoad, UserGroupIncrementalLoad]
+):
+    """Provisioning class for user groups in GoodData workspaces.
+
+    This class handles the creation, update, and deletion of user groups
+    based on the provided source data.
+    """
+
+    source_group_incremental: list[UserGroupIncrementalLoad]
+    source_group_full: list[UserGroupFullLoad]
+    upstream_user_groups: list[CatalogUserGroup]
+
+    @staticmethod
+    def _is_changed(
+        group: UserGroupModel, existing_group: CatalogUserGroup
+    ) -> bool:
+        """Checks if user group has some changes and needs to be updated."""
+        group.parent_user_groups.sort()
+        parents_changed = group.parent_user_groups != existing_group.get_parents
+        name_changed = group.user_group_name != existing_group.name
+        return parents_changed or name_changed
+
+    def _create_or_update_user_group(
+        self,
+        group_id: str,
+        group_name: str,
+        parent_user_groups: list[str],
+    ) -> None:
+        """Creates or updates user group in the project."""
+        catalog_user_group = CatalogUserGroup.init(
+            user_group_id=group_id,
+            user_group_name=group_name,
+            user_group_parent_ids=parent_user_groups,
+        )
+        try:
+            self._api.create_or_update_user_group(
+                catalog_user_group=catalog_user_group
+            )
+            self.logger.info(
+                f"Created/Updated user group: {group_id} - {group_name}"
+            )
+        except Exception as e:
+            self.logger.error(
+                f"Failed to create/update user group. Error: {e} "
+                + f"Context: {catalog_user_group.__dict__}"
+            )
+
+    def _create_missing_user_groups(
+        self,
+        groups_to_create: Sequence[UserGroupModel],
+    ) -> None:
+        """Provisions user groups that don't exist."""
+        # Sort user groups to create those without parents first
+        sorted_groups = sorted(
+            groups_to_create, key=lambda x: 1 if x.parent_user_groups else 0
+        )
+
+        for group in sorted_groups:
+            self._create_or_update_user_group(
+                group.user_group_id,
+                group.user_group_name,
+                group.parent_user_groups,
+            )
+
+    def _update_existing_user_groups(
+        self,
+        groups_to_update: Sequence[UserGroupModel],
+        upstream_user_groups: list[CatalogUserGroup],
+    ) -> None:
+        """Update existing user groups and update ws_permissions."""
+        existing_groups = {group.id: group for group in upstream_user_groups}
+
+        for group in groups_to_update:
+            existing_group = existing_groups[group.user_group_id]
+            if self._is_changed(group, existing_group):
+                self._create_or_update_user_group(
+                    group.user_group_id,
+                    group.user_group_name,
+                    group.parent_user_groups,
+                )
+
+    def _delete_user_group(self, group_ids_to_delete: set[str]) -> None:
+        """Deletes user group from the project."""
+        for group_id in group_ids_to_delete:
+            try:
+                self._api.delete_user_group(group_id)
+                self.logger.info(f"Deleted user group: {group_id}")
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to delete user group. Error: {e} "
+                    + f"Context: {{'user_group_id': {group_id}}}"
+                )
+
+    def _provision_incremental_load(self) -> None:
+        """Runs incremental provisioning of user groups."""
+        # Get existing user groups from GoodData Cloud
+        self.upstream_user_groups = self._api.list_user_groups()
+
+        # Create a set of upstream user group IDs
+        upstream_group_ids: set[str] = {
+            group.id for group in self.upstream_user_groups
+        }
+
+        # Create a set of active source user group IDs
+        active_source_groups: set[str] = {
+            group.user_group_id
+            for group in self.source_group_incremental
+            if group.is_active is True
+        }
+
+        # Create a set of inactive source user group IDs
+        inactive_source_groups: set[str] = {
+            group.user_group_id
+            for group in self.source_group_incremental
+            if group.is_active is False
+        }
+
+        # Create a set of user group IDs to create as the difference between active
+        # source groups and upstream groups - i.e, we are creating groups marked
+        # as active in the source data but which are missing upstream in GoodData Cloud.
+        group_ids_to_create: set[str] = active_source_groups.difference(
+            upstream_group_ids
+        )
+
+        # Create a set of user group IDs to update as the intersection between active
+        # source groups and upstream groups - i.e, we are updating groups marked
+        # as active in the source data and which are present upstream in GoodData Cloud.
+        # The `_update_existing_user_groups` method will check if the upstream group
+        # definition differs from the source and if so, it will update the group.
+        group_ids_to_update: set[str] = active_source_groups.intersection(
+            upstream_group_ids
+        )
+
+        # Create a set of user group IDs to delete as the intersection between
+        # inactive source groups and upstream groups - i.e, we are deleting groups
+        # marked as inactive in the source data and which are present upstream in
+        # GoodData Cloud.
+        group_ids_to_delete: set[str] = inactive_source_groups.intersection(
+            upstream_group_ids
+        )
+
+        # create lists of groups to create, update and delete based on the sets
+        groups_to_create: list[UserGroupIncrementalLoad] = []
+        groups_to_update: list[UserGroupIncrementalLoad] = []
+
+        for group in self.source_group_incremental:
+            if group.user_group_id in group_ids_to_create:
+                groups_to_create.append(group)
+            elif group.user_group_id in group_ids_to_update:
+                groups_to_update.append(group)
+
+        self._create_missing_user_groups(groups_to_create)
+        self._update_existing_user_groups(
+            groups_to_update, self.upstream_user_groups
+        )
+        self._delete_user_group(group_ids_to_delete)
+
+    def _provision_full_load(self) -> None:
+        """Runs full load provisioning of user groups."""
+        # Get upsream user groups
+        self.upstream_user_groups = self._api.list_user_groups()
+
+        # Create a set of upstream user group IDs
+        upstream_group_ids: set[str] = {
+            group.id for group in self.upstream_user_groups
+        }
+
+        # Create a set of source user group IDs
+        source_group_ids: set[str] = {
+            group.user_group_id for group in self.source_group_full
+        }
+
+        # Figure out which ids are to be created, deleted or exist in both systems
+        id_groups = self._create_groups(source_group_ids, upstream_group_ids)
+
+        groups_to_create: list[UserGroupFullLoad] = []
+        groups_to_update: list[UserGroupFullLoad] = []
+
+        for group in self.source_group_full:
+            if group.user_group_id in id_groups.ids_to_create:
+                groups_to_create.append(group)
+            elif group.user_group_id in id_groups.ids_in_both_systems:
+                groups_to_update.append(group)
+
+        # Create user groups
+        self._create_missing_user_groups(groups_to_create)
+
+        # Update user groups
+        self._update_existing_user_groups(
+            groups_to_update, self.upstream_user_groups
+        )
+
+        # Delete user groups
+        self._delete_user_group(id_groups.ids_to_delete)

gooddata_pipelines/provisioning/entities/users/users.py

@@ -0,0 +1,179 @@
+# (C) 2025 GoodData Corporation
+
+"""Module for provisioning users in GoodData workspaces."""
+
+from typing import TypeAlias
+
+from gooddata_api_client.exceptions import NotFoundException  # type: ignore
+from gooddata_sdk.catalog.user.entity_model.user import CatalogUser
+from gooddata_sdk.catalog.user.entity_model.user_group import CatalogUserGroup
+
+from gooddata_pipelines.provisioning.entities.users.models.users import (
+    UserFullLoad,
+    UserIncrementalLoad,
+)
+from gooddata_pipelines.provisioning.provisioning import Provisioning
+from gooddata_pipelines.provisioning.utils.context_objects import UserContext
+
+# Type alias for user model instances
+UserModel: TypeAlias = UserFullLoad | UserIncrementalLoad
+UserId: TypeAlias = str
+
+
+class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
+    """Provisioning class for users in GoodData workspaces.
+
+    This class handles the creation, update, and deletion of users
+    based on the provided source data.
+    """
+
+    source_group_incremental: list[UserIncrementalLoad]
+    source_group_full: list[UserFullLoad]
+
+    def __init__(self, host: str, token: str) -> None:
+        super().__init__(host, token)
+        self.upstream_user_cache: dict[UserId, UserModel] = {}
+
+    def _try_get_user(
+        self, user: UserModel, model: type[UserModel]
+    ) -> UserModel | None:
+        try:
+            if user.user_id in self.upstream_user_cache:
+                return self.upstream_user_cache[user.user_id]
+
+            user_sdk_obj = self._api._sdk.catalog_user.get_user(user.user_id)
+            return model.from_sdk_obj(user_sdk_obj)
+        except NotFoundException:
+            return None
+
+    def _get_or_create_user_groups(self, groups: list[str]) -> None:
+        """Ensures that all user groups exist in the project."""
+        for group in groups:
+            try:
+                self._api._sdk.catalog_user.get_user_group(group)
+            except NotFoundException:
+                #  Create the user gtoup if it does not exist
+                self._api.create_or_update_user_group(
+                    CatalogUserGroup.init(
+                        user_group_id=group, user_group_name=group
+                    ),
+                )
+                self.logger.info(f"Created user group: {group}")
+
+    def _user_is_equal_upstream(
+        self,
+        user: UserModel,
+        upstream_user: UserModel | None,
+    ) -> bool:
+        """
+        Checks if the user is different from the upstream user. Lists are checked by converting to sets.
+        """
+        if not upstream_user:
+            return False
+
+        user_data = user.model_dump()
+        upstream_data = upstream_user.model_dump()
+
+        for attr, source_value in user_data.items():
+            upstream_value = upstream_data.get(attr)
+
+            if isinstance(source_value, list):
+                if set(source_value) != set(upstream_value or []):
+                    return False
+            else:
+                if source_value != upstream_value:
+                    return False
+        return True
+
+    def _create_or_update_user(
+        self, user: UserModel, model: type[UserModel]
+    ) -> None:
+        """Creates or updates user in the project.
+
+        Determines if the user needs to be updated or created by getting the
+        upstream user from GoodData Cloud and comparing it with the source user.
+        If user is supposed to be placed in a User Group, the function will check
+        for its existence and create it if needed.
+
+        """
+        user_context = UserContext(
+            user_id=user.user_id,
+            user_groups=user.user_groups,
+        )
+
+        upstream_user = self._try_get_user(user, model)
+
+        if self._user_is_equal_upstream(user, upstream_user):
+            return
+
+        self._get_or_create_user_groups(user.user_groups)
+
+        self._api.create_or_update_user(
+            user.to_sdk_obj(), **user_context.__dict__
+        )
+        self.logger.info(f"User {user.user_id} created/updated successfully.")
+
+    def _delete_user(self, user_id: str) -> None:
+        """Deletes user from the project."""
+        try:
+            self._api._sdk.catalog_user.get_user(user_id)
+        except NotFoundException:
+            return
+
+        self._api.delete_user(user_id)
+        self.logger.info(f"Deleted user: {user_id}")
+
+    def _manage_user(self, user: UserIncrementalLoad) -> None:
+        """Manages user based on the provided GDUserTarget."""
+        if user.is_active:
+            self._create_or_update_user(user, UserIncrementalLoad)
+        else:
+            self._delete_user(user.user_id)
+
+    def _provision_incremental_load(self) -> None:
+        """Runs the incremental provisioning logic."""
+        for user in self.source_group_incremental:
+            # Attempt to process each user. On failure, log the error and continue
+            try:
+                self._manage_user(user)
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to manage user {user.user_id}. Error: {e} Context: {user.__dict__}"
+                )
+
+    def _provision_full_load(self) -> None:
+        """Runs the full load provisioning logic."""
+        # Get all upstream users
+        catalog_upstream_users: list[CatalogUser] = self._api.list_users()
+
+        # Convert catalog users to user models
+        upstream_users: list[UserFullLoad] = [
+            UserFullLoad.from_sdk_obj(user) for user in catalog_upstream_users
+        ]
+
+        # Cache the upstream users in a dict. It will be reused in `_try_get_user`
+        self.upstream_user_cache = {
+            user.user_id: user for user in upstream_users
+        }
+        # Get source IDs
+        source_ids: set[str] = {user.user_id for user in self.source_group_full}
+
+        # Get upstream IDs
+        upstream_ids: set[str] = {user.user_id for user in upstream_users}
+
+        # Create groups of IDs to delete, create, and in both systems
+        id_groups = self._create_groups(source_ids, upstream_ids)
+
+        # Iterate over source users and create/update
+        for user in self.source_group_full:
+            user_id = user.user_id
+
+            if (
+                user_id in id_groups.ids_to_create
+                or user_id in id_groups.ids_in_both_systems
+            ):
+                self._create_or_update_user(user, UserFullLoad)
+
+        # Delete users marked for deletion
+        for user_id in id_groups.ids_to_delete:
+            self._delete_user(user_id)

gooddata_pipelines/provisioning/entities/workspaces/__init__.py

@@ -0,0 +1 @@
+# (C) 2025 GoodData Corporation

gooddata_pipelines/provisioning/entities/workspaces/models.py

@@ -0,0 +1,78 @@
+# (C) 2025 GoodData Corporation
+"""Module containing models related to workspace provisioning in GoodData Cloud."""
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+@dataclass
+class WorkspaceDataMaps:
+    """Dataclass to hold various mappings related to workspace data."""
+
+    child_to_parent_id_map: dict[str, str] = field(default_factory=dict)
+    workspace_id_to_wdf_map: dict[str, dict[str, list[str]]] = field(
+        default_factory=dict
+    )
+    parent_ids: set[str] = field(default_factory=set)
+    source_ids: set[str] = field(default_factory=set)
+    workspace_id_to_name_map: dict[str, str] = field(default_factory=dict)
+    upstream_ids: set[str] = field(default_factory=set)
+
+
+class WorkspaceFullLoad(BaseModel):
+    """Model representing input for provisioning of workspaces in GoodData Cloud."""
+
+    model_config = ConfigDict(coerce_numbers_to_str=True)
+
+    parent_id: str
+    workspace_id: str
+    workspace_name: str
+    workspace_data_filter_id: str | None = None
+    workspace_data_filter_values: list[str] | None = None
+
+
+class WorkspaceIncrementalLoad(WorkspaceFullLoad):
+    """Model representing input for incremental provisioning of workspaces in GoodData Cloud."""
+
+    # TODO: double check that the model loads the data correctly, write a test
+    is_active: bool
+
+
+class WDFSettingAttributes(BaseModel):
+    title: str
+    filterValues: list[str]
+
+
+class WDFSettingRelationshipsData(BaseModel):
+    id: str
+    type: Literal["workspaceDataFilter"]
+
+
+class WDFSettingRelationships(BaseModel):
+    workspaceDataFilter: dict[str, WDFSettingRelationshipsData]
+
+
+class WDFSettingLinks(BaseModel):
+    self: str
+
+
+class WDFSettingMetaOrigin(BaseModel):
+    originType: str
+    originId: str
+
+
+class WDFSettingMeta(BaseModel):
+    origin: WDFSettingMetaOrigin
+
+
+class WDFSetting(BaseModel):
+    """Model representing a workspace data filter setting in GoodData Cloud."""
+
+    id: str
+    type: Literal["workspaceDataFilterSetting"]
+    attributes: WDFSettingAttributes
+    relationships: WDFSettingRelationships
+    links: WDFSettingLinks
+    meta: WDFSettingMeta