@kalisio/kdk 2.1.9 → 2.2.0

package/map/client/utils/utils.js

@@ -1,78 +1,6 @@
 import _ from 'lodash'
-import rhumbBearing from '@turf/rhumb-bearing'
-import rhumbDistance from '@turf/rhumb-distance'
-import rotate from '@turf/transform-rotate'
-import scale from '@turf/transform-scale'
-import translate from '@turf/transform-translate'
 import chroma from 'chroma-js'
-import config from 'config'
 import formatcoords from 'formatcoords'
-import { buildUrl } from '../../../core/common/index.js'
-import { api, Store } from '../../../core/client/index.js'
-
-// Build a color map from a JS object specification
-export function buildColorMap (options) {
-  let colorMap
-  const classes = _.get(options, 'classes')
-  const domain = _.get(options, 'domain')
-  const scale = _.get(options, 'scale')
-  const invert = _.get(options, 'invertScale')
-  if (scale) {
-    if (classes) {
-      colorMap = chroma.scale(scale).classes(invert ? classes.slice().reverse() : classes)
-    } else if (domain) {
-      colorMap = chroma.scale(scale).domain(invert ? domain.slice().reverse() : domain)
-    }
-  }
-  return colorMap
-}
-
-export function transformFeatures (features, transform) {
-  features.forEach(feature => {
-    const scaling = _.get(transform, 'scale')
-    const rotation = _.get(transform, 'rotate')
-    const translation = _.get(transform, 'translate')
-    if (scaling) {
-      scale(feature, scaling.factor,
-        Object.assign(_.omit(scaling, ['factor']), { mutate: true }))
-    }
-    if (rotation) {
-      rotate(feature, rotation.angle,
-        Object.assign(_.omit(rotation, ['angle']), { mutate: true }))
-    }
-    if (translation) {
-      // Could be expressed as direction/distance or target point
-      // Take care that turfjs uses a rhumb line
-      if (translation.point) {
-        translation.distance = rhumbDistance(translation.pivot || [0, 0], translation.point)
-        translation.direction = rhumbBearing(translation.pivot || [0, 0], translation.point)
-        delete translation.pivot
-        delete translation.point
-      }
-      translate(feature, translation.distance, translation.direction,
-        Object.assign(_.omit(translation, ['direction', 'distance']), { mutate: true }))
-    }
-  })
-}
-
-export async function fetchGeoJson (dataSource, options = {}) {
-  const response = await fetch(dataSource)
-  if (response.status !== 200) {
-    throw new Error(`Impossible to fetch ${dataSource}: ` + response.status)
-  }
-  const data = await response.json()
-  const features = (data.type === 'FeatureCollection' ? data.features : [data])
-  if (typeof options.processor === 'function') {
-    features.forEach(feature => options.processor(feature))
-  } else if (typeof options.processor === 'string') {
-    const compiler = _.template(options.processor)
-    features.forEach(feature => compiler({ feature, properties: feature.properties }))
-  }
-  if (options.transform) {
-    transformFeatures(features, options.transform)
-  }
-  return data
-}
 
 // Find the nearest time of a given one in a given moment time list
 export function getNearestTime (time, times) {
@@ -106,72 +34,6 @@ export function getTimeInterval (times, mode = 'minimum') {
   return interval
 }
 
-// Format (reverse) geocoding output
-export function formatGeocodingResult (element) {
-  let label = element.formattedAddress || ''
-  if (!label) {
-    if (element.streetNumber) label += (element.streetNumber + ', ')
-    if (element.streetName) label += (element.streetName + ' ')
-    if (element.city) label += (element.city + ' ')
-    if (element.zipcode) label += (' (' + element.zipcode + ')')
-  }
-  return label
-}
-
-// Helper to set a JWT as query param in a target URL
-export function setUrlJwt (item, path, baseUrl, jwtField, jwt) {
-  const url = _.get(item, path)
-  if (!url) return
-  // Check it conforms to required base URL
-  if (!url.startsWith(baseUrl)) return
-  // FIXME: specific case of Cesium OpenStreetMap provider
-  // Because Cesium generates the final url as base url + tile scheme + extension
-  // updating the base url property breaks it, for now we modify the extension
-  if ((path === 'cesium.url') && _.get(item, 'cesium.type') === 'OpenStreetMap') {
-    const ext = _.get(item, 'cesium.fileExtension', 'png')
-    _.set(item, 'cesium.fileExtension', ext + `?${jwtField}=${jwt}`)
-  } else {
-    _.set(item, path, buildUrl(url, { [jwtField]: jwt }))
-  }
-}
-
-// Helper to set required JWT as query param in a given set of layers for underlying engine
-export async function setEngineJwt (layers) {
-  // 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 = (config.gatewayJwt ? await api.get('storage').getItem(config.gatewayJwt) : null)
-  let jwtField = config.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', config.gateway)
-  if (jwt) {
-    layers.forEach(layer => {
-      setUrlJwt(layer, 'iconUrl', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'leaflet.source', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'opendap.url', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'geotiff.url', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'wfs.url', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'wcs.url', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'cesium.url', gatewayUrl, jwtField, jwt)
-      setUrlJwt(layer, 'cesium.source', gatewayUrl, jwtField, jwt)
-    })
-  }
-  // 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 = (config.apiJwt ? await api.get('storage').getItem(config.apiJwt) : null)
-  jwtField = 'jwt'
-  const apiUrl = api.getBaseUrl()
-  if (jwt) {
-    layers.forEach(layer => {
-      setUrlJwt(layer, 'geotiff.url', apiUrl, jwtField, jwt)
-    })
-    // We also allow absolute URLs for app like /api/storage/xxx
-    layers.forEach(layer => {
-      setUrlJwt(layer, 'geotiff.url', '/', jwtField, jwt)
-    })
-  }
-  return layers
-}
-
 export function getFeatureId (feature, layer) {
   let featureId = _.get(layer, 'featureId')
   // We need at least an internal ID to uniquely identify features for updates
@@ -213,16 +75,3 @@ export function coordinatesToGeoJSON (lat, lon, format, options) {
     }
   }
 }
