feat: add support for FilterView management

Enabling management of FilterViews via pythonSDK

JIRA: LX-428
risk: low

Author: chrisbonilla95

gooddata-sdk/gooddata_sdk/__init__.py

@@ -71,6 +71,7 @@
 from gooddata_sdk.catalog.identifier import (
     CatalogAssigneeIdentifier,
     CatalogDatasetWorkspaceDataFilterIdentifier,
+    CatalogDeclarativeAnalyticalDashboardIdentifier,
     CatalogExportDefinitionIdentifier,
     CatalogNotificationChannelIdentifier,
     CatalogUserIdentifier,
@@ -175,6 +176,7 @@
     CatalogDeclarativeModel,
 )
 from gooddata_sdk.catalog.workspace.declarative_model.workspace.workspace import (
+    CatalogDeclarativeFilterView,
     CatalogDeclarativeUserDataFilter,
     CatalogDeclarativeUserDataFilters,
     CatalogDeclarativeWorkspace,

gooddata-sdk/gooddata_sdk/catalog/identifier.py

@@ -7,6 +7,9 @@
 from attrs import define
 from gooddata_api_client.model.assignee_identifier import AssigneeIdentifier
 from gooddata_api_client.model.dataset_workspace_data_filter_identifier import DatasetWorkspaceDataFilterIdentifier
+from gooddata_api_client.model.declarative_analytical_dashboard_identifier import (
+    DeclarativeAnalyticalDashboardIdentifier,
+)
 from gooddata_api_client.model.declarative_export_definition_identifier import DeclarativeExportDefinitionIdentifier
 from gooddata_api_client.model.declarative_notification_channel_identifier import (
     DeclarativeNotificationChannelIdentifier,
@@ -114,3 +117,13 @@ class CatalogNotificationChannelIdentifier(Base):
     @staticmethod
     def client_class() -> builtins.type[DeclarativeNotificationChannelIdentifier]:
         return DeclarativeNotificationChannelIdentifier
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDeclarativeAnalyticalDashboardIdentifier(Base):
+    id: str
+    type: str = attr.field(validator=value_in_allowed)
+
+    @staticmethod
+    def client_class() -> builtins.type[DeclarativeAnalyticalDashboardIdentifier]:
+        return DeclarativeAnalyticalDashboardIdentifier

gooddata-sdk/gooddata_sdk/catalog/workspace/declarative_model/workspace/workspace.py

@@ -6,6 +6,7 @@
 from typing import Any, Optional
 
 import attr
+from gooddata_api_client.model.declarative_filter_view import DeclarativeFilterView
 from gooddata_api_client.model.declarative_user_data_filter import DeclarativeUserDataFilter
 from gooddata_api_client.model.declarative_user_data_filters import DeclarativeUserDataFilters
 from gooddata_api_client.model.declarative_workspace import DeclarativeWorkspace
@@ -17,6 +18,7 @@
 
 from gooddata_sdk.catalog.base import Base
 from gooddata_sdk.catalog.identifier import (
+    CatalogDeclarativeAnalyticalDashboardIdentifier,
     CatalogDeclarativeUserGroupIdentifier,
     CatalogUserIdentifier,
     CatalogWorkspaceIdentifier,
@@ -36,6 +38,7 @@
 LAYOUT_WORKSPACES_DIR = "workspaces"
 LAYOUT_WORKSPACES_DATA_FILTERS_DIR = "workspaces_data_filters"
 LAYOUT_USER_DATA_FILTERS_DIR = "user_data_filters"
+LAYOUT_FILTER_VIEWS_DIR = "filter_views"
 
 
 def get_workspace_folder(workspace_id: str, layout_organization_folder: Path) -> Path:
@@ -85,6 +88,7 @@ class CatalogDeclarativeWorkspace(Base):
     user_data_filters: list[CatalogDeclarativeUserDataFilter] = attr.field(factory=list)
     custom_application_settings: list[CatalogDeclarativeCustomApplicationSetting] = attr.field(factory=list)
     automations: list[CatalogDeclarativeAutomation] = attr.field(factory=list)
+    filter_views: list[CatalogDeclarativeFilterView] = attr.field(factory=list)
 
     @staticmethod
     def client_class() -> type[DeclarativeWorkspace]:
@@ -211,12 +215,13 @@ def load_from_disk(cls, workspaces_data_filter_file: Path) -> CatalogDeclarative
     @classmethod
     def from_dict(cls, data: dict[str, Any], camel_case: bool = True) -> CatalogDeclarativeWorkspaceDataFilter:
         """
-        :param data:    Data loaded for example from the file.
-        :param camel_case:  True if the variable names in the input
-                        data are serialized names as specified in the OpenAPI document.
-                        False if the variables names in the input data are python
-                        variable names in PEP-8 snake case.
-        :return:    CatalogDeclarativeWorkspaceDataFilter object.
+        Args:
+            data (dict[str, Any]): Data loaded, for example, from a file.
+            camel_case (bool): True if the variable names in the input data are serialized names as specified in the OpenAPI document.
+                               False if the variable names in the input data are Python variable names in PEP-8 snake case.
+
+        Returns:
+            CatalogDeclarativeWorkspaceDataFilter: CatalogDeclarativeWorkspaceDataFilter object.
         """
         declarative_workspace_data_filter = DeclarativeWorkspaceDataFilter.from_dict(data, camel_case)
         return cls.from_api(declarative_workspace_data_filter)
@@ -272,16 +277,73 @@ def load_from_disk(cls, user_data_filter_file: Path) -> CatalogDeclarativeUserDa
 
     @classmethod
     def from_dict(cls, data: dict[str, Any], camel_case: bool = True) -> CatalogDeclarativeUserDataFilter:
+        """
+        Args:
+            data (dict[str, Any]): Data loaded, for example, from a file.
+            camel_case (bool): True if the variable names in the input data are serialized names as specified in the OpenAPI document.
+                               False if the variable names in the input data are Python variable names in PEP-8 snake case.
+
+        Returns:
+            CatalogDeclarativeUserDataFilter: CatalogDeclarativeUserDataFilter object.
+        """
+        declarative_user_data_filter = DeclarativeUserDataFilter.from_dict(data, camel_case)
+        return cls.from_api(declarative_user_data_filter)
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDeclarativeFilterView(Base):
+    id: str
+    title: str
+    analytical_dashboard: Optional[CatalogDeclarativeAnalyticalDashboardIdentifier] = None
+    content: Optional[dict[str, Any]] = None
+    description: Optional[str] = None
+    is_default: Optional[bool] = None
+    tags: Optional[list[str]] = None
+    user: Optional[CatalogUserIdentifier] = None
+
+    @staticmethod
+    def client_class() -> type[DeclarativeFilterView]:
+        return DeclarativeFilterView
+
+    def store_to_disk(self, filter_views_folder: Path) -> None:
+        filter_view_file = filter_views_folder / f"{self.id}.yaml"
+        write_layout_to_file(filter_view_file, self.to_api().to_dict(camel_case=True))
+
+    @classmethod
+    def load_from_disk(cls, filter_view_file: Path) -> CatalogDeclarativeFilterView:
+        filter_view = read_layout_from_file(filter_view_file)
+        return CatalogDeclarativeFilterView.from_dict(filter_view, camel_case=True)
+
+    @classmethod
+    def store_filter_views_to_disk(
+        cls, filter_views: list[CatalogDeclarativeFilterView], layout_organization_folder: Path
+    ) -> None:
+        filter_views_folder = CatalogDeclarativeWorkspaces.filter_views_folder(layout_organization_folder)
+        create_directory(filter_views_folder)
+        for filter_view in filter_views:
+            filter_view.store_to_disk(filter_views_folder)
+
+    @classmethod
+    def load_filter_views_from_disk(cls, layout_organization_folder: Path) -> list[CatalogDeclarativeFilterView]:
+        filter_views_files = get_sorted_yaml_files(
+            CatalogDeclarativeWorkspaces.filter_views_folder(layout_organization_folder)
+        )
+        return [
+            CatalogDeclarativeFilterView.load_from_disk(filter_views_file) for filter_views_file in filter_views_files
+        ]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any], camel_case: bool = True) -> CatalogDeclarativeFilterView:
         """
         :param data:    Data loaded for example from the file.
         :param camel_case:  True if the variable names in the input
                         data are serialized names as specified in the OpenAPI document.
                         False if the variables names in the input data are python
                         variable names in PEP-8 snake case.
-        :return:    CatalogDeclarativeUserDataFilter object.
+        :return:    CatalogDeclarativeFilterView object.
         """
-        declarative_user_data_filter = DeclarativeUserDataFilter.from_dict(data, camel_case)
-        return cls.from_api(declarative_user_data_filter)
+        declarative_filter_view = DeclarativeFilterView.from_dict(data, camel_case)
+        return cls.from_api(declarative_filter_view)
 
 
 @attr.s(auto_attribs=True, kw_only=True)
@@ -305,6 +367,10 @@ def workspace_data_filters_folder(layout_organization_folder: Path) -> Path:
     def user_data_filters_folder(layout_organization_folder: Path) -> Path:
         return layout_organization_folder / LAYOUT_USER_DATA_FILTERS_DIR
 
+    @staticmethod
+    def filter_views_folder(layout_organization_folder: Path) -> Path:
+        return layout_organization_folder / LAYOUT_FILTER_VIEWS_DIR
+
     def store_to_disk(self, layout_organization_folder: Path) -> None:
         workspaces_folder = self.workspaces_folder(layout_organization_folder)
         workspaces_data_filters_folder = self.workspace_data_filters_folder(layout_organization_folder)

gooddata-sdk/gooddata_sdk/catalog/workspace/entity_model/filter_view.py

@@ -0,0 +1,146 @@
+# (C) 2024 GoodData Corporation
+from __future__ import annotations
+
+from typing import Any, Optional, Union
+
+import attr
+from gooddata_api_client.model.json_api_filter_view_in import JsonApiFilterViewIn
+from gooddata_api_client.model.json_api_filter_view_in_attributes import JsonApiFilterViewInAttributes
+from gooddata_api_client.model.json_api_filter_view_in_document import JsonApiFilterViewInDocument
+from gooddata_api_client.model.json_api_filter_view_in_relationships import JsonApiFilterViewInRelationships
+
+from gooddata_sdk.catalog.base import Base
+from gooddata_sdk.catalog.identifier import CatalogDeclarativeAnalyticalDashboardIdentifier, CatalogUserIdentifier
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogFilterViewDocument(Base):
+    data: CatalogFilterView
+
+    @staticmethod
+    def client_class() -> type[JsonApiFilterViewInDocument]:
+        return JsonApiFilterViewInDocument
+
+    def to_api(self) -> JsonApiFilterViewInDocument:
+        return JsonApiFilterViewInDocument(data=self.data.to_api())
+
+
+def _data_entity(value: Any) -> dict[str, Any]:
+    return {"data": value}
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogFilterView(Base):
+    id: Optional[str] = None
+    attributes: CatalogFilterViewAttributes
+    relationships: Optional[CatalogFilterViewRelationships] = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiFilterViewIn]:
+        return JsonApiFilterViewIn
+
+    @classmethod
+    def init(
+        cls,
+        filter_view_id: str,
+        content: dict[str, Any],
+        title: str,
+        are_relations_valid: Optional[bool] = None,
+        description: Optional[str] = None,
+        is_default: Optional[bool] = None,
+        tags: Optional[list[str]] = None,
+        user_id: Optional[str] = None,
+        analytical_dashboard_id: Optional[str] = None,
+    ) -> CatalogFilterView:
+        attributes = CatalogFilterViewAttributes(
+            content=content,
+            title=title,
+            are_relations_valid=are_relations_valid,
+            description=description,
+            is_default=is_default,
+            tags=tags,
+        )
+        relationships = CatalogFilterViewRelationships.create_user_analytical_dashboard_relationship(
+            user_id=user_id, analytical_dashboard_id=analytical_dashboard_id
+        )
+        return cls(id=filter_view_id, attributes=attributes, relationships=relationships)
+
+    def to_api(self) -> JsonApiFilterViewIn:
+        attributes = self.attributes.to_api()
+        relationships = self.relationships.to_api() if self.relationships is not None else None
+        return JsonApiFilterViewIn(id=self.id, attributes=attributes, relationships=relationships)
+
+    @property
+    def user_id(self) -> Union[str, None]:
+        if self.relationships and self.relationships.user:
+            return self.relationships.user["data"].id
+        return None
+
+    @property
+    def analytical_dashboard_id(self) -> Union[str, None]:
+        if self.relationships and self.relationships.analytical_dashboard:
+            return self.relationships.analytical_dashboard["data"].id
+        return None
+
+    def assign_user(self, user_id: str) -> None:
+        if self.relationships is None:
+            self.relationships = CatalogFilterViewRelationships.create_user_analytical_dashboard_relationship(
+                user_id=user_id
+            )
+        else:
+            self.relationships.user = _data_entity(CatalogUserIdentifier(id=user_id, type="user"))
+
+    def assign_analytical_dashboard(self, analytical_dashboard_id: str) -> None:
+        if self.relationships is None:
+            self.relationships = CatalogFilterViewRelationships.create_user_analytical_dashboard_relationship(
+                analytical_dashboard_id=analytical_dashboard_id
+            )
+        else:
+            self.relationships.analytical_dashboard = _data_entity(
+                CatalogDeclarativeAnalyticalDashboardIdentifier(id=analytical_dashboard_id, type="analyticalDashboard")
+            )
+
+    def clean_relationships(self) -> None:
+        if self.relationships is not None:
+            self.relationships.user = None
+            self.relationships.analytical_dashboard = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogFilterViewAttributes(Base):
+    content: dict[str, Any]
+    title: str
+    are_relations_valid: Optional[bool] = None
+    description: Optional[str] = None
+    is_default: Optional[bool] = None
+    tags: Optional[list[str]] = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiFilterViewInAttributes]:
+        return JsonApiFilterViewInAttributes
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogFilterViewRelationships(Base):
+    user: Optional[dict[str, CatalogUserIdentifier]] = None
+    analytical_dashboard: Optional[dict[str, CatalogDeclarativeAnalyticalDashboardIdentifier]] = None
+
+    @staticmethod
+    def client_class() -> type[JsonApiFilterViewInRelationships]:
+        return JsonApiFilterViewInRelationships
+
+    @classmethod
+    def create_user_analytical_dashboard_relationship(
+        cls, user_id: Optional[str] = None, analytical_dashboard_id: Optional[str] = None
+    ) -> CatalogFilterViewRelationships | None:
+        if user_id is None and analytical_dashboard_id is None:
+            return None
+        assignee_user = _data_entity(CatalogUserIdentifier(id=user_id, type="user")) if user_id else None
+        assignee_analytical_dashboard = (
+            _data_entity(
+                CatalogDeclarativeAnalyticalDashboardIdentifier(id=analytical_dashboard_id, type="analyticalDashboard")
+            )
+            if analytical_dashboard_id
+            else None
+        )
+        return cls(user=assignee_user, analytical_dashboard=assignee_analytical_dashboard)

gooddata-sdk/gooddata_sdk/catalog/workspace/entity_model/user_data_filter.py

@@ -91,13 +91,13 @@ def to_api(self, post: bool = False) -> Union[JsonApiUserDataFilterPostOptionalI
             return JsonApiUserDataFilterIn(id=self.id, attributes=attributes, relationships=relationships)
 
     @property
-    def user_id(self) -> str | None:
+    def user_id(self) -> Union[str, None]:
         if self.relationships and self.relationships.user:
             return self.relationships.user["data"].id
         return None
 
     @property
-    def user_group_id(self) -> str | None:
+    def user_group_id(self) -> Union[str, None]:
         if self.relationships and self.relationships.user_group:
             return self.relationships.user_group["data"].id
         return None