@kalisio/kdk 2.6.3 → 2.7.0

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

@@ -1,15 +1,17 @@
+import _ from 'lodash'
+import { ForecastProbeId, updateTimeSeries } from '../utils/utils.time-series.js'
+import { Layout } from '../../../core/client/layout.js'
+
 export const featureSelection = {
   watch: {
     'selection.items': {
       handler () {
-        this.updateHighlights()
-        this.handleWidget(this.getWidgetForSelection())
+        this.updateSelection()
       }
     },
     'probe.item': {
       handler () {
-        this.updateHighlights()
-        this.handleWidget(this.getWidgetForProbe())
+        this.updateSelection()
       }
     }
   },
@@ -19,11 +21,45 @@ export const featureSelection = {
       this.getSelectedItems().forEach(item => {
         this.highlight(item.feature || item.location, item.layer)
       })
-      if (this.hasProbedLocation()) this.highlight(this.getProbedLocation(), this.getProbedLayer())
+    },
+    async updateProbedLocationHighlight () {
+      if (this.hasProbedLocation()) {
+        this.highlight(this.getProbedLocation(), this.getProbedLayer() || { name: ForecastProbeId })
+      }
+    },
+    async updateSelection () {
+      this.updateHighlights()
+      await this.updateTimeSeries()
+      // As probed location depends on time series do this after
+      await this.updateProbedLocationHighlight()
+      if (this.hasProbedLocation() || this.hasSelectedItems()) {
+        this.handleWidget(this.getWidgetForProbe() || this.getWidgetForSelection())
+      }
+    },
+    async updateTimeSeries () {
+      if (!this.state) return
+      const timeSeries = await updateTimeSeries(this.state.timeSeries || [])
+      this.state.timeSeries = timeSeries
     },
     handleWidget (widget) {
       // If window already open on another widget keep it
       if (widget && (widget !== 'none') && !this.isWidgetWindowVisible(widget)) this.openWidget(widget)
     }
+  },
+  mounted () {
+    this.$engineEvents.on('forecast-model-changed', this.updateSelection)
+    this.$engineEvents.on('selected-level-changed', this.updateSelection)
+    // We use debounce here to avoid multiple refresh when editing settings for instance
+    this.requestTimeSeriesUpdate = _.debounce(() => this.updateTimeSeries(), 250)
+    this.$events.on('timeseries-group-by-changed', this.requestTimeSeriesUpdate)
+    this.$events.on('units-changed', this.requestTimeSeriesUpdate)
+    this.$events.on('time-current-time-changed', this.updateProbedLocationHighlight)
+  },
+  beforeUnmount () {
+    this.$engineEvents.off('forecast-model-changed', this.updateSelection)
+    this.$engineEvents.off('selected-level-changed', this.updateSelection)
+    this.$events.off('timeseries-group-by-changed', this.updateTimeSeries)
+    this.$events.off('units-changed', this.requestTimeSeriesUpdate)
+    this.$events.off('time-current-time-changed', this.requestTimeSeriesUpdate)
   }
 }

package/map/client/planets.js

