Support for time dimension

web/client/actions/__tests__/layers-test.js

@@ -22,6 +22,7 @@ var {
     HIDE_SETTINGS,
     UPDATE_SETTINGS,
     REFRESH_LAYERS,
+    UPDATE_LAYERS_DIMENSION,
     LAYERS_REFRESHED,
     LAYERS_REFRESH_ERROR,
     BROWSE_DATA,
@@ -44,6 +45,7 @@ var {
     hideSettings,
     updateSettings,
     refreshLayers,
+    updateLayerDimension,
     layersRefreshed,
     layersRefreshError,
     browseData,
@@ -111,6 +113,14 @@ describe('Test correctness of the layers actions', () => {
         expect(retval.error).toBe('err');
     });
 
+    it('updateLayerDimension', () => {
+        const retval = updateLayerDimension( "time", "2016-02-24T03:00:00.000Z", null, "A");
+        expect(retval).toExist();
+        expect(retval.type).toBe(UPDATE_LAYERS_DIMENSION);
+        expect(retval.layers).toBe("A");
+        expect(retval.dimension).toBe("time");
+        expect(retval.value).toBe("2016-02-24T03:00:00.000Z");
+    });
     it('toggleNode', () => {
         var retval = toggleNode('sample', 'groups', true);
 

web/client/actions/layers.js

@@ -7,6 +7,7 @@
  */
 
 const CHANGE_LAYER_PROPERTIES = 'CHANGE_LAYER_PROPERTIES';
+const CHANGE_LAYER_PARAMS = 'LAYERS:CHANGE_LAYER_PARAMS';
 const CHANGE_GROUP_PROPERTIES = 'CHANGE_GROUP_PROPERTIES';
 const TOGGLE_NODE = 'TOGGLE_NODE';
 const CONTEXT_NODE = 'CONTEXT_NODE';
@@ -22,6 +23,7 @@ const SHOW_SETTINGS = 'SHOW_SETTINGS';
 const HIDE_SETTINGS = 'HIDE_SETTINGS';
 const UPDATE_SETTINGS = 'UPDATE_SETTINGS';
 const REFRESH_LAYERS = 'REFRESH_LAYERS';
+const UPDATE_LAYERS_DIMENSION = 'LAYERS:UPDATE_LAYERS_DIMENSION';
 const LAYERS_REFRESHED = 'LAYERS_REFRESHED';
 const LAYERS_REFRESH_ERROR = 'LAYERS_REFRESH_ERROR';
 const BROWSE_DATA = 'LAYERS:BROWSE_DATA';
@@ -62,6 +64,20 @@ function changeLayerProperties(layer, properties) {
 
     };
 }
+/**
+ * Change params for a layer. Useful for WMS layers, when you need to change only the params (i.e. dimension) merging with existing ones.
+ * @memberof actions.layers
+ * @function
+ * @param {string|string[]} layer id(s) of the layers to change
+ * @param {object} params the params to change
+ */
+function changeLayerParams(layer, params) {
+    return {
+        type: CHANGE_LAYER_PARAMS,
+        layer,
+        params
+    };
+}
 
 function changeGroupProperties(group, properties) {
     return {
@@ -184,6 +200,15 @@ function layersRefreshError(layers, error) {
         error
     };
 }
+function updateLayerDimension(dimension, value, options, layers) {
+    return {
+        type: UPDATE_LAYERS_DIMENSION,
+        dimension,
+        value,
+        options,
+        layers
+    };
+}
 function browseData(layer) {
     return {
         type: BROWSE_DATA,
@@ -232,12 +257,13 @@ function hideLayerMetadata() {
     };
 }
 
-module.exports = {changeLayerProperties, changeGroupProperties, toggleNode, sortNode, removeNode, contextNode,
+module.exports = {
+    changeLayerProperties, changeLayerParams, changeGroupProperties, toggleNode, sortNode, removeNode, contextNode,
     updateNode, layerLoading, layerLoad, layerError, addLayer, removeLayer, showSettings, hideSettings, updateSettings, refreshLayers,
-    layersRefreshed, layersRefreshError, refreshLayerVersion, browseData, clearLayers, selectNode, filterLayers, showLayerMetadata,
+    layersRefreshed, layersRefreshError, refreshLayerVersion, updateLayerDimension, browseData, clearLayers, selectNode, filterLayers, showLayerMetadata,
     hideLayerMetadata, download,
-    CHANGE_LAYER_PROPERTIES, CHANGE_GROUP_PROPERTIES, TOGGLE_NODE, SORT_NODE,
+    CHANGE_LAYER_PROPERTIES, CHANGE_LAYER_PARAMS, CHANGE_GROUP_PROPERTIES, TOGGLE_NODE, SORT_NODE,
     REMOVE_NODE, UPDATE_NODE, LAYER_LOADING, LAYER_LOAD, LAYER_ERROR, ADD_LAYER, REMOVE_LAYER,
-    SHOW_SETTINGS, HIDE_SETTINGS, UPDATE_SETTINGS, CONTEXT_NODE, REFRESH_LAYERS, LAYERS_REFRESHED, LAYERS_REFRESH_ERROR, BROWSE_DATA, DOWNLOAD,
+    SHOW_SETTINGS, HIDE_SETTINGS, UPDATE_SETTINGS, CONTEXT_NODE, REFRESH_LAYERS, LAYERS_REFRESHED, LAYERS_REFRESH_ERROR, UPDATE_LAYERS_DIMENSION, BROWSE_DATA, DOWNLOAD,
     CLEAR_LAYERS, SELECT_NODE, FILTER_LAYERS, SHOW_LAYER_METADATA, HIDE_LAYER_METADATA
 };

web/client/epics/__tests__/layers-test.js

@@ -10,9 +10,15 @@ var expect = require('expect');
 
 const configureMockStore = require('redux-mock-store').default;
 const { createEpicMiddleware, combineEpics } = require('redux-observable');
-const {refreshLayers, LAYERS_REFRESHED, LAYERS_REFRESH_ERROR, UPDATE_NODE} = require('../../actions/layers');
+const {
+    refreshLayers, LAYERS_REFRESHED, LAYERS_REFRESH_ERROR, UPDATE_NODE,
+    updateLayerDimension, CHANGE_LAYER_PARAMS
+} = require('../../actions/layers');
+const {
+    testEpic
+} = require('./epicTestUtils');
 
-const {refresh } = require('../layers');
+const { refresh, updateDimension } = require('../layers');
 const rootEpic = combineEpics(refresh);
 const epicMiddleware = createEpicMiddleware(rootEpic);
 const mockStore = configureMockStore([epicMiddleware]);
@@ -77,4 +83,47 @@ describe('layers Epics', () => {
             }
         });
     });
+    it('test update dimension', done => {
+        const state = {
+            layers: {
+                flat: [{
+                    group: 'test',
+                    id: 'layer001',
+                    visibility: true,
+                    dimensions: [{
+                        name: 'time'
+                    }]
+                },
+                {
+                    group: 'test',
+                    id: 'layer002',
+                    visibility: true,
+                    dimensions: [{
+                        name: 'time'
+                    }, {
+                        name: 'elevation'
+                    }]
+                }]
+            }
+        };
+        testEpic(
+            updateDimension,
+            1,
+            updateLayerDimension('time', "2016-02-24T03:00:00.000Z"),
+            actions => {
+                expect(actions.length).toBe(1);
+                actions.map((action) => {
+                    switch (action.type) {
+                        case CHANGE_LAYER_PARAMS:
+                            expect(action.layer.length).toBe(2);
+                            expect(action.params.time).toBe("2016-02-24T03:00:00.000Z");
+                            break;
+                        default:
+                            expect(true).toBe(false);
+
+                    }
+                });
+                done();
+            }, state);
+    });
 });

web/client/epics/layers.js

@@ -8,9 +8,12 @@
 
 const Rx = require('rxjs');
 const Api = require('../api/WMS');
-const {REFRESH_LAYERS, layersRefreshed, updateNode, layersRefreshError} = require('../actions/layers');
+const { REFRESH_LAYERS, UPDATE_LAYERS_DIMENSION, layersRefreshed, updateNode, layersRefreshError, changeLayerParams} = require('../actions/layers');
+const {getLayersWithDimension} = require('../selectors/layers');
+
 const LayersUtils = require('../utils/LayersUtils');
 
+
 const assign = require('object-assign');
 const {isArray, head} = require('lodash');
 
@@ -86,7 +89,26 @@ const refresh = action$ =>
             .mergeAll();
         });
 
