feat: custom favorite filter for dashboards, charts and saved queries

superset/charts/api.py

@@ -41,7 +41,7 @@
     ChartUpdateFailedError,
 )
 from superset.charts.commands.update import UpdateChartCommand
-from superset.charts.filters import ChartAllTextFilter, ChartFilter
+from superset.charts.filters import ChartAllTextFilter, ChartFavoriteFilter, ChartFilter
 from superset.charts.schemas import (
     CHART_SCHEMAS,
     ChartDataQueryContextSchema,
@@ -139,13 +139,17 @@ class ChartRestApi(BaseSupersetModelRestApi):
         "datasource_name",
         "datasource_type",
         "description",
+        "id",
         "owners",
         "slice_name",
         "viz_type",
     ]
     base_order = ("changed_on", "desc")
     base_filters = [["id", ChartFilter, lambda: []]]
-    search_filters = {"slice_name": [ChartAllTextFilter]}
+    search_filters = {
+        "id": [ChartFavoriteFilter],
+        "slice_name": [ChartAllTextFilter],
+    }
 
     # Will just affect _info endpoint
     edit_columns = ["slice_name"]

superset/charts/filters.py

@@ -24,6 +24,7 @@
 from superset.connectors.sqla.models import SqlaTable
 from superset.models.slice import Slice
 from superset.views.base import BaseFilter
+from superset.views.base_api import BaseFavoriteFilter
 
 
 class ChartAllTextFilter(BaseFilter):  # pylint: disable=too-few-public-methods
@@ -44,6 +45,16 @@ def apply(self, query: Query, value: Any) -> Query:
         )
 
 
+class ChartFavoriteFilter(BaseFavoriteFilter):  # pylint: disable=too-few-public-methods
+    """
+    Custom filter for the GET list that filters all charts that a user has favored
+    """
+
+    arg_name = "chart_is_fav"
+    class_name = "slice"
+    model = Slice
+
+
 class ChartFilter(BaseFilter):  # pylint: disable=too-few-public-methods
     def apply(self, query: Query, value: Any) -> Query:
         if security_manager.can_access_all_datasources():

superset/dashboards/api.py

@@ -40,7 +40,11 @@
     DashboardUpdateFailedError,
 )
 from superset.dashboards.commands.update import UpdateDashboardCommand
-from superset.dashboards.filters import DashboardFilter, DashboardTitleOrSlugFilter
+from superset.dashboards.filters import (
+    DashboardFavoriteFilter,
+    DashboardFilter,
+    DashboardTitleOrSlugFilter,
+)
 from superset.dashboards.schemas import (
     DashboardPostSchema,
     DashboardPutSchema,
@@ -142,8 +146,18 @@ class DashboardRestApi(BaseSupersetModelRestApi):
     ]
     edit_columns = add_columns
 
-    search_columns = ("dashboard_title", "slug", "owners", "published", "created_by")
-    search_filters = {"dashboard_title": [DashboardTitleOrSlugFilter]}
+    search_columns = (
+        "created_by",
+        "dashboard_title",
+        "id",
+        "owners",
+        "published",
+        "slug",
+    )
+    search_filters = {
+        "dashboard_title": [DashboardTitleOrSlugFilter],
+        "id": [DashboardFavoriteFilter],
+    }
     base_order = ("changed_on", "desc")
 
     add_model_schema = DashboardPostSchema()

superset/dashboards/filters.py

@@ -25,6 +25,7 @@
 from superset.models.dashboard import Dashboard
 from superset.models.slice import Slice
 from superset.views.base import BaseFilter, get_user_roles
+from superset.views.base_api import BaseFavoriteFilter
 
 
 class DashboardTitleOrSlugFilter(BaseFilter):  # pylint: disable=too-few-public-methods
@@ -43,6 +44,18 @@ def apply(self, query: Query, value: Any) -> Query:
         )
 
 
