@kalisio/kdk 2.4.1 → 2.5.1

package/core/client/utils/utils.session.js

@@ -1,21 +1,31 @@
 import _ from 'lodash'
 import logger from 'debug'
+import { LocalCache } from '../local-cache.js'
 import { Store } from '../store.js'
 import { api } from '../api.js'
 import { i18n } from '../i18n.js'
 import { defineAbilities } from '../../common/permissions.js'
 
+async function authenticate(authentication) {
+  // Do not update data twice in any case
+  let user = Store.get('user')
+  if (user) return
+  // Store latest authentication data for offline mode
+  await LocalCache.setItem('authentication', authentication)
+  // Anonymous user or user account ?
+  user = authentication.user ? authentication.user : { name: i18n.t('composables.ANONYMOUS'), anonymous: true }
+  Store.set('user', user)
+  await updateAbilities()
+}
+
 export async function login (email, password) {
   const payload = {
     strategy: 'local',
     email: email,
     password: password
   }
-  const response = await api.authenticate(payload)
-  // Anonymous user or service account ?
-  const user = response.user ? response.user : { name: i18n.t('composables.ANONYMOUS'), anonymous: true }
-  Store.set('user', user)
-  await updateAbilities()
+  const authentication = await api.authenticate(payload)
+  await authenticate(authentication)
 }
 
 export async function register (user) {
@@ -26,6 +36,7 @@ export async function register (user) {
 
 export async function logout () {
   try {
+    await LocalCache.removeItem('authentication')
     await api.logout()
     Store.set('user', null)
   } catch (error) {
@@ -39,15 +50,25 @@ export async function logout () {
 
 export async function restoreSession () {
   try {
-    const response = await api.reAuthenticate()
-    const user = response.user ? response.user : { name: i18n.t('composables.ANONYMOUS'), anonymous: true }
-    Store.set('user', user)
-    await updateAbilities()
+    let authentication
+    if (api.isDisconnected) {
+      authentication = await LocalCache.getItem('authentication')
+      if (authentication) {
+        // In this specific case as we bypass actual authentication the events will not be emitted
+        api.emit('login', authentication)
+        api.emit('authenticated', authentication)
+      }
+    } 
+    // In local first mode we allow to use remote service if offline information doesn't exist
+    if (!authentication) {
+      authentication = await api.reAuthenticate()
+    }
+    await authenticate(authentication)
   } catch (error) {
     // This ensure an old token is not kept e.g. when the user has been deleted
-    // await logout()
     // It actually causes a call to the remove method on the authentication service, which fails due to missing access token
     // See https://github.com/kalisio/kdk/issues/757, as a consequence we prefer to clean the token manually instead
+    // await logout()
     await api.authentication.removeAccessToken()
     // Rethrow for caller to handle
     throw error
@@ -76,14 +97,29 @@ export async function updateUser (user) {
   }
 }
 
+export async function logoutUser (user) {
+  // User has logout from another client session, logout here as well.
+  // No check required for user ID as only the target user should receive the logout event.
+  // We cannot use the logout route directly or api.logout() as this will trigger a new remove request to the authentication service.
+  // Here we just want to set the application state "as if" the user as requested a logout without doing it actually.
+  await LocalCache.removeItem('authentication')
+  await api.authentication.removeAccessToken()
+  await api.authentication.reset()
+  Store.set('user', null)
+  // In this specific case as we bypass actual authentication the events will not be emitted
+  api.emit('logout', user)
+}
+
 export function subscribeToUserChanges () {
-  // Listen to the 'patched' event on the users
+  // Listen to the 'patched'/'logout' event on the users
   const users = api.getService('users')
   users.on('patched', updateUser)
+  users.on('logout', logoutUser)
 }
 
 export function unsubscribeToUserChanges () {
-  // Listen to the 'patched' event on the users
+  // Listen to the 'patched'/'logout' event on the users
   const users = api.getService('users')
   users.off('patched', updateUser)
+  users.off('logout', logoutUser)
 }

package/core/client/utils/utils.shapes.js

@@ -86,13 +86,12 @@ export const Shapes = {
 /*
   Helper functions
 */
-function addTagAttribute (tag, attibute, value) {
-  return tag.slice(0, -1) + ` ${attibute}="${value}">`
+function addTagAttribute (tag, attribute, value) {
+  return tag.slice(0, -1) + ` ${attribute}="${value}">`
 }
-function addSvgAttribute (svg, attibute, value) {
-  return svg.slice(0, -2) + ` ${attibute}="${value}" />`
+function addSvgAttribute (svg, attribute, value) {
+  return svg.slice(0, -2) + ` ${attribute}="${value}" />`
 }
-
 function getSize (size) {
   if (!Array.isArray(size)) return { width: size, height: size }
   return { width: size[0], height: size[1] }
@@ -168,7 +167,8 @@ export function createShape (options) {
   }
   // Set div container vars
   const extraStyle = _.get(options, 'extraStyle', '')
-  const beginDivTag = `<div style="position: relative; width: ${size.width}px; height: ${size.height}px; ${extraStyle}">`
+  const idAttr = _.get(options, 'id') ? `id=${options.id}`: ''
+  const beginDivTag = `<div ${idAttr} style="position: relative; width: ${size.width}px; height: ${size.height}px; ${extraStyle}">`
   const endDivTag = '</div>'
   // Render shape
   let beginSvgTag = ''
@@ -180,16 +180,16 @@ export function createShape (options) {
     const translation = shape.translation || [0, 0]
     const rotation = shape.rotation || 0
     beginSvgTag = `<svg xmlns="http://www.w3.org/2000/svg" width="${size.width}" height="${size.height}" preserveAspectRatio="none"
-                  style="transform: translate(${translation[0]},${translation[1]}) rotate(${rotation}deg); ${extraShapeStyle}">`
+                   style="transform: translate(${translation[0]},${translation[1]}) rotate(${rotation}deg); ${extraShapeStyle}">`
     beginSvgTag = addTagAttribute(beginSvgTag, 'viewBox', _.join(shape.viewBox, ' '))
     svgShapeContent = shape.content
     svgClipPath = ''
     endSvgTag = '</svg>'
     // Apply fill style
-    const color = getHtmlColor(options.color, defaultColor)
+    const color = options.color ? getHtmlColor(options.color) : 'none'
     svgShapeContent = addSvgAttribute(svgShapeContent, 'fill', color)
     if (!_.isNil(options.opacity)) svgShapeContent = addSvgAttribute(svgShapeContent, 'fill-opacity', options.opacity)
-    // Aply stroke style
+    // Apply stroke style
     if (options.stroke) {
       // Ensure the stroke color is defined and not transparent
       const strokeColor = getHtmlColor(options.stroke.color, defaultColor)
@@ -206,10 +206,14 @@ export function createShape (options) {
         if (options.stroke.join) svgShapeContent = addSvgAttribute(svgShapeContent, 'stroke-linejoin', options.stroke.join)
         if (options.stroke.dashArray) svgShapeContent = addSvgAttribute(svgShapeContent, 'stroke-dasharray', options.stroke.dashArray)
         if (options.stroke.dashOffset) svgShapeContent = addSvgAttribute(svgShapeContent, 'stroke-dashoffset', options.stroke.dashOffset)
+        if (_.has(options, 'stroke.opacity')) svgShapeContent = addSvgAttribute(svgShapeContent, 'stroke-opacity', options.stroke.opacity)
         const clipId = uid()
         // clip the shape to avoid stroke overflow
-        svgShapeContent = addSvgAttribute(svgShapeContent, 'clip-path', `url(#${clipId})`)
-        svgClipPath = `<clipPath id="${clipId}">${_.clone(shape.content)}</clipPath>`
+        const clipPath = _.get(shape, 'clipPath', true)
+        if (clipPath) {
+          svgShapeContent = addSvgAttribute(svgShapeContent, 'clip-path', `url(#${clipId})`)
+          svgClipPath = `<clipPath id="${clipId}">${_.clone(shape.content)}</clipPath>`
+        }
       }
     }
   }

package/core/common/permissions.js

@@ -115,13 +115,14 @@ defineAbilities.unregisterHook = function (hook) {
 export function hasServiceAbilities (abilities, service) {
   if (!abilities) return false
   // The unique identifier of a service is its path not its name.
-  // Indeed we have for instance a 'groups' service in each organisation
+  // Indeed we have for instance a 'groups' service in each context
   // Take care that in client we have the service path while on server we have the actual object
   const path = typeof service === 'string' ? service : service.getPath()
   // */groups will allow to access any groups service in any context
+  const allContextsPath = _.replace(path, /^.*\//, '*/')
   return abilities.can('service', path) ||
          abilities.can('service', `*/${path}`) ||
-         abilities.can('service', _.replace(path, /^.*\//, '*/'))
+         abilities.can('service', allContextsPath)
 }
 
 export function hasResourceAbilities (abilities, operation, resourceType, context, resource) {
@@ -194,112 +195,6 @@ export function countSubjectsForResource (subjectService, resourceScope, resourc
   return subjectService.find({ query })
 }
 
-// Hook computing organisation abilities for a given user
-export function defineOrganisationAbilities (subject, can, cannot) {
-  if (subject) {
-    // Create new organisations
-    can('service', 'organisations')
-    can('create', 'organisations')
-
-    if (subject.organisations) {
-      subject.organisations.forEach(organisation => {
-        if (organisation._id) {
-          // Generic rules for resources
-          defineResourceRules(subject, organisation, 'organisations', can)
-          // Specific rules for organisations
-          const role = Roles[organisation.permissions]
-          if (role >= Roles.member) {
-            // The unique identifier of a service is its path not its name.
-            // Indeed we have for instance a 'groups' service in each organisation.
-            can('service', organisation._id.toString() + '/members')
-            can('read', 'members', { context: organisation._id })
-            can('service', organisation._id.toString() + '/tags')
-            // Tags are public
-            can('read', 'tags', { context: organisation._id })
-            // Groups are private
-            can('service', organisation._id.toString() + '/groups')
-            can('service', organisation._id.toString() + '/storage')
-            can(['read', 'create', 'remove', 'createMultipartUpload', 'completeMultipartUpload', 'uploadPart', 'putObject'], 'storage', { context: organisation._id })
-          }
-          if (role >= Roles.manager) {
-            can('update', 'members', { context: organisation._id })
-            // Managers can manage all groups/tags
-            can('all', 'groups', { context: organisation._id })
-            can(['create', 'remove'], 'authorisations', { resourcesService: organisation._id.toString() + '/groups', scope: 'groups' })
-            can('all', 'tags', { context: organisation._id })
-            // Remove invited members
-            can(['remove'], 'users', { 'sponsor.organisationId': organisation._id })
-          }
-        }
-      })
-    }
-  }
-}
-
-// Hook computing group abilities for a given user
-export function defineGroupAbilities (subject, can, cannot) {
-  if (subject) {
-    if (subject.groups) {
-      subject.groups.forEach(group => {
-        if (group._id) {
-          // Specific rules for groups
-          const role = Roles[group.permissions]
-
-          if (role >= Roles.member) {
-            can('read', 'groups', { _id: group._id })
-          }
-          if (role >= Roles.manager) {
-            can(['create', 'remove'], 'authorisations', { resource: group._id, permissions: 'member' })
-          }
-        }
-      })
-    }
-  }
-}
-
-// Helper functions to find the members of a given organisation
-export function findMembersOfOrganisation (usersService, organisationId, role) {
-  return findSubjectsForResource(usersService, 'organisations', organisationId, role)
-}
-
-export function countMembersOfOrganisation (usersService, organisationId, role) {
-  return countSubjectsForResource(usersService, 'organisations', organisationId, role)
-}
-
-// Helper functions to find the members of a given group
-export function findMembersOfGroup (membersService, groupId, role) {
-  return findSubjectsForResource(membersService, 'groups', groupId, role)
-}
-
-export function countMembersOfGroup (membersService, groupId, role) {
-  return countSubjectsForResource(membersService, 'groups', groupId, role)
-}
-
-// Helper functions to find the members with a given tag
-export function findMembersWithTag (membersService, tagId) {
-  return findSubjectsForResource(membersService, 'tags', tagId)
-}
-
-export function countMembersWithTag (membersService, tagId) {
-  return countSubjectsForResource(membersService, 'tags', tagId)
-}
-
-export function getRoleForOrganisation (user, organisationId) {
-  const result = _.find(user.organisations, { _id: organisationId })
-  if (!_.isUndefined(result)) return result.permissions
-  return undefined
-}
-
-export function getRoleForGroup (user, organisationId, groupId) {
-  const result = _.find(user.groups, { context: organisationId, _id: groupId })
-  if (!_.isUndefined(result)) return result.permissions
-  return undefined
-}
-
-export function findGroupsWithRole (user, organisationId, role) {
-  return _.filter(user.groups || [], { context: organisationId, permissions: (typeof role === 'string' ? role : RoleNames[role]) })
-}
-
 export function isSeniorRole (roleName, juniorName) {
   return Roles[roleName] >= Roles[juniorName]
 }

package/core/common/schemas/messages.update.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/messages.edit.json",
+  "description": "Messages edition schema",
+  "type": "object",
+  "properties": {
+    "body": {
+      "type": "string",
+      "minLength": 1,
+      "field": {
+        "component": "form/KTextareaField"
+      }
+    }
+  },
+  "required": ["body"]
+}

package/core/common/schemas/settings.update.json

@@ -80,7 +80,7 @@
       "group": "group-timeline",
       "field": {
         "component": "form/KSelectField",
-        "label": "schemas.TIMELINE_STEP",
+        "label": "schemas.TIMELINE_STEP",        
         "options": [
           { "label": "5m", "value": 5  },
           { "label": "10m", "value": 10 },
@@ -93,7 +93,8 @@
           { "label": "6H", "value": 360 },
           { "label": "12H", "value": 720 },
           { "label": "24H", "value": 1440 }
-        ]
+        ],
+        "clearable": false
       }
     },
     "timelineInterval": {
@@ -101,7 +102,7 @@
       "group": "group-timeline",
       "field": {
         "component": "form/KSelectField",
-        "label": "schemas.TIMELINE_INTERVAL",
+        "label": "schemas.TIMELINE_INTERVAL",        
         "options": [
           { "label": "10s", "value": 10  },
           { "label": "30s", "value": 30  },
@@ -110,7 +111,8 @@
           { "label": "10m", "value": 600 },
           { "label": "15m", "value": 900 },
           { "label": "30m", "value": 1800 }
-        ]
+        ],
+        "clearable": false
       }
     },
     "timeseriesSpan": {
@@ -118,7 +120,7 @@
       "group": "group-timeseries",
       "field": {
         "component": "form/KSelectField",
-        "label": "schemas.TIMESERIES_SPAN",
+        "label": "schemas.TIMESERIES_SPAN",      
         "options": [
           { "label": "3H", "value": 180 },
           { "label": "6H", "value": 360 },
@@ -127,7 +129,8 @@
           { "label": "48H", "value": 2880 },
           { "label": "72H", "value": 4320 },
           { "label": "96H", "value": 5760 }
-        ]
+        ],
+        "clearable": false
       }
     },
     "timeseriesGroupBy": {
@@ -139,7 +142,8 @@
         "options": [
           { "label": "schemas.TIMESERIES_GROUP_BY_VARIABLE", "value": "variable" },
           { "label": "schemas.TIMESERIES_GROUP_BY_FEATURE", "value": "feature", "selected": true }
-        ]
+        ],
+        "clearable": false
       }
     },
     "restoreView": {
@@ -167,6 +171,20 @@
         "helper": { "icon": "las la-question-circle", "url": "https://github.com/nerik/formatcoords#formatting" }
       }
     },
+    "navigator": {
+      "type": "string",
+      "group": "group-map",
+      "field": {
+        "component": "form/KSelectField",
+        "label": "schemas.NAVIGATOR_APP_LABEL",
+        "options": [
+          { "label": "Waze", "value": "waze" },
+          { "label": "Google Maps", "value": "google-maps" },
+          { "label": "Apple Plan", "value": "apple-plan" }
+        ],
+        "clearable": false
+      }
+    },
     "defaultLength": {
       "type": "string",
       "group": "group-units",
@@ -240,7 +258,8 @@
           { "label": "schemas.AUTO_NOTATION_FIELD_LABEL", "value": "auto", "selected": true },
           { "label": "schemas.FIXED_NOTATION_FIELD_LABEL", "value": "fixed" },
           { "label": "schemas.EXPONENTIAL_NOTATION_FIELD_LABEL", "value": "exponential" }
-        ]
+        ],
+        "clearable": false
       }
     },
     "defaultPrecision": {

package/core/common/utils.js

@@ -1,5 +1,7 @@
 import _ from 'lodash'
 
+export * from './utils.offline.js'
+
 // Append a parameter value to a given URL
 export function addQueryParameter (baseUrl, parameter, value) {
   // Check if this is the first parameter to be added or not

package/core/common/utils.offline.js

@@ -0,0 +1,38 @@
+import _ from 'lodash'
+import makeDebug from 'debug'
+const debug = makeDebug('kdk:core:offline')
+
+export async function makeServiceSnapshot (service, options) {
+  let { baseQuery, baseQueries, offlineService, dataPath = 'data' } = options
+  let items = []
+  // We can used a combination of queries to get data
+  if (!baseQueries) baseQueries = [baseQuery]
+  for (let i = 0; i < baseQueries.length; i++) {
+    const query = Object.assign({ $skip: 0 }, baseQueries[i])
+    debug(`[KDK] making service snapshot with query ${JSON.stringify(query)}`)
+    // Clear offline service first if required
+    if (offlineService && _.get(options, 'clear', true)) await offlineService.remove(null, { query: _.omit(baseQueries[i], ['$limit']) })
+    let result = await service.find({ query })
+    let data = _.get(result, dataPath) || result
+    // No pagination or first page
+    if (offlineService) await offlineService.create(data, { addId: false, snapshot: true })
+    items = items.concat(data)
+    // No pagination => stop here
+    if (!_.get(result, dataPath)) return items
+
+    const { total, limit } = result
+    // Remaining pages to process ?
+    while (query.$skip + data.length < total) {
+      query.$skip += limit
+      debug(`[KDK] getting service ${service.name} next page with query ${JSON.stringify(query)}`)
+      result = await service.find({ query })
+      data = _.get(result, dataPath)
+      if (offlineService) {
+        await offlineService.create(data, { addId: false, snapshot: true })
+      } else {
+        items = items.concat(data)
+      }
+    }
+  }
+  return items
+}