The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
Fix broken duplication of inline dashboard filters (#78549)
Kevin Kelleher6e9d52021cc6
diff --git a/frontend/src/metabase/dashboard/actions/cards.unit.spec.ts b/frontend/src/metabase/dashboard/actions/cards.unit.spec.tsindex e7920c41ef3..f8f4a4bd9ef 100644--- a/frontend/src/metabase/dashboard/actions/cards.unit.spec.ts+++ b/frontend/src/metabase/dashboard/actions/cards.unit.spec.ts@@ -19,6 +19,7 @@ import type {DashCardId,Dashboard,DashboardTabId,+ QuestionDashboardCard,} from "metabase-types/api";import {createMockCard,@@ -48,6 +49,7 @@ import type { AddCardToDashboardOpts } from "./cards-typed";import {addCardToDashboard,addSectionToDashboard,+ duplicateCard,replaceCard,} from "./cards-typed";@@ -295,6 +297,92 @@ describe("dashboard/actions/cards", () => {expect(nextDashCard.parameter_mappings).toEqual([]);});});++ describe("duplicateCard", () => {+ it("should duplicate inline parameters including settings like default and required", async () => {+ const cardParameter = createMockParameter({+ id: "card-filter",+ name: "Card Filter",+ type: "number/=",+ sectionId: "number",+ default: [10],+ required: true,+ isMultiSelect: false,+ });+ const questionDashcard = createMockDashboardCard({+ id: 10,+ card_id: ORDERS_TABLE_CARD.id,+ card: ORDERS_TABLE_CARD,+ inline_parameters: [cardParameter.id],+ parameter_mappings: [+ {+ card_id: ORDERS_TABLE_CARD.id,+ parameter_id: cardParameter.id,+ target: [+ "dimension",+ ["field", ORDERS.QUANTITY, { "base-type": "type/Integer" }],+ ],+ },+ ],+ });+ const dashboard = createMockDashboard({+ id: 1,+ dashcards: [questionDashcard],+ parameters: [cardParameter],+ });++ const { store } = setup({+ dashboard,+ dashcards: [questionDashcard],+ });++ await duplicateCard({ id: questionDashcard.id })(+ store.dispatch,+ store.getState,+ );++ const nextState = store.getState();+ const nextDashboard = getDashboardById(nextState, dashboard.id);+ const duplicatedDashcardId = nextDashboard.dashcards.find(+ (dashcardId) => dashcardId !== questionDashcard.id,+ );+ expect(duplicatedDashcardId).toBeDefined();++ // question is a QuestionDashboardCard+ const duplicatedDashcard = getDashCardById(+ nextState,+ duplicatedDashcardId!,+ ) as QuestionDashboardCard;+ expect(duplicatedDashcard.inline_parameters).toHaveLength(1);++ const newParameterId = duplicatedDashcard.inline_parameters![0];+ expect(newParameterId).not.toBe(cardParameter.id);+ expect(duplicatedDashcard.parameter_mappings).toEqual([+ expect.objectContaining({ parameter_id: newParameterId }),+ ]);++ const newParameter = nextDashboard.parameters?.find(+ (parameter) => parameter.id === newParameterId,+ );+ expect(newParameter).toMatchObject({+ name: "Card Filter 1",+ default: [10],+ required: true,+ isMultiSelect: false,+ });++ // Original card still references the original parameter+ expect(+ // question is a QuestionDashboardCard+ (+ getDashCardById(+ nextState,+ questionDashcard.id,+ ) as QuestionDashboardCard+ ).inline_parameters,+ ).toEqual([cardParameter.id]);+ });+ });});type RunAddSectionOpts = SetupOpts & {diff --git a/frontend/src/metabase/dashboard/actions/parameters.tsx b/frontend/src/metabase/dashboard/actions/parameters.tsxindex ff851abb3b8..0fcf42442e1 100644--- a/frontend/src/metabase/dashboard/actions/parameters.tsx+++ b/frontend/src/metabase/dashboard/actions/parameters.tsx@@ -139,7 +139,10 @@ export function duplicateParameters(getState: GetState,parameterIds: ParameterId[],) {- const parameters = getParameters(getState());+ // getParameters returns UiParameters, which are not serializable+ // so the duplicated parameter will throw on save. we need dashboard.parameters instead+ const dashboard = getDashboard(getState());+ const parameters = dashboard?.parameters ?? [];const newParameters = parameterIds.map((parameterId) => {const parameter = parameters.find((p) => p.id === parameterId);diff --git a/frontend/src/metabase/dashboard/actions/tabs.ts b/frontend/src/metabase/dashboard/actions/tabs.tsindex f93efb22a7c..f444fcd2081 100644--- a/frontend/src/metabase/dashboard/actions/tabs.ts+++ b/frontend/src/metabase/dashboard/actions/tabs.ts@@ -23,16 +23,18 @@ import type {DashCardId,DashboardId,DashboardTabId,+ ParameterId,} from "metabase-types/api";import { trackCardMoved } from "../analytics";import { INITIAL_DASHBOARD_STATE } from "../constants";-import { getDashCardById } from "../selectors";+import { getDashCardById, getDashcards } from "../selectors";import {calculateDashCardRowAfterUndo,generateTemporaryDashcardId,} from "../utils";+import { duplicateParameters } from "./parameters";import { getDashCardMoveToTabUndoMessage, getExistingDashCards } from "./utils";type CreateNewTabPayload = {@@ -41,6 +43,7 @@ type CreateNewTabPayload = {type DuplicateTabPayload = {sourceTabId: DashboardTabId | null;newTabId: DashboardTabId;+ sourceToNewParameterIdMap: Record<ParameterId, ParameterId>;};type DeleteTabPayload = {tabId: DashboardTabId | null;@@ -138,13 +141,35 @@ export function createNewTab() {const duplicateTabAction = createAction<DuplicateTabPayload>(DUPLICATE_TAB);-export function duplicateTab(sourceTabId: DashboardTabId | null) {- // Decrement by 2 to leave space for two new tabs if dash doesn't have tabs already- const newTabId = tempTabId;- tempTabId -= 2;+export const duplicateTab =+ (sourceTabId: DashboardTabId | null) =>+ (dispatch: Dispatch, getState: GetState) => {+ // Decrement by 2 to leave space for two new tabs if dash doesn't have tabs already+ const newTabId = tempTabId;+ tempTabId -= 2;- return duplicateTabAction({ sourceTabId, newTabId });-}+ const sourceTabDashCards = Object.values(getDashcards(getState())).filter(+ (dashcard) => dashcard.dashboard_tab_id === sourceTabId,+ );+ const sourceParameters = sourceTabDashCards.flatMap((dashcard) =>+ "inline_parameters" in dashcard ? (dashcard.inline_parameters ?? []) : [],+ );+ const newParameters = duplicateParameters(+ dispatch,+ getState,+ sourceParameters,+ );+ const sourceToNewParameterIdMap = Object.fromEntries(+ sourceParameters.map((parameter, index) => [+ parameter,+ newParameters[index].id,+ ]),+ );++ dispatch(+ duplicateTabAction({ sourceTabId, newTabId, sourceToNewParameterIdMap }),+ );+ };function _selectTab({state,@@ -302,7 +327,10 @@ export const tabsReducer = createReducer<DashboardState>(builder.addCase<typeof duplicateTabAction>(duplicateTabAction,- (state, { type, payload: { sourceTabId, newTabId } }) => {+ (+ state,+ { type, payload: { sourceTabId, newTabId, sourceToNewParameterIdMap } },+ ) => {const { dashId, prevDash, prevTabs } = getPrevDashAndTabs({ state });if (!dashId || !prevDash) {throw new Error(@@ -353,13 +381,49 @@ export const tabsReducer = createReducer<DashboardState>(prevDash.dashcards.push(newDashCardId);- state.dashcards[newDashCardId] = {+ const newDashCard = {...sourceDashCard,id: newDashCardId,dashboard_tab_id: newTabId,isDirty: true,};+ if (+ "inline_parameters" in newDashCard &&+ newDashCard.inline_parameters+ ) {+ newDashCard.inline_parameters = newDashCard.inline_parameters.map(+ (parameterId) => {+ const newParameterId = sourceToNewParameterIdMap[parameterId];+ if (newParameterId == null) {+ // Should never happen: the thunk builds this map from the same+ // source tab's inline parameters. Fall back rather than abort+ // the whole tab duplication.+ console.warn(+ `Missing mapping for inline parameter ${parameterId} when duplicating tab; keeping original id`,+ );+ return parameterId;+ }+ return newParameterId;+ },+ );+ }++ if (newDashCard.parameter_mappings) {+ newDashCard.parameter_mappings = newDashCard.parameter_mappings.map(+ (mapping) => ({+ ...mapping,+ parameter_id:+ // sourceToNewParameterIdMap has inline parameters only+ // so we need to fallback to the original mapping for dashboard level parameters+ sourceToNewParameterIdMap[mapping.parameter_id] ??+ mapping.parameter_id,+ }),+ );+ }++ state.dashcards[newDashCardId] = newDashCard;+// We don't have card (question) data for virtual dashcards (text, heading, link, action)if (isVirtualDashCard(sourceDashCard as StoreDashcard)) {return;diff --git a/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts b/frontend/src/metabase/dashboard/actions/tabs.unit.spec.tsindex 39f985d6c55..32330ef00bd 100644--- a/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts+++ b/frontend/src/metabase/dashboard/actions/tabs.unit.spec.ts@@ -1,6 +1,77 @@+import _ from "underscore";++import { getMainStore } from "__support__/entities-store";+import type { StoreDashcard } from "metabase/redux/store";+import {+ createMockDashboardState,+ createMockState,+ createMockStoreDashboard,+} from "metabase/redux/store/mocks";+import type {+ Parameter,+ QuestionDashboardCard,+ VirtualDashboardCard,+} from "metabase-types/api";+import {+ createMockCard,+ createMockDashboardCard,+ createMockDashboardTab,+ createMockHeadingDashboardCard,+ createMockParameter,+ createMockParameterMapping,+ createMockStructuredDatasetQuery,+} from "metabase-types/api/mocks";+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 {+ duplicateTab,+ getIdFromSlug,+ moveTab,+ resetTempTabId,+ tabsReducer,+} from "./tabs";++const ORDERS_CARD = createMockCard({+ id: 1,+ dataset_query: createMockStructuredDatasetQuery({+ query: { "source-table": ORDERS_ID },+ }),+});++const DASHBOARD_LEVEL_PARAMETER = createMockParameter({+ id: "dashboard-filter",+ name: "Dashboard Filter",+ type: "string/=",+ sectionId: "string",+});-import { getIdFromSlug, moveTab, tabsReducer } from "./tabs";+const HEADER_PARAMETER = createMockParameter({+ id: "header-filter",+ name: "Header Filter",+ type: "string/=",+ sectionId: "string",+ default: ["Gadget"],+ required: true,+});++const CARD_PARAMETER = createMockParameter({+ id: "card-filter",+ name: "Card Filter",+ type: "number/=",+ sectionId: "number",+ default: [10],+ required: true,+});++const dimensionTarget = (+ fieldId: number,+): ["dimension", ["field", number, { "base-type": string }]] => [+ "dimension",+ ["field", fieldId, { "base-type": "type/Text" }],+];/*** It's preferred to write tests in `DashboardTabs.unit.spec.tsx`,@@ -29,3 +100,225 @@ describe("getIdFromSlug", () => {expect(getIdFromSlug("tab-name")).toEqual(undefined);});});++describe("duplicateTab", () => {+ beforeEach(() => {+ resetTempTabId();+ });++ it("should duplicate header filters with new ids and remapped card mappings (#77002)", () => {+ const headingDashcard = createMockHeadingDashboardCard({+ id: 1,+ dashboard_tab_id: 1,+ inline_parameters: [HEADER_PARAMETER.id],+ });+ const questionDashcard = createMockDashboardCard({+ id: 2,+ dashboard_tab_id: 1,+ card_id: ORDERS_CARD.id,+ card: ORDERS_CARD,+ parameter_mappings: [+ createMockParameterMapping({+ parameter_id: HEADER_PARAMETER.id,+ card_id: ORDERS_CARD.id,+ target: dimensionTarget(PRODUCTS.CATEGORY),+ }),+ ],+ });++ const { store } = setup({+ parameters: [HEADER_PARAMETER],+ dashcards: [headingDashcard, questionDashcard],+ });++ duplicateTab(1)(store.dispatch, store.getState);++ const state = store.getState();+ const dashboard = getDashboard(state);+ const dashcards = Object.values(getDashcards(state));+ const newTabId = -2;++ const duplicatedHeading = dashcards.find(+ (dc) =>+ dc.dashboard_tab_id === newTabId &&+ "inline_parameters" in dc &&+ dc.card.display === "heading",+ );+ const duplicatedQuestion = dashcards.find(+ (dc) => dc.dashboard_tab_id === newTabId && dc.card_id === ORDERS_CARD.id,+ );++ expect(duplicatedHeading).toBeDefined();+ expect(duplicatedQuestion).toBeDefined();++ // heading dashcard is a VirtualDashboardCard+ const newHeaderParameterId = (duplicatedHeading as VirtualDashboardCard)+ .inline_parameters![0];+ expect(newHeaderParameterId).not.toBe(HEADER_PARAMETER.id);++ const newHeaderParameter = dashboard?.parameters?.find(+ (parameter) => parameter.id === newHeaderParameterId,+ );+ expect(newHeaderParameter).toMatchObject({+ name: "Header Filter 1",+ default: ["Gadget"],+ required: true,+ });++ expect(duplicatedQuestion!.parameter_mappings).toEqual([+ expect.objectContaining({+ parameter_id: newHeaderParameterId,+ card_id: ORDERS_CARD.id,+ }),+ ]);++ // Source tab still references the original parameter+ expect(headingDashcard.inline_parameters).toEqual([HEADER_PARAMETER.id]);+ expect(getDashcards(state)[questionDashcard.id].parameter_mappings).toEqual(+ [expect.objectContaining({ parameter_id: HEADER_PARAMETER.id })],+ );+ });++ it("should duplicate card filters independently from the source tab", () => {+ const questionDashcard = createMockDashboardCard({+ id: 1,+ dashboard_tab_id: 1,+ card_id: ORDERS_CARD.id,+ card: ORDERS_CARD,+ inline_parameters: [CARD_PARAMETER.id],+ parameter_mappings: [+ createMockParameterMapping({+ parameter_id: CARD_PARAMETER.id,+ card_id: ORDERS_CARD.id,+ target: dimensionTarget(ORDERS.QUANTITY),+ }),+ ],+ });++ const { store } = setup({+ parameters: [CARD_PARAMETER],+ dashcards: [questionDashcard],+ });++ duplicateTab(1)(store.dispatch, store.getState);++ const state = store.getState();+ const dashboard = getDashboard(state);+ const newTabId = -2;+ // question is a QuestionDashboardCard+ const duplicatedQuestion = Object.values(getDashcards(state)).find(+ (dc) => dc.dashboard_tab_id === newTabId && dc.card_id === ORDERS_CARD.id,+ ) as QuestionDashboardCard;++ expect(duplicatedQuestion).toBeDefined();+ expect(duplicatedQuestion.inline_parameters).toHaveLength(1);++ const newCardParameterId = duplicatedQuestion.inline_parameters![0];+ expect(newCardParameterId).not.toBe(CARD_PARAMETER.id);+ expect(duplicatedQuestion!.parameter_mappings).toEqual([+ expect.objectContaining({ parameter_id: newCardParameterId }),+ ]);++ const newCardParameter = dashboard?.parameters?.find(+ (parameter) => parameter.id === newCardParameterId,+ );+ expect(newCardParameter).toMatchObject({+ name: "Card Filter 1",+ default: [10],+ required: true,+ });++ // Original card still uses the original parameter id+ expect(+ // question is a QuestionDashboardCard+ (getDashcards(state)[questionDashcard.id] as QuestionDashboardCard)+ .inline_parameters,+ ).toEqual([CARD_PARAMETER.id]);+ });++ it("should keep dashboard-level parameter mappings pointing at the original parameter", () => {+ const questionDashcard = createMockDashboardCard({+ id: 1,+ dashboard_tab_id: 1,+ card_id: ORDERS_CARD.id,+ card: ORDERS_CARD,+ parameter_mappings: [+ createMockParameterMapping({+ parameter_id: DASHBOARD_LEVEL_PARAMETER.id,+ card_id: ORDERS_CARD.id,+ target: dimensionTarget(PRODUCTS.CATEGORY),+ }),+ ],+ });++ const { store } = setup({+ parameters: [DASHBOARD_LEVEL_PARAMETER],+ dashcards: [questionDashcard],+ });++ duplicateTab(1)(store.dispatch, store.getState);++ const newTabId = -2;+ const duplicatedQuestion = Object.values(+ getDashcards(store.getState()),+ ).find(+ (dc) => dc.dashboard_tab_id === newTabId && dc.card_id === ORDERS_CARD.id,+ );++ expect(duplicatedQuestion!.parameter_mappings).toEqual([+ expect.objectContaining({+ parameter_id: DASHBOARD_LEVEL_PARAMETER.id,+ }),+ ]);+ // dashboard level parameters should not be duplicated+ expect(getDashboard(store.getState())?.parameters).toEqual([+ DASHBOARD_LEVEL_PARAMETER,+ ]);+ });+});++function createDashboardState({+ parameters,+ dashcards,+}: {+ parameters: Parameter[];+ dashcards: StoreDashcard[];+}) {+ return createMockDashboardState({+ dashboardId: 1,+ selectedTabId: 1,+ dashboards: {+ 1: createMockStoreDashboard({+ id: 1,+ dashcards: dashcards.map((dc) => dc.id),+ parameters,+ tabs: [+ createMockDashboardTab({ id: 1, name: "Tab 1" }),+ createMockDashboardTab({ id: 2, name: "Tab 2" }),+ ],+ }),+ },+ dashcards: _.indexBy(dashcards, "id"),+ dashcardData: Object.fromEntries(+ dashcards+ .filter((dc) => dc.card_id != null)+ .map((dc) => [dc.id, { [dc.card_id!]: null }]),+ ),+ });+}++function setup({+ parameters,+ dashcards,+}: {+ parameters: Parameter[];+ dashcards: StoreDashcard[];+}) {+ const store = getMainStore(+ createMockState({+ dashboard: createDashboardState({ parameters, dashcards }),+ }),+ );++ return { store };+}diff --git a/frontend/src/metabase/parameters/utils/dashboards.ts b/frontend/src/metabase/parameters/utils/dashboards.tsindex 37dd03a492e..32f2e21c46b 100644--- a/frontend/src/metabase/parameters/utils/dashboards.ts+++ b/frontend/src/metabase/parameters/utils/dashboards.ts@@ -34,7 +34,8 @@ type ExtendedMapping = DashboardParameterMapping & {card: Card;};-export type NewParameterOpts = Pick<Parameter, "name" | "type" | "sectionId">;+export type NewParameterOpts = Pick<Parameter, "name" | "type"> &+ Partial<Omit<Parameter, "name" | "type">>;export function createParameter(opts: NewParameterOpts,@@ -58,11 +59,10 @@ export function createParameter(}const parameter: Parameter = {+ ...opts,name: "",slug: "",id: generateParameterId(),- type: opts.type,- sectionId: opts.sectionId,};return setParameterName(parameter, name);diff --git a/frontend/src/metabase/parameters/utils/dashboards.unit.spec.tsx b/frontend/src/metabase/parameters/utils/dashboards.unit.spec.tsxindex f78a10ae065..343179a6d6a 100644--- a/frontend/src/metabase/parameters/utils/dashboards.unit.spec.tsx+++ b/frontend/src/metabase/parameters/utils/dashboards.unit.spec.tsx@@ -92,6 +92,37 @@ describe("metabase/parameters/utils/dashboards", () => {type: "category",});});++ it("should preserve parameter settings when duplicating", () => {+ expect(+ createParameter(+ {+ name: "Category",+ type: "string/=",+ sectionId: "string",+ default: ["Gadget"],+ required: true,+ isMultiSelect: false,+ values_query_type: "list",+ values_source_type: "static-list",+ values_source_config: { values: ["Gadget", "Widget"] },+ },+ [],+ ),+ ).toEqual({+ id: expect.any(String),+ name: "Category",+ slug: "category",+ type: "string/=",+ sectionId: "string",+ default: ["Gadget"],+ required: true,+ isMultiSelect: false,+ values_query_type: "list",+ values_source_type: "static-list",+ values_source_config: { values: ["Gadget", "Widget"] },+ });+ });});describe("setParameterName", () => {