15560777340

Committed 10 Jun 2025 01:25PM UTC coverage: 76.954% (-0.04%) from 76.993%

Build # 15560777340

Build Type

Pull #11026

github

Committed by

web-flow

Commit Message

Merge 9eb3869d2 into 710995799

Pull Request Pull Request #11026: Update User Guide - Legend filtering for WMS layers

Run Details

31047 of 48334 branches covered (64.23%)

38674 of 50256 relevant lines covered (76.95%)

36.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

19.05

/web/client/plugins/widgetbuilder/MapBuilder.jsx

/*
 * Copyright 2017, GeoSolutions Sas.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree.
 */
import React from 'react';
import { connect } from 'react-redux';
import { branch, compose, renderComponent, withHandlers, withProps, withState } from 'recompose';
import find from 'lodash/find';
import { onEditorChange } from '../../actions/widgets';

import BorderLayout from '../../components/layout/BorderLayout';
import handleNodeSelection from '../../components/widgets/builder/wizard/map/enhancers/handleNodeSelection';
import ToolbarComp from '../../components/widgets/builder/wizard/map/Toolbar';
import MapWizardComp from '../../components/widgets/builder/wizard/MapWizard';
import BuilderHeader from './BuilderHeader';
import { wizardSelector, wizardStateToProps } from './commons';
import mapBuilderConnectMask from './enhancers/connection/mapBuilderConnectMask';
import handleNodeEditing from './enhancers/handleNodeEditing';
import layerSelector from './enhancers/layerSelector';
import manageLayers from './enhancers/manageLayers';
import mapToolbar from './enhancers/mapToolbar';
import MapLayerSelectorComp from './MapLayerSelector';
import MapSelector from './MapSelector';
import { catalogEditorEnhancer } from './enhancers/catalogEditorEnhancer';
import { getLayerTileMatrixSetsInfo } from '../../api/WMTS';
import { generateGeoServerWMTSUrl } from '../../utils/WMTSUtils';
import { isProjectionAvailable } from '../../utils/ProjectionUtils';
import { normalizeSRS } from '../../utils/CoordinatesUtils';


const Toolbar = mapToolbar(ToolbarComp);

/*
 * Prompts Map Selection or Layer selector (to add layers)
 */
const chooseMapEnhancer = compose(
    connect(wizardSelector, {
        onResetChange: onEditorChange
    }),
    // map selector
    branch(
        ({ editorData = {} } = {}) => !editorData.maps,
        renderComponent(MapSelector)
    ),
    // layer selector - to add layers to the map
    withState('layerSelectorOpen', 'toggleLayerSelector', false),
    catalogEditorEnhancer,
    branch(
        ({ layerSelectorOpen = false } = {}) => layerSelectorOpen,
        renderComponent(
            compose(
                manageLayers,
                withHandlers({
                    onLayerChoice: ({ toggleLayerSelector = () => { }, addLayer = () => { } }) => (layer) => {
                        // fetching 'tileGridData' if layer has truthy flag 'remoteTileGrids' and adding the required props to layer object
                        let tileGridPromise = layer.type === 'wms' && layer.remoteTileGrids ? getLayerTileMatrixSetsInfo(generateGeoServerWMTSUrl(layer), layer.name, layer) : new Promise((resolve) => resolve(null));
                        tileGridPromise.then((tileGridData) => {
                            let tileGridProperties = {};
                            if (tileGridData) {
                                const filteredTileGrids = tileGridData.tileGrids.filter(({ crs }) => isProjectionAvailable(normalizeSRS(crs)));
                                tileGridProperties = tileGridData !== undefined ? {
                                    tileGrids: tileGridData.tileGrids,
                                    tileGridStrategy: 'custom',
                                    tileGridCacheSupport: filteredTileGrids?.length > 0 ?
                                        tileGridData.formats ? {formats: tileGridData.formats} : {}
                                        : undefined
                                } : {};
                            }
                            addLayer({...layer, ...tileGridProperties});
                            toggleLayerSelector(false);
                        });
                    }
                }),
                layerSelector
            )(MapLayerSelectorComp)
        )
    ),
    // add button to back to map selection
    withProps(({ onResetChange = () => { } }) => ({
        exitButton: {
            glyph: 'arrow-left',
            onClick: () => {
                // options will not be valid anymore in case of layer change
                onResetChange("maps", undefined);
                onResetChange("selectedMapId", undefined);
            }
        }
    }))
);
const Builder = connect(
    wizardSelector,
    {
        onChange: onEditorChange
    },
    wizardStateToProps
)(MapWizardComp);

