Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

GDGT-3353: Remove inline filters when their dashboard tab is deleted (#84145)

Will Fry25145b9c70fe
diff --git a/frontend/src/metabase/dashboard/actions/parameters.tsx b/frontend/src/metabase/dashboard/actions/parameters.tsx
index 57fe3760482..dbceb412e55 100644
--- a/frontend/src/metabase/dashboard/actions/parameters.tsx
+++ b/frontend/src/metabase/dashboard/actions/parameters.tsx
@@ -385,6 +385,108 @@ export function removeParameterAndReferences(
});
}
+/**
+ * Undoes `removeParameterAndReferences` for `parameterIds`, given the
+ * `originalParameters` from before the removal:
+ * - those parameters come back as they were, right after the parameter they
+ * originally followed, minus references to parameters that no longer exist
+ * - other parameters get back their references to them, and otherwise keep
+ * any changes made since, including their order, additions and removals
+ */
+export function restoreParametersAndReferences(
+ dispatch: Dispatch,
+ getState: GetState,
+ originalParameters: Parameter[],
+ parameterIds: ParameterId[],
+) {
+ const restoredIds = new Set(parameterIds);
+ const parametersToRestore = originalParameters.filter(({ id }) =>
+ restoredIds.has(id),
+ );
+
+ updateParameters(dispatch, getState, (parameters) => {
+ const nextParameters = parametersToRestore.reduce(
+ (result, parameter) =>
+ insertAfterOriginalPredecessor(result, parameter, originalParameters),
+ parameters.map((parameter) =>
+ restoreReferences(parameter, originalParameters, restoredIds),
+ ),
+ );
+
+ const nextIds = new Set(nextParameters.map(({ id }) => id));
+ return nextParameters.map((parameter) =>
+ restoredIds.has(parameter.id) && parameter.filteringParameters
+ ? {
+ ...parameter,
+ filteringParameters: parameter.filteringParameters.filter((id) =>
+ nextIds.has(id),
+ ),
+ }
+ : parameter,
+ );
+ });
+}
+
+/**
+ * Returns `parameters` with `parameter` inserted right after the nearest
+ * parameter that came before it in `originalParameters` and is still present,
+ * or at the start if there is none. Unchanged if `parameter` is already there.
+ */
+function insertAfterOriginalPredecessor(
+ parameters: Parameter[],
+ parameter: Parameter,
+ originalParameters: Parameter[],
+): Parameter[] {
+ const isPresent = (id: ParameterId) =>
+ parameters.some((current) => current.id === id);
+ if (isPresent(parameter.id)) {
+ return parameters;
+ }
+
+ const originalIndex = originalParameters.findIndex(
+ ({ id }) => id === parameter.id,
+ );
+ const predecessor = originalParameters
+ .slice(0, Math.max(originalIndex, 0))
+ .reverse()
+ .find(({ id }) => isPresent(id));
+ const insertAt = predecessor
+ ? parameters.findIndex(({ id }) => id === predecessor.id) + 1
+ : 0;
+
+ return [
+ ...parameters.slice(0, insertAt),
+ parameter,
+ ...parameters.slice(insertAt),
+ ];
+}
+
+/**
+ * Returns `parameter` with the references to `restoredIds` it had in
+ * `originalParameters` added back to its current ones.
+ */
+function restoreReferences(
+ parameter: Parameter,
+ originalParameters: Parameter[],
+ restoredIds: Set<ParameterId>,
+): Parameter {
+ const original = originalParameters.find(({ id }) => id === parameter.id);
+ const removedReferences = (original?.filteringParameters ?? []).filter((id) =>
+ restoredIds.has(id),
+ );
+ if (removedReferences.length === 0) {
+ return parameter;
+ }
+
+ return {
+ ...parameter,
+ filteringParameters: [
+ ...(parameter.filteringParameters ?? []),
+ ...removedReferences,
+ ],
+ };
+}
+
export const removeParameter = createThunkAction(
REMOVE_PARAMETER,
(parameterId: ParameterId) => (dispatch, getState) => {
diff --git a/frontend/src/metabase/dashboard/actions/tabs-thunks.ts b/frontend/src/metabase/dashboard/actions/tabs-thunks.ts
index 0bcfaef8f8f..4d91c91bcd3 100644
--- a/frontend/src/metabase/dashboard/actions/tabs-thunks.ts
+++ b/frontend/src/metabase/dashboard/actions/tabs-thunks.ts
@@ -1,17 +1,32 @@
+import { t } from "ttag";
+
import type { Dispatch, GetState } from "metabase/redux/store";
import { addUndo } from "metabase/redux/undo";
import { checkNotNull } from "metabase/utils/types";
import type { DashboardTabId } from "metabase-types/api";
import { trackCardMoved } from "../analytics";
-import { getDashCardById, getDashcards } from "../selectors";
+import {
+ getCurrentDashcards,
+ getDashCardById,
+ getDashboard,
+ getDashcards,
+ getTabs,
+} from "../selectors";
+import { hasInlineParameters } from "../utils";
-import { duplicateParameters } from "./parameters";
+import {
+ duplicateParameters,
+ removeParameterAndReferences,
+ restoreParametersAndReferences,
+} from "./parameters";
import type { MoveDashCardToTabPayload } from "./tabs";
import {
_moveDashCardToTab,
+ deleteTabAction,
duplicateTabAction,
takeTempTabId,
+ undoDeleteTabAction,
undoMoveDashCardToTab,
} from "./tabs";
import { getDashCardMoveToTabUndoMessage } from "./utils";
@@ -52,6 +67,53 @@ export const duplicateTab =
);
};
+let nextTabDeletionId = 1;
+
+/**
+ * Deletes a tab along with its cards and the inline filters on those cards,
+ * and offers an undo toast that brings all of them back. Throws if no tab
+ * with `tabId` exists.
+ */
+export const deleteTab =
+ (tabId: DashboardTabId | null) =>
+ (dispatch: Dispatch, getState: GetState) => {
+ const dashboard = checkNotNull(getDashboard(getState()));
+ const tabName = getTabs(getState()).find(({ id }) => id === tabId)?.name;
+ if (!tabName) {
+ throw Error(`deleteTab was called but no tab with id ${tabId} was found`);
+ }
+
+ const originalParameters = dashboard.parameters ?? [];
+ const inlineParameterIds = getCurrentDashcards(getState())
+ .filter((dashcard) => dashcard.dashboard_tab_id === tabId)
+ .flatMap((dashcard) =>
+ hasInlineParameters(dashcard) ? dashcard.inline_parameters : [],
+ );
+ inlineParameterIds.forEach((parameterId) =>
+ removeParameterAndReferences(dispatch, getState, parameterId),
+ );
+
+ const tabDeletionId = nextTabDeletionId++;
+ dispatch(deleteTabAction({ tabId, tabDeletionId }));
+
+ dispatch(
+ addUndo({
+ message: t`Deleted "${tabName}"`,
+ action: () => {
+ dispatch(undoDeleteTabAction({ tabDeletionId }));
+ if (inlineParameterIds.length > 0) {
+ restoreParametersAndReferences(
+ dispatch,
+ getState,
+ originalParameters,
+ inlineParameterIds,
+ );
+ }
+ },
+ }),
+ );
+ };
+
export const moveDashCardToTab =
({ destinationTabId, dashCardId }: MoveDashCardToTabPayload) =>
(dispatch: Dispatch, getState: GetState) => {
diff --git a/frontend/src/metabase/dashboard/actions/tabs.ts b/frontend/src/metabase/dashboard/actions/tabs.ts
index a9da083e9a3..7dbae643ff9 100644
--- a/frontend/src/metabase/dashboard/actions/tabs.ts
+++ b/frontend/src/metabase/dashboard/actions/tabs.ts
@@ -151,9 +151,9 @@ function _selectTab({
state.selectedTabId = tabId;
}
-export const deleteTab = createAction<DeleteTabPayload>(DELETE_TAB);
+export const deleteTabAction = createAction<DeleteTabPayload>(DELETE_TAB);
-export const undoDeleteTab =
+export const undoDeleteTabAction =
createAction<UndoDeleteTabPayload>(UNDO_DELETE_TAB);
export const renameTab = createAction<RenameTabPayload>(RENAME_TAB);
@@ -385,7 +385,7 @@ export const tabsReducer = createReducer<DashboardState>(
);
builder.addCase(
- deleteTab,
+ deleteTabAction,
(state, { type, payload: { tabId, tabDeletionId } }) => {
const { prevDash, prevTabs } = getPrevDashAndTabs({
state,
@@ -431,7 +431,7 @@ export const tabsReducer = createReducer<DashboardState>(
);
builder.addCase(
- undoDeleteTab,
+ undoDeleteTabAction,
(state, { type, payload: { tabDeletionId } }) => {
const { prevTabs } = getPrevDashAndTabs({ state });
const { tabId, removedDashCardIds } = state.tabDeletions[tabDeletionId];
diff --git a/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts b/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts
index 537ebfab084..f27ef58bd47 100644
--- a/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts
+++ b/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts
@@ -6,7 +6,10 @@ import {
createMockState,
createMockStoreDashboard,
} from "__support__/state";
+import { waitFor } from "__support__/ui";
import type { StoreDashcard } from "metabase/redux/store";
+import { performUndo } from "metabase/redux/undo";
+import { checkNotNull } from "metabase/utils/types";
import type {
DashCardDataMap,
Parameter,
@@ -26,10 +29,11 @@ import {
import { ORDERS, ORDERS_ID, PRODUCTS } from "metabase-types/api/mocks/presets";
import { TEST_DASHBOARD_STATE } from "../components/DashboardTabs/test-utils";
-import { getDashboard, getDashcards } from "../selectors";
+import { getDashboard, getDashcards, getTabs } from "../selectors";
+import { setDashboardAttributes } from "./core";
import { getIdFromSlug, moveTab, resetTempTabId, tabsReducer } from "./tabs";
-import { duplicateTab } from "./tabs-thunks";
+import { deleteTab, duplicateTab } from "./tabs-thunks";
const ORDERS_CARD = createMockCard({
id: 1,
@@ -335,6 +339,146 @@ describe("duplicateTab", () => {
});
});
+describe("deleteTab", () => {
+ const TAB_1_CARD_PARAMETER = createMockParameter({
+ id: "tab-1-card-filter",
+ name: "Tab 1 Card Filter",
+ type: "string/=",
+ sectionId: "string",
+ });
+ const FILTERED_DASHBOARD_PARAMETER = {
+ ...DASHBOARD_LEVEL_PARAMETER,
+ filteringParameters: [CARD_PARAMETER.id],
+ };
+ const PARAMETERS = [
+ FILTERED_DASHBOARD_PARAMETER,
+ TAB_1_CARD_PARAMETER,
+ CARD_PARAMETER,
+ ];
+
+ const TAB_3_CARD_PARAMETER = createMockParameter({
+ id: "tab-3-card-filter",
+ name: "Tab 3 Card Filter",
+ type: "string/=",
+ sectionId: "string",
+ });
+
+ function setupTabsWithCardFilters({ tabCount = 2 } = {}) {
+ const hasTab3 = tabCount === 3;
+ return setup({
+ parameters: hasTab3 ? [...PARAMETERS, TAB_3_CARD_PARAMETER] : PARAMETERS,
+ tabCount,
+ dashcards: [
+ createMockDashboardCard({
+ id: 1,
+ dashboard_tab_id: 1,
+ card_id: ORDERS_CARD.id,
+ card: ORDERS_CARD,
+ inline_parameters: [TAB_1_CARD_PARAMETER.id],
+ }),
+ createMockDashboardCard({
+ id: 2,
+ dashboard_tab_id: 2,
+ card_id: ORDERS_CARD.id,
+ card: ORDERS_CARD,
+ inline_parameters: [CARD_PARAMETER.id],
+ }),
+ ...(hasTab3
+ ? [
+ createMockDashboardCard({
+ id: 3,
+ dashboard_tab_id: 3,
+ card_id: ORDERS_CARD.id,
+ card: ORDERS_CARD,
+ inline_parameters: [TAB_3_CARD_PARAMETER.id],
+ }),
+ ]
+ : []),
+ ],
+ });
+ }
+
+ it("should remove card filters on the deleted tab and references to them (#78567)", () => {
+ const { store } = setupTabsWithCardFilters();
+
+ deleteTab(2)(store.dispatch, store.getState);
+
+ expect(getTabs(store.getState()).map(({ id }) => id)).toEqual([1]);
+ expect(getDashboard(store.getState())?.parameters).toEqual([
+ { ...DASHBOARD_LEVEL_PARAMETER, filteringParameters: [] },
+ TAB_1_CARD_PARAMETER,
+ ]);
+ });
+
+ it("should restore the tab and its card filters on undo", async () => {
+ const { store } = setupTabsWithCardFilters();
+
+ deleteTab(2)(store.dispatch, store.getState);
+ await waitFor(() => expect(store.getState().undo).toHaveLength(1));
+ const [undo] = store.getState().undo;
+ expect(undo.message).toBe('Deleted "Tab 2"');
+ store.dispatch(performUndo(undo.id));
+
+ expect(getTabs(store.getState()).map(({ id }) => id)).toEqual([1, 2]);
+ expect(getDashboard(store.getState())?.parameters).toEqual(PARAMETERS);
+ expect(getDashcards(store.getState())[2]).toMatchObject({
+ isRemoved: false,
+ inline_parameters: [CARD_PARAMETER.id],
+ });
+ });
+
+ it("should keep filter changes made between deleting and undoing", async () => {
+ const { store } = setupTabsWithCardFilters();
+ const addedParameter = createMockParameter({ id: "added-filter" });
+ const renamedParameter = { ...TAB_1_CARD_PARAMETER, name: "Renamed" };
+
+ deleteTab(2)(store.dispatch, store.getState);
+ store.dispatch(
+ setDashboardAttributes({
+ id: 1,
+ attributes: {
+ parameters: [
+ renamedParameter,
+ { ...DASHBOARD_LEVEL_PARAMETER, filteringParameters: [] },
+ addedParameter,
+ ],
+ },
+ }),
+ );
+ await waitFor(() => expect(store.getState().undo).toHaveLength(1));
+ store.dispatch(performUndo(store.getState().undo[0].id));
+
+ expect(getDashboard(store.getState())?.parameters).toEqual([
+ renamedParameter,
+ CARD_PARAMETER,
+ FILTERED_DASHBOARD_PARAMETER,
+ addedParameter,
+ ]);
+ });
+
+ it("should only restore the filters of the tab being undone", async () => {
+ const { store } = setupTabsWithCardFilters({ tabCount: 3 });
+
+ deleteTab(2)(store.dispatch, store.getState);
+ deleteTab(3)(store.dispatch, store.getState);
+ await waitFor(() => expect(store.getState().undo).toHaveLength(2));
+ const tab2Undo = store
+ .getState()
+ .undo.find(({ message }) => message === 'Deleted "Tab 2"');
+ store.dispatch(performUndo(checkNotNull(tab2Undo).id));
+
+ expect(getTabs(store.getState()).map(({ id }) => id)).toEqual([1, 2]);
+ expect(getDashboard(store.getState())?.parameters).toEqual(PARAMETERS);
+ });
+});
+
+type SetupOpts = {
+ parameters: Parameter[];
+ dashcards: StoreDashcard[];
+ dashcardData?: DashCardDataMap;
+ tabCount?: number;
+};
+
function createDashboardState({
parameters,
dashcards,
@@ -343,11 +487,8 @@ function createDashboardState({
.filter((dc) => dc.card_id != null)
.map((dc) => [dc.id, { [dc.card_id!]: null }]),
),
-}: {
- parameters: Parameter[];
- dashcards: StoreDashcard[];
- dashcardData?: DashCardDataMap;
-}) {
+ tabCount = 2,
+}: SetupOpts) {
return createMockDashboardState({
dashboardId: 1,
selectedTabId: 1,
@@ -356,10 +497,9 @@ function createDashboardState({
id: 1,
dashcards: dashcards.map((dc) => dc.id),
parameters,
- tabs: [
- createMockDashboardTab({ id: 1, name: "Tab 1" }),
- createMockDashboardTab({ id: 2, name: "Tab 2" }),
- ],
+ tabs: _.range(1, tabCount + 1).map((id) =>
+ createMockDashboardTab({ id, name: `Tab ${id}` }),
+ ),
}),
},
dashcards: _.indexBy(dashcards, "id"),
@@ -367,18 +507,10 @@ function createDashboardState({
});
}
-function setup({
- parameters,
- dashcards,
- dashcardData,
-}: {
- parameters: Parameter[];
- dashcards: StoreDashcard[];
- dashcardData?: DashCardDataMap;
-}) {
+function setup(opts: SetupOpts) {
const store = getMainStore(
createMockState({
- dashboard: createDashboardState({ parameters, dashcards, dashcardData }),
+ dashboard: createDashboardState(opts),
}),
);
diff --git a/frontend/src/metabase/dashboard/components/DashboardTabs/use-dashboard-tabs.ts b/frontend/src/metabase/dashboard/components/DashboardTabs/use-dashboard-tabs.ts
index 21721b49a4d..df37f72d8b2 100644
--- a/frontend/src/metabase/dashboard/components/DashboardTabs/use-dashboard-tabs.ts
+++ b/frontend/src/metabase/dashboard/components/DashboardTabs/use-dashboard-tabs.ts
@@ -1,13 +1,8 @@
import type { UniqueIdentifier } from "@dnd-kit/core";
-import { t } from "ttag";
import { trackTabDuplicated } from "metabase/dashboard/analytics";
import { useDashboardContext } from "metabase/dashboard/context";
-import { useDispatch } from "metabase/redux";
import type { SelectedTabId } from "metabase/redux/store";
-import { addUndo } from "metabase/redux/undo";
-
-let tabDeletionId = 1;
function isTabIdType(id: unknown): id is SelectedTabId {
return typeof id === "number" || id === null;
@@ -19,16 +14,13 @@ export function useDashboardTabs() {
tabs,
selectedTabId,
duplicateTab: duplicateTabAction,
- deleteTab: deleteTabAction,
- undoDeleteTab,
+ deleteTab: deleteTabById,
moveTab: moveTabAction,
selectTab,
renameTab,
createNewTab,
} = useDashboardContext();
- const dispatch = useDispatch();
-
const duplicateTab = (tabId: UniqueIdentifier | null) => {
if (!isTabIdType(tabId)) {
throw Error("duplicateTab was called but tab id is invalid");
@@ -45,19 +37,7 @@ export function useDashboardTabs() {
throw Error("deleteTab was called but tab id is invalid");
}
- const tabName = tabs.find(({ id }) => id === tabId)?.name;
- if (!tabName) {
- throw Error(`deleteTab was called but no tab with id ${tabId} was found`);
- }
- const id = tabDeletionId++;
-
- deleteTabAction({ tabId, tabDeletionId: id });
- dispatch(
- addUndo({
- message: t`Deleted "${tabName}"`,
- action: () => undoDeleteTab({ tabDeletionId: id }),
- }),
- );
+ deleteTabById(tabId);
};
const moveTab = (activeId: UniqueIdentifier, overId: UniqueIdentifier) =>
diff --git a/frontend/src/metabase/dashboard/context/context.redux.ts b/frontend/src/metabase/dashboard/context/context.redux.ts
index fee1a58c1fc..be7e860d491 100644
--- a/frontend/src/metabase/dashboard/context/context.redux.ts
+++ b/frontend/src/metabase/dashboard/context/context.redux.ts
@@ -44,12 +44,13 @@ import {
} from "metabase/dashboard/actions";
import {
createNewTab,
- deleteTab,
moveTab,
renameTab,
- undoDeleteTab,
} from "metabase/dashboard/actions/tabs";
-import { duplicateTab } from "metabase/dashboard/actions/tabs-thunks";
+import {
+ deleteTab,
+ duplicateTab,
+} from "metabase/dashboard/actions/tabs-thunks";
import { connect } from "metabase/redux";
import {
initialize,
@@ -169,7 +170,6 @@ export const mapDispatchToProps = {
moveTab,
renameTab,
selectTab,
- undoDeleteTab,
};
export const connector = connect(mapStateToProps, mapDispatchToProps, null, {