-
+/**
+ * Update dimension to all layers that have that dimension set, or for the layers indicated in the action.
+ * @memberof epics.layers
+ * @param {external:Observable} action$ manages `UPDATE_LAYERS_DIMENSION`
+ * @return {external:Observable}
+ */
+const updateDimension = (action$, {getState = () => {}} = {}) =>
+    action$.ofType(UPDATE_LAYERS_DIMENSION)
+        .map(({ layers, dimension, ...other }) => ({ ...other, dimension, layers: layers || getLayersWithDimension(getState(), dimension)}))
+        .switchMap(({layers, dimension, value}) =>
+            Rx.Observable.of(
+                changeLayerParams(
+                    layers.map(l => l.id),
+                    {
+                        [dimension]: value
+                    }
+                )
+            )
+        );
 module.exports = {
-    refresh
+    refresh,
+    updateDimension
 };

web/client/plugins/AutoMapUpdate.jsx

@@ -12,7 +12,6 @@ const {connect} = require('react-redux');
 const {manageAutoMapUpdate} = require('../epics/automapupdate');
 const {autoMapUpdateSelector} = require('../selectors/automapupdate');
 const {setControlProperty} = require('../actions/controls');
-const {refresh} = require('../epics/layers');
 
 const OverlayProgressBar = require('../components/misc/progressbars/OverlayProgressBar/OverlayProgressBar');
 