const mapBuilder = compose(
    chooseMapEnhancer,
    withProps(({ editorData = {}}) => ({
        map: find(editorData?.maps, ({mapId} = {}) => mapId === editorData.selectedMapId) || {}
    })),
    mapBuilderConnectMask,
    handleNodeSelection,
    handleNodeEditing
);


export default mapBuilder(({
    enabled, onClose = () => {},
    toggleLayerSelector = () => {},
    editorData = {},
    addonsItems = [],
    editNode, setEditNode, closeNodeEditor, isLocalizedLayerStylesEnabled, env, selectedGroups = [], exitButton, selectedLayers = [], selectedNodes, onNodeSelect = () => {},
    availableDependencies = [], toggleConnection = () => {}, ...props
} = {}) =>
    (<BorderLayout
        className = "map-selector"
        header={(<BuilderHeader onClose={onClose}>
            <Toolbar
                exitButton={exitButton}
                editorData={editorData}
                availableDependencies={availableDependencies}
                toggleConnection={toggleConnection}
                selectedNodes={selectedNodes}
                selectedLayers={selectedLayers}
                selectedGroups={selectedGroups}
                onNodeSelect={onNodeSelect}
                toggleLayerSelector={toggleLayerSelector}/></BuilderHeader>)}
    >
        {enabled ? <Builder
            setEditNode={setEditNode}
            addonsItems={addonsItems}
            editNode={editNode}
            closeNodeEditor={closeNodeEditor}
            onNodeSelect={onNodeSelect}
            isLocalizedLayerStylesEnabled={isLocalizedLayerStylesEnabled}
            env={env}
            selectedNodes={selectedNodes} {...props} /> : null}
    </BorderLayout>));

