@kalisio/kdk 2.5.1 → 2.5.3

package/map/api/hooks/hooks.query.js

@@ -355,14 +355,16 @@ export async function aggregateFeaturesQuery (hook) {
           // Delete accumulator
           _.unset(result, element)
         }
-        // Keep track of result in map to improve search later
-        const resultKeys = keys.map(key => _.get(singleTime ? result : result._id, key))
-        const resultKey = resultKeys.join('-')
-        if (!aggregatedResultsMap.has(resultKey)) aggregatedResultsMap.set(resultKey, result)
       })
       // Now merge with previous element results
       if (!aggregatedResults) {
         aggregatedResults = elementResults
+        aggregatedResults.forEach(result => {
+          // Keep track of result in map to improve search later
+          const resultKeys = keys.map(key => _.get(singleTime ? result : result._id, key))
+          const resultKey = resultKeys.join('-')
+          aggregatedResultsMap.set(resultKey, result)
+        })
       } else {
         elementResults.forEach(result => {
           // When single time no aggregation is performed at all so we only have raw features
@@ -385,6 +387,7 @@ export async function aggregateFeaturesQuery (hook) {
             _.set(previousResult, prefix + element, _.get(result, prefix + element))
           } else {
             aggregatedResults.push(result)
+            aggregatedResultsMap.set(resultKey, result)
           }
         })
       }

package/map/api/services/styles/styles.hooks.js

@@ -3,7 +3,7 @@ import { hooks as kdkCoreHooks } from '../../../../core/api/index.js'
 
 export default {
   before: {
-    all: [],
+    all: [kdkCoreHooks.marshallHttpQuery],
     find: [
       fuzzySearch({ fields: ['name'] }),
       kdkCoreHooks.diacriticSearch()

package/map/client/components/KLayerEditor.vue

@@ -430,7 +430,11 @@ function apply () {
 
   const layer = CurrentActivity.value.getLayerByName(props.layerName)
   if (isInMemoryLayer(layer)) {
+    const previousName = _.get(layer, 'name', '')
     _.merge(layer, updatedLayer)
+    if (previousName !== layer.name) {
+      CurrentActivity.value.renameLayer(previousName, layer.name)
+    }
     CurrentActivity.value.resetLayer(layer)
   } else {
     // Dotify the layer to avoid patching the whole object

package/map/client/components/catalog/KLayerCategories.vue

@@ -233,6 +233,7 @@ export default {
           throw error
         }
         this.mode = 'list'
+        this.addForm = null
       }
     },
     async onEdit () {
@@ -248,6 +249,7 @@ export default {
         }
         this.editedCategory = null
         this.mode = 'list'
+        this.editForm = null
       }
     },
     refreshCategories (items) {

package/map/client/components/stickies/KAttribution.vue

@@ -64,17 +64,18 @@ import KShape from '../../../../core/client/components/media/KShape.vue'
 // Data
 const { CurrentActivity } = useCurrentActivity({ selection: false, probe: false })
 const attributions = ref({})
-const header = ref(_.get(config, 'attribution.header', []))
-const headerClass = ref(_.get(config, 'attribution.headerClass', ''))
-const footer = ref(_.get(config, 'attribution.footer', []))
-const footerClass = ref(_.get(config, 'attribution.footerClass', ''))
+const header = _.get(config, 'attribution.header', [])
+const headerClass = _.get(config, 'attribution.headerClass', '')
+const footer = _.get(config, 'attribution.footer', [])
+const footerClass = _.get(config, 'attribution.footerClass', '')
 
 // Computed
 const sanitizedAttributions = computed(() => {
-  let content = ''
-  _.forOwn(attributions.value, (attribution, layer) => {
+  const filteredAttributions = _.uniq(_.map(attributions.value))
+  const content = _.reduce(filteredAttributions, (content, attribution) => {
     content += `${attribution}<br>`
-  })
+    return content
+  }, '')
   return Document.sanitizeHtml(content)
 })
 

package/map/client/components/stickies/KLevelSlider.vue

@@ -32,7 +32,7 @@
         class="text-caption text-grey-9"
         style="writing-mode: vertical-lr; min-width: 1rem;"
       >
-        {{ $t(label) }} - {{ getFormattedLevel(CurrentActivity.selectedLevel) }}
+        {{ $t(label) }} - {{ getFormattedLevel(level) }}
       </div>
     </div>
   </div>
@@ -68,6 +68,10 @@ const levels = computed(() => {
   const selectableLevels = _.get(CurrentActivity.value, 'selectableLevels')
   return !_.isEmpty(selectableLevels) ? selectableLevels : null
 })
+const unit = computed(() => {
+  const selectableLevels = _.get(CurrentActivity.value, 'selectableLevels')
+  return !_.isEmpty(selectableLevels) ? selectableLevels.unit : ''
+})
 const label = computed(() => {
   return _.get(levels.value, 'label')
 })
@@ -85,10 +89,9 @@ const sliderStep = computed(() => {
 })
 
 // Watch
-watch(() => CurrentActivity.value.selectableLevels, (levels) => {
-  if (levels.values) level.value = _.head(levels.values)
-  else if (levels.range) level.value = _.get(levels.range, 'min', 0)
-  else level.value = 0
+watch(() => CurrentActivity.value.selectedLevel, (selectedLevel) => {
+  if (levels.value && levels.value.values) level.value = levels.value.values.indexOf(selectedLevel)
+  else level.value = selectedLevel
 })
 
 // Functions
@@ -100,9 +103,8 @@ function onLevelChanged (level) {
   }
 }
 function getFormattedLevel (level) {
-  const unit = _.get(CurrentActivity.value.selectableLevels, 'unit')
-  if (levels.value.values) return `${levels.value.values[level]} ${unit}`
-  return `${level} ${unit}`
+  if (levels.value.values) return `${levels.value.values[level]} ${unit.value}`
+  return `${level} ${unit.value}`
 }
 </script>
 

package/map/client/components/styles/KStyleEditor.vue

@@ -224,7 +224,7 @@ const canEditPolygon = computed(() => props.allowedTypes.includes('polygon'))
 
 // Watch
 watch(() => props.style, (value) => {
-  if (!value) model.value = _.clone(engine.value.style)
+  if (!value) model.value = _.clone(_.pick(engine.value.style, ['point', 'line', 'polygon']))
   else model.value = value
 }, { immediate: true })
 

package/map/client/components/styles/KStyleManager.vue

@@ -154,7 +154,13 @@ function applyToSelection (styleToApply) {
   _.forEach(getSelectedFeaturesByLayer(), layer => {
     if (isLayerStyleEditable(layer.layer)) {
       _.forEach(layer.features, f => {
-        _.set(f, 'style', _.get(styleToApply, ['item', _.get(type, f.geometry.type, 'point')], null))
+        let geometryType = f.geometry.type
+        if (_.has(f, 'properties.entityStyle')) {
+          // Walls and corridors must be treated as polygons in style editor
+          if (_.has(f, 'properties.entityStyle.wall')) geometryType = 'Polygon'
+          else if (_.has(f, 'properties.entityStyle.corridor')) geometryType = 'Polygon'
+        }
+        _.set(f, 'style', _.get(styleToApply, ['item', _.get(type, geometryType, 'point')], null))
       })
       if (CurrentActivity.value.isInMemoryLayer(layer.layer)) {
         CurrentActivity.value.resetLayer(layer.layer)

package/map/client/composables/highlight.js

@@ -122,8 +122,12 @@ export function useHighlight (name, options = {}) {
         // If highlight size is based on a shape with a radius use it, otherwise go for size
         if (radius) Object.assign(highlightStyle, { radius: radius + 0.5 * HighlightMargin }) 
         else if (size) Object.assign(highlightStyle, { size: [size[0] + HighlightMargin, size[1] + HighlightMargin] })
+      
+        Object.assign(highlight, { style: highlightStyle })
+      } else {
+        // In 3D, keep important style properties from feature, such as "altitudeMode"
+        Object.assign(highlight, { style: _.defaults({}, highlightStyle, feature.style) })
       }
-      Object.assign(highlight, { style: highlightStyle })
     } else {
       // Retrieve feature sytle
       Object.assign(highlight, { style: feature.style })

package/map/client/i18n/map_en.json

@@ -386,7 +386,10 @@
   "KOwsServiceField": {
     "INVALID_URL": "Invalid URL",
     "CANNOT_FETCH_URL": "Failed fetching resource.",
-    "WFS_MISSING_GEOJSON_SUPPORT": "The WFS service has no support for GeoJSON, which is required."
+    "WFS_MISSING_GEOJSON_SUPPORT": "The WFS service has no support for GeoJSON, which is required.",
+    "HEADER_KEY": "Token header key",
+    "HEADER_VALUE": "Token value",
+    "UNAUTHORIZED_MESSAGE": "You do not seem to be authorized to access this service, you might need to add an API key in the request header."
   },
   "KOwsLayerField": {
     "UNABLE_TO_DESCRIBE_FEATURE_TYPE": "Failed fetching layer's description.",

package/map/client/i18n/map_fr.json

@@ -375,7 +375,7 @@
     },
     "side-nav": {
       "HELP_LABEL": "Accédez à notre aide en ligne à tout moment",
-      "CONTEXT_HELP_LABEL": "Pour obtenir de l'aide contextuelle lorsque vous êtes perdu cliquez à tout moment cette l'icône",
+      "CONTEXT_HELP_LABEL": "Pour obtenir de l'aide contextuelle lorsque vous êtes perdu, cliquez à tout moment sur cette icône",
       "ABOUT_LABEL": "Affichez les informations détaillées du système et signalez-nous une anomalie.",
       "BUG_LABEL": "Signalez-nous une anomalie via un email contenant automatiquement les informations nécessaires.",
       "SETTINGS_LABEL": "Modifiez les paramètres généraux du système sur votre appareil.",
@@ -386,7 +386,10 @@
   "KOwsServiceField": {
     "INVALID_URL": "URL invalide",
     "CANNOT_FETCH_URL": "Impossible de récupérer la ressource.",
-    "WFS_MISSING_GEOJSON_SUPPORT": "Le service WFS ne supporte pas le format GeoJSON qui est un prérequis."
+    "WFS_MISSING_GEOJSON_SUPPORT": "Le service WFS ne supporte pas le format GeoJSON qui est un prérequis.",
+    "HEADER_KEY": "Clef d'en-tête du jeton",
+    "HEADER_VALUE": "Valeur du jeton",
+    "UNAUTHORIZED_MESSAGE": "Vous ne semblez pas autorisé(e) à accéder à ce service, un jeton d'accès dans l'en-tête de requête peut être nécessaire."
   },
   "KOwsLayerField": {
     "UNABLE_TO_DESCRIBE_FEATURE_TYPE": "Impossible de récupérer la description des propriétés de la couche.",

package/map/client/leaflet/utils/utils.geojson.js

@@ -93,14 +93,13 @@ export function getUpdateFeatureFunction(leafletOptions) {
     if (!oldLayer) return
     const oldType = _.get(oldLayer, 'feature.geometry.type')
     const type = _.get(feature, 'geometry.type')
-    // The feature is changing its geometry type, recreate it
-    if (type !== oldType) return
     const staticGeometry = _.get(leafletOptions, 'staticGeometry', false)
+    // The feature is changing its geometry type, recreate it except for static geometry
+    // as we'd like the geometry of the features tu remain stable in this case (eg lines in for probes vs bbox for measures)
+    if (!staticGeometry && (type !== oldType)) return
     // Keep track of previous geometry if we don't want to update it
     // Indeed, styling might depend on it
     if (staticGeometry) feature.geometry = _.get(oldLayer, 'feature.geometry')
-    // Now update coordinates if not static geometry
-    if (staticGeometry) return oldLayer
     // An existing one is found, simply update styling, properties, etc.
     leafletOptions.onEachFeature(feature, oldLayer)
     if (oldLayer.setStyle) {
@@ -130,6 +129,8 @@ export function getUpdateFeatureFunction(leafletOptions) {
       // oldLayer.setIcon(_.get(leafletOptions.pointToLayer(feature, oldLayer.getLatLng()), 'options.icon'))
       return
     }
+    // Now update coordinates if not static geometry
+    if (staticGeometry) return oldLayer
     const coordinates = feature.geometry.coordinates
     // FIXME: support others geometry types ?
     switch (type) {

package/map/client/mixins/globe/mixin.geojson-layers.js

@@ -138,7 +138,8 @@ export const geojsonLayers = {
               outlineColor: new ConstantProperty(stroke),
               outlineWidth: strokeWidth,
               outline: new ConstantProperty(true)
-            }
+            },
+            feature: entity.feature
           })
           entitiesToRemove.push(entity)
         }
@@ -172,8 +173,10 @@ export const geojsonLayers = {
                 outlineColor: new ConstantProperty(stroke),
                 outlineWidth: strokeWidth,
                 outline: new ConstantProperty(true)
-              }
+              },
+              feature: entity.feature
             })
+            entitiesToRemove.push(entity)
           }
         }
         // Corridors
@@ -206,7 +209,8 @@ export const geojsonLayers = {
                 outlineColor: new ConstantProperty(stroke),
                 outlineWidth: strokeWidth,
                 outline: new ConstantProperty(true)
-              }
+              },
+              feature: entity.feature
             })
             entitiesToRemove.push(entity)
           }
@@ -234,7 +238,8 @@ export const geojsonLayers = {
               outlineColor: new ConstantProperty(stroke),
               outlineWidth: strokeWidth
             },
-            billboard: billboardImage ? { image: billboardImage } : undefined
+            billboard: billboardImage ? { image: billboardImage } : undefined,
+            feature: entity.feature
           })
           entitiesToRemove.push(entity)
         }
@@ -257,7 +262,8 @@ export const geojsonLayers = {
                 width: strokeWidth,
                 material: stroke,
                 clampToGround: true
-              }
+              },
+              feature: entity.feature
             }
             entitiesToAdd.push(strokeEntity)
             if (dataSource.entities.getById(strokeEntity.id)) {

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

@@ -130,6 +130,15 @@ export const activity = {
     isLayerRemovable: layers.isLayerRemovable,
     isLayerStyleEditable: layers.isLayerStyleEditable,
     isLayerDataEditable: layers.isLayerDataEditable,
+    canCreateLayer () {
+      return this.$can('create', 'catalog')
+    },
+    canUpdateLayer (layer) {
+      return layers.isInMemoryLayer(layer) || this.$can('update', 'catalog')
+    },
+    canRemoveLayer (layer) {
+      return layers.isInMemoryLayer(layer) || this.$can('remove', 'catalog')
+    },
     async resetLayer (layer) {
       // Keep track of data as we will reset the layer
       let geoJson

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

@@ -48,8 +48,6 @@ export function isLayerStorable (layer) {
 }
 
 export function isLayerEditable (layer) {
-  // Only possible when saved by default
-  if (!layer._id) return false
   return _.get(layer, 'isEditable', isUserLayer(layer))
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kalisio/kdk",
   "description": "Kalisio Development Kit",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "homepage": "https://github.com/kalisio/kdk",
   "type": "module",
   "keywords": [

package/test/api/core/index.test.js

@@ -1,9 +1,11 @@
+/* eslint-disable no-unused-expressions */
 import path, { dirname } from 'path'
 import assert from 'assert'
 import fs from 'fs-extra'
 import request from 'superagent'
 import chai from 'chai'
 import chailint from 'chai-lint'
+import spies from 'chai-spies'
 import core, { kdk, hooks, permissions, createMessagesService } from '../../../core/api/index.js'
 import { fileURLToPath } from 'url'
 
@@ -13,10 +15,12 @@ const { util, expect } = chai
 
 describe('core:services', () => {
   let app, server, port, baseUrl, accessToken,
-    userService, userObject, authorisationService, messagesService, messageObject
+    userService, userObject, authorisationService, messagesService, messageObject,
+    spyUpdateAbilities
 
   before(async () => {
     chailint(chai, util)
+    chai.use(spies)
 
     // Register default rules for all users
     permissions.defineAbilities.registerHook(permissions.defineUserAbilities)
@@ -52,6 +56,7 @@ describe('core:services', () => {
     authorisationService.hooks({
       before: { create: hooks.preventEscalation, remove: hooks.preventEscalation }
     })
+    spyUpdateAbilities = chai.spy.on(authorisationService, 'updateAbilities')
     // Now app is configured launch the server
     server = await app.listen(port)
     await new Promise(resolve => server.once('listening', () => resolve()))
@@ -129,42 +134,37 @@ describe('core:services', () => {
   // Let enough time to process
     .timeout(20000)
 
-  it('creates a user', () => {
+  it('creates a user', async () => {
     // Test password generation
     const hook = hooks.generatePassword()({ type: 'before', data: {}, params: {}, app })
-    return userService.create({
+    userObject = await userService.create({
       email: 'test@test.org',
       password: hook.data.password,
       name: 'test-user',
       profile: { phone: '0623256968' }
     }, { checkAuthorisation: true })
-      .then(user => {
-        userObject = user
-        // Keep track of clear password
-        userObject.clearPassword = hook.data.password
-        return userService.find({ query: { 'profile.name': 'test-user' } })
-      })
-      .then(users => {
-        expect(users.data.length > 0).beTrue()
-        expect(users.data[0].email).toExist()
-        expect(users.data[0].clearPassword).beUndefined()
-        expect(users.data[0].profile).toExist()
-        expect(users.data[0].profile.name).toExist()
-        expect(users.data[0].profile.description).toExist()
-      })
+    expect(spyUpdateAbilities).to.have.been.called.once
+    spyUpdateAbilities.reset()
+    // Keep track of clear password
+    userObject.clearPassword = hook.data.password
+    const users = await userService.find({ query: { 'profile.name': 'test-user' } })
+    expect(users.data.length > 0).beTrue()
+    expect(users.data[0].email).toExist()
+    expect(users.data[0].clearPassword).beUndefined()
+    expect(users.data[0].profile).toExist()
+    expect(users.data[0].profile.name).toExist()
+    expect(users.data[0].profile.description).toExist()
   })
   // Let enough time to process
     .timeout(10000)
 
-  it('changing user password keeps password history', () => {
-    return userService.patch(userObject._id.toString(), { password: userObject.password })
-      .then(() => {
-        return userService.get(userObject._id.toString())
-      })
-      .then(user => {
-        expect(user.previousPasswords).toExist()
-        expect(user.previousPasswords).to.deep.equal([userObject.password])
-      })
+  it('changing user password keeps password history', async () => {
+    await userService.patch(userObject._id.toString(), { password: userObject.password })
+    expect(spyUpdateAbilities).to.have.been.called.once
+    spyUpdateAbilities.reset()
+    const user = await userService.get(userObject._id.toString())
+    expect(user.previousPasswords).toExist()
+    expect(user.previousPasswords).to.deep.equal([userObject.password])
   })
 
   it('authenticates a user', () => {
@@ -257,8 +257,8 @@ describe('core:services', () => {
   // Let enough time to process
     .timeout(5000)
 
-  it('creates an authorisation', () => {
-    return authorisationService.create({
+  it('creates an authorisation', async () => {
+    const authorisation = await authorisationService.create({
       scope: 'authorisations',
       permissions: 'manager',
       subjects: userObject._id.toString(),
@@ -268,16 +268,13 @@ describe('core:services', () => {
     }, {
       user: userObject
     })
-      .then(authorisation => {
-        expect(authorisation).toExist()
-        return userService.get(userObject._id.toString())
-      })
-      .then(user => {
-        userObject = user
-        expect(user.authorisations).toExist()
-        expect(user.authorisations.length > 0).beTrue()
-        expect(user.authorisations[0].permissions).to.deep.equal('manager')
-      })
+    expect(authorisation).toExist()
+    expect(spyUpdateAbilities).to.have.been.called.once
+    spyUpdateAbilities.reset()
+    userObject = await userService.get(userObject._id.toString())
+    expect(userObject.authorisations).toExist()
+    expect(userObject.authorisations.length > 0).beTrue()
+    expect(userObject.authorisations[0].permissions).to.deep.equal('manager')
   })
   // Let enough time to process
     .timeout(5000)
@@ -323,8 +320,8 @@ describe('core:services', () => {
       })
   })
 
-  it('removes an authorisation', () => {
-    return authorisationService.remove(messageObject._id, {
+  it('removes an authorisation', async () => {
+    const authorisation = await authorisationService.remove(messageObject._id, {
       query: {
         scope: 'authorisations',
         subjects: userObject._id.toString(),
@@ -334,14 +331,12 @@ describe('core:services', () => {
       user: userObject,
       checkEscalation: true
     })
-      .then(authorisation => {
-        expect(authorisation).toExist()
-        return userService.get(userObject._id.toString())
-      })
-      .then(user => {
-        expect(user.authorisations).toExist()
-        expect(user.authorisations.length === 0).beTrue()
-      })
+    expect(authorisation).toExist()
+    expect(spyUpdateAbilities).to.have.been.called.once
+    spyUpdateAbilities.reset()
+    const user = await userService.get(userObject._id.toString())
+    expect(user.authorisations).toExist()
+    expect(user.authorisations.length === 0).beTrue()
   })
   // Let enough time to process
     .timeout(5000)
@@ -365,21 +360,15 @@ describe('core:services', () => {
       })
   })
 
-  it('removes a user', () => {
-    return userService.remove(userObject._id, {
+  it('removes a user', async () => {
+    await userService.remove(userObject._id, {
       user: userObject,
       checkAuthorisation: true
     })
-      .then(user => {
-        return userService.find({ query: { name: 'test-user' } })
-      })
-      .then(users => {
-        expect(users.data.length === 0).beTrue()
-        return messagesService.find({ query: { title: 'Title' } })
-      })
-      .then(messages => {
-        expect(messages.data.length === 0).beTrue()
-      })
+    const users = await userService.find({ query: { name: 'test-user' } })
+    expect(users.data.length === 0).beTrue()
+    const messages = await messagesService.find({ query: { title: 'Title' } })
+    expect(messages.data.length === 0).beTrue()
   })
   // Let enough time to process
     .timeout(5000)

package/test/api/core/push.test.js

@@ -175,7 +175,7 @@ describe('core:push', () => {
     expect(operation.succesful.length === 1).beTrue()
     expect(operation.succesful[0].statusCode).to.equal(201)
     expect(operation.failed.length === 1).beTrue()
-    expect(operation.failed[0].statusCode).to.equal(404)
+    expect((operation.failed[0].statusCode === 404) || (operation.failed[0].statusCode === 410)).beTrue()
     expect(operation.failed[0].endpoint).to.equal(expiredSubscription.endpoint)
   })
   // Let enough time to process

package/test/api/core/test-log-2025-06-25.log

@@ -0,0 +1,9 @@
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/messages - Method: create: You are not allowed to access service messages"}
+{"level":"error","message":"error: api/users - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/users - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/authorisations - Method: create: You are not allowed to change authorisation on resource"}
+{"level":"error","message":"error: api/authorisations - Method: remove: You are not allowed to change authorisation on subject(s)"}
+{"level":"info","message":"This is a log test"}