6275612987

Committed 22 Sep 2023 02:33PM UTC coverage: 19.833%. Remained the same

Build # 6275612987

Build Type

push

github

Committed by

geographika

Commit Message

Remove raf.polyfill.js as only required for IE9 or less

Run Details

372 of 2475 branches covered (0.0%)

Branch coverage included in aggregate %.

1176 of 5330 relevant lines covered (22.06%)

1.93 hits per line

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

8.18

/app/controller/button/FeatureSelectionButtonController.js

/**
* This class is the controller for the button 'FeatureSelectionButton'
 */
Ext.define('CpsiMapview.controller.button.FeatureSelectionButtonController', {
    extend: 'Ext.app.ViewController',

    alias: 'controller.cmv_feature_selection_btn',

    requires: [
        'Ext.window.Toast',
        'BasiGX.util.Layer'
    ],

    /**
    * The OpenLayers map. If not given, will be auto-detected.
    * @cfg
    */
    map: null,

    /**
     * The selector UI for the #filterMode. Created in #onBtnToggle.
     * @property
     * @readonly
     */
    modeSelector: null,

    /**
     * The filter mode (set by the user via #modeSelector UI).
     * @property
     * @readonly
     */
    filterMode: 'ADD_TO_SELECTION', // ADD_TO_SELECTION or NEW_SELECTION

    /**
     * The feature IDs (FIDs) used for filtering.
     * @property
     * @readonly
     */
    fidsToFilter: [],

    constructor: function () {
        var me = this;
        me.onMapClick = me.onMapClick.bind(me);
        me.callParent(arguments);
    },

    init: function () {
        var me = this;
        var ownerGrid = this.getView().up('grid');
        if (ownerGrid) {
            // reset FIDs if grid clears its filters
            ownerGrid.on('cmv-clear-filters', function() {
                me.fidsToFilter = [];
            });
        }
    },

    /**
     * Activates this tool.
     * Adds a click handler to the map and tries to detect the IDs of the
     * clicked features. Builds a filter object for the ("where ID IN(1,2,3))
     * and forwards it to the grid so it gets applied to the underlying WFS.
     *
     * @param {Ext.button.Button} btn The toggled button.
     * @param {Boolean} pressed The toggle state.
     */
    onBtnToggle: function (btn, pressed) {
        var me = this;
        var view = me.getView();

        if (view.map && view.map instanceof ol.Map) {
            me.map = view.map;
        } else {
            // guess map as fallback
            me.map = BasiGX.util.Map.getMapComponent().map;
        }

        if (!view.queryLayer) {
            me.findWfsLayer();
        }

        if (pressed) {
            // create and show selector UI
            me.addModeSelectorUi();
            view.queryLayer.setVisible(true);
            me.map.on('click', me.onMapClick);
        } else {
            me.modeSelector.hide();
            view.queryLayer.setVisible(false);
            me.map.un('click', me.onMapClick);
        }

    },

    /**
     * Adds the mode selector UI to the toolbar (if not existing) and shows it.
     */
    addModeSelectorUi: function () {
        var me = this;

        if (!me.modeSelector) {
            me.modeSelector = Ext.create('Ext.button.Split', {
                viewModel: me.getViewModel(),
                bind: {
                    text: '{addToSelectionLabel}'
                },
                hidden: false,
                menu: new Ext.menu.Menu({
                    items: [
                        {
                            bind: {
                                text: '{addToSelectionLabel}'
                            },
                            handler: function (menu) {
                                me.filterMode = 'ADD_TO_SELECTION';
                                me.modeSelector.setText(menu.text);
                            }
                        },
                        {
                            bind: {
                                text: '{newSelectionLabel}'
                            },
                            handler: function (menu) {
                                me.filterMode = 'NEW_SELECTION';
                                me.modeSelector.setText(menu.text);
                            }
                        },
                    ]
                })
            });

            var tb = me.getView().up('toolbar');
            var btnGroup = me.getView().up('buttongroup');
            if (tb && btnGroup) {
                btnGroup.add(me.modeSelector);
            }
        }

        me.modeSelector.show();
    },

    /**
     * Function to determine the WFS layer to connect the click handler if not
     * yet defined.
     */
    findWfsLayer: function () {
        var me = this;
        var view = me.getView();
        if (!view.queryLayer && view.vectorLayerKey) {
            view.queryLayer = BasiGX.util.Layer.getLayerBy(
                'layerKey', view.vectorLayerKey
            );
        }

        if (!view.queryLayer) {
            Ext.Logger.warn('No queryLayer found in the map for the FeaureSelectionButton with the name: ' + view.queryLayerName);
        } else {
            // save the ID property name for future use
            me.idProperty = view.queryLayer.get('idProperty');
        }

    },

    /**
     * Handles map click for selection of features.
     *
     * @param {ol.MapBrowserEvent} evt The OL event
     */
    onMapClick: function (evt) {
        var me = this;
        var view = me.getView();

        // clear FIDs to filter when we have a new selection
        if (me.filterMode === 'NEW_SELECTION') {
            me.fidsToFilter = [];
        }

        // collect all IDs of clicked features
        var clickedFeatureIds = [];
        me.map.forEachFeatureAtPixel(evt.pixel, function(feature, layer) {
            // add check for correct layer
            if (layer && view.queryLayer && (layer.id === view.queryLayer.id)) {

                var source = view.queryLayer.getSource();
                if (source instanceof ol.source.Cluster) {
                    var origFeats = feature.get('features');
                    if (Ext.isArray(origFeats)) {
                        // add all sub-feature due to clustering
                        Ext.each(origFeats, function (origFeat) {
                            me.fidsToFilter.push(origFeat.get(me.idProperty));
                            clickedFeatureIds.push(origFeat.get(me.idProperty));
                        });
                    }
                } else {
                    // "normal" layers without clustering
                    me.fidsToFilter.push(feature.get(me.idProperty));
                    clickedFeatureIds.push(feature.get(me.idProperty));
                }
            }
        });

        // inform that no feature was hit on the map
        if (clickedFeatureIds.length === 0) {
            if (view.showNoSelectionMessage) {
                Ext.toast('No feature(s) at clicked position.', null, 'br');
            }

            view.fireEvent('cmv-no-feature-selected', view);
            return;
        }

        // create ExtJS "IN" filter with unique values
        var uniqueFids = Ext.Array.unique(me.fidsToFilter);
        var extInFilter = new Ext.util.Filter({
            type: 'fid',
            property: me.idProperty,
            value   : uniqueFids,
            operator: 'in'
        });

        if (me.filterMode === 'NEW_SELECTION') {
            // removes all filters from grid without reloading WFS store
            view.fireEvent('cmv-reset-grid-filters');
        }
        // sets the ID filter in the grid
        view.fireEvent('cmv-id-filter-set', extInFilter);
    },

    onBeforeDestroy: function () {
        var me = this;
        var btn = me.getView();

        // detoggle button
        me.onBtnToggle(btn, false);
    }

});