-
-export function parseCoordinates (str) {
-  const coords = _.split(_.trim(str), ',')
-  if (coords.length !== 2) return
-  const latitude = Number(coords[0])
-  if (_.isNaN(latitude)) return
-  const longitude = Number(coords[1])
-  if (_.isNaN(longitude)) return
-  return {
-    latitude,
-    longitude
-  }
-}

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

@@ -0,0 +1,174 @@
+import _ from 'lodash'
+import logger from 'loglevel'
+import { Notify, Loading } from 'quasar'
+import explode from '@turf/explode'
+import { i18n, api, utils as kCoreUtils } from '../../../core/client/index.js'
+import { checkFeatures, createFeatures, removeFeatures } from './utils.features.js'
+
+export const InternalLayerProperties = ['actions', 'label', 'isVisible', 'isDisabled']
+
+export function isInMemoryLayer (layer) {
+  return layer._id === undefined
+}
+
+export function isUserLayer (layer) {
+  return (_.get(layer, 'scope') === 'user')
+}
+
+export function isFeatureLayer (layer) {
+  return (_.get(layer, 'service') === 'features')
+}
+
+export function hasFeatureSchema (layer) {
+  return _.has(layer, 'schema')
+}
+
+export function isLayerSelectable (layer) {
+  return _.get(layer, 'isSelectable', true)
+}
+
+export function isLayerProbable (layer) {
+  return _.get(layer, 'isProbable', false)
+}
+
+export function isLayerStorable (layer) {
+  // Only possible when not saved by default
+  if (layer._id) return false
+  return _.get(layer, 'isStorable', isUserLayer(layer))
+}
+
+export function isLayerEditable (layer) {
+  // Only possible when saved by default
+  if (!layer._id) return false
+  return _.get(layer, 'isEditable', isUserLayer(layer))
+}
+
+export function isLayerRemovable (layer) {
+  return _.get(layer, 'isRemovable', isUserLayer(layer))
+}
+
+export function isLayerStyleEditable (layer) {
+  return _.get(layer, 'isStyleEditable', isUserLayer(layer))
+}
+
+export function isLayerDataEditable (layer) {
+  return _.get(layer, 'isDataEditable', isUserLayer(layer) && isFeatureLayer(layer))
+}
+
+export function isTerrainLayer (layer) {
+  if (layer.type === 'TerrainLayer') return true
+  const cesiumOptions = layer.cesium || layer
+  return (cesiumOptions.type === 'Cesium') || (cesiumOptions.type === 'Ellipsoid')
+}
+
+export async function saveGeoJsonLayer (layer, geoJson, chunkSize = 5000) {
+  // Check for invalid features first
+  const check = checkFeatures(geoJson)
+  if (check.kinks.length > 0) {
+    const result = await kCoreUtils.dialog({
+      title: i18n.t('utils.layers.INVALID_FEATURES_DIALOG_TITLE', { total: check.kinks.length }),
+      message: i18n.t('utils.layers.INVALID_FEATURES_DIALOG_MESSAGE', { total: check.kinks.length }),
+      options: {
+        type: 'toggle',
+        model: [],
+        items: [
+          { label: i18n.t('utils.layers.DOWNLOAD_INVALID_FEATURES_LABEL'), value: 'download' }
+        ]
+      },
+      html: true,
+      ok: {
+        label: i18n.t('OK'),
+        flat: true
+      },
+      cancel: {
+        label: i18n.t('CANCEL'),
+        flat: true
+      }
+    })
+    if (!result.ok) return
+    // Export invalid features if required
+    if (_.get(result, 'data', []).includes('download')) {
+      kCoreUtils.downloadAsBlob(JSON.stringify({ type: 'FeatureCollection', features: check.kinks }),
+        i18n.t('utils.layers.INVALID_FEATURES_FILE'), 'application/json;charset=utf-8;')
+    }
+  }
+  // Change data source from in-memory to features service
+  _.set(layer, 'service', 'features')
+  if (_.has(layer, 'leaflet')) _.set(layer, 'leaflet.source', '/api/features')
+  if (_.has(layer, 'cesium')) _.set(layer, 'cesium.source', '/api/features')
+  const features = (geoJson.type === 'FeatureCollection' ? geoJson.features : [geoJson])
+  // If too much data use tiling
+  // The threshold is based on the number of points and not features.
+  // Indeed otherwise the complexity will be different depending on the geometry type
+  // (eg a bucket of 1000 polygons can actually contains a lot of points).
+  let nbPoints = 0
+  features.forEach(feature => {
+    nbPoints += explode(feature).features.length
+  })
+  if (nbPoints > 5000) {
+    _.set(layer, 'leaflet.tiled', true)
+    _.set(layer, 'leaflet.minZoom', 15)
+  }
+  Loading.show({ message: i18n.t('utils.layers.SAVING_LABEL', { processed: 0, total: features.length }), html: true })
+  let createdLayer
+  try {
+    createdLayer = await api.getService('catalog')
+      .create(_.omit(layer, InternalLayerProperties))
+    let nbFeatures = 0
+    // We use the generated DB ID as layer ID on features
+    await createFeatures(geoJson, createdLayer._id, chunkSize, (i, chunk) => {
+      // Update saving message according to new chunk data
+      nbFeatures += chunk.length
+      Loading.show({
+        message: i18n.t('utils.layers.SAVING_LABEL', { processed: nbFeatures, total: features.length }),
+        html: true
+      })
+    })
+    // Because we save all features in a single service use filtering to separate layers
+    createdLayer = await api.getService('catalog').patch(createdLayer._id, { baseQuery: { layer: createdLayer._id } })
+    if (_.get(layer, 'leaflet.tiled')) {
+      Notify.create({ type: 'positive', message: i18n.t('utils.layers.SAVE_DIALOG_MESSAGE'), timeout: 10000, html: true })
+    }
+  } catch (error) {
+    // User error message on operation should be raised by error hook, otherwise this is more a coding error
+    logger.error(`[KDK] ${error}`)
+  }
+  Loading.hide()
+  return createdLayer
+}
+
+export async function saveLayer (layer) {
+  await api.getService('catalog').create(_.omit(layer, InternalLayerProperties))
+}
+
+export async function removeLayer (layer) {
+  const result = await kCoreUtils.dialog({
+    title: i18n.t('utils.layers.REMOVE_DIALOG_TITLE', { layer: layer.label || layer.name }),
+    message: i18n.t('utils.layers.REMOVE_DIALOG_MESSAGE', { layer: layer.label || layer.name }),
+    html: true,
+    ok: {
+      label: i18n.t('OK'),
+      flat: true
+    },
+    cancel: {
+      label: i18n.t('CANCEL'),
+      flat: true
+    }
+  })
+  if (!result.ok) return false
+  Loading.show({ message: i18n.t('utils.layers.REMOVING_LABEL'), html: true })
+  try {
+    if (layer._id) {
+      // If persistent feature layer remove features as well
+      if (isFeatureLayer(layer)) {
+        await removeFeatures(layer._id)
+      }
+      await api.getService('catalog').remove(layer._id)
+    }
+  } catch (error) {
+    // User error message on operation should be raised by error hook, otherwise this is more a coding error
+    logger.error(`[KDK] ${error}`)
+  }
+  Loading.hide()
+  return true
+}