1	/*
2	* Copyright 2017, GeoSolutions Sas.
3	* All rights reserved.
4	*
5	* This source code is licensed under the BSD-style license found in the
6	* LICENSE file in the root directory of this source tree.
7	*/
8	import React from 'react';
9	import { connect } from 'react-redux';
10	import { branch, compose, renderComponent, withHandlers, withProps, withState } from 'recompose';
11	import find from 'lodash/find';
12	import { onEditorChange } from '../../actions/widgets';
13
14	import BorderLayout from '../../components/layout/BorderLayout';
15	import handleNodeSelection from '../../components/widgets/builder/wizard/map/enhancers/handleNodeSelection';
16	import ToolbarComp from '../../components/widgets/builder/wizard/map/Toolbar';
17	import MapWizardComp from '../../components/widgets/builder/wizard/MapWizard';
18	import BuilderHeader from './BuilderHeader';
19	import { wizardSelector, wizardStateToProps } from './commons';
20	import mapBuilderConnectMask from './enhancers/connection/mapBuilderConnectMask';
21	import handleNodeEditing from './enhancers/handleNodeEditing';
22	import layerSelector from './enhancers/layerSelector';
23	import manageLayers from './enhancers/manageLayers';
24	import mapToolbar from './enhancers/mapToolbar';
25	import MapLayerSelectorComp from './MapLayerSelector';
26	import MapSelector from './MapSelector';
27	import { catalogEditorEnhancer } from './enhancers/catalogEditorEnhancer';
28	import { getLayerTileMatrixSetsInfo } from '../../api/WMTS';
29	import { generateGeoServerWMTSUrl } from '../../utils/WMTSUtils';
30	import { isProjectionAvailable } from '../../utils/ProjectionUtils';
31	import { normalizeSRS } from '../../utils/CoordinatesUtils';
32
33
34	const Toolbar = mapToolbar(ToolbarComp);	1✔
35
36	/*
37	* Prompts Map Selection or Layer selector (to add layers)
38	*/
39	const chooseMapEnhancer = compose(	1✔
40	connect(wizardSelector, {
41	onResetChange: onEditorChange
42	}),
43	// map selector
44	branch(
45	({ editorData = {} } = {}) => !editorData.maps,	×
46	renderComponent(MapSelector)
47	),
48	// layer selector - to add layers to the map
49	withState('layerSelectorOpen', 'toggleLayerSelector', false),
50	catalogEditorEnhancer,
51	branch(
52	({ layerSelectorOpen = false } = {}) => layerSelectorOpen,	×
53	renderComponent(
54	compose(
55	manageLayers,
56	withHandlers({
57	onLayerChoice: ({ toggleLayerSelector = () => { }, addLayer = () => { } }) => (layer) => {	×
58	// fetching 'tileGridData' if layer has truthy flag 'remoteTileGrids' and adding the required props to layer object
59	let tileGridPromise = layer.type === 'wms' && layer.remoteTileGrids ? getLayerTileMatrixSetsInfo(generateGeoServerWMTSUrl(layer), layer.name, layer) : new Promise((resolve) => resolve(null));	×
60	tileGridPromise.then((tileGridData) => {	×
61	let tileGridProperties = {};	×
62	if (tileGridData) {	×
63	const filteredTileGrids = tileGridData.tileGrids.filter(({ crs }) => isProjectionAvailable(normalizeSRS(crs)));	×
64	tileGridProperties = tileGridData !== undefined ? {	×
65	tileGrids: tileGridData.tileGrids,
66	tileGridStrategy: 'custom',
67	tileGridCacheSupport: filteredTileGrids?.length > 0 ?	×
68	tileGridData.formats ? {formats: tileGridData.formats} : {}	×
69	: undefined
70	} : {};
71	}
72	addLayer({...layer, ...tileGridProperties});	×
73	toggleLayerSelector(false);	×
74	});
75	}
76	}),
77	layerSelector
78	)(MapLayerSelectorComp)
79	)
80	),
81	// add button to back to map selection
82	withProps(({ onResetChange = () => { } }) => ({	×
83	exitButton: {
84	glyph: 'arrow-left',
85	onClick: () => {
86	// options will not be valid anymore in case of layer change
87	onResetChange("maps", undefined);	×
88	onResetChange("selectedMapId", undefined);	×
89	}
90	}
91	}))
92	);
93	const Builder = connect(	1✔
94	wizardSelector,
95	{
96	onChange: onEditorChange
97	},
98	wizardStateToProps
99	)(MapWizardComp);
100
101	const mapBuilder = compose(	1✔
102	chooseMapEnhancer,
103	withProps(({ editorData = {}}) => ({	×
104	map: find(editorData?.maps, ({mapId} = {}) => mapId === editorData.selectedMapId) \|\| {}	×
105	})),
106	mapBuilderConnectMask,
107	handleNodeSelection,
108	handleNodeEditing
109	);
110
111
112	export default mapBuilder(({	×
113	enabled, onClose = () => {},	×
114	toggleLayerSelector = () => {},	×
115	editorData = {},	×
116	addonsItems = [],	×
117	editNode, setEditNode, closeNodeEditor, isLocalizedLayerStylesEnabled, env, selectedGroups = [], exitButton, selectedLayers = [], selectedNodes, onNodeSelect = () => {},	×
118	availableDependencies = [], toggleConnection = () => {}, ...props	×
119	} = {}) =>
120	(<BorderLayout	×
121	className = "map-selector"
122	header={(<BuilderHeader onClose={onClose}>
123	<Toolbar
124	exitButton={exitButton}
125	editorData={editorData}
126	availableDependencies={availableDependencies}
127	toggleConnection={toggleConnection}
128	selectedNodes={selectedNodes}
129	selectedLayers={selectedLayers}
130	selectedGroups={selectedGroups}
131	onNodeSelect={onNodeSelect}
132	toggleLayerSelector={toggleLayerSelector}/></BuilderHeader>)}
133	>
134	{enabled ? <Builder	×
135	setEditNode={setEditNode}
136	addonsItems={addonsItems}
137	editNode={editNode}
138	closeNodeEditor={closeNodeEditor}
139	onNodeSelect={onNodeSelect}
140	isLocalizedLayerStylesEnabled={isLocalizedLayerStylesEnabled}
141	env={env}
142	selectedNodes={selectedNodes} {...props} /> : null}
143	</BorderLayout>));

geosolutions-it / MapStore2 / 15560777340

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous