@kalisio/kdk 2.1.8 → 2.2.0

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

@@ -1,11 +1,11 @@
 import _ from 'lodash'
 import logger from 'loglevel'
 import config from 'config'
-import explode from '@turf/explode'
-import { Loading, Dialog } from 'quasar'
+import { Store, utils as kCoreUtils } from '../../../core/client/index.js'
 import { Geolocation } from '../geolocation.js'
-import { setEngineJwt } from '../utils.js'
-import { i18n, utils as kCoreUtils } from '../../../core/client/index.js'
+import { setEngineJwt, getLayers, getCategories } from '../utils/utils.catalog.js'
+import * as layers from '../utils/utils.layers.js'
+import { getCatalogProjectQuery } from '../utils/utils.project.js'
 
 export const activity = {
   data () {
@@ -41,33 +41,27 @@ export const activity = {
       return []
     },
     async getCatalogLayers () {
-      let layers = []
-      // We get layers coming from global catalog first if any
-      const globalCatalogService = this.$api.getService('catalog', '')
-      if (globalCatalogService) {
-        const response = await globalCatalogService.find()
-        layers = layers.concat(response.data)
+      const query = {}
+      // Do we get layers coming from project ?
+      if (this.project) {
+        Object.assign(query, this.catalogProjectQuery ? this.catalogProjectQuery : getCatalogProjectQuery(this.project))
+      } else {
+        this.project = null
       }
+
+      // We get layers coming from global catalog first if any
+      let layers = await getLayers({ query })
       // Then we get layers coming from contextual catalog if any
-      const catalogService = this.$api.getService('catalog')
-      if (catalogService && (catalogService !== globalCatalogService)) {
-        const response = await catalogService.find()
-        layers = layers.concat(response.data)
-      }
-      // Do we need to inject a token ?
-      await setEngineJwt(layers)
+      const context = Store.get('context')
+      if (context) layers = layers.concat(await getLayers({ query, context }))
       return layers
     },
     async addCatalogLayer (layer) {
       // Check if available for current engine
       if (layer[this.engine]) {
-        // Process i18n
-        if (layer.i18n) i18n.registerTranslation(layer.i18n)
-        layer.label = this.$tie(layer.name)
-        layer.description = this.$tie(layer.description)
         // Check for Weacast API availability
         const isWeacastLayer = _.get(layer, `${this.engine}.type`, '').startsWith('weacast.')
-        if (isWeacastLayer && (!this.weacastApi || !this.forecastModel)) return
+        if (isWeacastLayer && (!this.getWeacastApi() || !this.forecastModel)) return
         await this.addLayer(layer)
       }
       // Filter layers with variables, not just visible ones because we might want to
@@ -82,26 +76,14 @@ export const activity = {
       }
     },
     async getCatalogCategories () {
-      let categories = []
       // We get categories coming from global catalog first if any
-      const globalCatalogService = this.$api.getService('catalog', '')
-      if (globalCatalogService) {
-        const response = await globalCatalogService.find({ query: { type: 'Category' } })
-        categories = categories.concat(response.data)
-      }
+      let categories = await getCategories()
       // Then we get categories coming from contextual catalog if any
-      const catalogService = this.$api.getService('catalog')
-      if (catalogService && (catalogService !== globalCatalogService)) {
-        const response = await catalogService.find({ query: { type: 'Category' } })
-        categories = categories.concat(response.data)
-      }
+      const context = Store.get('context')
+      if (context) categories = categories.concat(await getCategories({ context }))
       return categories
     },
     async addCatalogCategory (category) {
-      // Process i18n
-      if (category.i18n) i18n.registerTranslation(category.i18n)
-      category.label = this.$tie(category.name)
-      category.description = this.$tie(category.description)
       this.layerCategories.push(category)
     },
     async refreshLayerCategories () {
@@ -128,45 +110,21 @@ export const activity = {
         if (baseLayer) await this.showLayer(baseLayer.name)
       }
     },
-    isInMemoryLayer (layer) {
-      return layer._id === undefined
-    },
-    isUserLayer (layer) {
-      return (_.get(layer, 'scope') === 'user')
-    },
-    isFeatureLayer (layer) {
-      return (_.get(layer, 'service') === 'features')
-    },
-    hasFeatureSchema (layer) {
-      return _.has(layer, 'schema')
-    },
+    isInMemoryLayer: layers.isInMemoryLayer,
+    isUserLayer: layers.isUserLayer,
+    isFeatureLayer: layers.isFeatureLayer,
+    hasFeatureSchema: layers.hasFeatureSchema,
     isLayerSelectable (layer) {
       // Only possible when not edited by default
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) return false
-      return _.get(layer, 'isSelectable', true)
-    },
-    isLayerProbable (layer) {
-      return _.get(layer, 'isProbable', false)
-    },
-    isLayerStorable (layer) {
-      // Only possible when not saved by default
-      if (layer._id) return false
-      return _.get(layer, 'isStorable', this.isUserLayer(layer))
-    },
-    isLayerEditable (layer) {
-      // Only possible when saved by default
-      if (!layer._id) return false
-      return _.get(layer, 'isEditable', this.isUserLayer(layer))
-    },
-    isLayerRemovable (layer) {
-      return _.get(layer, 'isRemovable', this.isUserLayer(layer))
-    },
-    isLayerStyleEditable (layer) {
-      return _.get(layer, 'isStyleEditable', this.isUserLayer(layer))
-    },
-    isLayerDataEditable (layer) {
-      return _.get(layer, 'isDataEditable', this.isUserLayer(layer) && this.isFeatureLayer(layer))
-    },
+      return layers.isLayerSelectable(layer)
+    },
+    isLayerProbable: layers.isLayerProbable,
+    isLayerStorable: layers.isLayerStorable,
+    isLayerEditable: layers.isLayerEditable,
+    isLayerRemovable: layers.isLayerRemovable,
+    isLayerStyleEditable: layers.isLayerStyleEditable,
+    isLayerDataEditable: layers.isLayerDataEditable,
     async resetLayer (layer) {
       // Reset layer with new setup but keep track of current visibility state
       // as adding the layer back will restore default visibility state
@@ -217,90 +175,26 @@ export const activity = {
     async onSaveLayer (layer) {
       // Stop any running edition
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) await this.stopEditLayer('accept')
+      let createdLayer
       // Take care that WFS layers rely on the same type as our own feature layers
       if (!_.has(layer, 'wfs') && _.get(layer, `${this.engine}.type`) === 'geoJson') {
         const geoJson = this.toGeoJson(layer.name)
-        // Check for invalid features first
-        const check = this.checkFeatures(geoJson)
-        if (check.kinks.length > 0) {
-          const result = await kCoreUtils.dialog({
-            title: this.$t('mixins.activity.INVALID_FEATURES_DIALOG_TITLE', { features: check.kinks }),
-            message: this.$t('mixins.activity.INVALID_FEATURES_DIALOG_MESSAGE', { features: check.kinks }),
-            options: {
-              type: 'toggle',
-              model: [],
-              items: [
-                { label: this.$t('mixins.activity.DOWNLOAD_INVALID_FEATURES_LABEL'), value: 'download' }
-              ]
-            },
-            html: true,
-            ok: {
-              label: this.$t('OK'),
-              flat: true
-            },
-            cancel: {
-              label: this.$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 }),
-              this.$t('mixins.activity.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 (this.is2D() && (nbPoints > 5000)) {
-          _.set(layer, 'leaflet.tiled', true)
-          _.set(layer, 'leaflet.minZoom', 15)
-        }
-        Loading.show({ message: this.$t('mixins.activity.SAVING_LABEL', { processed: 0, total: features.length }), html: true })
-        try {
-          let createdLayer = await this.$api.getService('catalog')
-            .create(_.omit(layer, ['actions', 'label', 'isVisible', 'isDisabled']))
-          const chunkSize = _.get(this, 'activityOptions.featuresChunkSize', 5000)
-          let nbFeatures = 0
-          // We use the generated DB ID as layer ID on features
-          await this.createFeatures(geoJson, createdLayer._id, chunkSize, (i, chunk) => {
-            // Update saving message according to new chunk data
-            nbFeatures += chunk.length
-            Loading.show({
-              message: this.$t('mixins.activity.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 this.$api.getService('catalog').patch(createdLayer._id, { baseQuery: { layer: createdLayer._id } })
-          // Reset layer with new setup
-          await this.resetLayer(createdLayer)
-          if (_.get(layer, 'leaflet.tiled')) {
-            this.$notify({ type: 'positive', message: this.$t('mixins.activity.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()
+        createdLayer = await layers.saveGeoJsonLayer(layer, geoJson, _.get(this, 'activityOptions.featuresChunkSize', 5000))
       } else {
         // Otherwise simply save in catalog
-        const createdLayer = await this.$api.getService('catalog')
-          .create(_.omit(layer, ['actions', 'label', 'isVisible', 'isDisabled']))
-        // Reset layer with new setup
-        await this.resetLayer(createdLayer)
+        createdLayer = await layers.saveLayer(layer)
+      }
+      // Add layer to current project ?
+      if (this.project) {
+        this.project.layers.push({ _id: createdLayer._id })
+        await this.$api.getService('projects').patch(this.project._id, {
+          layers: this.project.layers
+        })
       }
+      // Reset layer with new setup
+      // It should be triggerred by real-time event
+      // but as we might not always use sockets perform it anyway
+      if (createdLayer) await this.resetLayer(createdLayer)
     },
     editLayerByName (name, editOptions = {}) {
       // this one is used through postRobot to trigger edition
@@ -324,39 +218,14 @@ export const activity = {
       await this.stopEditLayer(status)
     },
     async onRemoveLayer (layer) {
-      Dialog.create({
-        title: this.$t('mixins.activity.REMOVE_DIALOG_TITLE', { layer: layer.label || layer.name }),
-        message: this.$t('mixins.activity.REMOVE_DIALOG_MESSAGE', { layer: layer.label || layer.name }),
-        html: true,
-        ok: {
-          label: this.$t('OK'),
-          flat: true
-        },
-        cancel: {
-          label: this.$t('CANCEL'),
-          flat: true
-        }
-      }).onOk(async () => {
-        Loading.show({ message: this.$t('mixins.activity.REMOVING_LABEL'), html: true })
-        try {
-          // Stop any running edition
-          if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) await this.stopEditLayer('reject')
-          if (layer._id) {
-            // If persistent feature layer remove features as well
-            if (this.isFeatureLayer(layer)) {
-              await this.removeFeatures(layer._id)
-            }
-            await this.$api.getService('catalog').remove(layer._id)
-          }
-          // Actual layer removal should be triggerred by real-time event
-          // but as we might not always use sockets perform it anyway
-          this.removeLayer(layer.name)
-        } 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()
-      })
+      // Stop any running edition
+      if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) await this.stopEditLayer('reject')
+      if (await layers.removeLayer(layer)) {
+        // Actual layer removal should be triggerred by real-time event
+        // but as we might not always use sockets perform it anyway
+        this.removeLayer(layer.name)
+      }
+      // Removing the layer should automatically update all projects
     },
     onEngineReady (engine) {
       this.engine = engine
@@ -401,10 +270,13 @@ export const activity = {
       this.catalogListeners = {}
       if (globalCatalogService.events !== undefined) {
         globalCatalogService.events.forEach(event => {
-          this.catalogListeners[event] = (object) => this.onCatalogUpdated(event, object)
-          globalCatalogService.on(event, this.catalogListeners[event])
-          if (catalogService && (catalogService !== globalCatalogService)) {
-            catalogService.on(event, this.catalogListeners[event])
+          // Avoid reentrance
+          if (!this.catalogListeners[event]) {
+            this.catalogListeners[event] = (object) => this.onCatalogUpdated(event, object)
+            globalCatalogService.on(event, this.catalogListeners[event])
+            if (catalogService && (catalogService !== globalCatalogService)) {
+              catalogService.on(event, this.catalogListeners[event])
+            }
           }
         })
       }
@@ -415,9 +287,12 @@ export const activity = {
       const catalogService = this.$api.getService('catalog')
       if (globalCatalogService.events !== undefined) {
         globalCatalogService.events.forEach(event => {
-          globalCatalogService.removeListener(event, this.catalogListeners[event])
-          if (catalogService && (catalogService !== globalCatalogService)) {
-            catalogService.removeListener(event, this.catalogListeners[event])
+          // Avoid reentrance
+          if (this.catalogListeners[event]) {
+            globalCatalogService.removeListener(event, this.catalogListeners[event])
+            if (catalogService && (catalogService !== globalCatalogService)) {
+              catalogService.removeListener(event, this.catalogListeners[event])
+            }
           }
         })
       }

package/map/client/mixins/mixin.catalog-panel.js

@@ -3,24 +3,24 @@ export const catalogPanel = {
     panelStyle () {
       const screenHeight = this.$q.screen.height
       this.scrollAreaMaxHeight = screenHeight * 0.75 // 75vh
-      this.scrollAreaMaxWidth = 390
+      this.scrollAreaMinWidth = 390
       if (this.$q.screen.lt.sm) {
         this.scrollAreaMaxHeight = screenHeight * 0.6
-        this.scrollAreaMaxWidth = 300
+        this.scrollAreaMinWidth = 300
       } else if (this.$q.screen.lt.md) {
         this.scrollAreaMaxHeight = screenHeight * 0.65
-        this.scrollAreaMaxWidth = 330
+        this.scrollAreaMinWidth = 330
       } else if (this.$q.screen.lt.lg) {
         this.scrollAreaMaxHeight = screenHeight * 0.7
-        this.scrollAreaMaxWidth = 360
+        this.scrollAreaMinWidth = 360
       }
-      return `height: ${this.scrollAreaMaxHeight}px; width: ${this.scrollAreaMaxWidth}px`
+      return `height: ${this.scrollAreaMaxHeight}px; min-width: ${this.scrollAreaMinWidth}px;'`
     }
   },
   data () {
     return {
       scrollAreaMaxHeight: 0,
-      scrollAreaMaxWidth: 390
+      scrollAreaMinWidth: 390
     }
   }
 }

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

@@ -1,13 +1,14 @@
 import _ from 'lodash'
 import moment from 'moment'
 import sift from 'sift'
-import { utils as kCoreUtils, Time, Store } from '../../../core/client/index.js'
+import { utils as kCoreUtils, Time, Store, LocalStorage } from '../../../core/client/index.js'
+import { isTerrainLayer } from '../utils/utils.layers.js'
 
 export const context = {
   methods: {
     getContextKey (context) {
       // Generate a unique key to store context based on app name, map activity name and context type
-      return this.getAppName().toLowerCase() + `-${this.activityName}-${context}`
+      return `${this.activityName}-${context}`
     },
     shouldRestoreContext (context) {
       // Use user settings except if the view has explicitly revoked restoration
@@ -61,7 +62,7 @@ export const context = {
           break
         case 'time': {
           targetParameters = {
-            time: Time.getCurrentTime().restoreContext()
+            time: Time.getCurrentTime()
           }
           break
         }
@@ -130,8 +131,8 @@ export const context = {
           // Take care that 3D requires at least a terrain layer.
           // So if we try to remove a terrain layer without activating a new one, keep it active
           // (this can be the case when the view has been saved from the 2D activity and restored in the 3D activity).
-          const inactivatedTerrainLayer = _.find(inactivatedLayers, (name) => this.hasLayer(name) && (this.getLayerByName(name).type === 'TerrainLayer'))
-          const activatedTerrainLayer = _.find(activedLayers, (name) => this.hasLayer(name) && (this.getLayerByName(name).type === 'TerrainLayer'))
+          const inactivatedTerrainLayer = _.find(inactivatedLayers, (name) => this.hasLayer(name) && isTerrainLayer(this.getLayerByName(name)))
+          const activatedTerrainLayer = _.find(activedLayers, (name) => this.hasLayer(name) && isTerrainLayer(this.getLayerByName(name)))
           if (inactivatedTerrainLayer && !activatedTerrainLayer) _.pull(inactivatedLayers, inactivatedTerrainLayer)
           await Promise.all(activedLayers.map(layer => this.showLayer(layer)))
           await Promise.all(inactivatedLayers.map(layer => this.hideLayer(layer)))
@@ -160,16 +161,16 @@ export const context = {
         if (!_.isEqual(this.getRouteContext(context), targetParameters)) {
           this.updateRouteContext(context, targetParameters)
         }
-        window.localStorage.setItem(this.getContextKey(context), JSON.stringify(targetParameters))
+        LocalStorage.set(this.getContextKey(context), targetParameters)
       }
     },
     async restoreContext (context) {
       let targetParameters = this.getRouteContext(context)
       // Restore from local storage/catalog if no route parameters
       if (_.isEmpty(targetParameters)) {
-        const savedParameters = window.localStorage.getItem(this.getContextKey(context))
-        if (this.shouldRestoreContext(context) && savedParameters) {
-          targetParameters = JSON.parse(savedParameters)
+        const savedParameters = LocalStorage.get(this.getContextKey(context))
+        if (this.shouldRestoreContext(context) && !_.isEmpty(savedParameters)) {
+          targetParameters = savedParameters
           // Backward compatibility: we previously stored the bounds as an array
           if (Array.isArray(targetParameters)) {
             targetParameters = {
@@ -227,7 +228,8 @@ export const context = {
       if (hasLayers) {
         Object.assign(context, this.getContextParameters('layers'))
       }
-      await this.$api.getService('catalog').create(context)
+      context = await this.$api.getService('catalog').create(context)
+      return context
     },
     async loadContext (context) {
       // If not context object retrieve it from catalog first
@@ -242,6 +244,7 @@ export const context = {
       if (!context) throw new Error('Cannot find or invalid context')
       this.setContextParameters('view', context)
       this.setContextParameters('layers', context)
+      return context
     },
     updateViewSettings (enabled) {
       if (!enabled) this.clearContext('view')