+class DashboardFavoriteFilter(
+    BaseFavoriteFilter
+):  # pylint: disable=too-few-public-methods
+    """
+    Custom filter for the GET list that filters all dashboards that a user has favored
+    """
+
+    arg_name = "dashboard_is_fav"
+    class_name = "Dashboard"
+    model = Dashboard
+
+
 class DashboardFilter(BaseFilter):  # pylint: disable=too-few-public-methods
     """
     List dashboards with the following criteria:

superset/models/sql_lab.py

@@ -182,6 +182,9 @@ class SavedQuery(Model, AuditMixinNullable, ExtraJSONMixin):
         backref=backref("saved_queries", cascade="all, delete-orphan"),
     )
 
+    def __repr__(self) -> str:
+        return str(self.label)
+
     @property
     def pop_tab_link(self) -> Markup:
         return Markup(

superset/queries/saved_queries/api.py

@@ -34,6 +34,7 @@
 )
 from superset.queries.saved_queries.filters import (
     SavedQueryAllTextFilter,
+    SavedQueryFavoriteFilter,
     SavedQueryFilter,
 )
 from superset.queries.saved_queries.schemas import (
@@ -96,7 +97,11 @@ class SavedQueryRestApi(BaseSupersetModelRestApi):
         "database.database_name",
     ]
 
-    search_filters = {"label": [SavedQueryAllTextFilter]}
+    search_columns = ["id", "label"]
+    search_filters = {
+        "id": [SavedQueryFavoriteFilter],
+        "label": [SavedQueryAllTextFilter],
+    }
 
     apispec_parameter_schemas = {
         "get_delete_ids_schema": get_delete_ids_schema,

superset/queries/saved_queries/filters.py

@@ -24,6 +24,7 @@
 
 from superset.models.sql_lab import SavedQuery
 from superset.views.base import BaseFilter
+from superset.views.base_api import BaseFavoriteFilter
 
 
 class SavedQueryAllTextFilter(BaseFilter):  # pylint: disable=too-few-public-methods
@@ -44,6 +45,19 @@ def apply(self, query: Query, value: Any) -> Query:
         )
 
 
+class SavedQueryFavoriteFilter(
+    BaseFavoriteFilter
+):  # pylint: disable=too-few-public-methods
+    """
+    Custom filter for the GET list that filters all saved queries that a user has
+    favored
+    """
+
+    arg_name = "saved_query_is_fav"
+    class_name = "query"
+    model = SavedQuery
+
+
 class SavedQueryFilter(BaseFilter):  # pylint: disable=too-few-public-methods
     def apply(self, query: BaseQuery, value: Any) -> BaseQuery:
         """

superset/views/base_api.py

@@ -20,15 +20,22 @@
 
 from apispec import APISpec
 from apispec.exceptions import DuplicateComponentNameError
-from flask import Blueprint, Response
+from flask import Blueprint, g, Response
 from flask_appbuilder import AppBuilder, ModelRestApi
 from flask_appbuilder.api import expose, protect, rison, safe
 from flask_appbuilder.models.filters import BaseFilter, Filters
 from flask_appbuilder.models.sqla.filters import FilterStartsWith
 from flask_appbuilder.models.sqla.interface import SQLAInterface
+from flask_babel import lazy_gettext as _
 from marshmallow import fields, Schema
-from sqlalchemy import distinct, func
-
+from sqlalchemy import and_, distinct, func
+from sqlalchemy.orm.query import Query
+
+from superset.extensions import db, security_manager
+from superset.models.core import FavStar
+from superset.models.dashboard import Dashboard
+from superset.models.slice import Slice
+from superset.sql_lab import Query as SqllabQuery
 from superset.stats_logger import BaseStatsLogger
 from superset.typing import FlaskResponse
 from superset.utils.core import time_function
@@ -84,6 +91,31 @@ def __init__(self, field_name: str, filter_class: Type[BaseFilter]):
         self.filter_class = filter_class
 
 