@@ -24,7 +24,7 @@ export const Planets = {
 
     const client = await createClient(options)
     setupApi.bind(client)(options)
-    client.on('authenticated', (data) => {
+    client.on('login', (data) => {
       // Store API gateway token if any
       if (data.gatewayToken) client.get('storage').setItem(options.gatewayJwt, data.gatewayToken)
     })

package/map/client/readers/reader.kml.js

@@ -2,7 +2,7 @@ import logger from 'loglevel'
 import _ from 'lodash'
 import { kml } from '@tmcw/togeojson'
 import { i18n } from '../../../core/client/i18n.js'
-import { convertSimpleStyleToPointStyle, convertSimpleStyleToLineStyle, convertSimpleStyleToPolygonStyle } from '../utils/utils.style.js'
+import { convertSimpleStyleToPointStyle, convertSimpleStyleToLineStyle, convertSimpleStyleToPolygonStyle, kmlStyleSpecialProperties } from '../utils/utils.style.js'
 
 export const KMLReader = {
   read (files, options) {
@@ -39,13 +39,12 @@ export const KMLReader = {
 
 function getExtraPropertiesFromKMLByName (document) {
   const properties = {}
-  const propertiesToAdd = ['extrude', 'altitudeMode']
   const placemarks = document.getElementsByTagName('Placemark')
   _.forEach(placemarks, placemark => {
     const nameElements = placemark.getElementsByTagName('name')
     if (!nameElements.length) return
     const name = nameElements[0].textContent
-    _.forEach(propertiesToAdd, property => {
+    _.forEach(kmlStyleSpecialProperties, property => {
       const propertyElements = placemark.getElementsByTagName(property)
       if (!propertyElements.length) return
 

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

@@ -2,6 +2,7 @@ import _ from 'lodash'
 import sift from 'sift'
 import { api, i18n, Store } from '../../../core/client/index.js'
 import { buildUrl } from '../../../core/common/index.js'
+import { getCatalogProjectQuery, getViewsProjectQuery } from './utils.project.js'
 
 // Helper to set a JWT as query param in a target URL
 export function setUrlJwt (item, path, baseUrl, jwtField, jwt) {
@@ -104,17 +105,19 @@ export async function getLayers (options = {}) {
     context: '',
     planetApi: api
   })
-
+  // We expect the project object to expose the underlying API
+  const planetApi = (options.project && typeof options.project.getPlanetApi === 'function' ? options.project.getPlanetApi() : options.planetApi)
+    
   let layers = []
-  const catalogService = options.planetApi.getService('catalog', options.context)
+  const catalogService = planetApi.getService('catalog', options.context)
   if (catalogService) {
-    const response = await catalogService.find({ query: options.query })
+    const response = await catalogService.find({ query: (options.project ? Object.assign(getCatalogProjectQuery(options.project), options.query) : options.query) })
     _.forEach(response.data, processTranslations)
     // Set which API to use to retrieve layer data
-    layers = layers.concat(response.data.map(layer => Object.assign(layer, { getPlanetApi: () => options.planetApi })))
+    layers = layers.concat(response.data.map(layer => Object.assign(layer, { getPlanetApi: () => planetApi })))
   }
   // Do we need to inject a token ?
-  await setEngineJwt(layers, options.planetApi)
+  await setEngineJwt(layers, planetApi)
   return layers
 }
 
@@ -124,9 +127,11 @@ export async function getCategories (options = {}) {
     context: '',
     planetApi: api
   })
+  // We expect the project object to expose the underlying API
+  const planetApi = (options.project && typeof options.project.getPlanetApi === 'function' ? options.project.getPlanetApi() : options.planetApi)
 
   let categories = []
-  const catalogService = options.planetApi.getService('catalog', options.context)
+  const catalogService = planetApi.getService('catalog', options.context)
   if (catalogService) {
     const response = await catalogService.find({ query: Object.assign({ type: 'Category' }, options.query) })
     _.forEach(response.data, processTranslations)
@@ -141,9 +146,11 @@ export async function getSublegends (options = {}) {
     context: '',
     planetApi: api
   })
+  // We expect the project object to expose the underlying API
+  const planetApi = (options.project && typeof options.project.getPlanetApi === 'function' ? options.project.getPlanetApi() : options.planetApi)
 
   let sublegends = []
-  const catalogService = options.planetApi.getService('catalog', options.context)
+  const catalogService = planetApi.getService('catalog', options.context)
   if (catalogService) {
     const response = await catalogService.find({ query: Object.assign({ type: 'Sublegend' }, options.query) })
     _.forEach(response.data, processTranslations)
@@ -173,13 +180,32 @@ export async function getViews (options = {}) {
     context: '',
     planetApi: api
   })
-
+  // We expect the project object to expose the underlying API
+  const planetApi = (options.project && typeof options.project.getPlanetApi === 'function' ? options.project.getPlanetApi() : options.planetApi)
+  
   let views = []
-  const catalogService = options.planetApi.getService('catalog', options.context)
+  const catalogService = planetApi.getService('catalog', options.context)
   if (catalogService) {
-    const response = await catalogService.find({ query: Object.assign({ type: 'Context' }, options.query) })
+    const response = await catalogService.find({
+      query: Object.assign({ type: 'Context' }, (options.project ? Object.assign(getViewsProjectQuery(options.project), options.query) : options.query))
+    })
     _.forEach(response.data, processTranslations)
     views = views.concat(response.data)
   }
   return views
 }
+
+// Order is given as an array of catalog item IDs or names
+export function orderCatalogItemsBy(items, itemsOrder) {
+  if (!_.isEmpty(itemsOrder)) {
+    for (let i = itemsOrder.length; i >= 0; i--) {
+      const itemIdOrName = itemsOrder[i]
+      // Move item to beginning of array          
+      const itemIndex = items.findIndex(item => (item?._id === itemIdOrName) || (item?.name === itemIdOrName))
+      if (itemIndex >= 0) {
+        const removedItems = items.splice(itemIndex, 1)
+        if (removedItems.length > 0) items.unshift(removedItems[0])
+      }
+    }
+  }
+}

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

@@ -1,5 +1,6 @@
 import _ from 'lodash'
 import logger from 'loglevel'
+import sift from 'sift'
 import { Notify, Loading, uid } from 'quasar'
 import explode from '@turf/explode'
 import SphericalMercator from '@mapbox/sphericalmercator'
@@ -366,8 +367,8 @@ async function generateStyleFromFilters (layer, defaultStyle) {
   const templates = generateStyleTemplates(defaultStyle, filters)
   const result = Object.assign(
     {},
-    _.mapKeys(templates, (value, key) => `leaflet.${key}`),
-    _.mapKeys(templates, (value, key) => `cesium.${key}`)
+    _.has(layer, 'leaflet') ? _.mapKeys(templates, (value, key) => `leaflet.${key}`) : {},
+    _.has(layer, 'cesium') ? _.mapKeys(templates, (value, key) => `cesium.${key}`) : {}
   )
   return result
 }
@@ -384,13 +385,18 @@ export async function editLayerStyle (layer, style, ignoreFeatureStyle = false)
       await api.getService('catalog').patch(layer._id, result)
     } else {
       const legend = await getLegendForLayer(Object.assign({}, layer, { 'cesium.style': style, 'leaflet.style': style }))
-      const patch = Object.assign({}, { 'cesium.style': style, 'leaflet.style': style }, legend)
+      const patch = Object.assign(
+        {},
+        _.has(layer, 'cesium') ? { 'cesium.style': style } : {},
+        _.has(layer, 'leaflet') ? { 'leaflet.style': style } : {},
+        legend
+      )
       if (ignoreFeatureStyle) patch.ignoreFeatureStyle = true
       await api.getService('catalog').patch(layer._id, patch)
     }
   } else {
-    _.set(layer, 'cesium.style', style)
-    _.set(layer, 'leaflet.style', style)
+    if (_.has(layer, 'cesium')) _.set(layer, 'cesium.style', style)
+    if (_.has(layer, 'leaflet')) _.set(layer, 'leaflet.style', style)
     Object.assign(layer, await getLegendForLayer(layer))
     if (ignoreFeatureStyle) layer.ignoreFeatureStyle = true
   }
@@ -399,7 +405,7 @@ export async function editLayerStyle (layer, style, ignoreFeatureStyle = false)
 
 export async function updateLayerWithFiltersStyle (layer) {
   if (!layer._id) return
-  const defaultStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', {}))
+  const defaultStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', _.get(layer, 'cesium.style', {})))
   const style = await generateStyleFromFilters(layer, defaultStyle)
   if (!style) return
 
@@ -408,7 +414,7 @@ export async function updateLayerWithFiltersStyle (layer) {
 
 export async function editFilterStyle (layer, filter, engineStyle, style, ignoreFeatureStyle = false) {
   if (!layer._id) return
-  const layerDefaultStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', {}))
+  const layerDefaultStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', _.get(layer, 'cesium.style', {})))
 
   const filters = await parseFiltersFromLayer(layer)
   const targetFilterCondition = filterQueryToConditions(filter.active)
@@ -499,7 +505,7 @@ export async function getLegendForLayer (layer) {
     if (!hasFilterWithStyle) return { $unset: { legend: '' } }
     return legend
   } else {
-    const layerStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', {}))
+    const layerStyle = getDefaultStyleFromTemplates(_.get(layer, 'leaflet.style', _.get(layer, 'cesium.style', {})))
     const legend = generateLegendFromStyle(layer, layerStyle, _.get(layer, 'geometryTypes', []))
     legend.label = _.get(layer, 'label', _.get(layer, 'name'))
     return { legend }
@@ -680,3 +686,28 @@ export async function removeLayer (layer) {
   Loading.hide()
   return true
 }
+
+export function getFilterFunctionFromLayerFilters (layer) {
+  // To be flexible enough filters can provide a query for their active and inactive state
+  // Similarly, filters can be combined with a different operator for each state
+  const filterOperators = _.get(layer, 'filterOperators', { active: '$or', inactive: '$and' })
+  const activeFilters = layer.filters
+    .filter(filter => filter.isActive)
+    .map(filter => filter.active)
+    .filter(filter => !_.isEmpty(filter))
+  const activeCondition = activeFilters.length > 1
+    ? { [filterOperators.active]: activeFilters }
+    : activeFilters.length === 1 ? activeFilters[0] : {}
+  const inactiveFilters = layer.filters
+    .filter(filter => !filter.isActive)
+    .map(filter => filter.inactive)
+    .filter(filter => !_.isEmpty(filter))
+  const inactiveCondition = inactiveFilters.length > 1
+    ? { [filterOperators.inactive]: inactiveFilters }
+    : inactiveFilters.length === 1 ? inactiveFilters[0] : {}
+
+  const finalCondition = activeFilters.length && inactiveFilters.length
+    ? { '$and': [ activeCondition, inactiveCondition ] } : activeFilters.length ? activeCondition : inactiveCondition
+
+  return sift(finalCondition)
+}

package/map/client/utils/utils.project.js

@@ -6,3 +6,7 @@ export function getCatalogProjectQuery (project) {
   const nameQuery = { name: { $in: _.map(_.filter(project.layers, 'name'), 'name') } }
   return { $or: [idQuery, nameQuery] }
 }
+
+export function getViewsProjectQuery (project) {
+  return { _id: { $in: _.map(project.views, '_id') } }
+}

package/map/client/utils/utils.style.js

@@ -182,6 +182,8 @@ export const DefaultStyle = {
   }
 }
 
+export const kmlStyleSpecialProperties = ['extrude', 'altitudeMode']
+
 // Map properties of a given style according to given mapping, performing number conversion if required
 export function convertStyle (style, mapping, asNumber = []) {
   let convertedStyle = {}
@@ -328,12 +330,30 @@ export function generateStyleTemplates (defaultStyle, styles, dotify = true) {
 
     // Process all properties, for each property
     properties.forEach((property, index) => {
-      if (!_.has(style.values, property)) return
-      // Conversion from palette to RGB color is required
-      const value = (property.includes('color')
-        ? kdkCoreUtils.getHtmlColor(_.get(style.values, property))
-        : _.get(style.values, property))
+      // Don't need to create template if the section (point, line, polygon) is not defined in the style
+      if (!_.get(style.values, property.split('.')[0])) return
+
+      let value = null
+      // If no value is defined for the given property, that means this property is in a optional sub-object (e.g. stroke, icon)
+      // So we need to hide the element corresponding to this sub-object by setting all of its properties to null or default values
+      // We must create the condition anyway to prevent default style from being applied on this case
+      if (!_.get(style.values, property)) {
+        if (_.isNumber(_.get(DefaultStyle, property))) {
+          value = 0
+        } else if (property.includes('shape')) {
+          value = _.get(DefaultStyle, property)
+        } else if (property.includes('color')) {
+          value = kdkCoreUtils.getHtmlColor(_.get(defaultStyle, property))
+        }
+      } else {
+        // Conversion from palette to RGB color is required
+        value = (property.includes('color')
+          ? kdkCoreUtils.getHtmlColor(_.get(style.values, property))
+          : _.get(style.values, property))
+      }
+
       // Generate style value for given property value
+      if (_.isNil(value)) return
       templates[index] += `if (${predicate}) { %>${value}<% } else `
     })
   })
@@ -346,18 +366,28 @@ export function generateStyleTemplates (defaultStyle, styles, dotify = true) {
     const value = (property.includes('color')
       ? kdkCoreUtils.getHtmlColor(_.get(defaultStyle, property))
       : _.get(defaultStyle, property))
+    if (_.isNil(value)) return
     // Avoid converting numbers to string on default values
     if (hasStyles) templates[index] += `{ %>${value}<% }`
     else templates[index] = value
   })
   // Set all templates
+  options.template = []
   properties.forEach((property, index) => {
-    if (!_.has(defaultStyle, property)) return
+    if (!_.has(defaultStyle, property) || _.isEmpty(templates[index])) return
     // We voluntary use dot notation here by default as this object should be used to update style values using a patch operation
     if (dotify) options[`style.${property}`] = (hasStyles ? `<% ${templates[index]} %>` : templates[index])
     else _.set(options, `style.${property}`, (hasStyles ? `<% ${templates[index]} %>` : templates[index]))
+
+    // Check if templating is needed
+    if (options[`style.${property}`].startsWith('<% if')) {
+      options.template.push(`style.${property}`)
+      // Remove duplicates "<% { %>" that are added to default style (else statement) when filters are reapplied
+      options[`style.${property}`] = options[`style.${property}`].replace(/(<% { %>)+/g, '<% { %>').replace(/(<% } %>)+/g, '<% } %>')
+    } else {
+      options[`style.${property}`] = options[`style.${property}`].replace(/(<% { %>)+/g, '').replace(/(<% } %>)+/g, '')
+    }
   })
-  options.template = (hasStyles ? properties : []).map(property => `style.${property}`)
   return options
 }
 

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

@@ -1,10 +1,68 @@
 import _ from 'lodash'
 import moment from 'moment'
+import { unref } from 'vue'
+import sift from 'sift'
+import chroma from 'chroma-js'
 import centroid from '@turf/centroid'
-import { Time, Units, i18n } from '../../../core/client/index.js'
-import { isMeasureLayer } from './utils.layers.js'
+import { Time, Store, Units, i18n } from '../../../core/client/index.js'
+import { getFeatureId, getFeatureLabel } from './utils.js'
 import { getMeasureForFeature } from './utils.features.js'
+import { formatUserCoordinates } from './utils.location.js'
+import { isMeasureLayer } from './utils.layers.js'
 import { getForecastForLocation, getForecastProbe, getForecastForFeature } from './utils.weacast.js'
+import { useCurrentActivity } from '../composables/activity.js'
+
+// When organizing time series by feature the dataset color is the variable color as given in the layer
+// eg 'temperature' data in red and 'humidity' data in blue
+// When organizing time series by variable the dataset color should be different for each feature
+// eg 'Toulouse' data in red, 'Paris' data in blue, etc.
+// We pregenerate a fixed set of colors for this to ensure they are always assigned in the same order
+const nbColors = 10
+const Colors = chroma.scale('Set1').colors(nbColors)
+
+// Add a small delta (minutes) to data time range so that some ticks are always visible
+// and points on on the left/right side are not cut
+const TimeRangeDelta = 2
+
+// ID of weather forecast probe timeseries
+export const ForecastProbeId = 'forecast-probe'
+
+export function getChartOptions (title) {
+  return {
+    title: {
+      display: true,
+      text: title,
+      align: 'start'
+    },
+    scales: {
+      x: {
+        min: (startTime, endTime) => startTime.clone().subtract(TimeRangeDelta, 'minutes').valueOf(),
+        max: (startTime, endTime) => endTime.clone().add(TimeRangeDelta, 'minutes').valueOf()
+      }
+    },
+    plugins: {
+      legend: {
+        labels: {
+          usePointStyle: true,
+          generateLabels: (chart) => {
+            return chart.data.datasets.map((dataset, index) => {
+              // If we have a single value but like to draw a line it does not make sense so that we "force" point display
+              const hasSingleValue = (dataset.data.length === 1)
+              return {
+                text: dataset.label,
+                datasetIndex: index,
+                fillStyle: dataset.backgroundColor,
+                strokeStyle: dataset.borderColor,
+                pointStyle: (hasSingleValue ? 'rectRot' : 'line'),
+                hidden: !chart.isDatasetVisible(index)
+              }
+            })
+          }
+        }
+      }
+    }
+  }
+}
 
 // Extract target variable data for timeseries from timeseries request result
 async function getDataForVariable(data, variable, forecastLevel, runTime) {
@@ -81,7 +139,7 @@ async function fetchDataForMeasureSeries({
 // Build timeseries to be used in charts for target feature and associated layer definition or probe location
 export function getForecastTimeSeries({
   feature, location, layer, startTime, endTime, runTime,
-  forecastLayers, forecastModel, forecastLevel, weacastApi, fetchDelay
+  forecastLayers, forecastModel, forecastLevel, forecastLevelUnit, weacastApi, fetchDelay
 }) {
   let forecastVariables = []
   if (forecastLayers && forecastLayers.length > 0) forecastLayers.forEach(layer => { forecastVariables = forecastVariables.concat(_.get(layer, 'variables', [])) })
@@ -106,12 +164,16 @@ export function getForecastTimeSeries({
     // Known by the unit system ?
     const unit = Units.getUnit(baseUnit)
     const targetUnit = Units.getTargetUnit(baseUnit)
+    // We allow variable name to be customized based on level information
+    const label = _.template(i18n.tie(variable.label))({
+      level: forecastLevel, levelUnit: forecastLevelUnit
+    })
     const serie = {
       probedLocationData: forecastData,
       data: getDataForVariable(forecastData, variable, forecastLevel, runTime),
       variable: {
         name: variable.name,
-        label: `${i18n.tie(variable.label)} (${Units.getTargetUnitSymbol(baseUnit)})`,
+        label: `${label} (${Units.getTargetUnitSymbol(baseUnit)})`,
         unit,
         targetUnit,
         chartjs: Object.assign({
@@ -138,7 +200,7 @@ export function getForecastTimeSeries({
 // Build timeseries to be used in charts for target feature and associated layer definition or probe location
 export function getMeasureTimeSeries({
   feature, location, layer, layers, startTime, endTime, runTime,
-  level, probeFunction, fetchDelay
+  level, levelUnit, probeFunction, fetchDelay
 }) {
   // A feature comes from a single layer so target variables from it by default
   let variables = _.get(layer, 'variables', [])
@@ -165,12 +227,16 @@ export function getMeasureTimeSeries({
     // Known by the unit system ?
     const unit = Units.getUnit(baseUnit)
     const targetUnit = Units.getTargetUnit(baseUnit)
+    // We allow variable name to be customized based on level information
+    const label = _.template(i18n.tie(variable.label))({
+      level, levelUnit
+    })
     const serie = {
       probedLocationData: data,
       data: getDataForVariable(data, variable),
       variable: {
         name: variable.name,
-        label: `${i18n.tie(variable.label)} (${Units.getTargetUnitSymbol(baseUnit)})`,
+        label: `${label} (${Units.getTargetUnitSymbol(baseUnit)})`,
         unit,
         targetUnit,
         chartjs: Object.assign({
@@ -193,3 +259,146 @@ export function getMeasureTimeSeries({
 
   return series
 }
+
+// Helper function to update time series whenever something related changes, eg time span
+export async function updateTimeSeries (previousTimeSeries) {
+  const { CurrentActivity, hasSelectedItems, getSelectedItems, hasProbedLocation, getProbedLocation } = useCurrentActivity()
+  const activity = unref(CurrentActivity)
+  if (!activity) return
+  // Initialize the time range
+  const span = Store.get('timeseries.span')
+  const start = moment(Time.getCurrentTime()).subtract(span, 'm')
+  const end = moment(Time.getCurrentTime()).add(span, 'm')
+  Time.patchRange({ start, end })
+  // Weather probe targets variables coming from multiple layers
+  const forecastLayers = _.values(activity.layers).filter(sift({ tags: ['weather', 'forecast'] }))
+  const featureLevel = activity.selectableLevelsLayer ? ` - ${activity.selectedLevel} ${activity.selectableLevels.unit}` : ''
+  const forecastLevel = activity.forecastLevel ? ` - ${activity.forecastLevel} ${activity.selectableLevels.unit}` : ''
+
+  let timeSeries = []
+  if (hasProbedLocation()) {
+    const coordinates = formatUserCoordinates(getProbedLocation().lat, getProbedLocation().lng, Store.get('locationFormat', 'FFf'))
+    // When custom probe function we provide visible layers as input
+    if (activity.probeLocation) {
+      let variableLayers = _.difference(_.values(activity.layers).filter(sift({ variables: { $exists: true }, isVisible: true })), forecastLayers)
+      variableLayers = variableLayers.filter(layer => activity.canProbeLocation({ location: getProbedLocation(), layer, level: activity.selectedLevel }))
+      variableLayers.forEach(layer => {
+        const series = getMeasureTimeSeries({
+          location: getProbedLocation(),
+          layer,
+          level: activity.selectedLevel,
+          levelUnit: (activity.selectableLevels ? activity.selectableLevels.unit : ''),
+          probeFunction: activity.probeLocation
+        })
+        if (!_.isEmpty(series)) {
+          timeSeries.push({
+            id: `${layer.name}-measure-probe`,
+            label: `${layer.label} (${coordinates})` + featureLevel,
+            series
+          })
+        }
+      })
+    }
+    // Or weather forecast probe
+    if (_.isEmpty(timeSeries) && activity.forecastModel) {
+      const series = getForecastTimeSeries({
+        location: getProbedLocation(),
+        forecastLayers,
+        forecastModel: activity.forecastModel,
+        forecastLevel: activity.forecastLevel,
+        forecastLevelUnit: (activity.selectableLevels ? activity.selectableLevels.unit : ''),
+        weacastApi: activity.getWeacastApi()
+      })
+      if (!_.isEmpty(series)) {
+        timeSeries.push({
+          id: ForecastProbeId,
+          label: `${activity.forecastModel.label} (${coordinates})` + forecastLevel,
+          series
+        })
+      }
+    }
+  }
+  if (hasSelectedItems()) {
+    getSelectedItems().forEach(item => {
+      const featureId = getFeatureId(item.feature, item.layer)
+      const featureLabel = getFeatureLabel(item.feature, item.layer)
+      // Measure
+      if (isMeasureLayer(item.layer)) {
+        const series = getMeasureTimeSeries({
+          feature: item.feature,
+          layer: item.layer,
+          level: activity.selectedLevel
+        })
+        if (!_.isEmpty(series)) {
+          timeSeries.push({
+            id: `${item.layer.name}-${featureId}-measure`,
+            label: `${item.layer.label} - ${featureLabel || featureId}` + featureLevel,
+            series
+          })
+        }
+      }
+      // Or weather forecast probe
+      if (_.isEmpty(timeSeries) && activity.forecastModel) {
+        const series = getForecastTimeSeries({
+          feature: item.feature,
+          layer: item.layer,
+          forecastLayers,
+          forecastModel: activity.forecastModel,
+          forecastLevel: activity.forecastLevel,
+          weacastApi: activity.getWeacastApi()
+        })
+        if (!_.isEmpty(series)) {
+          timeSeries.push({
+            id: `${item.layer.name}-${featureId}-probe`,
+            label: `${activity.forecastModel.label} (${item.layer.label} - ${featureLabel || featureId})` + forecastLevel,
+            series
+          })
+        }
+      }
+    })
+  }
+
+  const groupBy = Store.get('timeseries.groupBy')
+  // Default is to group by feature
+  if (groupBy === 'variable') {
+    const timeSeriesByVariable = {}
+    timeSeries.forEach((timeSerie, index) => {
+      timeSerie.series.forEach(serie => {
+        // We do not mix variables with different units
+        const variable = `${_.get(serie, 'variable.name')}-${_.get(serie, 'variable.unit.name')}`
+        const variableLabel = _.get(serie, 'variable.label')
+        // When organizing time series by feature chart name is the feature name while the dataset label is the variable name,
+        // eg a 'Toulouse' station collecting 'temperature' and 'humidity' data
+        // When organizing time series by variable the chart name is the variable name while the dataset label is the feature name
+        // eg the 'temperature' data for different stations 'Toulouse', 'Paris', etc.
+        _.set(serie, 'variable.label', timeSerie.label)
+        _.set(serie, 'variable.chartjs.backgroundColor', Colors[index % nbColors])
+        _.set(serie, 'variable.chartjs.borderColor', Colors[index % nbColors])
+        if (timeSeriesByVariable[variable]) {
+          timeSeriesByVariable[variable].series.push(serie)
+        } else {
+          timeSeriesByVariable[variable] = {
+            id: variable,
+            label: variableLabel,
+            series: [serie]
+          }
+        }
+      })
+    })
+    timeSeries = _.values(timeSeriesByVariable)
+  }
+  // Restore previous state if any
+  if (previousTimeSeries) {
+    timeSeries.forEach(timeSerie => {
+      const previousTimeSerie = _.find(previousTimeSeries, { id: timeSerie.id })
+      // Keep track of some states only
+      if (previousTimeSerie) Object.assign(timeSerie, _.pick(previousTimeSerie, ['visible', 'pinned', 'logarithmic']))
+    })
+  }
+  // Make first serie visible if required, always measure first if any
+  if (!_.isEmpty(timeSeries) && !_.find(timeSeries, { visible: true })) {
+    const timeSerie = _.find(timeSeries, timeSerie => timeSerie.label.includes('measure')) || timeSeries[0]
+    timeSerie.visible = true
+  }
+  return timeSeries
+}

package/map/common/schemas/catalog.update.json

@@ -16,7 +16,7 @@
     },
     "description": {
       "type": ["string", "null"],
-      "maxLength": 256,
+      "maxLength": 4096,
       "field": {
         "component": "form/KTextField",
         "label": "schemas.CATALOG_DESCRIPTION_FIELD_LABEL"

package/map/common/weacast-grid-source.js

@@ -58,7 +58,7 @@ export class WeacastGridSource extends GridSource {
   constructor (options) {
     super(options)
 
-    this.api = options.weacastApi
+    this.api = options.planetApi
     this.usable = false
   }