15022980938

Committed 14 May 2025 02:11PM UTC coverage: 26.333% (+0.04%) from 26.29%

Build # 15022980938

Build Type

push

github

Committed by

geographika

Commit Message

Move describe to test globals

Run Details

492 of 2344 branches covered (20.99%)

Branch coverage included in aggregate %.

1464 of 5084 relevant lines covered (28.8%)

1.17 hits per line

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

2.88

/app/controller/button/SplitByClickButtonController.js

/**
 * This class is the controller for the SplitByClick button.
 */
Ext.define('CpsiMapview.controller.button.SplitByClickButtonController', {
    extend: 'Ext.app.ViewController',
    requires: [
        'BasiGX.util.Map',
        'GeoExt.component.FeatureRenderer',
        'GeoExt.data.store.Features'
    ],

    alias: 'controller.cmv_split_by_click_button',

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

    /**
     * The BasiGX mapComponent. If not given, will be auto-detected
     */
    mapComponent: null,

    /**
     * Temporary vector layer used to display the response split features
     */
    resultLayer: null,

    constructor: function () {
        const me = this;
        me.splitOnClickedPosition = me.splitOnClickedPosition.bind(me);

        me.callParent(arguments);
    },

    /**
     * Set the layer used to store features returned by the split service
     * @param {ol.Layer} layer
     */
    setResultLayer: function (layer) {
        const me = this;

        if (!me.map) {
            return;
        }

        if (me.resultLayer) {
            me.map.removeLayer(me.resultLayer);
        }

        me.resultLayer = layer;
    },

    /**
     * Main handler which activates or deactivates the click listener for the
     * map.
     *
     * @param {Ext.button.Button} btn The button that has been pressed
     * @param {boolean} pressed The toggle state of the button
     */
    onToggle: function (btn, pressed) {
        const me = this;
        const view = me.getView();

        // guess the map if not given
        if (!me.map) {
            me.map = BasiGX.util.Map.getMapComponent().map;
        }

        // create a result layer unless one has already been set
        if (!me.resultLayer) {
            me.resultLayer = view.resultLayer;
        }

        if (pressed) {
            me.map.on('click', me.splitOnClickedPosition);
        } else {
            me.map.un('click', me.splitOnClickedPosition);
        }
    },

    /**
     * Asynchronously request and proceed split features depending on clicked
     * position.
     *
     * @param {Event} evt OpenLayers click event
     * @returns {Ext.Promise<any|undefined>}
     */
    splitOnClickedPosition: function (evt) {
        const me = this;
        const map = me.map;
        const proj = map.getView().getProjection().getCode();
        const coordinates = evt.coordinate;
        const point = new ol.Feature(new ol.geom.Point(coordinates));
        const extent = point.getGeometry().getExtent();
        const associatedWin = this.getView().up('window');
        const associatedVm = associatedWin.getViewModel();
        const parentId = associatedVm.get('currentRecord.publicPrivateSplitId');
        const buffered = ol.extent.buffer(
            extent,
            me.getView().getPointExtentBuffer()
        );
        // transform to ITM since this projection is expected by backend.
        const bufferedITM = ol.proj.transformExtent(
            buffered,
            proj,
            'EPSG:2157'
        );
        const bboxSearchParam =
            '&bbox=' + encodeURIComponent(bufferedITM.join(','));
        let idParam = 'publicPrivateSplitId=';

        if (isNaN(parentId)) {
            // we're going to create a new split
            idParam += '0';
        } else {
            // we're going to edit the existing one
            idParam += parentId;
        }
        const searchParams = idParam + bboxSearchParam;

        return me
            .doAjaxRequest(searchParams)
            .then(me.parseSplitResponse.bind(me))
            .then(me.handleFinalResult.bind(me));
    },

    /**
     * Parses the split result to OpenLayers features
     *
     * @param {XMLHttpRequest} response
     * @returns {ol.Feature[]}
     */
    parseSplitResponse: function (response) {
        if (response) {
            let json;

            if (!Ext.isEmpty(response.responseText)) {
                try {
                    json = Ext.decode(response.responseText);
                } catch (e) {
                    BasiGX.error(
                        'Could not parse the response: ' + response.responseText
                    );
                    Ext.log.error(e);
                    return;
                }

                if (json.success && json.data) {
                    const existingPpSplitId =
                        json.data.existingPublicPrivateSplitId;
                    if (existingPpSplitId !== null) {
                        this.handleExistingSplit(existingPpSplitId);
                    } else {
                        const splitEdgeFeats = json.data.splitEdgeFeatures;
                        if (
                            splitEdgeFeats.features &&
                            splitEdgeFeats.features.length === 2
                        ) {
                            const format = new ol.format.GeoJSON();
                            return format.readFeaturesFromObject(
                                splitEdgeFeats
                            );
                        }
                    }
                } else {
                    BasiGX.error(
                        'Could not perform the split: ' +
                            (json.message ? json.message : JSON.stringify(json))
                    );
                }
            } else {
                BasiGX.error(
                    'Could not perform the split: ' +
                        (json.message ? json.message : JSON.stringify(json))
                );
            }
        } else {
            BasiGX.error('Response was empty');
        }
    },

    /**
     * Issues an Ext.Ajax.request against the configured endpoint with
     * the given params.
     *
     * @param {string} searchParams The serarchParams which will be
     *   appended to the request url
     * @returns {Ext.request.Base}
     */
    doAjaxRequest: function (searchParams) {
        const me = this;
        const mapComponent =
            me.mapComponent || BasiGX.util.Map.getMapComponent();
        const view = me.getView();
        let url = view.getApiUrl();

        if (!url) {
            Ext.log.warn('No API URL passed - split is not possible.');
            return;
        }

        if (searchParams) {
            url = Ext.urlAppend(url, searchParams);
        }

        mapComponent.setLoading(true);

        return new Ext.Promise(function (resolve) {
            Ext.Ajax.request({
                url: url,
                method: 'GET',
                success: function (response) {
                    mapComponent.setLoading(false);
                    resolve(response);
                },
                failure: function (response) {
                    mapComponent.setLoading(false);

                    if (response.aborted !== true) {
                        let errorMessage =
                            'Error while requesting the API endpoint';

                        if (
                            response.responseText &&
                            response.responseText.message
                        ) {
                            errorMessage +=
                                ': ' + response.responseText.message;
                        }

                        BasiGX.error(errorMessage);
                    }
                }
            });
        });
    },

    /**
     * Show confirm dialog to decide, whether the found existing split should be
     * opened for edit.
     * @param {number} splitId
     */
    handleExistingSplit: function (splitId) {
        const msg =
            'This edge has already been split. Open existing split record?';
        const me = this;

        BasiGX.confirm(msg, {
            title: 'Open Existing Split?',
            fn: function (buttonId) {
                if (buttonId === 'yes') {
                    const win = me.getView().up('window');
                    win.fireEvent('splitedgesupdate', splitId);
                }
            }
        });
    },

    /**
     * Handles the final result from endopoint. Refreshes the result layer with
     * retrieved split features.
     *
     * @param {undefined|ol.Feature[]} features The features returned from the API.
     */
    handleFinalResult: function (features) {
        if (features) {
            const me = this;
            const resultSource = me.resultLayer.getSource();
            resultSource.clear();
            resultSource.addFeatures(features);
        }
    },

    /**
     * Remove the result layer when this component gets destroyed.
     */
    onBeforeDestroy: function () {
        const me = this;
        const btn = me.getView();

        // detoggle button
        me.onToggle(btn, false);

        if (me.resultLayer) {
            me.map.removeLayer(me.resultLayer);
        }
    }
});