+class BaseFavoriteFilter(BaseFilter):  # pylint: disable=too-few-public-methods
+    """
+    Base Custom filter for the GET list that filters all dashboards, slices
+    that a user has favored or not
+    """
+
+    name = _("Is favorite")
+    arg_name = ""
+    class_name = ""
+    """ The FavStar class_name to user """
+    model: Type[Union[Dashboard, Slice, SqllabQuery]] = Dashboard
+    """ The SQLAlchemy model """
+
+    def apply(self, query: Query, value: Any) -> Query:
+        # If anonymous user filter nothing
+        if security_manager.current_user is None:
+            return query
+        users_favorite_query = db.session.query(FavStar.obj_id).filter(
+            and_(FavStar.user_id == g.user.id, FavStar.class_name == self.class_name)
+        )
+        if value:
+            return query.filter(and_(self.model.id.in_(users_favorite_query)))
+        return query.filter(and_(~self.model.id.in_(users_favorite_query)))
+
+
 class BaseSupersetModelRestApi(ModelRestApi):
     """
     Extends FAB's ModelResApi to implement specific superset generic functionality

tests/charts/api_tests.py

@@ -24,12 +24,14 @@
 import humanize
 import prison
 import pytest
+from sqlalchemy import and_
 from sqlalchemy.sql import func
 
 from superset.utils.core import get_example_database
 from tests.test_app import app
 from superset.connectors.connector_registry import ConnectorRegistry
 from superset.extensions import db, security_manager
+from superset.models.core import FavStar
 from superset.models.dashboard import Dashboard
 from superset.models.slice import Slice
 from superset.utils import core as utils
@@ -38,6 +40,7 @@
 from tests.fixtures.query_context import get_query_context
 
 CHART_DATA_URI = "api/v1/chart/data"
+CHARTS_FIXTURE_COUNT = 10
 
 
 class TestChartApi(SupersetTestCase, ApiOwnersTestCaseMixin):
@@ -76,6 +79,30 @@ def insert_chart(
         db.session.commit()
         return slice
 
+    @pytest.fixture()
+    def create_charts(self):
+        with self.create_app().app_context():
+            charts = []
+            admin = self.get_user("admin")
+            for cx in range(CHARTS_FIXTURE_COUNT - 1):
+                charts.append(self.insert_chart(f"name{cx}", [admin.id], 1))
+            fav_charts = []
+            for cx in range(round(CHARTS_FIXTURE_COUNT / 2)):
+                fav_star = FavStar(
+                    user_id=admin.id, class_name="slice", obj_id=charts[cx].id
+                )
+                db.session.add(fav_star)
+                db.session.commit()
+                fav_charts.append(fav_star)
+            yield charts
+
+            # rollback changes
+            for chart in charts:
+                db.session.delete(chart)
+            for fav_chart in fav_charts:
+                db.session.delete(fav_chart)
+            db.session.commit()
+
     def test_delete_chart(self):
         """
         Chart API: Test delete
@@ -656,6 +683,53 @@ def test_get_charts_custom_filter(self):
         db.session.delete(chart5)
         db.session.commit()
 
+    @pytest.mark.usefixtures("create_charts")
+    def test_get_charts_favorite_filter(self):
+        """
+        Chart API: Test get charts favorite filter
+        """
+        admin = self.get_user("admin")
+        users_favorite_query = db.session.query(FavStar.obj_id).filter(
+            and_(FavStar.user_id == admin.id, FavStar.class_name == "slice")
+        )
+        expected_models = (
+            db.session.query(Slice)
+            .filter(and_(Slice.id.in_(users_favorite_query)))
+            .order_by(Slice.slice_name.asc())
+            .all()
+        )
+
+        arguments = {
+            "filters": [{"col": "id", "opr": "chart_is_fav", "value": True}],
+            "order_column": "slice_name",
+            "order_direction": "asc",
+            "keys": ["none"],
+            "columns": ["slice_name"],
+        }
+        self.login(username="admin")
+        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        rv = self.client.get(uri)
+        data = json.loads(rv.data.decode("utf-8"))
+        assert rv.status_code == 200
+        assert len(expected_models) == data["count"]
+
+        for i, expected_model in enumerate(expected_models):
+            assert expected_model.slice_name == data["result"][i]["slice_name"]
+
+        # Test not favorite charts
+        expected_models = (
+            db.session.query(Slice)
+            .filter(and_(~Slice.id.in_(users_favorite_query)))
+            .order_by(Slice.slice_name.asc())
+            .all()
+        )
+        arguments["filters"][0]["value"] = False
+        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        rv = self.client.get(uri)
+        data = json.loads(rv.data.decode("utf-8"))
+        assert rv.status_code == 200
+        assert len(expected_models) == data["count"]
+
     def test_get_charts_page(self):
         """
         Chart API: Test get charts filter