7502bc54d1
All checks were successful
FarmMaps.Develop/FarmMapsLib/pipeline/head This commit looks good
637 lines
26 KiB
TypeScript
637 lines
26 KiB
TypeScript
import { tassign } from 'tassign';
|
|
import { IItem,Item } from '@farmmaps/common';
|
|
import { IItemLayer,ItemLayer,ITemporalItemLayer,TemporalItemLayer} from '../models/item.layer';
|
|
import { IMapState} from '../models/map.state';
|
|
import { IQueryState} from '@farmmaps/common';
|
|
import { IPeriodState } from '../models/period.state';
|
|
import { IStyles} from '../models/style.cache';
|
|
import { ILayervalue } from '../models/layer.value';
|
|
import * as mapActions from '../actions/map.actions';
|
|
import {commonActions} from '@farmmaps/common';
|
|
import { createSelector, createFeatureSelector } from '@ngrx/store';
|
|
|
|
import {Feature} from 'ol';
|
|
import {Geometry} from 'ol/geom';
|
|
|
|
|
|
import { ROUTER_NAVIGATION, RouterNavigationAction } from '@ngrx/router-store';
|
|
|
|
import { MODULE_NAME } from '../module-name';
|
|
|
|
const startDate:Date = new Date(new Date(Date.now()).getFullYear(), new Date(Date.now()).getMonth() - 3, 1);
|
|
const endDate:Date = new Date(Date.now());
|
|
|
|
export const initialQueryState: IQueryState = {
|
|
itemCode: null,
|
|
parentCode: null,
|
|
level: 1,
|
|
itemType: null,
|
|
bboxFilter: false,
|
|
query: null,
|
|
tags: null,
|
|
endDate: null,
|
|
startDate: null,
|
|
bbox: []
|
|
};
|
|
|
|
export interface IQuery {
|
|
querystate: IQueryState,
|
|
replace: boolean
|
|
}
|
|
|
|
export interface State {
|
|
period:IPeriodState,
|
|
mapState: IMapState,
|
|
viewExtent: number[],
|
|
queryState: IQueryState,
|
|
query:IQuery,
|
|
parentCode: string,
|
|
features: Array<Feature<Geometry>>,
|
|
panelVisible: boolean,
|
|
panelCollapsed: boolean,
|
|
selectedFeature: Feature<Geometry>,
|
|
selectedItem:IItem,
|
|
parentItem:IItem,
|
|
clearEnabled: boolean,
|
|
searchCollapsed: boolean,
|
|
searchMinified: boolean,
|
|
extent: number[],
|
|
baseLayers: Array<IItemLayer>
|
|
overlayLayers: Array<IItemLayer>,
|
|
selectedItemLayer: IItemLayer,
|
|
projection: string,
|
|
selectedBaseLayer: IItemLayer,
|
|
selectedOverlayLayer: IItemLayer,
|
|
styles:IStyles,
|
|
showLayerSwitcher:boolean,
|
|
inSearch:boolean,
|
|
inZoom:boolean,
|
|
replaceUrl:boolean,
|
|
layerValuesX:number,
|
|
layerValuesY:number,
|
|
layerValuesEnabled:boolean,
|
|
layerValues: Array<ILayervalue>
|
|
showDataLayerSlide:boolean,
|
|
}
|
|
|
|
export const initialState: State = {
|
|
period: {
|
|
startDate: startDate,
|
|
endDate: endDate
|
|
},
|
|
mapState: {
|
|
zoom: 8,
|
|
rotation: 0,
|
|
xCenter: 5.377554,
|
|
yCenter: 52.162422,
|
|
baseLayerCode: ""
|
|
},
|
|
viewExtent:[],
|
|
queryState: tassign(initialQueryState),
|
|
query: null,
|
|
parentCode: null,
|
|
features: [],
|
|
panelVisible: false,
|
|
panelCollapsed: false,
|
|
selectedFeature: null,
|
|
selectedItem: null,
|
|
parentItem: null,
|
|
clearEnabled: false,
|
|
searchCollapsed: true,
|
|
searchMinified:false,
|
|
extent: null,
|
|
baseLayers: [],
|
|
overlayLayers: [],
|
|
projection: "EPSG:3857",
|
|
selectedBaseLayer: null,
|
|
selectedOverlayLayer: null,
|
|
selectedItemLayer: null,
|
|
styles: {},
|
|
showLayerSwitcher: false,
|
|
inSearch:false,
|
|
inZoom:false,
|
|
replaceUrl:true,
|
|
layerValuesX:0,
|
|
layerValuesY:0,
|
|
layerValuesEnabled:false,
|
|
layerValues:[],
|
|
showDataLayerSlide:false
|
|
}
|
|
|
|
export function reducer(state = initialState, action: mapActions.Actions | commonActions.Actions | RouterNavigationAction): State {
|
|
switch (action.type) {
|
|
case ROUTER_NAVIGATION: {
|
|
let a = action as RouterNavigationAction;
|
|
return tassign(state);
|
|
}
|
|
case mapActions.SETMAPSTATE: {
|
|
let a = action as mapActions.SetMapState;
|
|
return tassign(state, {
|
|
mapState: a.mapState
|
|
});
|
|
}
|
|
case mapActions.SETQUERYSTATE: {
|
|
let a = action as mapActions.SetQueryState;
|
|
return tassign(state, { queryState: tassign(a.queryState ),replaceUrl:a.replaceUrl});
|
|
}
|
|
case mapActions.SETSTATE: {
|
|
let a = action as mapActions.SetState;
|
|
return tassign(state, { mapState: tassign(a.mapState), queryState: tassign(a.queryState)});
|
|
}
|
|
case mapActions.SETVIEWEXTENT: {
|
|
let a = action as mapActions.SetViewExtent;
|
|
return tassign(state, { viewExtent: a.extent });
|
|
}
|
|
case mapActions.SETPARENT: {
|
|
let a = action as mapActions.SetParent;
|
|
return tassign(state, {
|
|
parentCode : a.parentCode
|
|
});
|
|
}
|
|
case mapActions.STARTSEARCHSUCCESS: {
|
|
let a = action as mapActions.StartSearchSuccess;
|
|
return tassign(state, {
|
|
features: a.features,
|
|
inSearch:false
|
|
});
|
|
}
|
|
case mapActions.SETFEATURES: {
|
|
let a = action as mapActions.SetFeatures;
|
|
return tassign(state, {
|
|
features: a.features
|
|
});
|
|
}
|
|
case mapActions.SELECTFEATURE: {
|
|
let a = action as mapActions.SelectFeature;
|
|
return tassign(state, {
|
|
selectedFeature: state.selectedItem?state.selectedFeature: a.feature
|
|
});
|
|
}
|
|
case mapActions.SELECTITEM: {
|
|
let a = action as mapActions.SelectItem;
|
|
let itemCode = state.selectedItem ? state.selectedItem.code : "";
|
|
let inSearch = a.itemCode != itemCode;
|
|
return tassign(state, {
|
|
selectedItem: null,
|
|
selectedItemLayer: null,
|
|
showDataLayerSlide: false,
|
|
features:[],
|
|
inSearch:inSearch
|
|
});
|
|
}
|
|
case mapActions.SELECTITEMSUCCESS: {
|
|
let a = action as mapActions.SelectItemSuccess;
|
|
return tassign(state, {
|
|
inSearch:false,
|
|
selectedItem: a.item,
|
|
parentItem: a.parentItem,
|
|
panelVisible: a.item != null,
|
|
clearEnabled: a.item != null,
|
|
searchCollapsed: false,
|
|
searchMinified: true,
|
|
queryState: tassign(state.queryState, {itemCode:a.item ? a.item.code:null})
|
|
});
|
|
}
|
|
case mapActions.SETSELECTEDITEMLAYER: {
|
|
let a = action as mapActions.SetSelectedItemLayer;
|
|
var itemLayer = null;
|
|
if (a.item && "vnd.farmmaps.itemtype.layer,vnd.farmmaps.itemtype.shape.processed,vnd.farmmaps.itemtype.geotiff.processed".indexOf(a.item.itemType) >=0 ) {
|
|
itemLayer = new ItemLayer(a.item);
|
|
itemLayer.layerIndex = a.layerIndex>=0?a.layerIndex:a.item.data.layers?a.item.data.layers[0].index:-1;
|
|
} else if (a.item && a.item.itemType == "vnd.farmmaps.itemtype.temporal") {
|
|
itemLayer = new TemporalItemLayer(a.item);
|
|
}
|
|
|
|
return tassign(state, {
|
|
selectedItemLayer: itemLayer,
|
|
});
|
|
}
|
|
case mapActions.SELECTTEMPORALITEMSSUCCESS:{
|
|
let a = action as mapActions.SelectTemporalItemsSuccess;
|
|
let selectedItemLayer=tassign(state.selectedItemLayer) as TemporalItemLayer;
|
|
let layerIndex=-1;
|
|
selectedItemLayer.temporalItems = a.temporalItems;
|
|
if(a.temporalItems.length>0) {
|
|
let item = a.temporalItems[a.temporalItems.length-1];
|
|
layerIndex = item.data.layers[0].index;
|
|
selectedItemLayer.selectedItemLayer = new ItemLayer(item,1,true,layerIndex);
|
|
} else {
|
|
selectedItemLayer.selectedItemLayer = null;
|
|
}
|
|
selectedItemLayer.previousItemLayer = a.temporalItems.length>1?new ItemLayer(a.temporalItems[a.temporalItems.length-2],0,true,layerIndex):null;
|
|
selectedItemLayer.nextItemLayer = null;
|
|
if(selectedItemLayer.selectedItemLayer) {
|
|
let layerIndex = selectedItemLayer.selectedItemLayer.item.data.layers[0].index;
|
|
selectedItemLayer.layerIndex = layerIndex;
|
|
}
|
|
|
|
return tassign(state,{selectedItemLayer:tassign(state.selectedItemLayer,selectedItemLayer as ItemLayer)});
|
|
}
|
|
case mapActions.NEXTTEMPORAL: {
|
|
let temporalLayer = state.selectedItemLayer as ITemporalItemLayer;
|
|
if(temporalLayer.temporalItems && temporalLayer.temporalItems.length>0) {
|
|
let index = temporalLayer.temporalItems.indexOf(temporalLayer.selectedItemLayer.item);
|
|
if(index == (temporalLayer.temporalItems.length-1)) {
|
|
return state;
|
|
} else {
|
|
temporalLayer.previousItemLayer = temporalLayer.selectedItemLayer;
|
|
if( temporalLayer.previousItemLayer) {
|
|
temporalLayer.previousItemLayer.opacity=0;
|
|
temporalLayer.previousItemLayer.layerIndex = temporalLayer.layerIndex;
|
|
}
|
|
temporalLayer.selectedItemLayer = temporalLayer.nextItemLayer;
|
|
if( temporalLayer.selectedItemLayer) {
|
|
temporalLayer.selectedItemLayer.opacity=1;
|
|
temporalLayer.selectedItemLayer.layerIndex=temporalLayer.layerIndex;
|
|
}
|
|
temporalLayer.nextItemLayer = index+2 < temporalLayer.temporalItems.length ? new ItemLayer(temporalLayer.temporalItems[index+2],0,true,temporalLayer.layerIndex):null;
|
|
if( temporalLayer.nextItemLayer) {
|
|
temporalLayer.nextItemLayer.opacity=0;
|
|
temporalLayer.nextItemLayer.layerIndex = temporalLayer.layerIndex;
|
|
}
|
|
return tassign(state,{selectedItemLayer:tassign(state.selectedItemLayer,temporalLayer as ItemLayer)});
|
|
}
|
|
} else {
|
|
return state;
|
|
}
|
|
}
|
|
case mapActions.PREVIOUSTEMPORAL: {
|
|
let temporalLayer = state.selectedItemLayer as ITemporalItemLayer;
|
|
if(temporalLayer.temporalItems && temporalLayer.temporalItems.length>0) {
|
|
let index = temporalLayer.temporalItems.indexOf(temporalLayer.selectedItemLayer.item);
|
|
if(index == 0) {
|
|
return state;
|
|
} else {
|
|
temporalLayer.nextItemLayer = temporalLayer.selectedItemLayer;
|
|
if( temporalLayer.nextItemLayer) {
|
|
temporalLayer.nextItemLayer.opacity=0;
|
|
temporalLayer.nextItemLayer.layerIndex = temporalLayer.layerIndex;
|
|
}
|
|
temporalLayer.selectedItemLayer = temporalLayer.previousItemLayer;
|
|
if( temporalLayer.selectedItemLayer) {
|
|
temporalLayer.selectedItemLayer.opacity=1;
|
|
temporalLayer.selectedItemLayer.layerIndex = temporalLayer.layerIndex;
|
|
}
|
|
temporalLayer.previousItemLayer = index-2 >=0? new ItemLayer(temporalLayer.temporalItems[index-2],0,true,temporalLayer.layerIndex):null;
|
|
if( temporalLayer.previousItemLayer) {
|
|
temporalLayer.previousItemLayer.opacity=0;
|
|
temporalLayer.previousItemLayer.layerIndex = temporalLayer.layerIndex;
|
|
}
|
|
return tassign(state,{selectedItemLayer:tassign(state.selectedItemLayer,temporalLayer as ItemLayer)});
|
|
}
|
|
} else {
|
|
return state;
|
|
}
|
|
}
|
|
case mapActions.SELECTTEMPORAL:{
|
|
//todo implement
|
|
}
|
|
case mapActions.STARTSEARCH: {
|
|
let a = action as mapActions.StartSearch;
|
|
let panelVisible = a.queryState.itemCode!=null ||a.queryState.itemType!=null||a.queryState.parentCode!=null || a.queryState.query != null || a.queryState.tags != null;
|
|
return tassign(state, {
|
|
selectedItem: null,
|
|
features:[],
|
|
selectedItemLayer:null,
|
|
searchCollapsed: !panelVisible,
|
|
panelVisible: panelVisible,
|
|
clearEnabled: panelVisible,
|
|
searchMinified: panelVisible,
|
|
inSearch:panelVisible
|
|
});
|
|
}
|
|
case commonActions.FAIL:{
|
|
return tassign(state,{inSearch:false});
|
|
}
|
|
case mapActions.DOQUERY: {
|
|
let a = action as mapActions.DoQuery;
|
|
return tassign(state, {
|
|
query: tassign(state.query,
|
|
{
|
|
querystate: tassign(a.query, { bbox: a.query.bboxFilter ? state.viewExtent : [] }),
|
|
replace:a.replace
|
|
})
|
|
})
|
|
}
|
|
|
|
case mapActions.SETPERIOD: {
|
|
return tassign(state,{ period: action.period});
|
|
}
|
|
|
|
case mapActions.ADDFEATURESUCCESS: {
|
|
let a = action as mapActions.AddFeatureSuccess;
|
|
let features = state.features.slice();
|
|
features.push(a.feature);
|
|
return tassign(state, {
|
|
panelVisible: true,
|
|
selectedFeature: a.feature,
|
|
extent: a.feature.getGeometry().getExtent(),
|
|
searchCollapsed: false,
|
|
clearEnabled:true,
|
|
features:features
|
|
});
|
|
}
|
|
case mapActions.UPDATEFEATURESUCCESS: {
|
|
let a = action as mapActions.UpdateFeatureSuccess;
|
|
let features: any[] = [];
|
|
var index = -1;
|
|
for (var i = 0; i < state.features.length; i++) {
|
|
if (state.features[i].getId() == a.feature.getId()) {
|
|
features.push(a.feature);
|
|
} else {
|
|
features.push(state.features[i]);
|
|
}
|
|
}
|
|
return tassign(state, { features: features });
|
|
}
|
|
case mapActions.EXPANDSEARCH: {
|
|
return tassign(state, { searchCollapsed: false });
|
|
}
|
|
case mapActions.COLLAPSESEARCH: {
|
|
return tassign(state, { searchCollapsed: state.panelVisible ? false: true});
|
|
}
|
|
case commonActions.CLOSEALL: {
|
|
return tassign(state, { searchCollapsed: state.panelVisible ? false: true,showLayerSwitcher:false});
|
|
}
|
|
case mapActions.SETEXTENT: {
|
|
let a = action as mapActions.SetExtent;
|
|
return tassign(state, { extent: a.extent });
|
|
}
|
|
case mapActions.ADDLAYER: {
|
|
let a = action as mapActions.AddLayer;
|
|
let itemLayers = state.overlayLayers.slice(0);
|
|
let itemLayer = new ItemLayer(a.item);
|
|
itemLayer.layerIndex = a.layerIndex == -1 ? 0 : a.layerIndex;
|
|
let existing = itemLayers.filter(il => il.item.code == itemLayer.item.code && il.layerIndex == itemLayer.layerIndex);
|
|
if(existing.length==0) {
|
|
itemLayers.push(itemLayer);
|
|
return tassign(state, { overlayLayers: itemLayers, selectedOverlayLayer: itemLayer });
|
|
} else {
|
|
return state;
|
|
}
|
|
|
|
}
|
|
case mapActions.REMOVELAYER: {
|
|
let a = action as mapActions.RemoveLayer;
|
|
let newLayers = state.overlayLayers.slice(0);
|
|
let i = state.overlayLayers.indexOf(a.itemLayer);
|
|
var selectedOverlayLayer: IItemLayer = null;
|
|
if (i>0 && state.overlayLayers.length > 1)
|
|
selectedOverlayLayer = state.overlayLayers[i - 1];
|
|
else if (i == 0 && state.overlayLayers.length > 1)
|
|
selectedOverlayLayer = state.overlayLayers[i + 1];
|
|
newLayers.splice(i, 1);
|
|
return tassign(state, { overlayLayers: newLayers, selectedOverlayLayer: selectedOverlayLayer });
|
|
}
|
|
case mapActions.CLEARLAYERS: {
|
|
return tassign(state, {overlayLayers: [], selectedOverlayLayer: null});
|
|
}
|
|
case mapActions.SETVISIBILITY: {
|
|
let a = action as mapActions.SetVisibility;
|
|
if(state.selectedItemLayer == a.itemLayer) {
|
|
return tassign(state,{selectedItemLayer: tassign(state.selectedItemLayer,{visible:a.visibility})});
|
|
} else {
|
|
let newLayers = state.overlayLayers.slice(0);
|
|
let i = state.overlayLayers.indexOf(a.itemLayer);
|
|
newLayers[i].visible = a.visibility;
|
|
return tassign(state, { overlayLayers: newLayers });
|
|
}
|
|
}
|
|
case mapActions.SETOPACITY: {
|
|
let a = action as mapActions.SetOpacity;
|
|
if(state.selectedItemLayer == a.itemLayer) {
|
|
return tassign(state,{selectedItemLayer: tassign(state.selectedItemLayer,{opacity:a.opacity})});
|
|
} else {
|
|
let newLayers = state.overlayLayers.slice(0);
|
|
let i = state.overlayLayers.indexOf(a.itemLayer);
|
|
newLayers[i].opacity = a.opacity;
|
|
return tassign(state, { overlayLayers: newLayers });
|
|
}
|
|
}
|
|
case mapActions.SETLAYERINDEX: {
|
|
let a = action as mapActions.SetLayerIndex;
|
|
if (a.itemLayer == null) {
|
|
if(state.selectedItemLayer.item.itemType == "vnd.farmmaps.itemtype.temporal") {
|
|
var newItemlayer = tassign(state.selectedItemLayer,{layerIndex:a.layerIndex});
|
|
let tl = newItemlayer as ITemporalItemLayer;
|
|
if(tl.previousItemLayer) {
|
|
let nl = new ItemLayer(tl.previousItemLayer.item);
|
|
nl.opacity = tl.previousItemLayer.opacity;
|
|
nl.visible = tl.previousItemLayer.visible;
|
|
nl.layerIndex = a.layerIndex;
|
|
tl.previousItemLayer = nl;
|
|
}
|
|
if(tl.selectedItemLayer) {
|
|
let nl = new ItemLayer(tl.selectedItemLayer.item);
|
|
nl.opacity = tl.selectedItemLayer.opacity;
|
|
nl.visible = tl.selectedItemLayer.visible;
|
|
nl.layerIndex = a.layerIndex;
|
|
tl.selectedItemLayer = nl;
|
|
}
|
|
if(tl.nextItemLayer) {
|
|
let nl = new ItemLayer(tl.nextItemLayer.item);
|
|
nl.opacity = tl.nextItemLayer.opacity;
|
|
nl.visible = tl.nextItemLayer.visible;
|
|
nl.layerIndex = a.layerIndex;
|
|
tl.nextItemLayer = nl;
|
|
}
|
|
} else {
|
|
var newItemlayer = new ItemLayer(state.selectedItemLayer.item);
|
|
newItemlayer.layerIndex = a.layerIndex;
|
|
|
|
}
|
|
return tassign(state, { selectedItemLayer: newItemlayer})
|
|
} else {
|
|
let newLayers = state.overlayLayers.slice(0);
|
|
let i = state.overlayLayers.indexOf(a.itemLayer);
|
|
newLayers[i].layerIndex = a.layerIndex;
|
|
return tassign(state, { overlayLayers: newLayers });
|
|
}
|
|
}
|
|
case mapActions.LOADBASELAYERSSUCCESS: {
|
|
let a =action as mapActions.LoadBaseLayersSuccess;
|
|
let baseLayers:ItemLayer[] = [];
|
|
for (let item of a.items) {
|
|
var l = new ItemLayer(item);
|
|
l.visible = false;
|
|
baseLayers.push(l);
|
|
}
|
|
var selectedBaseLayer: IItemLayer = null;
|
|
var mapState = tassign(state.mapState);
|
|
let sb = baseLayers.filter(layer => layer.item.code === mapState.baseLayerCode);
|
|
let db = baseLayers.filter(layer => layer.item.data && layer.item.data.default === true);
|
|
if (baseLayers.length > 0 && mapState.baseLayerCode != "" && sb.length>0) {
|
|
selectedBaseLayer = sb[0];
|
|
selectedBaseLayer.visible = true;
|
|
} else if (baseLayers.length >0 && db.length>0){
|
|
selectedBaseLayer = db[0];
|
|
selectedBaseLayer.visible = true;
|
|
} else if (baseLayers.length > 0) {
|
|
selectedBaseLayer = baseLayers[0];
|
|
selectedBaseLayer.visible = true;
|
|
mapState.baseLayerCode = selectedBaseLayer.item.code;
|
|
}
|
|
return tassign(state, { mapState:mapState, baseLayers: baseLayers, selectedBaseLayer: selectedBaseLayer });
|
|
}
|
|
case mapActions.SELECTBASELAYER: {
|
|
let a = action as mapActions.SelectBaseLayer;
|
|
let baseLayers = state.baseLayers.slice(0);
|
|
baseLayers.forEach((l) => l.visible = false);
|
|
let i = state.baseLayers.indexOf(a.itemLayer);
|
|
baseLayers[i].visible = true;
|
|
var mapState = tassign(state.mapState);
|
|
mapState.baseLayerCode = a.itemLayer.item.code;
|
|
return tassign(state, {mapState:mapState, baseLayers:baseLayers,selectedBaseLayer:a.itemLayer });
|
|
}
|
|
case mapActions.SELECTOVERLAYLAYER: {
|
|
let a = action as mapActions.SelectOverlayLayer;
|
|
return tassign(state, { selectedOverlayLayer: a.itemLayer });
|
|
}
|
|
|
|
case mapActions.CLEAR: {
|
|
let newQueryState = tassign(state.queryState, { query: null, tags: null, itemCode: null, parentCode: null, itemType: null });
|
|
return tassign(state, {
|
|
panelVisible: false,
|
|
panelCollapsed:false,
|
|
selectedItem: null,
|
|
selectedItemLayer: null,
|
|
selectedFeature: null,
|
|
queryState: newQueryState,
|
|
clearEnabled: false,
|
|
layerValuesEnabled: false,
|
|
searchCollapsed: true,
|
|
searchMinified: false,
|
|
features: [],
|
|
query:initialState.query,
|
|
showLayerSwitcher: false,
|
|
extent: null,
|
|
showDataLayerSlide: false
|
|
});
|
|
}
|
|
case mapActions.SETSTYLE:{
|
|
let a = action as mapActions.SetStyle;
|
|
let styles = tassign(state.styles);
|
|
styles[a.itemType] = a.style;
|
|
return tassign(state,{styles:styles});
|
|
}
|
|
case mapActions.SHOWLAYERSWITCHER:{
|
|
let a = action as mapActions.ShowLayerSwitcher;
|
|
return tassign(state,{showLayerSwitcher:a.show});
|
|
}
|
|
case mapActions.TOGGLESHOWDATALAYERSLIDE:{
|
|
return tassign(state,{showDataLayerSlide:!state.showDataLayerSlide});
|
|
}
|
|
case mapActions.SETREPLACEURL: {
|
|
let a= action as mapActions.SetReplaceUrl;
|
|
return tassign(state,{replaceUrl:a.replaceUrl});
|
|
}
|
|
case mapActions.TOGGLELAYERVALUESENABLED: {
|
|
return tassign(state,{layerValuesEnabled:!state.layerValuesEnabled});
|
|
}
|
|
case mapActions.SETLAYERVALUESLOCATION: {
|
|
let a= action as mapActions.SetLayerValuesLocation;
|
|
return tassign(state,{layerValuesX: a.x, layerValuesY:a.y,layerValues:[]});
|
|
}
|
|
case mapActions.GETLAYERVALUESUCCESS:{
|
|
let a= action as mapActions.GetLayerValueSuccess;
|
|
let v = state.layerValues.slice(0);
|
|
v.push(a.layervalue);
|
|
return tassign(state,{layerValues:v});
|
|
}
|
|
case commonActions.ITEMDELETEDEVENT:{
|
|
let a= action as commonActions.ItemDeletedEvent;
|
|
if(state.selectedItem && state.selectedItem.code == a.itemCode) {
|
|
return tassign(state,{
|
|
selectedItem: null,
|
|
selectedItemLayer: null,
|
|
showDataLayerSlide: false,
|
|
features:[]
|
|
});
|
|
}
|
|
if(state.features.length>0) {
|
|
var index = -1;
|
|
for (var i = 0; i < state.features.length; i++) {
|
|
if (state.features[i].getId() == a.itemCode ) {
|
|
index=i;
|
|
}
|
|
}
|
|
if(index>=0) {
|
|
let newFeatures = state.features.slice(0);
|
|
newFeatures.splice(index,1);
|
|
return tassign(state,{features:newFeatures});
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
default: {
|
|
return state;
|
|
}
|
|
}
|
|
}
|
|
|
|
export const getMapState = (state: State) => state.mapState;
|
|
export const getParentCode = (state: State) => state.parentCode;
|
|
export const getFeatures = (state: State) => state.features;
|
|
export const getPanelVisible = (state: State) => state.panelVisible;
|
|
export const getPanelCollapsed = (state: State) => state.panelCollapsed;
|
|
export const getSelectedFeature = (state: State) => state.selectedFeature;
|
|
export const getSelectedItem = (state: State) => state.selectedItem;
|
|
export const getParentItem = (state: State) => state.parentItem;
|
|
export const getQueryState = (state: State) => state.queryState;
|
|
export const getClearEnabled = (state: State) => state.clearEnabled;
|
|
export const getSearchCollapsed = (state: State) => state.searchCollapsed;
|
|
export const getSearchMinified = (state: State) => state.searchMinified;
|
|
export const getExtent = (state: State) => state.extent;
|
|
export const getOverlayLayers = (state: State) => state.overlayLayers;
|
|
export const getBaseLayers = (state: State) => state.baseLayers;
|
|
export const getProjection = (state: State) => state.projection;
|
|
export const getSelectedBaseLayer = (state: State) => state.selectedBaseLayer;
|
|
export const getSelectedOverlayLayer = (state: State) => state.selectedOverlayLayer;
|
|
export const getQuery = (state: State) => state.query;
|
|
export const getSelectedItemLayer = (state: State) => state.selectedItemLayer;
|
|
export const getPeriod = (state:State) => state.period;
|
|
export const getStyles = (state:State) => state.styles;
|
|
export const getShowLayerSwitcher = (state:State) => state.showLayerSwitcher;
|
|
export const getShowDataLayerSlide = (state:State) => state.showDataLayerSlide;
|
|
export const getInSearch = (state:State) => state.inSearch;
|
|
export const getState = (state:State) => {return {mapState:state.mapState,queryState:state.queryState,replaceUrl:state.replaceUrl};}
|
|
export const getLayerValuesEnabled = (state:State) => state.layerValuesEnabled;
|
|
export const getLayerValues = (state:State) => state.layerValues;
|
|
export const getLayerValuesX = (state:State) => state.layerValuesX;
|
|
export const getLayerValuesY = (state:State) => state.layerValuesY;
|
|
|
|
|
|
export const selectMapState = createFeatureSelector<State>(MODULE_NAME);
|
|
export const selectGetMapState= createSelector(selectMapState, getMapState);
|
|
export const selectGetParentCode = createSelector(selectMapState, getParentCode);
|
|
export const selectGetFeatures = createSelector(selectMapState, getFeatures);
|
|
export const selectGetPanelVisible = createSelector(selectMapState, getPanelVisible);
|
|
export const selectGetPanelCollapsed = createSelector(selectMapState, getPanelCollapsed);
|
|
export const selectGetSelectedFeature = createSelector(selectMapState, getSelectedFeature);
|
|
export const selectGetSelectedItem = createSelector(selectMapState, getSelectedItem);
|
|
export const selectGetParentItem = createSelector(selectMapState, getParentItem);
|
|
export const selectGetQueryState = createSelector(selectMapState, getQueryState);
|
|
export const selectGetClearEnabled = createSelector(selectMapState, getClearEnabled);
|
|
export const selectGetSearchCollapsed = createSelector(selectMapState, getSearchCollapsed);
|
|
export const selectGetSearchMinified = createSelector(selectMapState, getSearchMinified);
|
|
export const selectGetExtent = createSelector(selectMapState, getExtent);
|
|
export const selectGetOverlayLayers = createSelector(selectMapState, getOverlayLayers);
|
|
export const selectGetBaseLayers = createSelector(selectMapState, getBaseLayers);
|
|
export const selectGetProjection = createSelector(selectMapState, getProjection);
|
|
export const selectGetSelectedBaseLayer = createSelector(selectMapState, getSelectedBaseLayer);
|
|
export const selectGetSelectedOverlayLayer = createSelector(selectMapState, getSelectedOverlayLayer);
|
|
export const selectGetQuery = createSelector(selectMapState, getQuery);
|
|
export const selectGetSelectedItemLayer = createSelector(selectMapState, getSelectedItemLayer);
|
|
export const selectGetPeriod = createSelector(selectMapState, getPeriod);
|
|
export const selectGetStyles = createSelector(selectMapState, getStyles);
|
|
export const selectGetShowLayerSwitcher = createSelector(selectMapState,getShowLayerSwitcher);
|
|
export const selectGetShowdataLayerSlide = createSelector(selectMapState,getShowDataLayerSlide);
|
|
export const selectGetInSearch = createSelector(selectMapState,getInSearch);
|
|
export const selectGetState = createSelector(selectMapState,getState);
|
|
export const selectGetLayerValuesEnabled = createSelector(selectMapState,getLayerValuesEnabled);
|
|
export const selectGetLayerValues = createSelector(selectMapState,getLayerValues);
|
|
export const selectGetLayerValuesX = createSelector(selectMapState,getLayerValuesX);
|
|
export const selectGetLayerValuesY = createSelector(selectMapState,getLayerValuesY);
|
|
|
|
|