@@ -78,5 +77,5 @@ const AutoMapUpdatePlugin = connect(autoMapUpdateSelector, {
 module.exports = {
     AutoMapUpdatePlugin,
     reducers: {},
-    epics: {manageAutoMapUpdate, refresh}
+    epics: {manageAutoMapUpdate}
 };

web/client/reducers/__tests__/layers-test.js

@@ -7,6 +7,8 @@
  */
 var expect = require('expect');
 var layers = require('../layers');
+const { changeLayerParams } = require('../../actions/layers');
+
 
 describe('Test the layers reducer', () => {
 
@@ -178,7 +180,44 @@ describe('Test the layers reducer', () => {
         expect(state.flat[0].visibility).toBe(false);
         expect(state.flat[1].visibility).toBe(true);
     });
+    it('changeLayerParams', () => {
+        const state = {
+            flat: [{
+                "type": "osm",
+                "title": "Open Street Map",
+                "name": "mapnik",
+                "id": "mapnik",
+                "group": "background",
+                "visibility": true
+            }, {
+                "type": "wms",
+                "url": "/reflector/open/service",
+                "visibility": false,
+                "title": "e-Geos Ortofoto RealVista 1.0",
+                "name": "rv1",
+                "id": "rv1",
+                "group": "background",
+                "format": "image/png"
+            }, {
+                "type": "wms",
+                "url": "/reflector/open/service",
+                "visibility": false,
+                "title": "e-Geos Ortofoto RealVista 1.0",
+                "name": "rv2",
+                "id": "rv2",
+                "group": "background",
+                "format": "image/png"
+            }]
+        };
+        const state1 = layers(state, changeLayerParams("rv1", {elevation: 200}));
+        expect(state1.flat[1].params).toExist();
+        expect(state1.flat[1].params.elevation).toBe(200);
+        expect(state1.flat[2].params).toNotExist();
+        const state2 = layers(state, changeLayerParams(["rv1", "rv2"], { elevation: 200 }));
+        expect(state2.flat[1].params.elevation).toBe(200);
+        expect(state2.flat[2].params.elevation).toBe(200);
 
+    });
     it('a layer is loading, loading flag is updated', () => {
         const action1 = {
             type: 'LAYER_LOADING',

web/client/reducers/layers.js

@@ -6,15 +6,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-var {LAYER_LOADING, LAYER_LOAD, LAYER_ERROR, CHANGE_LAYER_PROPERTIES, CHANGE_GROUP_PROPERTIES,
+var { LAYER_LOADING, LAYER_LOAD, LAYER_ERROR, CHANGE_LAYER_PARAMS, CHANGE_LAYER_PROPERTIES, CHANGE_GROUP_PROPERTIES,
     TOGGLE_NODE, SORT_NODE, REMOVE_NODE, UPDATE_NODE, ADD_LAYER, REMOVE_LAYER,
     SHOW_SETTINGS, HIDE_SETTINGS, UPDATE_SETTINGS, REFRESH_LAYERS, LAYERS_REFRESH_ERROR, LAYERS_REFRESHED, CLEAR_LAYERS, SELECT_NODE, FILTER_LAYERS, SHOW_LAYER_METADATA, HIDE_LAYER_METADATA
     } = require('../actions/layers');
 
 const {TOGGLE_CONTROL} = require('../actions/controls');
 
 var assign = require('object-assign');
-var {isObject, isArray, head, isString} = require('lodash');
+var {isObject, isArray, head, isString, includes, castArray} = require('lodash');
 
 const LayersUtils = require('../utils/LayersUtils');
 
@@ -102,15 +102,24 @@ function layers(state = [], action) {
             });
             return assign({}, state, {refreshing: newLayers});
         }
+        case CHANGE_LAYER_PARAMS:
         case CHANGE_LAYER_PROPERTIES: {
             const flatLayers = (state.flat || []);
             let isBackground = flatLayers.reduce(
                     (background, layer) => background || (layer.id === action.layer && layer.group === 'background'),
             false);
             const newLayers = flatLayers.map((layer) => {
-                if (layer.id === action.layer) {
-                    return assign({}, layer, action.newProperties);
-                } else if (layer.group === 'background' && isBackground && action.newProperties.visibility) {
+                if ( includes(castArray(action.layer), layer.id )) {
+                    return assign(
+                        {},
+                        layer,
+                        action.newProperties,
+                        action.params
+                            ? {
+                                params: assign({}, layer.params, action.params)
+                            }
+                            : {});
+                } else if (layer.group === 'background' && isBackground && action.newProperties && action.newProperties.visibility) {
                     // TODO remove
                     return assign({}, layer, {visibility: false});
                 }

web/client/selectors/__tests__/layers-test.js

@@ -8,7 +8,7 @@
 
 const expect = require('expect');
 const {layersSelector, layerSelectorWithMarkers, groupsSelector, selectedNodesSelector, layerFilterSelector, layerSettingSelector,
-    layerMetadataSelector, wfsDownloadSelector, backgroundControlsSelector, currentBackgroundSelector, tempBackgroundSelector, centerToMarkerSelector} = require('../layers');
+    layerMetadataSelector, wfsDownloadSelector, backgroundControlsSelector, currentBackgroundSelector, tempBackgroundSelector, centerToMarkerSelector, getLayersWithDimension} = require('../layers');
 
 describe('Test layers selectors', () => {
     it('test layersSelector from config', () => {
@@ -405,5 +405,32 @@ describe('Test layers selectors', () => {
         });
         expect(props).toEqual(true);
     });
+    it('test getLayerWidDimension', () => {
+        const state = {
+            layers: {
+                flat: [{
+                    group: 'test',
+                    id: 'layer001',
+                    visibility: true,
+                    dimensions: [{
+                        name: 'time'
+                    }]
+                },
+                {
+                    group: 'test',
+                    id: 'layer002',
+                    visibility: true,
+                    dimensions: [{
+                        name: 'time'
+                    }, {
+                        name: 'elevation'
+                    }]
+                }]
+            }
+        };
+        expect(getLayersWithDimension(state, 'time').length).toBe(2);
+        expect(getLayersWithDimension(state, 'elevation').length).toBe(1);
+        expect(getLayersWithDimension(state, 'reference').length).toBe(0);
+    });
 
 });

web/client/selectors/layers.js

@@ -11,7 +11,7 @@ const {createSelector} = require('reselect');
 const MapInfoUtils = require('../utils/MapInfoUtils');
 const LayersUtils = require('../utils/LayersUtils');
 const {getNormalizedLatLon} = require('../utils/CoordinatesUtils');
-const {get, head, isEmpty, find, isObject} = require('lodash');
+const {get, head, isEmpty, find, isObject, castArray} = require('lodash');
 
 const layersSelector = state => state.layers && state.layers.flat || state.layers || state.config && state.config.layers || [];
 const currentBackgroundLayerSelector = state => head(layersSelector(state).filter(l => l && l.visibility && l.group === "background"));
@@ -81,14 +81,20 @@ const tempBackgroundSelector = (state) => {
     const layers = allBackgroundLayerSelector(state) || [];
     return controls.tempLayer && !isEmpty(controls.tempLayer) ? controls.tempLayer : head(layers.filter((l) => l.visibility)) || {};
 };
-
+const getLayersWithDimension = (state, dimension) =>
+    (layersSelector(state) || [])
+        .filter(l =>
+            l
+            && l.dimensions
+            && find(castArray(l.dimensions), {name: dimension}));
 module.exports = {
     layersSelector,
     layerSelectorWithMarkers,
     groupsSelector,
     currentBackgroundLayerSelector,
     allBackgroundLayerSelector,
     getLayerFromId,
+    getLayersWithDimension,
     selectedNodesSelector,
     getSelectedLayer,
     getSelectedLayers,