package/map/client/utils/utils.location.js

@@ -1,7 +1,59 @@
-import { Store, api } from '../../../core.client.js'
-import { formatGeocodingResult, parseCoordinates, formatUserCoordinates } from './utils.js'
+import _ from 'lodash'
+import logger from 'loglevel'
+import config from 'config'
+import { Store, api, i18n, Events } from '../../../core.client.js'
+import { formatUserCoordinates } from './utils.js'
 
-export async function searchLocation (pattern, options) {
+// Format (reverse) geocoding output
+function formatGeocodingResult (result) {
+  const properties = result.properties
+  if (!properties) {
+    logger.warn('[KDK] invalid geocoding result: missing \'properties\' property')
+    return
+  }
+  // check whether the result as a valid formatted address
+  let label = properties.formattedAddress || ''
+  // try to build a formatted address
+  if (!label) {
+    if (properties.streetNumber) label += (properties.streetNumber + ', ')
+    if (properties.streetName) label += (properties.streetName + ' ')
+    if (properties.city) label += (properties.city + ' ')
+    if (properties.zipcode) label += (' (' + properties.zipcode + ')')
+  }
+  // otherwise retireve the match prop
+  if (!label) {
+    if (!_.has(result, 'geokoder.matchProp')) {
+      logger.warn('[KDK] invalid geocoding result: missing \'geokoder.matchProp\' property')
+      return
+    }
+    label = _.get(result, result.geokoder.matchProp, '')
+  }
+  return label
+}
+
+export function parseCoordinates (str) {
+  const coords = _.split(_.trim(str), ',')
+  if (coords.length !== 2) return
+  const latitude = Number(coords[0])
+  if (_.isNaN(latitude)) return
+  const longitude = Number(coords[1])
+  if (_.isNaN(longitude)) return
+  return {
+    latitude,
+    longitude
+  }
+}
+
+export async function queryGeocoder(planetConfig, path, query = '') {
+  const endpoint = planetConfig.gateway + '/geocoder'
+  const jwt = await api.get('storage').getItem(planetConfig.gatewayJwt)
+  let url = `${endpoint}/${path}`
+  if (query) url += `?${query}`
+  const results = await fetch(url, { headers: { Authorization: `Bearer ${jwt}` } }).then((response) => response.json())
+  return results
+}
+
+export async function searchLocation (planetConfig, pattern, options) {
   const locations = []
   // Try to parse lat/long coordinates
   const coordinates = parseCoordinates(pattern)
@@ -17,29 +69,45 @@ export async function searchLocation (pattern, options) {
       }
     })
   } else {
-    // TODO
-    // Use the geocoders list in the options object to perform the query to the service
-    // The new result should be an array of GeoJSON so the following formatting should be removed
-    const geocoderService = api.getService('geocoder')
-    if (!geocoderService) throw new Error('Cannot find geocoder service')
-    const response = await geocoderService.create({ address: pattern })
-    response.forEach(element => {
-      locations.push({
-        type: 'Feature',
-        geometry: {
-          type: 'Point',
-          coordinates: [element.longitude, element.latitude]
-        },
-        properties: {
-          name: formatGeocodingResult(element)
-        }
-      })
+    let filter = ''
+    if (!_.isEmpty(options.geocoders)) {
+      // only request geocoder results from specified sources
+      filter = '&sources=*(' + options.geocoders.join('|') + ')'
+    }
+    const results = await queryGeocoder(planetConfig, 'forward', `q=${pattern}${filter}`)
+    results.forEach(result => {
+      locations.push(
+        Object.assign(
+          _.pick(result, ['type', 'geometry']),
+          { properties: { name: formatGeocodingResult(result), source: result.geokoder.source } }))
     })
   }
   return locations
 }
 
-export async function listGeocoders () {
-  // TODO
-  return ['nominatin', 'ban']
+export async function listGeocoders (planetConfig) {
+  let response
+  try {
+    response = await queryGeocoder(planetConfig, 'capabilities/forward')
+    if (response.i18n) i18n.registerTranslation(response.i18n)
+  } catch (error) {
+    Events.emit('error', { message: i18n.t('errors.NETWORK_ERROR') })
+  }
+  return _.get(response, 'geocoders', [])
 }
+
+// Filter geocoder sources based on given project
+export function filterGeocoders(geocoders, project) {
+  return geocoders.filter(geocoder => {
+    // Geocoder id can directly be a string or the value of UI elements with label/value
+    const id = geocoder.value || geocoder
+    if (project && id.startsWith('kano:')) {
+      const service = id.replace('kano:', '')
+      // Depending on the layer the geocoding source (i.e. collection/service) is not the same
+      let layer = _.find(project.layers, { service })
+      if (!layer) layer = _.find(project.layers, { probeService: service })
+      return layer
+    }
+    return true
+  })
+}

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

@@ -0,0 +1,8 @@
+import _ from 'lodash'
+
+export function getCatalogProjectQuery (project) {
+  // As we keep track of ID/name depending on if a layer is a user-defined one or not we need to process both
+  const idQuery = { _id: { $in: _.map(_.filter(project.layers, '_id'), '_id') } }
+  const nameQuery = { name: { $in: _.map(_.filter(project.layers, 'name'), 'name') } }
+  return { $or: [idQuery, nameQuery] }
+}

package/map/client/utils/utils.schema.js

@@ -38,7 +38,6 @@ export function generatePropertiesSchema (geoJson, name) {
         component: (type === 'number'
           ? 'form/KNumberField'
           : (type === 'boolean' ? 'form/KToggleField' : 'form/KTextField')),
-        helper: key,
         label: key
       }
     }