1	/**
2	* This class is the controller for the SplitByClick button.
3	*/
4	Ext.define('CpsiMapview.controller.button.SplitByClickButtonController', {	1✔
5	extend: 'Ext.app.ViewController',
6	requires: [
7	'BasiGX.util.Map',
8	'GeoExt.component.FeatureRenderer',
9	'GeoExt.data.store.Features'
10	],
11
12	alias: 'controller.cmv_split_by_click_button',
13
14	/**
15	* The OpenLayers map. If not given, will be auto-detected
16	*/
17	map: null,
18
19	/**
20	* The BasiGX mapComponent. If not given, will be auto-detected
21	*/
22	mapComponent: null,
23
24	/**
25	* Temporary vector layer used to display the response split features
26	*/
27	resultLayer: null,
28
29	constructor: function () {
30	const me = this;	5✔
31	me.splitOnClickedPosition = me.splitOnClickedPosition.bind(me);	5✔
32
33	me.callParent(arguments);	5✔
34	},
35
36	/**
37	* Set the layer used to store features returned by the split service
38	* @param {ol.Layer} layer
39	*/
40	setResultLayer: function (layer) {
41	const me = this;	×
42
43	if (!me.map) {	×
44	return;	×
45	}
46
47	if (me.resultLayer) {	×
48	me.map.removeLayer(me.resultLayer);	×
49	}
50
51	me.resultLayer = layer;	×
52	},
53
54	/**
55	* Main handler which activates or deactivates the click listener for the
56	* map.
57	*
58	* @param {Ext.button.Button} btn The button that has been pressed
59	* @param {boolean} pressed The toggle state of the button
60	*/
61	onToggle: function (btn, pressed) {
62	const me = this;	×
63	const view = me.getView();	×
64
65	// guess the map if not given
66	if (!me.map) {	×
67	me.map = BasiGX.util.Map.getMapComponent().map;	×
68	}
69
70	// create a result layer unless one has already been set
71	if (!me.resultLayer) {	×
72	me.resultLayer = view.resultLayer;	×
73	}
74
75	if (pressed) {	×
76	me.map.on('click', me.splitOnClickedPosition);	×
77	} else {
78	me.map.un('click', me.splitOnClickedPosition);	×
79	}
80	},
81
82	/**
83	* Asynchronously request and proceed split features depending on clicked
84	* position.
85	*
86	* @param {Event} evt OpenLayers click event
87	* @returns {Ext.Promise<any\|undefined>}
88	*/
89	splitOnClickedPosition: function (evt) {
90	const me = this;	×
91	const map = me.map;	×
92	const proj = map.getView().getProjection().getCode();	×
93	const coordinates = evt.coordinate;	×
94	const point = new ol.Feature(new ol.geom.Point(coordinates));	×
95	const extent = point.getGeometry().getExtent();	×
96	const associatedWin = this.getView().up('window');	×
97	const associatedVm = associatedWin.getViewModel();	×
98	const parentId = associatedVm.get('currentRecord.publicPrivateSplitId');	×
99	const buffered = ol.extent.buffer(	×
100	extent,
101	me.getView().getPointExtentBuffer()
102	);
103	// transform to ITM since this projection is expected by backend.
104	const bufferedITM = ol.proj.transformExtent(	×
105	buffered,
106	proj,
107	'EPSG:2157'
108	);
109	const bboxSearchParam =
110	'&bbox=' + encodeURIComponent(bufferedITM.join(','));	×
111	let idParam = 'publicPrivateSplitId=';	×
112
113	if (isNaN(parentId)) {	×
114	// we're going to create a new split
115	idParam += '0';	×
116	} else {
117	// we're going to edit the existing one
118	idParam += parentId;	×
119	}
120	const searchParams = idParam + bboxSearchParam;	×
121
122	return me	×
123	.doAjaxRequest(searchParams)
124	.then(me.parseSplitResponse.bind(me))
125	.then(me.handleFinalResult.bind(me));
126	},
127
128	/**
129	* Parses the split result to OpenLayers features
130	*
131	* @param {XMLHttpRequest} response
132	* @returns {ol.Feature[]}
133	*/
134	parseSplitResponse: function (response) {
135	if (response) {	×
136	let json;
137
138	if (!Ext.isEmpty(response.responseText)) {	×
139	try {	×
140	json = Ext.decode(response.responseText);	×
141	} catch (e) {
142	BasiGX.error(	×
143	'Could not parse the response: ' + response.responseText
144	);
145	Ext.log.error(e);	×
146	return;	×
147	}
148
149	if (json.success && json.data) {	×
150	const existingPpSplitId =
151	json.data.existingPublicPrivateSplitId;	×
152	if (existingPpSplitId !== null) {	×
153	this.handleExistingSplit(existingPpSplitId);	×
154	} else {
155	const splitEdgeFeats = json.data.splitEdgeFeatures;	×
156	if (	×
157	splitEdgeFeats.features &&	×
158	splitEdgeFeats.features.length === 2
159	) {
160	const format = new ol.format.GeoJSON();	×
161	return format.readFeaturesFromObject(	×
162	splitEdgeFeats
163	);
164	}
165	}
166	} else {
167	BasiGX.error(	×
168	'Could not perform the split: ' +
169	(json.message ? json.message : JSON.stringify(json))	×
170	);
171	}
172	} else {
173	BasiGX.error(	×
174	'Could not perform the split: ' +
175	(json.message ? json.message : JSON.stringify(json))	×
176	);
177	}
178	} else {
179	BasiGX.error('Response was empty');	×
180	}
181	},
182
183	/**
184	* Issues an Ext.Ajax.request against the configured endpoint with
185	* the given params.
186	*
187	* @param {string} searchParams The serarchParams which will be
188	* appended to the request url
189	* @returns {Ext.request.Base}
190	*/
191	doAjaxRequest: function (searchParams) {
192	const me = this;	×
193	const mapComponent =
194	me.mapComponent \|\| BasiGX.util.Map.getMapComponent();	×
195	const view = me.getView();	×
196	let url = view.getApiUrl();	×
197
198	if (!url) {	×
199	Ext.log.warn('No API URL passed - split is not possible.');	×
200	return;	×
201	}
202
203	if (searchParams) {	×
204	url = Ext.urlAppend(url, searchParams);	×
205	}
206
207	mapComponent.setLoading(true);	×
208
209	return new Ext.Promise(function (resolve) {	×
210	Ext.Ajax.request({	×
211	url: url,
212	method: 'GET',
213	success: function (response) {
214	mapComponent.setLoading(false);	×
215	resolve(response);	×
216	},
217	failure: function (response) {
218	mapComponent.setLoading(false);	×
219
220	if (response.aborted !== true) {	×
221	let errorMessage =
222	'Error while requesting the API endpoint';	×
223
224	if (	×
225	response.responseText &&	×
226	response.responseText.message
227	) {
228	errorMessage +=	×
229	': ' + response.responseText.message;
230	}
231
232	BasiGX.error(errorMessage);	×
233	}
234	}
235	});
236	});
237	},
238
239	/**
240	* Show confirm dialog to decide, whether the found existing split should be
241	* opened for edit.
242	* @param {number} splitId
243	*/
244	handleExistingSplit: function (splitId) {
245	const msg =
246	'This edge has already been split. Open existing split record?';	×
247	const me = this;	×
248
249	BasiGX.confirm(msg, {	×
250	title: 'Open Existing Split?',
251	fn: function (buttonId) {
252	if (buttonId === 'yes') {	×
253	const win = me.getView().up('window');	×
254	win.fireEvent('splitedgesupdate', splitId);	×
255	}
256	}
257	});
258	},
259
260	/**
261	* Handles the final result from endopoint. Refreshes the result layer with
262	* retrieved split features.
263	*
264	* @param {undefined\|ol.Feature[]} features The features returned from the API.
265	*/
266	handleFinalResult: function (features) {
267	if (features) {	×
268	const me = this;	×
269	const resultSource = me.resultLayer.getSource();	×
270	resultSource.clear();	×
271	resultSource.addFeatures(features);	×
272	}
273	},
274
275	/**
276	* Remove the result layer when this component gets destroyed.
277	*/
278	onBeforeDestroy: function () {
279	const me = this;	×
280	const btn = me.getView();	×
281
282	// detoggle button
283	me.onToggle(btn, false);	×
284
285	if (me.resultLayer) {	×
286	me.map.removeLayer(me.resultLayer);	×
287	}
288	}
289	});

compassinformatics / cpsi-mapview / 15022980938

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