1	/**
2	* This class is the controller for the button 'FeatureSelectionButton'
3	*/
4	Ext.define('CpsiMapview.controller.button.FeatureSelectionButtonController', {	1✔
5	extend: 'Ext.app.ViewController',
6
7	alias: 'controller.cmv_feature_selection_btn',
8
9	requires: [
10	'Ext.window.Toast',
11	'BasiGX.util.Layer'
12	],
13
14	/**
15	* The OpenLayers map. If not given, will be auto-detected.
16	* @cfg
17	*/
18	map: null,
19
20	/**
21	* The selector UI for the #filterMode. Created in #onBtnToggle.
22	* @property
23	* @readonly
24	*/
25	modeSelector: null,
26
27	/**
28	* The filter mode (set by the user via #modeSelector UI).
29	* @property
30	* @readonly
31	*/
32	filterMode: 'ADD_TO_SELECTION', // ADD_TO_SELECTION or NEW_SELECTION
33
34	/**
35	* The feature IDs (FIDs) used for filtering.
36	* @property
37	* @readonly
38	*/
39	fidsToFilter: [],
40
41	constructor: function () {
42	var me = this;	3✔
43	me.onMapClick = me.onMapClick.bind(me);	3✔
44	me.callParent(arguments);	3✔
45	},
46
47	init: function () {
48	var me = this;	3✔
49	var ownerGrid = this.getView().up('grid');	3✔
50	if (ownerGrid) {	3!
51	// reset FIDs if grid clears its filters
52	ownerGrid.on('cmv-clear-filters', function() {	3✔
53	me.fidsToFilter = [];	×
54	});
55	}
56	},
57
58	/**
59	* Activates this tool.
60	* Adds a click handler to the map and tries to detect the IDs of the
61	* clicked features. Builds a filter object for the ("where ID IN(1,2,3))
62	* and forwards it to the grid so it gets applied to the underlying WFS.
63	*
64	* @param {Ext.button.Button} btn The toggled button.
65	* @param {Boolean} pressed The toggle state.
66	*/
67	onBtnToggle: function (btn, pressed) {
68	var me = this;	×
69	var view = me.getView();	×
70
71	if (view.map && view.map instanceof ol.Map) {	×
72	me.map = view.map;	×
73	} else {
74	// guess map as fallback
75	me.map = BasiGX.util.Map.getMapComponent().map;	×
76	}
77
78	if (!view.queryLayer) {	×
79	me.findWfsLayer();	×
80	}
81
82	if (pressed) {	×
83	// create and show selector UI
84	me.addModeSelectorUi();	×
85	view.queryLayer.setVisible(true);	×
86	me.map.on('click', me.onMapClick);	×
87	} else {
88	me.modeSelector.hide();	×
89	view.queryLayer.setVisible(false);	×
90	me.map.un('click', me.onMapClick);	×
91	}
92
93	},
94
95	/**
96	* Adds the mode selector UI to the toolbar (if not existing) and shows it.
97	*/
98	addModeSelectorUi: function () {
99	var me = this;	×
100
101	if (!me.modeSelector) {	×
102	me.modeSelector = Ext.create('Ext.button.Split', {	×
103	viewModel: me.getViewModel(),
104	bind: {
105	text: '{addToSelectionLabel}'
106	},
107	hidden: false,
108	menu: new Ext.menu.Menu({
109	items: [
110	{
111	bind: {
112	text: '{addToSelectionLabel}'
113	},
114	handler: function (menu) {
115	me.filterMode = 'ADD_TO_SELECTION';	×
116	me.modeSelector.setText(menu.text);	×
117	}
118	},
119	{
120	bind: {
121	text: '{newSelectionLabel}'
122	},
123	handler: function (menu) {
124	me.filterMode = 'NEW_SELECTION';	×
125	me.modeSelector.setText(menu.text);	×
126	}
127	},
128	]
129	})
130	});
131
132	var tb = me.getView().up('toolbar');	×
133	var btnGroup = me.getView().up('buttongroup');	×
134	if (tb && btnGroup) {	×
135	btnGroup.add(me.modeSelector);	×
136	}
137	}
138
139	me.modeSelector.show();	×
140	},
141
142	/**
143	* Function to determine the WFS layer to connect the click handler if not
144	* yet defined.
145	*/
146	findWfsLayer: function () {
147	var me = this;	×
148	var view = me.getView();	×
149	if (!view.queryLayer && view.vectorLayerKey) {	×
150	view.queryLayer = BasiGX.util.Layer.getLayerBy(	×
151	'layerKey', view.vectorLayerKey
152	);
153	}
154
155	if (!view.queryLayer) {	×
156	Ext.Logger.warn('No queryLayer found in the map for the FeaureSelectionButton with the name: ' + view.queryLayerName);	×
157	} else {
158	// save the ID property name for future use
159	me.idProperty = view.queryLayer.get('idProperty');	×
160	}
161
162	},
163
164	/**
165	* Handles map click for selection of features.
166	*
167	* @param {ol.MapBrowserEvent} evt The OL event
168	*/
169	onMapClick: function (evt) {
170	var me = this;	×
171	var view = me.getView();	×
172
173	// clear FIDs to filter when we have a new selection
174	if (me.filterMode === 'NEW_SELECTION') {	×
175	me.fidsToFilter = [];	×
176	}
177
178	// collect all IDs of clicked features
179	var clickedFeatureIds = [];	×
180	me.map.forEachFeatureAtPixel(evt.pixel, function(feature, layer) {	×
181	// add check for correct layer
182	if (layer && view.queryLayer && (layer.id === view.queryLayer.id)) {	×
183
184	var source = view.queryLayer.getSource();	×
185	if (source instanceof ol.source.Cluster) {	×
186	var origFeats = feature.get('features');	×
187	if (Ext.isArray(origFeats)) {	×
188	// add all sub-feature due to clustering
189	Ext.each(origFeats, function (origFeat) {	×
190	me.fidsToFilter.push(origFeat.get(me.idProperty));	×
191	clickedFeatureIds.push(origFeat.get(me.idProperty));	×
192	});
193	}
194	} else {
195	// "normal" layers without clustering
196	me.fidsToFilter.push(feature.get(me.idProperty));	×
197	clickedFeatureIds.push(feature.get(me.idProperty));	×
198	}
199	}
200	});
201
202	// inform that no feature was hit on the map
203	if (clickedFeatureIds.length === 0) {	×
204	if (view.showNoSelectionMessage) {	×
205	Ext.toast('No feature(s) at clicked position.', null, 'br');	×
206	}
207
208	view.fireEvent('cmv-no-feature-selected', view);	×
209	return;	×
210	}
211
212	// create ExtJS "IN" filter with unique values
213	var uniqueFids = Ext.Array.unique(me.fidsToFilter);	×
214	var extInFilter = new Ext.util.Filter({	×
215	type: 'fid',
216	property: me.idProperty,
217	value : uniqueFids,
218	operator: 'in'
219	});
220
221	if (me.filterMode === 'NEW_SELECTION') {	×
222	// removes all filters from grid without reloading WFS store
223	view.fireEvent('cmv-reset-grid-filters');	×
224	}
225	// sets the ID filter in the grid
226	view.fireEvent('cmv-id-filter-set', extInFilter);	×
227	},
228
229	onBeforeDestroy: function () {
230	var me = this;	×
231	var btn = me.getView();	×
232
233	// detoggle button
234	me.onBtnToggle(btn, false);	×
235	}
236
237	});

geographika / cpsi-mapview / 6275612987

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