You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by di...@apache.org on 2025/07/08 15:37:54 UTC
(superset) branch master updated: feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)
This is an automated email from the ASF dual-hosted git repository.
diegopucci pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/superset.git
The following commit(s) were added to refs/heads/master by this push:
new 85034b9748 feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)
85034b9748 is described below
commit 85034b9748c50a08b8d9b710db8408b68f49a95c
Author: Richard Fogaca Nienkotter <63...@users.noreply.github.com>
AuthorDate: Tue Jul 8 12:37:47 2025 -0300
feat(deck-gl): Enable individual deck.gl layer selection in FilterScope tree (#33769)
Co-authored-by: richardfn <ri...@appsilon.com>
Co-authored-by: amaannawab923 <am...@gmail.com>
---
CONTRIBUTING.md | 2 +-
.../legacy-preset-chart-deckgl/src/Multi/Multi.tsx | 223 ++++++--
.../components/SyncDashboardState/index.tsx | 12 +-
.../components/nativeFilters/FilterBar/index.tsx | 8 +-
.../FiltersConfigForm/FilterScope/ScopingTree.tsx | 118 +++-
.../FiltersConfigForm/FilterScope/state.ts | 21 +-
.../FiltersConfigForm/FilterScope/types.ts | 4 +
.../FiltersConfigForm/FilterScope/utils.ts | 179 +++++-
.../dashboard/components/nativeFilters/utils.ts | 163 ++++++
superset-frontend/src/dashboard/types.ts | 7 +
.../dashboard/util/activeAllDashboardFilters.ts | 122 +++-
.../util/charts/getFormDataWithExtraFilters.ts | 97 +++-
.../src/dashboard/util/getChartIdsInFilterScope.ts | 55 +-
.../components/ExploreViewContainer/index.jsx | 24 +-
.../controls/FilterControl/AdhocFilter/index.js | 2 +
.../FilterControl/AdhocFilterEditPopover/index.jsx | 160 +++++-
.../getFormDataWithDashboardContext.ts | 95 +++-
superset-frontend/src/pages/Chart/index.tsx | 19 +-
.../src/types/DashboardContextForExplore.ts | 3 +-
superset-frontend/src/utils/simpleFilterToAdhoc.ts | 43 +-
superset/viz.py | 162 +++++-
tests/integration_tests/viz_tests.py | 614 +++++++++++++++++++++
22 files changed, 1959 insertions(+), 174 deletions(-)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5dbf90157f..06ed3b146c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,7 +5,7 @@
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
- with the License. You may obtain a copy of the License at
+ with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
diff --git a/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx b/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
index 153a3e7917..d11d5ae21f 100644
--- a/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
+++ b/superset-frontend/plugins/legacy-preset-chart-deckgl/src/Multi/Multi.tsx
@@ -22,11 +22,15 @@
import { memo, useCallback, useEffect, useRef, useState } from 'react';
import { isEqual } from 'lodash';
import {
+ AdhocFilter,
Datasource,
+ ensureIsArray,
HandlerFunction,
+ isDefined,
JsonObject,
JsonValue,
QueryFormData,
+ QueryObjectFilterClause,
SupersetClient,
usePrevious,
} from '@superset-ui/core';
@@ -107,70 +111,175 @@ const DeckMulti = (props: DeckMultiProps) => {
}
}, []);
+ const getLayerIndex = useCallback(
+ (sliceId: number, payloadIndex: number, deckSlices?: number[]): number =>
+ deckSlices ? deckSlices.indexOf(sliceId) : payloadIndex,
+ [],
+ );
+
+ const processLayerFilters = useCallback(
+ (
+ subslice: JsonObject,
+ formData: QueryFormData,
+ layerIndex: number,
+ ): {
+ extraFilters: (AdhocFilter | QueryObjectFilterClause)[];
+ adhocFilters: AdhocFilter[];
+ } => {
+ const layerFilterScope = formData.layer_filter_scope;
+
+ const extraFilters: (AdhocFilter | QueryObjectFilterClause)[] = [
+ ...(subslice.form_data.extra_filters || []),
+ ...(formData.extra_filters || []),
+ ];
+
+ const adhocFilters: AdhocFilter[] = [
+ ...(subslice.form_data?.adhoc_filters || []),
+ ];
+
+ if (layerFilterScope) {
+ const filterDataMapping = formData.filter_data_mapping || {};
+ let shouldAddDashboardAdhocFilters = false;
+
+ Object.entries(layerFilterScope).forEach(
+ ([filterId, filterScope]: [string, number[]]) => {
+ const shouldApplyFilter =
+ ensureIsArray(filterScope).includes(layerIndex);
+
+ if (shouldApplyFilter) {
+ shouldAddDashboardAdhocFilters = true;
+ const filtersFromThisFilter = filterDataMapping[filterId] || [];
+ extraFilters.push(...filtersFromThisFilter);
+ }
+ },
+ );
+
+ if (shouldAddDashboardAdhocFilters) {
+ const dashboardAdhocFilters = formData.adhoc_filters || [];
+ adhocFilters.push(...dashboardAdhocFilters);
+ }
+ } else {
+ const originalExtraFormDataFilters =
+ formData.extra_form_data?.filters || [];
+ extraFilters.push(...originalExtraFormDataFilters);
+
+ const dashboardAdhocFilters = formData.adhoc_filters || [];
+ adhocFilters.push(...dashboardAdhocFilters);
+ }
+
+ return { extraFilters, adhocFilters };
+ },
+ [],
+ );
+
+ const createLayerFromData = useCallback(
+ (subslice: JsonObject, json: JsonObject): Layer =>
+ // @ts-ignore TODO(hainenber): define proper type for `form_data.viz_type` and call signature for functions in layerGenerators.
+ layerGenerators[subslice.form_data.viz_type](
+ subslice.form_data,
+ json,
+ props.onAddFilter,
+ setTooltip,
+ props.datasource,
+ [],
+ props.onSelect,
+ ),
+ [props.onAddFilter, props.onSelect, props.datasource, setTooltip],
+ );
+
+ const loadSingleLayer = useCallback(
+ (
+ subslice: JsonObject,
+ formData: QueryFormData,
+ payloadIndex: number,
+ ): void => {
+ const layerIndex = getLayerIndex(
+ subslice.slice_id,
+ payloadIndex,
+ formData.deck_slices,
+ );
+ let extraFilters: (AdhocFilter | QueryObjectFilterClause)[] = [];
+ let adhocFilters: AdhocFilter[] = [];
+ const isExplore = (window.location.href || '').includes('explore');
+ if (isExplore) {
+ // in explore all the filters are in the adhoc_filters
+ const adhocFiltersFromFormData = formData.adhoc_filters || [];
+ const finalAdhocFilters = adhocFiltersFromFormData
+ .map((filter: AdhocFilter & { layerFilterScope?: number[] }) => {
+ if (!isDefined(filter?.layerFilterScope)) {
+ return filter;
+ }
+ if (
+ Array.isArray(filter.layerFilterScope) &&
+ filter.layerFilterScope.length > 0
+ ) {
+ if (filter.layerFilterScope.includes(-1)) {
+ return filter;
+ }
+ if (filter.layerFilterScope.includes(layerIndex)) {
+ return filter;
+ }
+ }
+ return undefined;
+ })
+ .filter(filter => isDefined(filter));
+ adhocFilters = finalAdhocFilters as AdhocFilter[];
+ } else {
+ const {
+ extraFilters: processLayerFiltersResultExtraFilters,
+ adhocFilters: processLayerFiltersResultAdhocFilters,
+ } = processLayerFilters(subslice, formData, layerIndex);
+ extraFilters = processLayerFiltersResultExtraFilters;
+ adhocFilters = processLayerFiltersResultAdhocFilters;
+ }
+
+ const subsliceCopy = {
+ ...subslice,
+ form_data: {
+ ...subslice.form_data,
+ extra_filters: extraFilters,
+ adhoc_filters: adhocFilters,
+ },
+ } as any as JsonObject & { slice_id: number };
+
+ const url = getExploreLongUrl(subsliceCopy.form_data, 'json');
+
+ if (url) {
+ SupersetClient.get({ endpoint: url })
+ .then(({ json }) => {
+ const layer = createLayerFromData(subsliceCopy, json);
+ setSubSlicesLayers(subSlicesLayers => ({
+ ...subSlicesLayers,
+ [subsliceCopy.slice_id]: layer,
+ }));
+ })
+ .catch(error => {
+ console.error(
+ `Error loading layer for slice ${subsliceCopy.slice_id}:`,
+ error,
+ );
+ });
+ }
+ },
+ [getLayerIndex, processLayerFilters, createLayerFromData],
+ );
+
const loadLayers = useCallback(
- (formData: QueryFormData, payload: JsonObject, viewport?: Viewport) => {
+ (
+ formData: QueryFormData,
+ payload: JsonObject,
+ viewport?: Viewport,
+ ): void => {
setViewport(getAdjustedViewport());
setSubSlicesLayers({});
+
payload.data.slices.forEach(
- (subslice: { slice_id: number } & JsonObject) => {
- // Filters applied to multi_deck are passed down to underlying charts
- // note that dashboard contextual information (filter_immune_slices and such) aren't
- // taken into consideration here
- const extra_filters = [
- ...(subslice.form_data.extra_filters || []),
- ...(formData.extra_filters || []),
- ...(formData.extra_form_data?.filters || []),
- ];
-
- const adhoc_filters = [
- ...(formData.adhoc_filters || []),
- ...(subslice.formData?.adhoc_filters || []),
- ...(formData.extra_form_data?.adhoc_filters || []),
- ];
-
- const subsliceCopy = {
- ...subslice,
- form_data: {
- ...subslice.form_data,
- extra_filters,
- adhoc_filters,
- },
- };
-
- const url = getExploreLongUrl(subsliceCopy.form_data, 'json');
-
- if (url) {
- SupersetClient.get({
- endpoint: url,
- })
- .then(({ json }) => {
- // @ts-ignore TODO(hainenber): define proper type for `form_data.viz_type` and call signature for functions in layerGenerators.
- const layer = layerGenerators[subsliceCopy.form_data.viz_type](
- subsliceCopy.form_data,
- json,
- props.onAddFilter,
- setTooltip,
- props.datasource,
- [],
- props.onSelect,
- );
- setSubSlicesLayers(subSlicesLayers => ({
- ...subSlicesLayers,
- [subsliceCopy.slice_id]: layer,
- }));
- })
- .catch(() => {});
- }
+ (subslice: { slice_id: number } & JsonObject, payloadIndex: number) => {
+ loadSingleLayer(subslice, formData, payloadIndex);
},
);
},
- [
- props.datasource,
- props.onAddFilter,
- props.onSelect,
- setTooltip,
- getAdjustedViewport,
- ],
+ [getAdjustedViewport, loadSingleLayer],
);
const prevDeckSlices = usePrevious(props.formData.deck_slices);
diff --git a/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx b/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
index 27f649fb1f..51655e057c 100644
--- a/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
+++ b/superset-frontend/src/dashboard/components/SyncDashboardState/index.tsx
@@ -29,6 +29,7 @@ import {
} from 'src/utils/localStorageHelpers';
import { RootState } from 'src/dashboard/types';
import { getActiveFilters } from 'src/dashboard/util/activeDashboardFilters';
+import { getAllActiveFilters } from 'src/dashboard/util/activeAllDashboardFilters';
import { enforceSharedLabelsColorsArray } from 'src/utils/colorScheme';
import { Divider, Filter } from '@superset-ui/core';
@@ -65,8 +66,9 @@ const selectDashboardContextForExplore = createSelector(
(state: RootState) => state.dashboardState?.colorScheme,
(state: RootState) => state.nativeFilters?.filters,
(state: RootState) => state.dataMask,
+ (state: RootState) => state.dashboardState?.sliceIds || [],
],
- (metadata, dashboardId, colorScheme, filters, dataMask) => {
+ (metadata, dashboardId, colorScheme, filters, dataMask, sliceIds) => {
const nativeFilters = Object.keys(filters).reduce<
Record<string, Pick<Filter | Divider, 'chartsInScope'>>
>((acc, key) => {
@@ -74,6 +76,13 @@ const selectDashboardContextForExplore = createSelector(
return acc;
}, {});
+ const activeFilters = getAllActiveFilters({
+ chartConfiguration: metadata?.chart_configuration || EMPTY_OBJECT,
+ nativeFilters: filters,
+ dataMask,
+ allSliceIds: sliceIds,
+ });
+
return {
labelsColor: metadata?.label_colors || EMPTY_OBJECT,
labelsColorMap: metadata?.map_label_colors || EMPTY_OBJECT,
@@ -86,6 +95,7 @@ const selectDashboardContextForExplore = createSelector(
dataMask,
dashboardId,
filterBoxFilters: getActiveFilters(),
+ activeFilters,
};
},
);
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx b/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
index f69ff6fcef..391a481f20 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FilterBar/index.tsx
@@ -278,11 +278,11 @@ const FilterBar: FC<FiltersBarProps> = ({
const handleApply = useCallback(() => {
dispatch(logEvent(LOG_ACTIONS_CHANGE_DASHBOARD_FILTER, {}));
- const filterIds = Object.keys(dataMaskSelected);
setUpdateKey(1);
- filterIds.forEach(filterId => {
- if (dataMaskSelected[filterId]) {
- dispatch(updateDataMask(filterId, dataMaskSelected[filterId]));
+
+ Object.entries(dataMaskSelected).forEach(([filterId, dataMask]) => {
+ if (dataMask) {
+ dispatch(updateDataMask(filterId, dataMask));
}
});
}, [dataMaskSelected, dispatch]);
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
index 96a31d8170..72aa515e09 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/ScopingTree.tsx
@@ -18,14 +18,22 @@
*/
import { FC, useMemo, useState, memo } from 'react';
-import { NativeFilterScope } from '@superset-ui/core';
+import { NativeFilterScope, styled, css } from '@superset-ui/core';
import Tree from '@superset-ui/core/components/Tree';
import { DASHBOARD_ROOT_ID } from 'src/dashboard/util/constants';
import { Tooltip } from '@superset-ui/core/components';
import { Icons } from '@superset-ui/core/components/Icons';
+import { Layout } from 'src/dashboard/types';
import { useFilterScopeTree } from './state';
import { findFilterScope, getTreeCheckedItems } from './utils';
+const StyledTree = styled(Tree)`
+ .ant-tree-title {
+ display: flex;
+ align-items: center;
+ }
+`;
+
type ScopingTreeProps = {
forceUpdate: Function;
updateFormValues: (values: any) => void;
@@ -40,8 +48,29 @@ const buildTreeLeafTitle = (
label: string,
hasTooltip: boolean,
tooltipTitle?: string,
+ isDeckMultiChart?: boolean,
) => {
let title = <span>{label}</span>;
+
+ if (isDeckMultiChart) {
+ title = (
+ <span
+ css={css`
+ display: inline-flex;
+ align-items: center;
+ `}
+ >
+ <Icons.CheckSquareOutlined
+ iconSize="l"
+ css={css`
+ margin-right: 4px;
+ `}
+ />
+ {label}
+ </span>
+ );
+ }
+
if (hasTooltip) {
title = (
<>
@@ -55,6 +84,68 @@ const buildTreeLeafTitle = (
return title;
};
+const separateKeys = (
+ checkedKeys: string[],
+): { layerKeys: string[]; nonLayerKeys: string[] } => {
+ const layerKeys = checkedKeys.filter(key => key.includes('-layer-'));
+ const nonLayerKeys = checkedKeys.filter(key => !key.includes('-layer-'));
+ return { layerKeys, nonLayerKeys };
+};
+
+const extractParentChartIds = (layerKeys: string[]): Set<number> => {
+ const LAYER_KEY_REGEX = /^chart-(\d+)-layer-\d+$/;
+ const parentChartIds = new Set<number>();
+
+ layerKeys.forEach(layerKey => {
+ const match = layerKey.match(LAYER_KEY_REGEX);
+ if (match) {
+ const chartId = parseInt(match[1], 10);
+ parentChartIds.add(chartId);
+ }
+ });
+ return parentChartIds;
+};
+
+const updateScopeWithParentCharts = (
+ scope: NativeFilterScope,
+ parentChartIds: Set<number>,
+ nonLayerKeys: string[],
+ layout: Layout,
+): NativeFilterScope => {
+ const updatedScope = { ...scope };
+ parentChartIds.forEach(chartId => {
+ const chartLayoutKey = Object.keys(layout).find(
+ key => layout[key]?.meta?.chartId === chartId,
+ );
+ if (chartLayoutKey && layout[chartLayoutKey]) {
+ const tempScope = findFilterScope(
+ [...nonLayerKeys, chartLayoutKey],
+ layout,
+ );
+ updatedScope.rootPath = tempScope.rootPath;
+ updatedScope.excluded = tempScope.excluded;
+ }
+ });
+ return updatedScope;
+};
+
+const createFormValues = (
+ scope: NativeFilterScope,
+ layerKeys: string[],
+ chartId?: number,
+): { scope: NativeFilterScope & { selectedLayers?: string[] } } => {
+ const finalScope = { ...scope };
+ if (chartId !== undefined) {
+ finalScope.excluded = [...new Set([...finalScope.excluded, chartId])];
+ }
+ return {
+ scope:
+ layerKeys.length > 0
+ ? { ...finalScope, selectedLayers: layerKeys }
+ : finalScope,
+ };
+};
+
const ScopingTree: FC<ScopingTreeProps> = ({
formScope,
initialScope,
@@ -74,6 +165,7 @@ const ScopingTree: FC<ScopingTreeProps> = ({
buildTreeLeafTitle,
title,
);
+
const [autoExpandParent, setAutoExpandParent] = useState<boolean>(true);
const handleExpand = (expandedKeys: string[]) => {
@@ -83,22 +175,30 @@ const ScopingTree: FC<ScopingTreeProps> = ({
const handleCheck = (checkedKeys: string[]) => {
forceUpdate();
- const scope = findFilterScope(checkedKeys, layout);
- if (chartId !== undefined) {
- scope.excluded = [...new Set([...scope.excluded, chartId])];
- }
- updateFormValues({
+ const { layerKeys, nonLayerKeys } = separateKeys(checkedKeys);
+ const scope = findFilterScope(nonLayerKeys, layout);
+ const parentChartIds = extractParentChartIds(layerKeys);
+ const updatedScope = updateScopeWithParentCharts(
scope,
- });
+ parentChartIds,
+ nonLayerKeys,
+ layout,
+ );
+ updateFormValues(createFormValues(updatedScope, layerKeys, chartId));
};
const checkedKeys = useMemo(
- () => getTreeCheckedItems({ ...(formScope || initialScope) }, layout),
+ () =>
+ getTreeCheckedItems(
+ { ...(formScope || initialScope) },
+ layout,
+ ((formScope || initialScope) as any)?.selectedLayers,
+ ),
[formScope, initialScope, layout],
);
return (
- <Tree
+ <StyledTree
checkable
selectable={false}
onExpand={handleExpand}
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
index 42320f7d0a..f89cd6e918 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/state.ts
@@ -19,7 +19,7 @@
import { useMemo } from 'react';
import { useSelector } from 'react-redux';
import { t } from '@superset-ui/core';
-import { Charts, Layout, RootState } from 'src/dashboard/types';
+import { Charts, Layout, RootState, Slice } from 'src/dashboard/types';
import { DASHBOARD_ROOT_ID } from 'src/dashboard/util/constants';
import {
CHART_TYPE,
@@ -43,6 +43,15 @@ export function useFilterScopeTree(
);
const charts = useSelector<RootState, Charts>(({ charts }) => charts);
+
+ const sliceEntities = useSelector<RootState, Slice>(state => {
+ if (!state.sliceEntities) {
+ console.warn('sliceEntities not found in state');
+ return {};
+ }
+ return state.sliceEntities.slices || {};
+ });
+
const tree = {
children: [],
key: DASHBOARD_ROOT_ID,
@@ -72,8 +81,16 @@ export function useFilterScopeTree(
validNodes,
initiallyExcludedCharts,
buildTreeLeafTitle,
+ sliceEntities,
);
- }, [layout, tree, charts, initiallyExcludedCharts, buildTreeLeafTitle]);
+ }, [
+ layout,
+ tree,
+ charts,
+ initiallyExcludedCharts,
+ buildTreeLeafTitle,
+ sliceEntities,
+ ]);
return { treeData: [tree], layout };
}
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
index c99c1d65e8..fcb6e1d126 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/types.ts
@@ -24,10 +24,14 @@ export type TreeItem = {
children: TreeItem[];
key: string;
title: ReactNode;
+ nodeType?: 'CHART' | 'TAB' | 'ROOT' | 'DECKGL_LAYER';
+ chartId?: number;
+ layerType?: string;
};
export type BuildTreeLeafTitle = (
label: string,
hasTooltip: boolean,
tooltipTitle?: string,
+ isDeckMultiChart?: boolean,
) => ReactNode;
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
index 5e3079d3ae..0594e0fcc7 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/FiltersConfigModal/FiltersConfigForm/FilterScope/utils.ts
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-import { Charts, Layout, LayoutItem } from 'src/dashboard/types';
+import { Charts, Layout, LayoutItem, Slice } from 'src/dashboard/types';
import {
CHART_TYPE,
DASHBOARD_ROOT_TYPE,
@@ -37,6 +37,58 @@ export const getNodeTitle = (node: LayoutItem) =>
node?.id?.toString?.() ??
'';
+export const generateChartSubNodes = (
+ chartId: number,
+ chart: {
+ form_data?: {
+ viz_type?: string;
+ deck_slices?: number[];
+ };
+ } & Partial<Pick<Charts[keyof Charts], 'queriesResponse'>>,
+ buildTreeLeafTitle: BuildTreeLeafTitle,
+ sliceEntities?: Record<number, Slice>,
+): TreeItem[] => {
+ const subNodes: TreeItem[] = [];
+
+ if (chart?.form_data?.viz_type === 'deck_multi') {
+ const deckSliceIds = chart?.form_data?.deck_slices || [];
+
+ deckSliceIds.forEach((sliceId: number, index: number) => {
+ let sliceName = `Slice ${sliceId}`;
+
+ if (chart.queriesResponse?.[0]?.data?.slices) {
+ const slice = chart.queriesResponse[0].data.slices.find(
+ (s: { slice_id: number; slice_name?: string }) =>
+ s.slice_id === sliceId,
+ );
+ if (slice?.slice_name) {
+ sliceName = slice.slice_name;
+ }
+ }
+
+ const sliceInfo = sliceEntities?.[sliceId];
+ if (sliceInfo?.slice_name) {
+ sliceName = sliceInfo.slice_name;
+ }
+
+ subNodes.push({
+ key: `chart-${chartId}-layer-${index}`,
+ title: buildTreeLeafTitle(
+ sliceName,
+ false,
+ `Deck.gl layer: ${sliceName}`,
+ ),
+ children: [],
+ nodeType: 'DECKGL_LAYER',
+ chartId,
+ layerType: sliceInfo?.viz_type || 'deck_layer',
+ });
+ });
+ }
+
+ return subNodes;
+};
+
export const buildTree = (
node: LayoutItem,
treeItem: TreeItem,
@@ -45,7 +97,12 @@ export const buildTree = (
validNodes: string[],
initiallyExcludedCharts: number[],
buildTreeLeafTitle: BuildTreeLeafTitle,
+ sliceEntities?: Record<number, Slice>,
) => {
+ if (!node) {
+ return;
+ }
+
let itemToPass: TreeItem = treeItem;
if (
node &&
@@ -60,34 +117,60 @@ export const buildTree = (
t(
"This chart might be incompatible with the filter (datasets don't match)",
),
+ !!(
+ node.type === CHART_TYPE &&
+ node.meta?.chartId &&
+ charts &&
+ charts[node.meta.chartId]?.form_data?.viz_type === 'deck_multi'
+ ),
);
- const currentTreeItem = {
+ const currentTreeItem: TreeItem = {
key: node.id,
title,
children: [],
+ nodeType: node.type === CHART_TYPE ? 'CHART' : 'TAB',
+ chartId: node.meta?.chartId,
};
+
+ if (node.type === CHART_TYPE && node.meta?.chartId) {
+ const chart = charts?.[node.meta.chartId];
+ if (chart) {
+ const subNodes = generateChartSubNodes(
+ node.meta.chartId,
+ chart,
+ buildTreeLeafTitle,
+ sliceEntities,
+ );
+ currentTreeItem.children = subNodes;
+ }
+ }
+
treeItem.children.push(currentTreeItem);
itemToPass = currentTreeItem;
}
- node?.children?.forEach?.(child => {
- const node = layout?.[child];
- if (node) {
- buildTree(
- node,
- itemToPass,
- layout,
- charts,
- validNodes,
- initiallyExcludedCharts,
- buildTreeLeafTitle,
- );
- } else {
- logging.warn(
- `Unable to find item with id: ${child} in the dashboard layout. This may indicate you have invalid references in your dashboard and the references to id: ${child} should be removed.`,
- );
- }
- });
+
+ if (node.type !== CHART_TYPE) {
+ node?.children?.forEach?.(child => {
+ const childNode = layout?.[child];
+ if (childNode) {
+ buildTree(
+ childNode,
+ itemToPass,
+ layout,
+ charts,
+ validNodes,
+ initiallyExcludedCharts,
+ buildTreeLeafTitle,
+ sliceEntities,
+ );
+ } else {
+ logging.warn(
+ `Unable to find item with id: ${child} in the dashboard layout. This may indicate you have invalid references in your dashboard and the references to id: ${child} should be removed.`,
+ );
+ }
+ });
+ }
};
const addInvisibleParents = (layout: Layout, item: string) => [
@@ -102,7 +185,6 @@ const addInvisibleParents = (layout: Layout, item: string) => [
.map(({ id }) => id),
];
-// Generate checked options for Ant tree from redux scope
const checkTreeItem = (
checkedItems: string[],
layout: Layout,
@@ -125,12 +207,39 @@ const checkTreeItem = (
});
};
+const LAYER_KEY_REGEX = /^chart-(\d+)-layer-\d+$/;
+
export const getTreeCheckedItems = (
scope: NativeFilterScope,
layout: Layout,
+ selectedLayers?: string[],
) => {
const checkedItems: string[] = [];
checkTreeItem(checkedItems, layout, [...scope.rootPath], [...scope.excluded]);
+
+ // If we have individual layer selections, exclude their parent charts from checkedItems
+ // to prevent Tree component from auto-checking all children
+ if (selectedLayers && selectedLayers.length > 0) {
+ const parentChartIds = new Set<number>();
+ selectedLayers.forEach(layerKey => {
+ const match = layerKey.match(LAYER_KEY_REGEX);
+ if (match) {
+ const chartId = parseInt(match[1], 10);
+ parentChartIds.add(chartId);
+ }
+ });
+
+ const filteredItems = checkedItems.filter(item => {
+ if (layout[item]?.type === CHART_TYPE) {
+ const chartId = layout[item]?.meta?.chartId;
+ return chartId ? !parentChartIds.has(chartId) : true;
+ }
+ return true;
+ });
+
+ return [...new Set([...filteredItems, ...selectedLayers])];
+ }
+
return [...new Set(checkedItems)];
};
@@ -146,8 +255,32 @@ export const findFilterScope = (
};
}
+ const layerKeys = checkedKeys.filter(key => key.includes('-layer-'));
+ const chartKeys = checkedKeys.filter(key => {
+ if (layout[key]?.type === CHART_TYPE) {
+ return true;
+ }
+ if (key.includes('-layer-')) {
+ return false;
+ }
+ return true;
+ });
+
+ layerKeys.forEach(layerKey => {
+ const match = layerKey.match(LAYER_KEY_REGEX);
+ if (match) {
+ const chartId = parseInt(match[1], 10);
+ const chartLayoutKey = Object.keys(layout).find(
+ key => layout[key]?.meta?.chartId === chartId,
+ );
+ if (chartLayoutKey && !chartKeys.includes(chartLayoutKey)) {
+ chartKeys.push(chartLayoutKey);
+ }
+ }
+ });
+
// Get arrays of parents for selected charts
- const checkedItemParents = checkedKeys
+ const checkedItemParents = chartKeys
.filter(item => layout[item]?.type === CHART_TYPE)
.map(key => {
const parents = [DASHBOARD_ROOT_ID, ...(layout[key]?.parents || [])];
@@ -162,7 +295,7 @@ export const findFilterScope = (
const excluded: number[] = [];
const isExcluded = (parent: string, item: string) =>
- rootPath.includes(parent) && !checkedKeys.includes(item);
+ rootPath.includes(parent) && !chartKeys.includes(item);
// looking for charts to be excluded: iterate over all charts
// and looking for charts that have one of their parents in `rootPath` and not in selected items
Object.entries(layout).forEach(([key, value]) => {
diff --git a/superset-frontend/src/dashboard/components/nativeFilters/utils.ts b/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
index c883ed0403..45bbe5b826 100644
--- a/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
+++ b/superset-frontend/src/dashboard/components/nativeFilters/utils.ts
@@ -192,3 +192,166 @@ export const getFilterValueForDisplay = (
}
return t('Unknown value');
};
+
+export interface FilterTarget {
+ type: 'CHART' | 'LAYER';
+ chartId: string;
+ layerId?: string;
+}
+
+export interface FilterScope {
+ filterId: string;
+ targets: FilterTarget[];
+}
+
+// Matches layer keys in format: 'chart-123-layer-456' where 123 is chartId and 456 is layerId
+const LAYER_KEY_REGEX = /^chart-(\d+)-layer-(\d+)$/;
+// Matches chart keys in format: 'chart-123' where 123 is chartId
+const CHART_KEY_REGEX = /^chart-(\d+)$/;
+
+export function parseFilterTarget(scopeKey: string): FilterTarget | null {
+ const layerMatch = scopeKey.match(LAYER_KEY_REGEX);
+ if (layerMatch) {
+ return {
+ type: 'LAYER',
+ chartId: layerMatch[1],
+ layerId: layerMatch[2],
+ };
+ }
+
+ const chartMatch = scopeKey.match(CHART_KEY_REGEX);
+ if (chartMatch) {
+ return {
+ type: 'CHART',
+ chartId: chartMatch[1],
+ };
+ }
+
+ return null;
+}
+
+export function getFilterScope(
+ filterId: string,
+ filterScopes: Record<string, string[]>,
+): FilterScope {
+ const scopeKeys = filterScopes[filterId] || [];
+ const targets: FilterTarget[] = [];
+
+ scopeKeys.forEach(scopeKey => {
+ const target = parseFilterTarget(scopeKey);
+ if (target) {
+ targets.push(target);
+ } else {
+ console.warn(`Invalid filter scope key format: ${scopeKey}`);
+ }
+ });
+
+ return {
+ filterId,
+ targets,
+ };
+}
+
+export function aggregateFiltersForTarget(
+ dataMask: DataMaskStateWithId,
+ filterIds: string[],
+): ExtraFormData {
+ let aggregatedFormData: ExtraFormData = {};
+
+ filterIds.forEach(filterId => {
+ const filterData = dataMask[filterId];
+ if (filterData?.extraFormData) {
+ aggregatedFormData = mergeExtraFormData(
+ aggregatedFormData,
+ filterData.extraFormData,
+ );
+ }
+ });
+
+ return aggregatedFormData;
+}
+
+function createTargetKey(target: FilterTarget): string {
+ if (target.type === 'LAYER') {
+ return `${target.chartId}-${target.layerId}`;
+ }
+ return target.chartId;
+}
+
+export function groupFiltersByTarget(
+ dataMask: DataMaskStateWithId,
+ filterScopes: Record<string, string[]>,
+): {
+ chartFilters: Map<string, ExtraFormData>;
+ layerFilters: Map<string, ExtraFormData>;
+} {
+ const chartFilters = new Map<string, ExtraFormData>();
+ const layerFilters = new Map<string, ExtraFormData>();
+
+ Object.keys(dataMask).forEach(filterId => {
+ const scope = getFilterScope(filterId, filterScopes);
+
+ scope.targets.forEach(target => {
+ const filterData = dataMask[filterId]?.extraFormData || {};
+ const targetKey = createTargetKey(target);
+
+ if (target.type === 'CHART') {
+ const existing = chartFilters.get(targetKey) || {};
+ chartFilters.set(targetKey, mergeExtraFormData(existing, filterData));
+ } else if (target.type === 'LAYER') {
+ const existing = layerFilters.get(targetKey) || {};
+ layerFilters.set(targetKey, mergeExtraFormData(existing, filterData));
+ }
+ });
+ });
+
+ return { chartFilters, layerFilters };
+}
+
+export function buildFilterScopesFromFilters(
+ filters: any,
+): Record<string, string[]> {
+ const filterScopes: Record<string, string[]> = {};
+
+ Object.values(filters).forEach((filter: Filter) => {
+ if (filter.chartsInScope) {
+ filterScopes[filter.id] = filter.chartsInScope.map(
+ (chartId: number) => `chart-${chartId}`,
+ );
+ }
+ });
+
+ return filterScopes;
+}
+
+export function getLayerSpecificExtraFormData(
+ dataMask: DataMaskStateWithId,
+ filterIds: string[],
+ chartId: number,
+ layerId?: string,
+): ExtraFormData {
+ let extraFormData: ExtraFormData = {};
+
+ filterIds.forEach(filterId => {
+ const filterData = dataMask[filterId];
+ if (filterData?.extraFormData) {
+ extraFormData = mergeExtraFormData(
+ extraFormData,
+ filterData.extraFormData,
+ );
+ }
+ });
+
+ if (layerId) {
+ const layerKey = `${chartId}-${layerId}`;
+ const layerFilterData = dataMask[layerKey];
+ if (layerFilterData?.extraFormData) {
+ extraFormData = mergeExtraFormData(
+ extraFormData,
+ layerFilterData.extraFormData,
+ );
+ }
+ }
+
+ return extraFormData;
+}
diff --git a/superset-frontend/src/dashboard/types.ts b/superset-frontend/src/dashboard/types.ts
index 66fcf6418f..43d67bd351 100644
--- a/superset-frontend/src/dashboard/types.ts
+++ b/superset-frontend/src/dashboard/types.ts
@@ -39,6 +39,10 @@ import { ChartState } from '../explore/types';
export type { Dashboard } from 'src/types/Dashboard';
+export interface ExtendedNativeFilterScope extends NativeFilterScope {
+ selectedLayers?: string[];
+}
+
export type ChartReducerInitialState = typeof chart;
// chart query built from initialState
@@ -210,6 +214,9 @@ type ActiveFilter = {
targets: number[] | [Partial<NativeFilterTarget>];
scope: number[];
values: ExtraFormData;
+ layerScope?: {
+ [chartId: number]: number[];
+ };
};
export type ActiveFilters = {
diff --git a/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts b/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
index 0d3ae30eb4..bcc533780e 100644
--- a/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
+++ b/superset-frontend/src/dashboard/util/activeAllDashboardFilters.ts
@@ -16,27 +16,39 @@
* specific language governing permissions and limitations
* under the License.
*/
-import {
- DataMaskStateWithId,
- PartialFilters,
- JsonObject,
- DataMaskWithId,
-} from '@superset-ui/core';
+import { DataMaskStateWithId, PartialFilters } from '@superset-ui/core';
import { ActiveFilters, ChartConfiguration } from '../types';
export const getRelevantDataMask = (
dataMask: DataMaskStateWithId,
- prop: string,
-): JsonObject | DataMaskStateWithId =>
- Object.values(dataMask)
- .filter(item => item[prop as keyof DataMaskWithId])
- .reduce(
- (prev, next) => ({
- ...prev,
- [next.id]: prop ? next[prop as keyof DataMaskWithId] : next,
- }),
- {},
- );
+ filterId: string,
+): DataMaskStateWithId =>
+ dataMask[filterId] ? { [filterId]: dataMask[filterId] } : {};
+
+interface LayerInfo {
+ layerMap: { [chartId: number]: number[] };
+ chartIds: Set<number>;
+}
+
+const extractLayerIndicesFromKeys = (selectedLayers: string[]): LayerInfo => {
+ const layerMap: { [chartId: number]: number[] } = {};
+ const chartIds = new Set<number>();
+ selectedLayers.forEach(layerKey => {
+ const match = layerKey.match(/^chart-(\d+)-layer-(\d+)$/);
+ if (match) {
+ const chartId = parseInt(match[1], 10);
+ const layerIndex = parseInt(match[2], 10);
+ if (!Number.isNaN(chartId)) {
+ if (!layerMap[chartId]) {
+ layerMap[chartId] = [];
+ }
+ layerMap[chartId].push(layerIndex);
+ chartIds.add(chartId);
+ }
+ }
+ });
+ return { layerMap, chartIds };
+};
export const getAllActiveFilters = ({
chartConfiguration,
@@ -51,23 +63,87 @@ export const getAllActiveFilters = ({
}): ActiveFilters => {
const activeFilters: ActiveFilters = {};
- // Combine native filters with cross filters, because they have similar logic
+ const hasLayerSelectionsInAnyFilter = Object.values(dataMask).some(
+ ({ id: filterId }) => {
+ const selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+ ?.selectedLayers;
+ return selectedLayers && selectedLayers.length > 0;
+ },
+ );
+
+ let masterSelectedLayers: string[] = [];
+ let masterExcluded: number[] = [];
+ if (hasLayerSelectionsInAnyFilter) {
+ Object.values(dataMask).forEach(({ id: filterId }) => {
+ const selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+ ?.selectedLayers;
+ const excluded =
+ (nativeFilters?.[filterId]?.scope as any)?.excluded || [];
+ if (selectedLayers && selectedLayers.length > 0) {
+ masterSelectedLayers = selectedLayers;
+ masterExcluded = excluded;
+ }
+ });
+ }
+
Object.values(dataMask).forEach(({ id: filterId, extraFormData = {} }) => {
- const scope =
+ let scope =
nativeFilters?.[filterId]?.chartsInScope ??
chartConfiguration?.[parseInt(filterId, 10)]?.crossFilters
?.chartsInScope ??
allSliceIds ??
[];
const filterType = nativeFilters?.[filterId]?.filterType;
- const targets = nativeFilters?.[filterId]?.targets ?? scope;
- // Iterate over all roots to find all affected charts
+ const targets = nativeFilters?.[filterId]?.targets;
+
+ let selectedLayers = (nativeFilters?.[filterId]?.scope as any)
+ ?.selectedLayers;
+ let excludedCharts =
+ (nativeFilters?.[filterId]?.scope as any)?.excluded || [];
+
+ if (
+ hasLayerSelectionsInAnyFilter &&
+ (!selectedLayers || selectedLayers.length === 0)
+ ) {
+ selectedLayers = masterSelectedLayers;
+ excludedCharts = masterExcluded;
+ }
+
+ let layerScope;
+ if (selectedLayers && selectedLayers.length > 0) {
+ const layerInfo = extractLayerIndicesFromKeys(selectedLayers);
+ layerScope = layerInfo.layerMap;
+
+ const explicitlyTargetedCharts = new Set<number>(layerInfo.chartIds);
+
+ const originalScope = scope;
+ originalScope.forEach((chartId: number) => {
+ if (!excludedCharts.includes(chartId)) {
+ const hasLayerSelections = selectedLayers.some((key: string) =>
+ key.startsWith(`chart-${chartId}-layer-`),
+ );
+
+ if (!hasLayerSelections) {
+ explicitlyTargetedCharts.add(chartId);
+ }
+ }
+ });
+
+ scope = Array.from(explicitlyTargetedCharts);
+ } else {
+ scope = scope.filter(
+ (chartId: number) => !excludedCharts.includes(chartId),
+ );
+ }
+
activeFilters[filterId] = {
scope,
- filterType,
- targets,
+ targets: targets || [],
values: extraFormData,
+ filterType,
+ ...(layerScope && { layerScope }),
};
});
+
return activeFilters;
};
diff --git a/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts b/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
index 56cc787b1d..629bb74b95 100644
--- a/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
+++ b/superset-frontend/src/dashboard/util/charts/getFormDataWithExtraFilters.ts
@@ -24,7 +24,11 @@ import {
JsonObject,
PartialFilters,
} from '@superset-ui/core';
-import { ChartConfiguration, ChartQueryPayload } from 'src/dashboard/types';
+import {
+ ChartConfiguration,
+ ChartQueryPayload,
+ ActiveFilters,
+} from 'src/dashboard/types';
import { getExtraFormData } from 'src/dashboard/components/nativeFilters/utils';
import { areObjectsEqual } from 'src/reduxUtils';
import { isEqual } from 'lodash';
@@ -45,14 +49,18 @@ interface CachedFormData {
label_colors?: Record<string, string>;
shared_label_colors?: string[];
map_label_colors?: Record<string, string>;
+ layer_filter_scope?: {
+ [filterId: string]: number[];
+ };
+ filter_data_mapping?: {
+ [filterId: string]: any[];
+ };
}
export type CachedFormDataWithExtraControls = CachedFormData & {
[key: string]: any;
};
-// We cache formData objects so that our connected container components don't always trigger
-// render cascades. we cannot leverage the reselect library because our cache size is >1
const cachedFiltersByChart: Record<number, DataRecordFilters> = {};
const cachedFormdataByChart: Record<
number,
@@ -77,11 +85,25 @@ export interface GetFormDataWithExtraFiltersArguments {
labelsColorMap?: Record<string, string>;
sharedLabelsColors?: string[];
allSliceIds: number[];
+ activeFilters?: ActiveFilters;
}
-// this function merge chart's formData with dashboard filters value,
-// and generate a new formData which will be used in the new query.
-// filters param only contains those applicable to this chart.
+const createFilterDataMapping = (
+ dataMask: DataMaskStateWithId,
+ filterIdsAppliedOnChart: string[],
+): { [filterId: string]: any[] } => {
+ const filterDataMapping: { [filterId: string]: any[] } = {};
+
+ filterIdsAppliedOnChart.forEach(filterId => {
+ const filterFormData = getExtraFormData(dataMask, [filterId]);
+ if (filterFormData.filters && filterFormData.filters.length > 0) {
+ filterDataMapping[filterId] = filterFormData.filters;
+ }
+ });
+
+ return filterDataMapping;
+};
+
export default function getFormDataWithExtraFilters({
chart,
filters,
@@ -97,8 +119,8 @@ export default function getFormDataWithExtraFilters({
labelsColorMap,
sharedLabelsColors,
allSliceIds,
+ activeFilters: passedActiveFilters,
}: GetFormDataWithExtraFiltersArguments) {
- // if dashboard metadata + filters have not changed, use cache if possible
const cachedFormData = cachedFormdataByChart[sliceId];
if (
cachedFiltersByChart[sliceId] === filters &&
@@ -125,20 +147,62 @@ export default function getFormDataWithExtraFilters({
return cachedFormData;
}
- let extraData: { extra_form_data?: JsonObject } = {};
- const activeFilters = getAllActiveFilters({
- chartConfiguration,
- dataMask,
- nativeFilters,
- allSliceIds,
- });
+ const activeFilters: ActiveFilters =
+ passedActiveFilters ||
+ getAllActiveFilters({
+ chartConfiguration,
+ nativeFilters,
+ dataMask,
+ allSliceIds,
+ });
+
+ let extraData: JsonObject = {};
const filterIdsAppliedOnChart = Object.entries(activeFilters)
- .filter(([, { scope }]) => scope.includes(chart.id))
+ .filter(([, activeFilter]) => activeFilter.scope.includes(chart.id))
.map(([filterId]) => filterId);
+
if (filterIdsAppliedOnChart.length) {
+ const aggregatedFormData = getExtraFormData(
+ dataMask,
+ filterIdsAppliedOnChart,
+ );
extraData = {
- extra_form_data: getExtraFormData(dataMask, filterIdsAppliedOnChart),
+ extra_form_data: aggregatedFormData,
};
+
+ const isDeckMultiChart = chart.form_data?.viz_type === 'deck_multi';
+ const hasLayerScopeInActiveFilters =
+ passedActiveFilters &&
+ Object.values(passedActiveFilters).some(filter => filter.layerScope);
+
+ if (isDeckMultiChart || hasLayerScopeInActiveFilters) {
+ const filterDataMapping = createFilterDataMapping(
+ dataMask,
+ filterIdsAppliedOnChart,
+ );
+ extraData.filter_data_mapping = filterDataMapping;
+ }
+ }
+
+ let layerFilterScope: { [filterId: string]: number[] } | undefined;
+
+ const isDeckMultiChart = chart.form_data?.viz_type === 'deck_multi';
+ const hasLayerScopeInActiveFilters =
+ passedActiveFilters &&
+ Object.values(passedActiveFilters).some(filter => filter.layerScope);
+
+ if (isDeckMultiChart || hasLayerScopeInActiveFilters) {
+ layerFilterScope = {};
+
+ Object.entries(activeFilters).forEach(([filterId, activeFilter]) => {
+ if (activeFilter.layerScope?.[chart.id]) {
+ layerFilterScope![filterId] = activeFilter.layerScope[chart.id];
+ }
+ });
+
+ if (Object.keys(layerFilterScope).length === 0) {
+ layerFilterScope = undefined;
+ }
}
const formData: CachedFormDataWithExtraControls = {
@@ -154,6 +218,7 @@ export default function getFormDataWithExtraFilters({
extra_filters: getEffectiveExtraFilters(filters),
...extraData,
...extraControls,
+ ...(layerFilterScope && { layer_filter_scope: layerFilterScope }),
};
cachedFiltersByChart[sliceId] = filters;
diff --git a/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts b/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
index 5bd37f26bc..f6b3c91ae4 100644
--- a/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
+++ b/superset-frontend/src/dashboard/util/getChartIdsInFilterScope.ts
@@ -20,12 +20,59 @@ import { NativeFilterScope } from '@superset-ui/core';
import { CHART_TYPE } from './componentTypes';
import { LayoutItem } from '../types';
+interface ExtendedNativeFilterScope extends NativeFilterScope {
+ selectedLayers?: string[];
+}
+
export function getChartIdsInFilterScope(
- filterScope: NativeFilterScope,
+ filterScope: ExtendedNativeFilterScope,
chartIds: number[],
layoutItems: LayoutItem[],
-) {
- return chartIds.filter(
+): number[] {
+ if (filterScope.selectedLayers && filterScope.selectedLayers.length > 0) {
+ const targetChartIds: number[] = [];
+
+ filterScope.selectedLayers.forEach(selectionKey => {
+ const layerMatch = selectionKey.match(/^chart-(\d+)-layer-(\d+)$/);
+ if (layerMatch) {
+ const chartId = parseInt(layerMatch[1], 10);
+ if (chartIds.includes(chartId) && !targetChartIds.includes(chartId)) {
+ targetChartIds.push(chartId);
+ }
+ }
+ });
+ const chartsWithLayerSelections = new Set<number>();
+ filterScope.selectedLayers.forEach(selectionKey => {
+ const layerMatch = selectionKey.match(/^chart-(\d+)-layer-(\d+)$/);
+ if (layerMatch) {
+ chartsWithLayerSelections.add(parseInt(layerMatch[1], 10));
+ }
+ });
+
+ const regularChartIds = chartIds.filter(
+ chartId =>
+ !filterScope.excluded.includes(chartId) &&
+ !chartsWithLayerSelections.has(chartId) &&
+ layoutItems
+ .find(
+ layoutItem =>
+ layoutItem?.type === CHART_TYPE &&
+ layoutItem.meta?.chartId === chartId,
+ )
+ ?.parents?.some(elementId =>
+ filterScope.rootPath.includes(elementId),
+ ),
+ );
+
+ regularChartIds.forEach(chartId => {
+ if (!targetChartIds.includes(chartId)) {
+ targetChartIds.push(chartId);
+ }
+ });
+ return targetChartIds;
+ }
+
+ const traditionalResult = chartIds.filter(
chartId =>
!filterScope.excluded.includes(chartId) &&
layoutItems
@@ -36,4 +83,6 @@ export function getChartIdsInFilterScope(
)
?.parents?.some(elementId => filterScope.rootPath.includes(elementId)),
);
+
+ return traditionalResult;
}
diff --git a/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx b/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
index 6f6df842b4..13b67c5b99 100644
--- a/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
+++ b/superset-frontend/src/explore/components/ExploreViewContainer/index.jsx
@@ -769,7 +769,29 @@ function mapStateToProps(state) {
const fieldsToOmit = hasQueryMode
? retainQueryModeRequirements(hiddenFormData)
: Object.keys(hiddenFormData ?? {});
- const form_data = omit(getFormDataFromControls(controls), fieldsToOmit);
+
+ const controlsBasedFormData = omit(
+ getFormDataFromControls(controls),
+ fieldsToOmit,
+ );
+ const isDeckGLChart = explore.form_data?.viz_type === 'deck_multi';
+
+ const getDeckGLFormData = () => {
+ const formData = { ...controlsBasedFormData };
+
+ if (explore.form_data?.layer_filter_scope) {
+ formData.layer_filter_scope = explore.form_data.layer_filter_scope;
+ }
+
+ if (explore.form_data?.filter_data_mapping) {
+ formData.filter_data_mapping = explore.form_data.filter_data_mapping;
+ }
+
+ return formData;
+ };
+
+ const form_data = isDeckGLChart ? getDeckGLFormData() : controlsBasedFormData;
+
const slice_id = form_data.slice_id ?? slice?.slice_id ?? 0; // 0 - unsaved chart
form_data.extra_form_data = mergeExtraFormData(
{ ...form_data.extra_form_data },
diff --git a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
index 7c13236573..eeea251a39 100644
--- a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
+++ b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilter/index.js
@@ -63,6 +63,8 @@ export default class AdhocFilter {
this.isExtra = !!adhocFilter.isExtra;
this.isNew = !!adhocFilter.isNew;
this.datasourceWarning = !!adhocFilter.datasourceWarning;
+ this.deck_slices = adhocFilter?.deck_slices;
+ this.layerFilterScope = adhocFilter?.layerFilterScope;
this.filterOptionName =
adhocFilter.filterOptionName ||
diff --git a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
index 55a0515dd8..112580bfbc 100644
--- a/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
+++ b/superset-frontend/src/explore/components/controls/FilterControl/AdhocFilterEditPopover/index.jsx
@@ -18,9 +18,9 @@
*/
import { createRef, Component } from 'react';
import PropTypes from 'prop-types';
-import { Button, Icons } from '@superset-ui/core/components';
+import { Button, Icons, Select } from '@superset-ui/core/components';
import { ErrorBoundary } from 'src/components';
-import { styled, t } from '@superset-ui/core';
+import { styled, t, SupersetClient } from '@superset-ui/core';
import Tabs from '@superset-ui/core/components/Tabs';
import adhocMetricType from 'src/explore/components/controls/MetricControl/adhocMetricType';
@@ -32,6 +32,8 @@ import {
POPOVER_INITIAL_HEIGHT,
POPOVER_INITIAL_WIDTH,
} from 'src/explore/constants';
+import rison from 'rison';
+import { isObject } from 'lodash';
import { ExpressionTypes } from '../types';
const propTypes = {
@@ -86,6 +88,11 @@ const FilterActionsContainer = styled.div`
margin-top: ${({ theme }) => theme.sizeUnit * 2}px;
`;
+const LayerSelectContainer = styled.div`
+ margin-top: ${({ theme }) => theme.sizeUnit * 2}px;
+ margin-bottom: ${({ theme }) => theme.sizeUnit * 12}px;
+`;
+
export default class AdhocFilterEditPopover extends Component {
constructor(props) {
super(props);
@@ -97,6 +104,8 @@ export default class AdhocFilterEditPopover extends Component {
this.setSimpleTabIsValid = this.setSimpleTabIsValid.bind(this);
this.adjustHeight = this.adjustHeight.bind(this);
this.onTabChange = this.onTabChange.bind(this);
+ this.loadLayerOptions = this.loadLayerOptions.bind(this);
+ this.onLayerChange = this.onLayerChange.bind(this);
this.state = {
adhocFilter: this.props.adhocFilter,
@@ -104,6 +113,9 @@ export default class AdhocFilterEditPopover extends Component {
height: POPOVER_INITIAL_HEIGHT,
activeKey: this.props?.adhocFilter?.expressionType || 'SIMPLE',
isSimpleTabValid: true,
+ selectedLayers: [{ id: null, value: -1, label: 'All' }],
+ layerOptions: [],
+ hasLayerFilterScopeChanged: false,
};
this.popoverContentRef = createRef();
@@ -111,6 +123,26 @@ export default class AdhocFilterEditPopover extends Component {
componentDidMount() {
document.addEventListener('mouseup', this.onMouseUp);
+
+ // Load layer options if deck_slices exist
+ if (
+ this.props.adhocFilter?.deck_slices &&
+ this.props.adhocFilter.deck_slices.length > 0
+ ) {
+ this.loadLayerOptions(0, 100).then(result => {
+ this.setState({ layerOptions: result.data });
+ const layerFilterScope = this.props.adhocFilter?.layerFilterScope;
+ if (layerFilterScope) {
+ const selectedLayers = layerFilterScope.map(item => {
+ const layerOption = result.data.find(
+ option => option.value === item,
+ );
+ return layerOption;
+ });
+ this.setState({ selectedLayers });
+ }
+ });
+ }
}
componentWillUnmount() {
@@ -127,7 +159,28 @@ export default class AdhocFilterEditPopover extends Component {
}
onSave() {
- this.props.onChange(this.state.adhocFilter);
+ const hasDeckSlices =
+ this.state.adhocFilter.deck_slices &&
+ this.state.adhocFilter.deck_slices.length > 0;
+
+ if (!hasDeckSlices) {
+ this.props.onChange(this.state.adhocFilter);
+ this.props.onClose();
+ return;
+ }
+ // Update layer filter scope for deck multi
+ const selectedLayers = this.state.selectedLayers.map(item => {
+ if (isObject(item)) {
+ return item.value;
+ }
+ return item;
+ });
+ const correctedAdhocFilter = {
+ ...this.state.adhocFilter,
+ layerFilterScope: selectedLayers,
+ };
+ this.setState({ hasLayerFilterScopeChanged: false });
+ this.props.onChange(correctedAdhocFilter);
this.props.onClose();
}
@@ -167,6 +220,86 @@ export default class AdhocFilterEditPopover extends Component {
this.setState(state => ({ height: state.height + heightDifference }));
}
+ loadLayerOptions(page, pageSize) {
+ const query = rison.encode({
+ columns: ['id', 'slice_name', 'viz_type'],
+ filters: [{ col: 'viz_type', opr: 'sw', value: 'deck' }],
+ page,
+ page_size: pageSize,
+ order_column: 'slice_name',
+ order_direction: 'asc',
+ });
+
+ return SupersetClient.get({
+ endpoint: `/api/v1/chart/?q=${query}`,
+ }).then(response => {
+ if (!response?.json?.result) {
+ return {
+ data: [
+ {
+ id: null,
+ value: -1,
+ label: 'All',
+ },
+ ],
+ totalCount: 1,
+ };
+ }
+
+ const deckSlices = this.props.adhocFilter?.deck_slices || [];
+
+ const list = [
+ {
+ id: null,
+ value: -1,
+ label: 'All',
+ },
+ ...response.json.result
+ .map(item => {
+ const sliceIndex = deckSlices.indexOf(item.id);
+ return {
+ id: item.id,
+ value: sliceIndex >= 0 ? sliceIndex : item.id,
+ label: item.slice_name,
+ sliceIndex,
+ };
+ })
+ .filter(item => item.sliceIndex !== -1)
+ .map(({ sliceIndex, ...item }) => item),
+ ];
+
+ return {
+ data: list,
+ totalCount: list.length,
+ };
+ });
+ }
+
+ onLayerChange(selectedValue) {
+ let updatedSelectedLayers = selectedValue;
+
+ if (!selectedValue || selectedValue.length === 0) {
+ updatedSelectedLayers = [{ id: null, value: -1, label: 'All' }];
+ } else if (
+ selectedValue.length > 1 &&
+ selectedValue.some(item => item.value === -1 || item === -1)
+ ) {
+ if (
+ selectedValue[selectedValue.length - 1].value === -1 ||
+ selectedValue[selectedValue.length - 1] === -1
+ ) {
+ updatedSelectedLayers = [{ id: null, value: -1, label: 'All' }];
+ } else {
+ updatedSelectedLayers = selectedValue
+ .filter(item => item.value !== -1)
+ .filter(item => item !== -1);
+ }
+ }
+
+ this.setState({ selectedLayers: updatedSelectedLayers });
+ this.setState({ hasLayerFilterScopeChanged: true });
+ }
+
render() {
const {
adhocFilter: propsAdhocFilter,
@@ -182,10 +315,16 @@ export default class AdhocFilterEditPopover extends Component {
...popoverProps
} = this.props;
- const { adhocFilter } = this.state;
+ const { adhocFilter, selectedLayers, hasLayerFilterScopeChanged } =
+ this.state;
const stateIsValid = adhocFilter.isValid();
const hasUnsavedChanges =
- requireSave || !adhocFilter.equals(propsAdhocFilter);
+ requireSave ||
+ !adhocFilter.equals(propsAdhocFilter) ||
+ hasLayerFilterScopeChanged;
+
+ const hasDeckSlices =
+ adhocFilter.deck_slices && adhocFilter.deck_slices.length > 0;
return (
<FilterPopoverContentContainer
@@ -239,6 +378,17 @@ export default class AdhocFilterEditPopover extends Component {
},
]}
/>
+ {hasDeckSlices && (
+ <LayerSelectContainer>
+ <Select
+ options={this.state.layerOptions}
+ onChange={this.onLayerChange}
+ value={selectedLayers}
+ mode="multiple"
+ />
+ </LayerSelectContainer>
+ )}
+
<FilterActionsContainer>
<Button
buttonStyle="secondary"
diff --git a/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts b/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
index 4017883ab1..127df12155 100644
--- a/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
+++ b/superset-frontend/src/explore/controlUtils/getFormDataWithDashboardContext.ts
@@ -115,6 +115,8 @@ const mergeNativeFiltersToFormData = (
) => {
const nativeFiltersData: JsonObject = {};
const extraFormData = dashboardFormData.extra_form_data || {};
+ const layerFilterScope = dashboardFormData?.layer_filter_scope;
+ const filterDataMapping = dashboardFormData?.filter_data_mapping;
Object.entries(EXTRA_FORM_DATA_OVERRIDE_REGULAR_MAPPINGS).forEach(
([srcKey, targetKey]) => {
const val = extraFormData[srcKey];
@@ -150,7 +152,12 @@ const mergeNativeFiltersToFormData = (
}));
const appendFilters = ensureIsArray(extraFormData.filters).map(extraFilter =>
- simpleFilterToAdhoc({ ...extraFilter, isExtra: true }),
+ simpleFilterToAdhoc({
+ ...extraFilter,
+ isExtra: true,
+ filterDataMapping,
+ layerFilterScope,
+ }),
);
Object.keys(exploreFormData).forEach(key => {
if (key.match(/adhoc_filter.*/)) {
@@ -160,6 +167,7 @@ const mergeNativeFiltersToFormData = (
];
}
});
+
return nativeFiltersData;
};
@@ -186,15 +194,23 @@ const applyTimeRangeFilters = (
export const getFormDataWithDashboardContext = (
exploreFormData: QueryFormData,
dashboardContextFormData: JsonObject,
+ saveAction?: string | null,
) => {
const filterBoxData = mergeFilterBoxToFormData(
exploreFormData,
dashboardContextFormData,
);
+
const nativeFiltersData = mergeNativeFiltersToFormData(
exploreFormData,
dashboardContextFormData,
);
+ const isDeckGLChart =
+ exploreFormData.viz_type === 'deck_multi' ||
+ dashboardContextFormData.viz_type === 'deck_multi';
+
+ const deckSlices = exploreFormData?.deck_slices;
+
const adhocFilters = [
...Object.keys(exploreFormData),
...Object.keys(filterBoxData),
@@ -204,25 +220,77 @@ export const getFormDataWithDashboardContext = (
.reduce(
(acc, key) => ({
...acc,
- [key]: removeExtraFieldForNewCharts(
- applyTimeRangeFilters(
- dashboardContextFormData,
- removeAdhocFilterDuplicates([
- ...ensureIsArray(exploreFormData[key]),
- ...ensureIsArray(filterBoxData[key]),
- ...ensureIsArray(nativeFiltersData[key]),
- ]),
- ),
- exploreFormData.slice_id === 0,
- ),
+ [key]: (() => {
+ const beforeDuplicates = [
+ ...ensureIsArray(exploreFormData[key]),
+ ...ensureIsArray(filterBoxData[key]),
+ ...ensureIsArray(nativeFiltersData[key]),
+ ];
+
+ const afterDuplicates = removeAdhocFilterDuplicates(beforeDuplicates);
+
+ const final = removeExtraFieldForNewCharts(
+ applyTimeRangeFilters(dashboardContextFormData, afterDuplicates),
+ exploreFormData.slice_id === 0,
+ );
+
+ return final;
+ })(),
}),
{},
);
-
const ownColorScheme = exploreFormData.color_scheme;
const dashboardColorScheme = dashboardContextFormData.color_scheme;
const appliedColorScheme = dashboardColorScheme || ownColorScheme;
+ const deckGLProperties: JsonObject = {};
+
+ if (
+ isDeckGLChart &&
+ isDefined(deckSlices) &&
+ 'adhoc_filters' in adhocFilters &&
+ Array.isArray(adhocFilters?.adhoc_filters)
+ ) {
+ const adhocFiltersWithDeckSlices =
+ adhocFilters?.adhoc_filters?.map((filter: AdhocFilter) => ({
+ ...filter,
+ ...(Array.isArray(deckSlices) &&
+ deckSlices?.length > 0 &&
+ filter?.isExtra && {
+ deck_slices: deckSlices,
+ }),
+ })) || [];
+
+ adhocFilters.adhoc_filters = adhocFiltersWithDeckSlices;
+ }
+
+ if (isDeckGLChart) {
+ if (dashboardContextFormData.layer_filter_scope) {
+ deckGLProperties.layer_filter_scope =
+ dashboardContextFormData.layer_filter_scope;
+ }
+ if (dashboardContextFormData.filter_data_mapping) {
+ deckGLProperties.filter_data_mapping =
+ dashboardContextFormData.filter_data_mapping;
+ }
+ }
+
+ if (saveAction === 'overwrite') {
+ return {
+ ...dashboardContextFormData,
+ ...filterBoxData,
+ ...nativeFiltersData,
+ ...adhocFilters,
+ ...exploreFormData, // Explore form data comes last to override
+ own_color_scheme: ownColorScheme,
+ color_scheme: appliedColorScheme,
+ dashboard_color_scheme: dashboardColorScheme,
+ ...deckGLProperties,
+ };
+ }
+
+ // Default behavior: Dashboard context overrides explore data, but adhoc filters, color schemes
+ // and specific properties from filterBox and native filters take final precedence
return {
...exploreFormData,
...dashboardContextFormData,
@@ -232,5 +300,6 @@ export const getFormDataWithDashboardContext = (
own_color_scheme: ownColorScheme,
color_scheme: appliedColorScheme,
dashboard_color_scheme: dashboardColorScheme,
+ ...deckGLProperties,
};
};
diff --git a/superset-frontend/src/pages/Chart/index.tsx b/superset-frontend/src/pages/Chart/index.tsx
index cc2b431ffb..61edb9bfe5 100644
--- a/superset-frontend/src/pages/Chart/index.tsx
+++ b/superset-frontend/src/pages/Chart/index.tsx
@@ -108,7 +108,9 @@ const getDashboardContextFormData = () => {
filterBoxFilters,
dataMask,
dashboardId,
+ activeFilters,
} = dashboardContext;
+
const dashboardContextWithFilters = getFormDataWithExtraFilters({
chart: { id: sliceId },
filters: getAppliedFilterValues(sliceId, filterBoxFilters),
@@ -122,6 +124,7 @@ const getDashboardContextFormData = () => {
sliceId,
allSliceIds: [sliceId],
extraControls: {},
+ ...(activeFilters && { activeFilters }),
});
Object.assign(dashboardContextWithFilters, {
dashboardId,
@@ -143,16 +146,18 @@ export default function ExplorePage() {
URL_PARAMS.saveAction,
) as SaveActionType | null;
const dashboardContextFormData = getDashboardContextFormData();
+
if (!isExploreInitialized.current || !!saveAction) {
fetchExploreData(exploreUrlParams)
.then(({ result }) => {
- const formData =
- !isExploreInitialized.current && dashboardContextFormData
- ? getFormDataWithDashboardContext(
- result.form_data,
- dashboardContextFormData,
- )
- : result.form_data;
+ const formData = dashboardContextFormData
+ ? getFormDataWithDashboardContext(
+ result.form_data,
+ dashboardContextFormData,
+ saveAction,
+ )
+ : result.form_data;
+
dispatch(
hydrateExplore({
...result,
diff --git a/superset-frontend/src/types/DashboardContextForExplore.ts b/superset-frontend/src/types/DashboardContextForExplore.ts
index e9e964a1a3..b9d0c3bd4a 100644
--- a/superset-frontend/src/types/DashboardContextForExplore.ts
+++ b/superset-frontend/src/types/DashboardContextForExplore.ts
@@ -21,7 +21,7 @@ import {
DataRecordValue,
PartialFilters,
} from '@superset-ui/core';
-import { ChartConfiguration } from 'src/dashboard/types';
+import { ChartConfiguration, ActiveFilters } from 'src/dashboard/types';
export interface DashboardContextForExplore {
labelsColor: Record<string, string>;
@@ -40,6 +40,7 @@ export interface DashboardContextForExplore {
};
}
| {};
+ activeFilters?: ActiveFilters;
isRedundant?: boolean;
dashboardPageId?: string;
}
diff --git a/superset-frontend/src/utils/simpleFilterToAdhoc.ts b/superset-frontend/src/utils/simpleFilterToAdhoc.ts
index a3db14c074..4bff03eace 100644
--- a/superset-frontend/src/utils/simpleFilterToAdhoc.ts
+++ b/superset-frontend/src/utils/simpleFilterToAdhoc.ts
@@ -29,10 +29,50 @@ import {
import { OPERATOR_ENUM_TO_OPERATOR_TYPE } from '../explore/constants';
import { translateToSql } from '../explore/components/controls/FilterControl/utils/translateToSQL';
+const findMatchingFilterKey = (
+ filterClause: QueryObjectFilterClause & {
+ filterDataMapping?: Record<string, any[]>;
+ layerFilterScope?: Record<string, any>;
+ },
+): string | null => {
+ if (!filterClause.filterDataMapping) {
+ return null;
+ }
+
+ const { col, op } = filterClause;
+ const val = 'val' in filterClause ? filterClause.val : undefined;
+
+ for (const [key, filters] of Object.entries(filterClause.filterDataMapping)) {
+ if (Array.isArray(filters)) {
+ const matchingFilter = filters.find(
+ filter =>
+ filter.col === col &&
+ filter.op === op &&
+ JSON.stringify(filter.val) === JSON.stringify(val),
+ );
+
+ if (matchingFilter) {
+ return key;
+ }
+ }
+ }
+
+ return null;
+};
+
export const simpleFilterToAdhoc = (
- filterClause: QueryObjectFilterClause,
+ filterClause: QueryObjectFilterClause & {
+ filterDataMapping?: Record<string, any[]>;
+ layerFilterScope?: Record<string, any>;
+ },
clause: Clauses = Clauses.Where,
) => {
+ // Find matching filter key
+ const matchingFilterKey = findMatchingFilterKey(filterClause);
+ const filterScope = matchingFilterKey
+ ? filterClause.layerFilterScope?.[matchingFilterKey]
+ : undefined;
+
let result: AdhocFilter;
if (isAdhocColumn(filterClause.col)) {
result = {
@@ -60,6 +100,7 @@ export const simpleFilterToAdhoc = (
if (filterClause.isExtra) {
Object.assign(result, {
isExtra: true,
+ layerFilterScope: filterScope,
filterOptionName: `filter_${Math.random()
.toString(36)
.substring(2, 15)}_${Math.random().toString(36).substring(2, 15)}`,
diff --git a/superset/viz.py b/superset/viz.py
index 22e9e506f3..a180183d3a 100644
--- a/superset/viz.py
+++ b/superset/viz.py
@@ -1525,6 +1525,81 @@ class DeckGLMultiLayer(BaseViz):
def query_obj(self) -> QueryObjectDict:
return {}
+ def _filter_items_by_scope(
+ self,
+ items: list[Any],
+ layer_index: int,
+ layer_filter_scope: dict[str, list[int]],
+ ) -> list[Any]:
+ """Filter items based on layer filter scope."""
+ filtered_items = []
+ for filter_item in items:
+ filter_id = getattr(filter_item, "filterId", None)
+ if filter_id:
+ filter_scope = layer_filter_scope.get(filter_id, [])
+ if filter_scope is None:
+ filter_scope = []
+ if not filter_scope or layer_index in filter_scope:
+ filtered_items.append(filter_item)
+ else:
+ filtered_items.append(filter_item)
+ return filtered_items
+
+ def _process_extra_form_data_filters(
+ self,
+ layer_index: int,
+ layer_filter_scope: dict[str, list[int]],
+ filter_data_mapping: dict[str, list[Any]],
+ extra_form_data: dict[str, Any],
+ ) -> dict[str, Any]:
+ """Process extra_form_data filters with layer-specific filtering."""
+ if not extra_form_data or not filter_data_mapping:
+ return extra_form_data
+
+ filtered_extra_form_data_filters = []
+ for filter_id, filter_scope in layer_filter_scope.items():
+ if filter_scope is None:
+ filter_scope = []
+
+ if not filter_scope or layer_index in filter_scope:
+ filters_from_this_filter = filter_data_mapping.get(filter_id, [])
+ filtered_extra_form_data_filters.extend(filters_from_this_filter)
+
+ return {
+ **extra_form_data,
+ "filters": filtered_extra_form_data_filters,
+ }
+
+ def _apply_layer_filtering(
+ self, form_data: dict[str, Any], layer_index: int
+ ) -> dict[str, Any]:
+ """Apply layer-specific filtering to form data."""
+ layer_filter_scope = self.form_data.get("layer_filter_scope", {})
+ filter_data_mapping = self.form_data.get("filter_data_mapping", {})
+
+ if not layer_filter_scope:
+ form_data["extra_filters"] = self.form_data.get("extra_filters", [])
+ form_data["adhoc_filters"] = self.form_data.get("adhoc_filters")
+ form_data["extra_form_data"] = self.form_data.get("extra_form_data")
+ return form_data
+
+ filtered_extra_filters = self._filter_items_by_scope(
+ self.form_data.get("extra_filters", []), layer_index, layer_filter_scope
+ )
+ filtered_adhoc_filters = self._filter_items_by_scope(
+ self.form_data.get("adhoc_filters", []), layer_index, layer_filter_scope
+ )
+
+ extra_form_data = self.form_data.get("extra_form_data", {})
+ filtered_extra_form_data = self._process_extra_form_data_filters(
+ layer_index, layer_filter_scope, filter_data_mapping, extra_form_data
+ )
+
+ form_data["extra_filters"] = filtered_extra_filters
+ form_data["adhoc_filters"] = filtered_adhoc_filters
+ form_data["extra_form_data"] = filtered_extra_form_data
+ return form_data
+
@deprecated(deprecated_in="3.0")
def get_data(self, df: pd.DataFrame) -> VizData:
# Late imports to avoid circular import issues
@@ -1537,12 +1612,9 @@ class DeckGLMultiLayer(BaseViz):
features: dict[str, list[Any]] = {}
- for slc in slices:
+ for layer_index, slc in enumerate(slices):
form_data = slc.form_data
-
- form_data["extra_filters"] = self.form_data.get("extra_filters", [])
- form_data["extra_form_data"] = self.form_data.get("extra_form_data", {})
- form_data["adhoc_filters"] = self.form_data.get("adhoc_filters")
+ form_data = self._apply_layer_filtering(form_data, layer_index)
viz_type_name = form_data.get("viz_type")
viz_class = viz_types.get(viz_type_name)
@@ -1552,7 +1624,12 @@ class DeckGLMultiLayer(BaseViz):
viz_instance = viz_class(datasource=slc.datasource, form_data=form_data)
payload = viz_instance.get_payload()
- if payload and "data" in payload and "features" in payload["data"]:
+ if (
+ payload
+ and "data" in payload
+ and payload["data"] is not None
+ and "features" in payload["data"]
+ ):
if viz_type_name not in features:
features[viz_type_name] = []
features[viz_type_name].extend(payload["data"]["features"])
@@ -1560,7 +1637,7 @@ class DeckGLMultiLayer(BaseViz):
return {
"features": features,
"mapboxApiKey": config["MAPBOX_API_KEY"],
- "slices": [slc.data for slc in slices],
+ "slices": [slc.data for slc in slices if slc.data is not None],
}
@@ -1571,6 +1648,77 @@ class BaseDeckGLViz(BaseViz):
credits = '<a href="https://uber.github.io/deck.gl/">deck.gl</a>'
spatial_control_keys: list[str] = []
+ def __init__(
+ self, datasource: BaseDatasource, form_data: dict[str, Any], **kwargs: Any
+ ) -> None:
+ # Apply layer-specific filtering for deck multi layer charts in edit mode
+ if self._should_apply_layer_filtering(form_data):
+ form_data = self._apply_multilayer_filtering(form_data)
+ super().__init__(datasource, form_data, **kwargs)
+
+ def _should_apply_layer_filtering(self, form_data: dict[str, Any]) -> bool:
+ """Check if this is a deck layer that's part of a multilayer setup."""
+ return (
+ "slice_id" in form_data
+ and "adhoc_filters" in form_data
+ and self._has_layer_scoped_filters(form_data)
+ )
+
+ def _has_layer_scoped_filters(self, form_data: dict[str, Any]) -> bool:
+ """Check if any filter has layerFilterScope (indicates multilayer context)."""
+ for filter_item in form_data.get("adhoc_filters", []):
+ if (
+ isinstance(filter_item, dict)
+ and filter_item.get("layerFilterScope") is not None
+ ):
+ return True
+ return False
+
+ def _apply_multilayer_filtering(self, form_data: dict[str, Any]) -> dict[str, Any]:
+ """
+ Filter adhoc_filters based on layer scope for this specific layer.
+
+ In deck multi-layer charts, each individual layer should only receive:
+ 1. Global filters (filters without layerFilterScope)
+ 2. Filters specifically scoped to this layer
+
+ This prevents over-filtering when multiple layer-scoped filters are present.
+ """
+ slice_id = form_data.get("slice_id")
+ deck_slices = self._get_deck_slices_from_filters(form_data)
+
+ if not deck_slices or slice_id not in deck_slices:
+ return form_data
+
+ layer_index = deck_slices.index(slice_id)
+ filtered_adhoc_filters = []
+
+ for filter_item in form_data.get("adhoc_filters", []):
+ layer_scope = self._get_filter_layer_scope(filter_item)
+
+ # Include global filters (no layer scope) or filters scoped to this layer
+ if layer_scope is None or layer_index in layer_scope:
+ filtered_adhoc_filters.append(filter_item)
+
+ modified_form_data = form_data.copy()
+ modified_form_data["adhoc_filters"] = filtered_adhoc_filters
+ return modified_form_data
+
+ def _get_deck_slices_from_filters(
+ self, form_data: dict[str, Any]
+ ) -> list[int] | None:
+ """Extract deck_slices from any filter that contains it."""
+ for filter_item in form_data.get("adhoc_filters", []):
+ if isinstance(filter_item, dict) and "deck_slices" in filter_item:
+ return filter_item["deck_slices"]
+ return None
+
+ def _get_filter_layer_scope(self, filter_item: Any) -> list[int] | None:
+ """Extract layerFilterScope from a filter item."""
+ if isinstance(filter_item, dict):
+ return filter_item.get("layerFilterScope")
+ return getattr(filter_item, "layerFilterScope", None)
+
@deprecated(deprecated_in="3.0")
def get_metrics(self) -> list[str]:
# pylint: disable=attribute-defined-outside-init
diff --git a/tests/integration_tests/viz_tests.py b/tests/integration_tests/viz_tests.py
index 1631f8d7e0..b3f4a65da1 100644
--- a/tests/integration_tests/viz_tests.py
+++ b/tests/integration_tests/viz_tests.py
@@ -812,6 +812,620 @@ class TestBaseDeckGLViz(SupersetTestCase):
adhoc_filters = test_viz_deckgl.form_data["adhoc_filters"]
assert expected_results.get(mock_key) == adhoc_filters
+ def test_init_with_layer_filtering_applied(self):
+ """Test BaseDeckGLViz.__init__ applies layer filtering when conditions are
+ met."""
+ datasource = self.get_datasource_mock()
+ form_data = {
+ "slice_id": 123,
+ "adhoc_filters": [
+ {
+ "clause": "WHERE",
+ "subject": "col1",
+ "operator": "==",
+ "comparator": "value1",
+ "layerFilterScope": [0, 1],
+ "deck_slices": [123, 456],
+ },
+ {
+ "clause": "WHERE",
+ "subject": "col2",
+ "operator": "!=",
+ "comparator": "value2",
+ "layerFilterScope": [1],
+ "deck_slices": [123, 456],
+ },
+ ],
+ }
+
+ test_viz = viz.BaseDeckGLViz(datasource, form_data)
+
+ # Should only have the first filter (scoped to layer 0)
+ assert len(test_viz.form_data["adhoc_filters"]) == 1
+ assert test_viz.form_data["adhoc_filters"][0]["subject"] == "col1"
+
+ def test_init_without_layer_filtering(self):
+ """Test BaseDeckGLViz.__init__ doesn't apply filtering when conditions
+ aren't met."""
+ datasource = self.get_datasource_mock()
+ form_data = {
+ "adhoc_filters": [
+ {
+ "clause": "WHERE",
+ "subject": "col1",
+ "operator": "==",
+ "comparator": "value1",
+ }
+ ]
+ }
+ original_filters = form_data["adhoc_filters"].copy()
+
+ test_viz = viz.BaseDeckGLViz(datasource, form_data)
+
+ # Filters should remain unchanged
+ assert test_viz.form_data["adhoc_filters"] == original_filters
+
+ def test_should_apply_layer_filtering_true(self):
+ """Test _should_apply_layer_filtering returns True when all conditions are
+ met."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"slice_id": 123, "adhoc_filters": [{"layerFilterScope": [0, 1]}]}
+
+ result = test_viz._should_apply_layer_filtering(form_data)
+ assert result is True
+
+ def test_should_apply_layer_filtering_false_missing_slice_id(self):
+ """Test _should_apply_layer_filtering returns False when slice_id is missing."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"adhoc_filters": [{"layerFilterScope": [0, 1]}]}
+
+ result = test_viz._should_apply_layer_filtering(form_data)
+ assert result is False
+
+ def test_should_apply_layer_filtering_false_missing_adhoc_filters(self):
+ """Test _should_apply_layer_filtering returns False when adhoc_filters is
+ missing."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"slice_id": 123}
+
+ result = test_viz._should_apply_layer_filtering(form_data)
+ assert result is False
+
+ def test_should_apply_layer_filtering_false_no_layer_scoped_filters(self):
+ """Test _should_apply_layer_filtering returns False when no layer scoped
+ filters exist."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "slice_id": 123,
+ "adhoc_filters": [{"clause": "WHERE", "subject": "col1"}],
+ }
+
+ result = test_viz._should_apply_layer_filtering(form_data)
+ assert result is False
+
+ def test_has_layer_scoped_filters_true_with_dict(self):
+ """Test _has_layer_scoped_filters returns True when filter dict has
+ layerFilterScope."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "adhoc_filters": [{"layerFilterScope": [0, 1]}, {"clause": "WHERE"}]
+ }
+
+ result = test_viz._has_layer_scoped_filters(form_data)
+ assert result is True
+
+ def test_has_layer_scoped_filters_true_with_non_none_value(self):
+ """Test _has_layer_scoped_filters returns True when layerFilterScope is not
+ None."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "adhoc_filters": [
+ {"layerFilterScope": []}, # Empty list is not None
+ {"clause": "WHERE"},
+ ]
+ }
+
+ result = test_viz._has_layer_scoped_filters(form_data)
+ assert result is True
+
+ def test_has_layer_scoped_filters_false_none_value(self):
+ """Test _has_layer_scoped_filters returns False when layerFilterScope is
+ None."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"adhoc_filters": [{"layerFilterScope": None}, {"clause": "WHERE"}]}
+
+ result = test_viz._has_layer_scoped_filters(form_data)
+ assert result is False
+
+ def test_has_layer_scoped_filters_false_no_scoped_filters(self):
+ """Test _has_layer_scoped_filters returns False when no filters have
+ layerFilterScope."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "adhoc_filters": [
+ {"clause": "WHERE", "subject": "col1"},
+ {"clause": "WHERE", "subject": "col2"},
+ ]
+ }
+
+ result = test_viz._has_layer_scoped_filters(form_data)
+ assert result is False
+
+ def test_has_layer_scoped_filters_empty_filters(self):
+ """Test _has_layer_scoped_filters returns False when adhoc_filters is empty."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"adhoc_filters": []}
+
+ result = test_viz._has_layer_scoped_filters(form_data)
+ assert result is False
+
+ def test_apply_multilayer_filtering_filters_by_layer_scope(self):
+ """Test _apply_multilayer_filtering correctly filters by layer scope."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "slice_id": 456, # This is layer index 1
+ "adhoc_filters": [
+ {
+ "subject": "global_filter",
+ "deck_slices": [123, 456],
+ # No layerFilterScope = global filter
+ },
+ {
+ "subject": "layer_0_filter",
+ "layerFilterScope": [0],
+ "deck_slices": [123, 456],
+ },
+ {
+ "subject": "layer_1_filter",
+ "layerFilterScope": [1],
+ "deck_slices": [123, 456],
+ },
+ {
+ "subject": "layer_0_1_filter",
+ "layerFilterScope": [0, 1],
+ "deck_slices": [123, 456],
+ },
+ ],
+ }
+
+ result = test_viz._apply_multilayer_filtering(form_data)
+
+ # Should include: global_filter, layer_1_filter, layer_0_1_filter
+ assert len(result["adhoc_filters"]) == 3
+ subjects = [f["subject"] for f in result["adhoc_filters"]]
+ assert "global_filter" in subjects
+ assert "layer_1_filter" in subjects
+ assert "layer_0_1_filter" in subjects
+ assert "layer_0_filter" not in subjects
+
+ def test_apply_multilayer_filtering_no_deck_slices(self):
+ """Test _apply_multilayer_filtering returns original form_data when no
+ deck_slices."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"slice_id": 123, "adhoc_filters": [{"subject": "filter1"}]}
+
+ result = test_viz._apply_multilayer_filtering(form_data)
+
+ # Should return original form_data unchanged
+ assert result == form_data
+
+ def test_apply_multilayer_filtering_slice_not_in_deck_slices(self):
+ """Test _apply_multilayer_filtering returns original when slice_id not in
+ deck_slices."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "slice_id": 999, # Not in deck_slices
+ "adhoc_filters": [{"subject": "filter1", "deck_slices": [123, 456]}],
+ }
+
+ result = test_viz._apply_multilayer_filtering(form_data)
+
+ # Should return original form_data unchanged
+ assert result == form_data
+
+ def test_get_deck_slices_from_filters_found(self):
+ """Test _get_deck_slices_from_filters returns deck_slices when found."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {
+ "adhoc_filters": [
+ {"subject": "filter1"},
+ {"subject": "filter2", "deck_slices": [123, 456, 789]},
+ {"subject": "filter3"},
+ ]
+ }
+
+ result = test_viz._get_deck_slices_from_filters(form_data)
+
+ assert result == [123, 456, 789]
+
+ def test_get_deck_slices_from_filters_not_found(self):
+ """Test _get_deck_slices_from_filters returns None when not found."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"adhoc_filters": [{"subject": "filter1"}, {"subject": "filter2"}]}
+
+ result = test_viz._get_deck_slices_from_filters(form_data)
+
+ assert result is None
+
+ def test_get_deck_slices_from_filters_empty_filters(self):
+ """Test _get_deck_slices_from_filters returns None when adhoc_filters is
+ empty."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ form_data = {"adhoc_filters": []}
+
+ result = test_viz._get_deck_slices_from_filters(form_data)
+
+ assert result is None
+
+ def test_get_filter_layer_scope_dict(self):
+ """Test _get_filter_layer_scope with dict filter item."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ filter_item = {"layerFilterScope": [0, 1, 2]}
+ result = test_viz._get_filter_layer_scope(filter_item)
+
+ assert result == [0, 1, 2]
+
+ def test_get_filter_layer_scope_dict_none(self):
+ """Test _get_filter_layer_scope with dict that has None layerFilterScope."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ filter_item = {"layerFilterScope": None}
+ result = test_viz._get_filter_layer_scope(filter_item)
+
+ assert result is None
+
+ def test_get_filter_layer_scope_dict_missing_key(self):
+ """Test _get_filter_layer_scope with dict missing layerFilterScope."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ filter_item = {"subject": "col1"}
+ result = test_viz._get_filter_layer_scope(filter_item)
+
+ assert result is None
+
+ def test_get_filter_layer_scope_object_with_attribute(self):
+ """Test _get_filter_layer_scope with object having layerFilterScope
+ attribute."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ from unittest.mock import Mock
+
+ filter_item = Mock()
+ filter_item.layerFilterScope = [1, 2]
+
+ result = test_viz._get_filter_layer_scope(filter_item)
+
+ assert result == [1, 2]
+
+ def test_get_filter_layer_scope_object_without_attribute(self):
+ """Test _get_filter_layer_scope with object missing layerFilterScope
+ attribute."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ from unittest.mock import Mock
+
+ filter_item = Mock()
+ del filter_item.layerFilterScope # Remove the attribute
+
+ result = test_viz._get_filter_layer_scope(filter_item)
+
+ assert result is None
+
+ def test_get_filter_layer_scope_non_dict_non_object(self):
+ """Test _get_filter_layer_scope with non-dict, non-object types."""
+ datasource = self.get_datasource_mock()
+ test_viz = viz.BaseDeckGLViz(datasource, {})
+
+ # Test with string
+ result = test_viz._get_filter_layer_scope("string_filter")
+ assert result is None
+
+ # Test with number
+ result = test_viz._get_filter_layer_scope(123)
+ assert result is None
+
+ # Test with None
+ result = test_viz._get_filter_layer_scope(None)
+ assert result is None
+
+
+class TestDeckGLMultiLayer(SupersetTestCase):
+ def test_filter_items_by_scope_with_filter_id(self):
+ """Test _filter_items_by_scope method with items having filterId."""
+ datasource = self.get_datasource_mock()
+ form_data = {}
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ filter_item_1 = Mock()
+ filter_item_1.filterId = "filter_1"
+ filter_item_2 = Mock()
+ filter_item_2.filterId = "filter_2"
+ filter_item_3 = Mock()
+ filter_item_3.filterId = "filter_3"
+
+ items = [filter_item_1, filter_item_2, filter_item_3]
+ layer_index = 0
+ layer_filter_scope = {"filter_1": [0, 1], "filter_2": [1], "filter_3": []}
+
+ result = test_viz._filter_items_by_scope(items, layer_index, layer_filter_scope)
+
+ assert len(result) == 2
+ assert filter_item_1 in result
+ assert filter_item_3 in result
+ assert filter_item_2 not in result
+
+ def test_filter_items_by_scope_without_filter_id(self):
+ """Test _filter_items_by_scope method with items without filterId."""
+ datasource = self.get_datasource_mock()
+ form_data = {}
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ filter_item_1 = Mock()
+ del filter_item_1.filterId
+ filter_item_2 = Mock()
+ filter_item_2.filterId = None
+
+ items = [filter_item_1, filter_item_2]
+ layer_index = 0
+ layer_filter_scope = {"filter_1": [1]}
+
+ result = test_viz._filter_items_by_scope(items, layer_index, layer_filter_scope)
+
+ assert len(result) == 2
+ assert filter_item_1 in result
+ assert filter_item_2 in result
+
+ def test_process_extra_form_data_filters(self):
+ """Test _process_extra_form_data_filters method."""
+ datasource = self.get_datasource_mock()
+ form_data = {}
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ layer_index = 0
+ layer_filter_scope = {"filter_1": [0, 1], "filter_2": [1], "filter_3": []}
+ filter_data_mapping = {
+ "filter_1": [{"column": "col1", "op": "==", "val": "value1"}],
+ "filter_2": [{"column": "col2", "op": "!=", "val": "value2"}],
+ "filter_3": [{"column": "col3", "op": ">", "val": 100}],
+ }
+ extra_form_data = {"existing_key": "existing_value"}
+
+ result = test_viz._process_extra_form_data_filters(
+ layer_index, layer_filter_scope, filter_data_mapping, extra_form_data
+ )
+
+ expected_filters = [
+ {"column": "col1", "op": "==", "val": "value1"},
+ {"column": "col3", "op": ">", "val": 100},
+ ]
+ assert result["filters"] == expected_filters
+ assert result["existing_key"] == "existing_value"
+
+ def test_process_extra_form_data_filters_empty_inputs(self):
+ """Test _process_extra_form_data_filters with empty inputs."""
+ datasource = self.get_datasource_mock()
+ form_data = {}
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ result = test_viz._process_extra_form_data_filters(0, {}, {}, {})
+ assert result == {}
+
+ extra_form_data = {"key": "value"}
+ result = test_viz._process_extra_form_data_filters(0, {}, {}, extra_form_data)
+ assert result == extra_form_data
+
+ def test_apply_layer_filtering_without_layer_filter_scope(self):
+ """Test _apply_layer_filtering when layer_filter_scope is empty."""
+ datasource = self.get_datasource_mock()
+ form_data = {
+ "extra_filters": [Mock(), Mock()],
+ "adhoc_filters": [Mock()],
+ "extra_form_data": {"key": "value"},
+ }
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ layer_form_data = {"viz_type": "deck_scatter"}
+ layer_index = 0
+
+ result = test_viz._apply_layer_filtering(layer_form_data, layer_index)
+
+ assert result["extra_filters"] == form_data["extra_filters"]
+ assert result["adhoc_filters"] == form_data["adhoc_filters"]
+ assert result["extra_form_data"] == form_data["extra_form_data"]
+
+ def test_apply_layer_filtering_with_layer_filter_scope(self):
+ """Test _apply_layer_filtering with layer_filter_scope."""
+ datasource = self.get_datasource_mock()
+
+ extra_filter_1 = Mock()
+ extra_filter_1.filterId = "filter_1"
+ extra_filter_2 = Mock()
+ extra_filter_2.filterId = "filter_2"
+
+ adhoc_filter_1 = Mock()
+ adhoc_filter_1.filterId = "filter_1"
+
+ form_data = {
+ "layer_filter_scope": {"filter_1": [0], "filter_2": [1]},
+ "filter_data_mapping": {
+ "filter_1": [{"column": "col1", "op": "==", "val": "value1"}]
+ },
+ "extra_filters": [extra_filter_1, extra_filter_2],
+ "adhoc_filters": [adhoc_filter_1],
+ "extra_form_data": {"existing": "data"},
+ }
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ layer_form_data = {"viz_type": "deck_scatter"}
+ layer_index = 0
+
+ result = test_viz._apply_layer_filtering(layer_form_data, layer_index)
+
+ assert len(result["extra_filters"]) == 1
+ assert result["extra_filters"][0].filterId == "filter_1"
+ assert len(result["adhoc_filters"]) == 1
+ assert result["adhoc_filters"][0].filterId == "filter_1"
+ assert result["extra_form_data"]["filters"] == [
+ {"column": "col1", "op": "==", "val": "value1"}
+ ]
+
+ @patch("superset.viz.viz_types")
+ @patch("superset.db.session")
+ def test_get_data_with_layer_filtering(self, mock_db_session, mock_viz_types):
+ """Test get_data method with layer filtering enabled."""
+ datasource = self.get_datasource_mock()
+
+ slice_1 = Mock()
+ slice_1.form_data = {"viz_type": "deck_scatter", "layer_name": "Layer 1"}
+ slice_1.data = {"features": [{"type": "Feature"}]}
+ slice_1.datasource = datasource
+
+ slice_2 = Mock()
+ slice_2.form_data = {"viz_type": "deck_path", "layer_name": "Layer 2"}
+ slice_2.data = {"features": [{"type": "Feature"}]}
+ slice_2.datasource = datasource
+
+ # Mock the database query to return our slice objects
+ mock_db_session.query.return_value.filter.return_value.all.return_value = [
+ slice_1,
+ slice_2,
+ ]
+
+ mock_scatter_viz_class = Mock()
+ mock_scatter_viz_instance = Mock()
+ mock_scatter_viz_instance.get_payload.return_value = {
+ "data": {"features": [{"id": 1}]}
+ }
+ mock_scatter_viz_class.return_value = mock_scatter_viz_instance
+
+ mock_path_viz_class = Mock()
+ mock_path_viz_instance = Mock()
+ mock_path_viz_instance.get_payload.return_value = {
+ "data": {"features": [{"id": 2}]}
+ }
+ mock_path_viz_class.return_value = mock_path_viz_instance
+
+ mock_viz_types.get.side_effect = lambda viz_type: {
+ "deck_scatter": mock_scatter_viz_class,
+ "deck_path": mock_path_viz_class,
+ }.get(viz_type)
+
+ form_data = {
+ "layer_filter_scope": {"filter_1": [0], "filter_2": [1]},
+ "filter_data_mapping": {
+ "filter_1": [{"column": "col1", "op": "==", "val": "value1"}],
+ "filter_2": [{"column": "col2", "op": "!=", "val": "value2"}],
+ },
+ "deck_slices": [1, 2], # Use integer IDs instead of Mock objects
+ }
+
+ with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+
+ test_viz._apply_layer_filtering = Mock(
+ side_effect=lambda form_data, idx: form_data
+ )
+
+ result = test_viz.get_data(pd.DataFrame())
+
+ assert test_viz._apply_layer_filtering.call_count == 2
+ test_viz._apply_layer_filtering.assert_any_call(slice_1.form_data, 0)
+ test_viz._apply_layer_filtering.assert_any_call(slice_2.form_data, 1)
+
+ assert isinstance(result, dict)
+ assert "features" in result
+ assert "mapboxApiKey" in result
+ assert "slices" in result
+ assert result["mapboxApiKey"] == "test_key"
+
+ @patch("superset.viz.viz_types")
+ @patch("superset.db.session")
+ def test_get_data_filters_none_data_slices(self, mock_db_session, mock_viz_types):
+ """Test get_data method filters out slices with None data."""
+ datasource = self.get_datasource_mock()
+
+ slice_1 = Mock()
+ slice_1.form_data = {"viz_type": "deck_scatter"}
+ slice_1.data = {"features": [{"type": "Feature"}]}
+ slice_1.datasource = datasource
+
+ slice_2 = Mock()
+ slice_2.form_data = {"viz_type": "deck_path"}
+ slice_2.data = None
+ slice_2.datasource = datasource
+
+ # Mock the database query to return our slice objects
+ mock_db_session.query.return_value.filter.return_value.all.return_value = [
+ slice_1,
+ slice_2,
+ ]
+
+ mock_viz_class = Mock()
+ mock_viz_instance = Mock()
+ mock_viz_instance.get_payload.return_value = {"data": {"features": []}}
+ mock_viz_class.return_value = mock_viz_instance
+ mock_viz_types.get.return_value = mock_viz_class
+
+ form_data = {"deck_slices": [1, 2]} # Use integer IDs instead of Mock objects
+
+ with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+ result = test_viz.get_data(pd.DataFrame())
+
+ assert isinstance(result, dict)
+ assert len(result["slices"]) == 1
+ assert result["slices"][0] == slice_1.data
+
+ def test_get_data_empty_deck_slices(self):
+ """Test get_data method with empty deck_slices."""
+ datasource = self.get_datasource_mock()
+ form_data = {"deck_slices": []}
+
+ with patch("superset.viz.config", {"MAPBOX_API_KEY": "test_key"}):
+ test_viz = viz.DeckGLMultiLayer(datasource, form_data)
+ result = test_viz.get_data(pd.DataFrame())
+
+ assert isinstance(result, dict)
+ assert result["features"] == {}
+ assert result["slices"] == []
+ assert result["mapboxApiKey"] == "test_key"
+
class TestTimeSeriesViz(SupersetTestCase):
def test_timeseries_unicode_data(self):