@kalisio/kdk 2.3.2 → 2.4.0

package/map/client/mixins/mixin.feature-service.js

@@ -1,7 +1,9 @@
 import _ from 'lodash'
+import sift from 'sift'
 import { getType, getGeom } from '@turf/invariant'
 import logger from 'loglevel'
 import * as features from '../utils/utils.features.js'
+import * as layers from '../utils/utils.layers.js'
 
 export const featureService = {
   methods: {
@@ -31,7 +33,7 @@ export const featureService = {
     getFeaturesFromQuery: features.getFeaturesFromQuery,
     async getFeatures (options, queryInterval, queryLevel) {
       const query = await this.getFeaturesQuery(options, queryInterval, queryLevel)
-      const response = await this.getFeaturesFromQuery(options, query)
+      const response = await features.getFeaturesFromQuery(options, query)
       return response
     },
     async getFeaturesFromLayer (name, queryInterval) {
@@ -40,42 +42,23 @@ export const featureService = {
       if (!layer) return
       return this.getFeatures(layer, queryInterval)
     },
-    getMeasureForFeatureBaseQuery (layer, feature) {
-      // We might have a different ID to identify measures related to a timeseries (what is called a chronicle)
-      // than measures displayed on a map. For instance mobile measures might appear at different locations,
-      // but when selecting one we would like to display the timeseries related to all locations.
-      let featureId = layer.chronicleId || layer.featureId
-      // Support compound ID
-      featureId = (Array.isArray(featureId) ? featureId : [featureId])
-      const query = featureId.reduce((result, id) =>
-        Object.assign(result, { ['properties.' + id]: _.get(feature, 'properties.' + id) }),
-      {})
-      query.$groupBy = featureId
-      return query
-    },
+    getMeasureForFeatureBaseQuery: features.getMeasureForFeatureBaseQuery,
     async getMeasureForFeatureQuery (layer, feature, startTime, endTime) {
       const query = await this.getFeaturesQuery(_.merge({
-        baseQuery: this.getMeasureForFeatureBaseQuery(layer, feature)
+        baseQuery: features.getMeasureForFeatureBaseQuery(layer, feature)
       }, layer), {
         $gte: startTime.toISOString(),
         $lte: endTime.toISOString()
       })
       return query
     },
-    async getMeasureForFeatureFromQuery (layer, feature, query) {
-      const result = await this.getFeaturesFromQuery(layer, query)
-      if (result.features.length > 0) {
-        return result.features[0]
-      } else {
-        return _.cloneDeep(feature)
-      }
-    },
+    getMeasureForFeatureFromQuery: features.getMeasureForFeatureFromQuery,
     async getMeasureForFeature (layer, feature, startTime, endTime) {
       let probedLocation
       this.setCursor('processing-cursor')
       try {
         const query = await this.getMeasureForFeatureQuery(layer, feature, startTime, endTime)
-        probedLocation = await this.getMeasureForFeatureFromQuery(layer, feature, query)
+        probedLocation = await features.getMeasureForFeatureFromQuery(layer, feature, query)
       } catch (error) {
         logger.error(error)
       }
@@ -87,28 +70,69 @@ export const featureService = {
     editFeaturesGeometry: features.editFeaturesGeometry,
     editFeaturesProperties: features.editFeaturesProperties,
     removeFeatures: features.removeFeatures,
-    onFeaturesUpdated (feature) {
+    onFeaturesUpdated (feature, layerId) {
       // We only support single feature edition
       if (!getType(feature) || !getGeom(feature)) return
       // Find related layer
-      const layer = this.getLayerById(feature.layer)
+      const layer = this.getLayerById(layerId || feature.layer)
       if (!layer || !this.isLayerVisible(layer.name)) return
       // Only possible when not edited by default
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) return
+      // Check for time-based layers if update is in the currently visualized time range
+      // so that we don't add too much old features
+      if (!features.isFeatureInQueryInterval(feature, layer)) return
       // As by default we update the whole layer in fetch and replace mode force add/update only mode
       // Can only apply to realtime layers as we need to force a data refresh
-      if (typeof this.updateLayer === 'function') this.updateLayer(layer.name, feature, { removeMissing: false })
+      if (typeof this.updateLayer === 'function') {
+        // Check if feature should be filtered or not according to layer base query
+        const filteredFeature = [feature].filter(sift(_.omit(layer.baseQuery || {}, ['$skip', '$sort', '$limit', '$select'])))
+        if (filteredFeature.length > 0) this.updateLayer(layer.name, feature, { removeMissing: false })
+      }
     },
-    onFeaturesRemoved (feature) {
+    onFeaturesRemoved (feature, layerId) {
       // We only support single feature edition
       if (!getType(feature) || !getGeom(feature)) return
       // Find related layer
-      const layer = this.getLayerById(feature.layer)
+      const layer = this.getLayerById(layerId || feature.layer)
       if (!layer || !this.isLayerVisible(layer.name)) return
       // Only possible when not edited by default
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) return
+      // Check for time-based layers if update is in the currently visualized time range ? Should not be relevent in this case. 
+      // Indeed, as time has passed we might have old features that need to be cleaned,
+      // ie features now outside the request time range but inside the initial time range when they were requested
+      //if (!features.isFeatureInQueryInterval(feature, layer)) return
       // Can only apply to realtime layers as we need to force a data refresh
-      if (typeof this.updateLayer === 'function') this.updateLayer(layer.name, feature, { remove: true })
+      if (typeof this.updateLayer === 'function') {
+        // Check if feature should be filtered or not according to layer base query
+        const filteredFeature = [feature].filter(sift(_.omit(layer.baseQuery || {}, ['$skip', '$sort', '$limit', '$select'])))
+        if (filteredFeature.length > 0) this.updateLayer(layer.name, feature, { remove: true })
+      }
+    },
+    listenToServiceEvents (layer) {
+      // User-defined layers are already managed
+      if (!layer.service || !layer.serviceEvents || layers.isInMemoryLayer(layer) || layers.isFeatureLayer(layer)) return
+      const service = this.$api.getService(layer.service)
+      // Check if service available and not already registered
+      if (!service || this.layerServiceEventListeners[layer._id]) return
+      // Generate listeners targetting the right layer as in this case the features won't hold it contrary to user-defined layers
+      const onFeaturesUpdated = (feature) => this.onFeaturesUpdated(feature, layer._id)
+      const onFeaturesRemoved = (feature) => this.onFeaturesRemoved(feature, layer._id)
+      this.layerServiceEventListeners[layer._id] = { layerService: layer.service, onFeaturesUpdated, onFeaturesRemoved }
+      service.on('created', onFeaturesUpdated)
+      service.on('patched', onFeaturesUpdated)
+      service.on('removed', onFeaturesRemoved)
+    },
+    unlistenToServiceEvents (layer) {
+      // Check if listeners are registered for layer
+      if (!this.layerServiceEventListeners[layer._id]) return
+      const { layerService, onFeaturesUpdated, onFeaturesRemoved } = this.layerServiceEventListeners[layer._id]
+      const service = this.$api.getService(layerService)
+      // Check if service still available
+      if (!service) return
+      service.off('created', onFeaturesUpdated)
+      service.off('patched', onFeaturesUpdated)
+      service.off('removed', onFeaturesRemoved)
+      delete this.layerServiceEventListeners[layer._id]
     }
   },
   created () {
@@ -116,17 +140,34 @@ export const featureService = {
     this.$api.getService('features').timeout = 60 * 60 * 1000 // 1h should be sufficient since we also have size limits
   },
   mounted () {
-    // Listen to user layer changes
+    // Here we need to listen to service events for all realtime layers triggered by it
+    // 1) user-defined layers targetting the features service
     const featuresService = this.$api.getService('features')
     featuresService.on('created', this.onFeaturesUpdated)
     featuresService.on('patched', this.onFeaturesUpdated)
     featuresService.on('removed', this.onFeaturesRemoved)
+    // 2) built-in layers targetting specific services
+    // As we don't know target services upfront we register listeners when layer are added, we track it in a map
+    this.layerServiceEventListeners = {}
+    this.$engineEvents.on('layer-added', this.listenToServiceEvents)
+    this.$engineEvents.on('layer-removed', this.unlistenToServiceEvents)
   },
   beforeUnmount () {
-    // Remove event connections
+    // Remove all listeners
     const featuresService = this.$api.getService('features')
     featuresService.off('created', this.onFeaturesUpdated)
     featuresService.off('patched', this.onFeaturesUpdated)
     featuresService.off('removed', this.onFeaturesRemoved)
+    _.forOwn(this.layerServiceEventListeners, listeners => {
+      const { layerService, onFeaturesUpdated, onFeaturesRemoved } = listeners
+      const service = this.$api.getService(layerService)
+      // Check if service still available
+      if (!service) return
+      service.off('created', onFeaturesUpdated)
+      service.off('patched', onFeaturesUpdated)
+      service.off('removed', onFeaturesRemoved)
+    })
+    this.$engineEvents.off('layer-added', this.listenToServiceEvents)
+    this.$engineEvents.off('layer-removed', this.unlistenToServiceEvents)
   }
 }

package/map/client/mixins/mixin.levels.js

@@ -33,6 +33,7 @@ export const levels = {
       }
     },
     setSelectedLevel (level) {
+      if (this.selectedLevel === level) return
       this.selectedLevel = level
       this.onSelectedLevelChanged(level)
     },

package/map/client/mixins/mixin.weacast.js

@@ -1,5 +1,6 @@
 import _ from 'lodash'
 import logger from 'loglevel'
+import { getForecastForLocation, getForecastProbe, getForecastForFeature } from '../utils/utils.weacast.js'
 
 export const weacast = {
   emits: [
@@ -46,6 +47,7 @@ export const weacast = {
       this.setForecastModel(forecastModel)
     },
     setForecastModel (model) {
+      if (this.forecastModel === model) return
       this.forecastModel = model
       this.onForecastModelChanged(model)
     },
@@ -54,6 +56,7 @@ export const weacast = {
       this.$engineEvents.emit('forecast-model-changed', model)
     },
     setForecastLevel (level) {
+      if (this.forecastLevel === level) return
       this.forecastLevel = level
       this.onForecastLevelChanged(level)
     },
@@ -64,45 +67,11 @@ export const weacast = {
     async getForecastForLocation (long, lat, startTime, endTime) {
       // Not yet ready
       if (!this.forecastModel) return
-      // From now to last available time
-      const geometry = {
-        type: 'Point',
-        coordinates: [long, lat]
-      }
-      const query = {
-        forecastTime: {
-          $gte: startTime.format(),
-          $lte: endTime.format()
-        },
-        geometry: {
-          $geoIntersects: {
-            $geometry: geometry
-          }
-        }
-      }
-      let probedLocation
       this.setCursor('processing-cursor')
-      try {
-        let elements = this.forecastModel.elements.map(element => element.name)
-        // Filter available elements according to current level if any
-        if (this.forecastLevel) elements = elements.filter(element => element.endsWith(this.forecastLevel.toString()))
-        else {
-          elements = elements.filter(element => {
-            const tokens = element.split('-')
-            return (tokens.length === 0) || !_.isFinite(_.toNumber(tokens[tokens.length - 1]))
-          })
-        }
-        const response = await this.getWeacastApi().getService('probes')
-          .create({
-            forecast: this.forecastModel.name,
-            elements
-          }, { query })
-        if (response.features.length > 0) {
-          probedLocation = response.features[0]
-        } else throw new Error('Cannot find valid forecast at location')
-      } catch (error) {
-        logger.error(error)
-      }
+      const probedLocation = await getForecastForLocation({
+        long, lat, startTime, endTime, forecastModel: this.forecastModel,
+        forecastLevel: this.forecastLevel, weacastApi: this.getWeacastApi()
+      })
       this.unsetCursor('processing-cursor')
       return probedLocation
     },
@@ -113,20 +82,8 @@ export const weacast = {
       if (this.probe && (this.probe.name === name) && (this.probe.forecast === this.forecastModel.name)) {
         return this.probe
       }
-      const results = await this.getWeacastApi().getService('probes').find({
-        query: {
-          name,
-          forecast: this.forecastModel.name,
-          $paginate: false,
-          $select: ['elements', 'forecast', 'featureId']
-        }
-      })
-      if (results.length > 0) {
-        this.probe = results[0]
-        return this.probe
-      } else {
-        return null
-      }
+      this.probe = await getForecastProbe({ name, forecastModel: this.forecastModel, weacastApi: this.getWeacastApi() })
+      return this.probe
     },
     async getForecastForFeature (featureId, startTime, endTime) {
       // Not yet ready
@@ -134,42 +91,8 @@ export const weacast = {
       // Check if probe is available
       if (!this.probe) return
 
-      let probedLocation
       this.setCursor('processing-cursor')
-      try {
-        let elements = this.forecastModel.elements.map(element => element.name)
-        // Filter available elements according to current level if any
-        if (this.forecastLevel) {
-          elements = elements.filter(element => element.endsWith(this.forecastLevel.toString()))
-        } else {
-          elements = elements.filter(element => {
-            const tokens = element.split('-')
-            return (tokens.length === 0) || !_.isFinite(_.toNumber(tokens[tokens.length - 1]))
-          })
-        }
-        // Need to add derived values for static probes as they are not computed on the fly
-        const windDirection = (this.forecastLevel ? `windDirection-${this.forecastLevel}` : 'windDirection')
-        const windSpeed = (this.forecastLevel ? `windSpeed-${this.forecastLevel}` : 'windSpeed')
-        elements = elements.concat([windDirection, windSpeed])
-
-        const results = await this.getWeacastApi().getService('probe-results').find({
-          query: {
-            probeId: this.probe._id,
-            forecastTime: {
-              $gte: startTime.format(),
-              $lte: endTime.format()
-            },
-            [this.probe.featureId]: featureId,
-            $groupBy: this.probe.featureId,
-            $aggregate: elements
-          }
-        })
-        if (results.length > 0) {
-          probedLocation = results[0]
-        } else throw new Error('Cannot find valid forecast for feature')
-      } catch (error) {
-        logger.error(error)
-      }
+      const probedLocation = await getForecastForFeature({ probe: this.probe, featureId, startTime, endTime, forecastModel: this.forecastModel, forecastLevel: this.forecastLevel, weacastApi: this.getWeacastApi() })
       this.unsetCursor('processing-cursor')
       return probedLocation
     },

package/map/client/utils/index.js

@@ -7,3 +7,4 @@ export * from './utils.location.js'
 export * from './utils.project.js'
 export * from './utils.schema.js'
 export * from './utils.style.js'
+export * from './utils.time-series.js'

package/map/client/utils/utils.capture.js

@@ -103,7 +103,7 @@ function headerFooterComponent (text, position) {
   return { content: [{ component: _.get(config, `capture.${position}.component`, 'KCaptureTextArea'), text, position }], visible: true }
 }
 function compassComponent (position) {
-  return { content: _.union(Layout.getPage().content, [{ component: 'layout/KPageSticky', position, offset: [0, 5], content: [{ component: 'KNorth' }] }]) }
+  return { content: _.union(Layout.getStickies().content, [{ position, offset: [0, 5], content: [{ component: 'KNorth' }] }]) }
 }
 function legendComponent () {
   return {

package/map/client/utils/utils.catalog.js

@@ -24,17 +24,17 @@ export function setUrlJwt (item, path, baseUrl, jwtField, jwt) {
 export async function setEngineJwt (layers, planetApi) {
   // Backward compatibility when we previously used a single API
   if (!planetApi) planetApi = api
-  const planetConfig = planetApi.getConfig()
   // If we need to use API gateway forward token as query parameter
   // (Leaflet does not support anything else by default as it mainly uses raw <img> tags)
-  let jwt = (planetConfig.gatewayJwt ? await planetApi.get('storage').getItem(planetConfig.gatewayJwt) : null)
-  let jwtField = planetConfig.gatewayJwtField
-  // Check both the default built-in config or the server provided one if any (eg mobile apps)
-  const gatewayUrl = Store.get('capabilities.api.gateway') || planetConfig.gateway
+  let jwt = (planetApi.hasConfig('gatewayJwt') ? await planetApi.get('storage').getItem(planetApi.getConfig('gatewayJwt')) : null)
+  let jwtField = planetApi.getConfig('gatewayJwtField')
+  // Check both the default built-in config or the server provided one if any
+  const gatewayUrl = (planetApi.hasConfig('gateway') ? planetApi.getConfig('gateway') : Store.get('capabilities.api.gateway'))
   if (jwt) {
     layers.forEach(layer => {
       setUrlJwt(layer, 'iconUrl', gatewayUrl, jwtField, jwt)
       setUrlJwt(layer, 'leaflet.source', gatewayUrl, jwtField, jwt)
+      setUrlJwt(layer, 'leaflet.url', gatewayUrl, jwtField, jwt)
       setUrlJwt(layer, 'opendap.url', gatewayUrl, jwtField, jwt)
       setUrlJwt(layer, 'geotiff.url', gatewayUrl, jwtField, jwt)
       setUrlJwt(layer, 'wfs.url', gatewayUrl, jwtField, jwt)
@@ -45,9 +45,9 @@ export async function setEngineJwt (layers, planetApi) {
   }
   // We might also proxy some data directly from the app when using object storage
   // This is only for raw raster data not OGC protocols
-  jwt = (planetConfig.apiJwt ? await planetApi.get('storage').getItem(planetConfig.apiJwt) : null)
+  jwt = (planetApi.hasConfig('apiJwt') ? await planetApi.get('storage').getItem(planetApi.getConfig('apiJwt')) : null)
   jwtField = 'jwt'
-  const apiUrl = planetApi.getBaseUrl()
+  const apiUrl = planetApi.getConfig('domain')
   if (jwt) {
     layers.forEach(layer => {
       setUrlJwt(layer, 'geotiff.url', apiUrl, jwtField, jwt)

package/map/client/utils/utils.features.js

@@ -216,6 +216,24 @@ export async function getFeaturesQuery (options, queryInterval, queryLevel) {
   return query
 }
 
+export function isFeatureInQueryInterval (feature, options) {
+  // We assume this is not a time-varying layer
+  if (!feature.time) return true
+  const queryInterval = getFeaturesQueryInterval(options)
+  if (!moment.isDuration(queryInterval)) return true
+  const now = Time.getCurrentTime()
+  const time = moment.utc(feature.time)
+  // Depending on the duration format we might have negative or positive values
+  const gte = (queryInterval.asMilliseconds() > 0
+    ? now.clone().subtract(queryInterval)
+    : now.clone().add(queryInterval))
+  const lte = now
+  // In realtime mode take into account that we don't update time continuously but according to a frequency
+  // so that we might receive features "in the future" according to the current time
+  if (Time.isRealtime()) lte.add(Time.get().interval, 's')
+  return time.isSameOrAfter(gte) && time.isSameOrBefore(lte)
+}
+
 export async function getFeaturesFromQuery (options, query) {
   // Check API to be used in case the layer is coming from a remote "planet"
   const planetApi = (typeof options.getPlanetApi === 'function' ? options.getPlanetApi() : api)
@@ -225,6 +243,46 @@ export async function getFeaturesFromQuery (options, query) {
   return response
 }
 
+export function getMeasureForFeatureBaseQuery (layer, feature) {
+  // We might have a different ID to identify measures related to a timeseries (what is called a chronicle)
+  // than measures displayed on a map. For instance mobile measures might appear at different locations,
+  // but when selecting one we would like to display the timeseries related to all locations.
+  let featureId = layer.chronicleId || layer.featureId
+  // Support compound ID
+  featureId = (Array.isArray(featureId) ? featureId : [featureId])
+  const query = featureId.reduce((result, id) =>
+    Object.assign(result, { ['properties.' + id]: _.get(feature, 'properties.' + id) }),
+  {})
+  query.$groupBy = featureId
+  return query
+}
+
+export async function getMeasureForFeatureQuery (layer, feature, startTime, endTime, level) {
+  const query = await getFeaturesQuery(_.merge({
+    baseQuery: getMeasureForFeatureBaseQuery(layer, feature)
+  }, layer), {
+    $gte: startTime.toISOString(),
+    $lte: endTime.toISOString()
+  }, level)
+  return query
+}
+
+export async function getMeasureForFeatureFromQuery (layer, feature, query) {
+  const result = await getFeaturesFromQuery(layer, query)
+  return _.get(result, 'features[0]')
+}
+
+export async function getMeasureForFeature (layer, feature, startTime, endTime, level) {
+  let probedLocation
+  try {
+    const query = await getMeasureForFeatureQuery(layer, feature, startTime, endTime, level)
+    probedLocation = await getMeasureForFeatureFromQuery(layer, feature, query)
+  } catch (error) {
+    logger.error(error)
+  }
+  return probedLocation
+}
+
 export function checkFeatures (geoJson, options = {
   kinks: true,
   redundantCoordinates: true
@@ -361,4 +419,4 @@ export function getFeatureStyleType (feature) {
   if (['Polygon', 'MultiPolygon'].includes(geometryType)) return 'polygon'
   logger.warn(`[KDK] unsupported geometry of type of ${geometryType}`)
   return
-}
+}

package/map/client/utils/utils.layers.js

@@ -27,6 +27,10 @@ export function isLayerSelectable (layer) {
   return _.get(layer, 'isSelectable', true)
 }
 
+export function isLayerHighlightable (layer) {
+  return _.get(layer, 'isHighlightable', true)
+}
+
 export function isLayerProbable (layer) {
   return _.get(layer, 'isProbable', false)
 }
@@ -61,6 +65,10 @@ export function isTerrainLayer (layer) {
   return (cesiumOptions.type === 'Cesium') || (cesiumOptions.type === 'Ellipsoid')
 }
 
+export function isMeasureLayer (layer) {
+  return layer.variables && layer.service
+}
+
 export async function saveGeoJsonLayer (layer, geoJson, chunkSize = 5000) {
   // Check for invalid features first
   const check = checkFeatures(geoJson)

package/map/client/utils/utils.time-series.js

@@ -0,0 +1,121 @@
+import _ from 'lodash'
+import moment from 'moment'
+import { Time, Units, i18n } from '../../../core/client/index.js'
+import { isMeasureLayer } from './utils.layers.js'
+import { getMeasureForFeature } from './utils.features.js'
+import { getForecastForLocation, getForecastProbe, getForecastForFeature } from './utils.weacast.js'
+
+async function getDataForVariable(data, variable, forecastLevel, runTime) {
+  data = await data
+  const times = _.get(data, 'time', _.get(data, 'forecastTime', {}))
+  const runTimes = _.get(data, 'runTime', {})
+  const properties = _.get(data, 'properties', {})
+  // Check if we are targetting a specific variable at level (forecast model case)
+  const name = (forecastLevel ? `${variable.name}-${forecastLevel}` : variable.name)
+  let values = []
+  // Aggregated variable available for feature ?
+  if (properties[name] && Array.isArray(properties[name])) {
+    // Build data structure as expected by visualisation
+    values = properties[name].map((value, index) => {
+      value = Units.convert(value, variable.unit, variable.targetUnit)
+      return { time: moment.utc(times[name][index]).valueOf(), [name]: value }
+    })
+    // Keep only selected value if multiple are provided for the same time (eg different forecasts)
+    if (variable.runTimes && runTime && !_.isEmpty(_.get(runTimes, name))) {
+      values = values.filter((value, index) => (runTimes[name][index] === runTime.toISOString()))
+    } else values = _.uniqBy(values, 'time')
+  }
+  return values
+}
+
+async function fetchDataForSeries({
+  feature, location, layer, startTime, endTime,
+  level, forecastModel, forecastLevel, probeFunction, weacastApi
+}) {
+  // Use current time range if not provided
+  const { start, end } = Time.getRange()
+  if (!startTime) startTime = start
+  if (!endTime) endTime = end
+  // Depending on input use the right function to retrieve data
+  let data
+  // No feature clicked => custom probe function or dynamic weacast probe at position
+  if (!feature) {
+    if (probeFunction) data = await probeFunction({ longitude: location.lng, latitude: location.lat, startTime, endTime })
+    else data = await getForecastForLocation({ longitude: location.lng, latitude: location.lat, startTime, endTime, forecastModel, forecastLevel, weacastApi })
+  } else if (layer.probe) { // Static weacast probe
+    const probe = await getForecastProbe({ name: layer.probe, forecastModel, weacastApi })
+    if (probe) {
+      data = await getForecastForFeature({ probe, featureId: _.get(feature, probe.featureId), startTime, endTime, forecastModel, forecastLevel, weacastApi })
+    }
+  } else if (isMeasureLayer(layer)) { // Static measure probe
+    data = await getMeasureForFeature(layer, feature, startTime, endTime, level)
+  } else { // dynamic weacast probe at feature position
+    const location = centroid(feature)
+    const longitude = _.get(location, 'geometry.coordinates[0]')
+    const latitude = _.get(location, 'geometry.coordinates[1]')
+    data = await getForecastForLocation({ longitude, latitude, startTime, endTime, forecastModel, forecastLevel, weacastApi })
+  }
+  return data
+}
+
+// Build timeseries to be used in charts for target feature and associated layer definition or probe location
+export function getTimeSeries({
+  feature, location, layer, layers, startTime, endTime, runTime,
+  level, forecastModel, forecastLevel, probeFunction, weacastApi, fetchDelay
+}) {
+  // A feature comes from a single layer so target variables from it
+  let variables = _.get(layer, 'variables', [])
+  // However, a probe can target variables coming from multiple layers
+  if (layers && layers.length > 0) layers.forEach(layer => { variables = variables.concat(_.get(layer, 'variables', [])) })
+  variables = _.uniqBy(variables, 'name')
+  if (variables.length === 0) return []
+  const properties = _.get(feature, 'properties', {})
+  // Create promise to fetch data as it will be shared by all series,
+  // indeed a measure stores all aggregated variables
+  const data = fetchDataForSeries({
+    feature, location, layer, startTime, endTime,
+    level, forecastModel, forecastLevel, probeFunction, weacastApi
+  })
+  // Fetch data function to request data update,
+  // we use debounce as a measure stores all aggregated variables
+  // so that when all series are updated at once a single query will be send.
+  const fetch = _.debounce(() => fetchDataForSeries({
+      feature, location, layer, startTime, endTime,
+      level, forecastModel, forecastLevel, probeFunction, weacastApi
+    }), fetchDelay || 250, { leading: true, trailing: false })
+  
+  const series = variables.map(variable => {
+    // Base unit could be either directly the unit or the property of the measure storing the unit
+    const baseUnit = _.get(properties, 'unit', variable.unit)
+    // Known by the unit system ?
+    const unit = Units.getUnit(baseUnit)
+    const targetUnit = Units.getTargetUnit(baseUnit)
+    const serie = {
+      probedLocation: data,
+      data: getDataForVariable(data, variable, forecastLevel),
+      variable: {
+        name: variable.name,
+        label: `${i18n.tie(variable.label)} (${Units.getTargetUnitSymbol(baseUnit)})`,
+        unit,
+        targetUnit,
+        chartjs: Object.assign({
+          parsing: {
+            xAxisKey: 'time',
+            yAxisKey: (forecastLevel ? `${variable.name}-${forecastLevel}` : variable.name)
+          },
+          cubicInterpolationMode: 'monotone',
+          tension: 0.4
+        }, _.cloneDeep(variable.chartjs))
+      }
+    }
+    // FIXME: how to share promise between series ?
+    serie.fetch = () => {
+      serie.probedLocation = fetch()
+      serie.data = getDataForVariable(serie.probedLocation, variable, forecastLevel, runTime)
+      return serie.data
+    }
+    return serie
+  })
+
+  return series
+}