@kalisio/kdk 2.1.5 → 2.1.7

package/core/client/search.js

@@ -1,47 +1,47 @@
-import _ from 'lodash'
-import { api } from './api.js'
-import { getIconName, processIcon } from './utils/index.js'
-
-// Export singleton
-export const Search = {
-  async query (services, pattern) {
-    const results = []
-    // Ensure the services are of type of array
-    if (!Array.isArray(services)) services = [services]
-    // Perform request for partial match to all registered services
-    const requests = _.map(services, serviceDescriptor => {
-      // Retrieve the service using the service or name key
-      const service = api.getService(serviceDescriptor.service)
-      // Build the query using given template if any
-      const query = Object.assign({}, serviceDescriptor.baseQuery)
-      // Then add partial match
-      // We don't use set by dot here because Mongo queries on nested fields
-      // require the key to contain the path and not nested objects
-      query[serviceDescriptor.field] = { $search: pattern }
-      return service.find({ query })
-    })
-    // Execute the search
-    const responses = await Promise.all(requests)
-    // Buld the result
-    for (let i = 0; i < responses.length; i++) {
-      const response = responses[i]
-      const serviceDescriptor = services[i]
-      // Process the response
-      if (response.total > 0) {
-        // Format the result
-        response.data.forEach(data => {
-          data.service = serviceDescriptor.service
-          data.field = serviceDescriptor.field
-          const icon = getIconName(data)
-          if (_.isEmpty(icon) && _.has(serviceDescriptor, 'icon')) {
-            data.icon = serviceDescriptor.icon
-            processIcon(data)
-          }
-          // And store it
-          results.push(data)
-        })
-      }
-    }
-    return results
-  }
-}
+import _ from 'lodash'
+import { api } from './api.js'
+import { getIconName, processIcon } from './utils/index.js'
+
+// Export singleton
+export const Search = {
+  async query (services, pattern) {
+    const results = []
+    // Ensure the services are of type of array
+    if (!Array.isArray(services)) services = [services]
+    // Perform request for partial match to all registered services
+    const requests = _.map(services, serviceDescriptor => {
+      // Retrieve the service using the service or name key
+      const service = api.getService(serviceDescriptor.service)
+      // Build the query using given template if any
+      const query = Object.assign({}, serviceDescriptor.baseQuery)
+      // Then add partial match
+      // We don't use set by dot here because Mongo queries on nested fields
+      // require the key to contain the path and not nested objects
+      query[serviceDescriptor.field] = { $search: pattern }
+      return service.find({ query })
+    })
+    // Execute the search
+    const responses = await Promise.all(requests)
+    // Buld the result
+    for (let i = 0; i < responses.length; i++) {
+      const response = responses[i]
+      const serviceDescriptor = services[i]
+      // Process the response
+      if (response.total > 0) {
+        // Format the result
+        response.data.forEach(data => {
+          data.service = serviceDescriptor.service
+          data.field = serviceDescriptor.field
+          const icon = getIconName(data)
+          if (_.isEmpty(icon) && _.has(serviceDescriptor, 'icon')) {
+            data.icon = serviceDescriptor.icon
+            processIcon(data)
+          }
+          // And store it
+          results.push(data)
+        })
+      }
+    }
+    return results
+  }
+}

package/core/client/services/index.js

@@ -1,49 +1,49 @@
-import _ from 'lodash'
-import LocalSettingsService from './local-settings.service.js'
-import config from 'config'
-
-export { LocalSettingsService }
-
-export default function init () {
-  const api = this
-
-  // Declare the built-in services, others are optional
-  api.declareService('users')
-  api.declareService('authorisations')
-  api.declareService('tags', { context: true })
-  api.declareService('organisations')
-  api.declareService('members', { context: true })
-  api.declareService('groups', { context: true })
-  api.declareService('storage', { context: true })
-  // TODO we use createService because of the custom methods
-  // https://github.com/kalisio/kdk/issues/781
-  api.createService('account', { methods: ['create', 'verifyEmail']})
-
-  // Setup service for settings edition
-  api.createService('settings', _.merge(config.settings || {}, {
-    service: LocalSettingsService,
-    propertyMapping: {
-      shortTime: 'time.format.time.short',
-      longTime: 'time.format.time.long',
-      shortDate: 'time.format.date.short',
-      longDate: 'time.format.date.long',
-      shortYear: 'time.format.year.short',
-      longYear: 'time.format.year.long',
-      timezone: 'time.format.timezone',
-      timelineStep: 'time.step',
-      timelineInterval: 'time.interval',
-      timeseriesSpan: 'timeseries.span',
-      location: 'locationFormat',
-      restoreView: 'restore.view',
-      restoreLayers: 'restore.layers',
-      defaultLength: 'units.default.length',
-      defaultAltitude: 'units.default.altitude',
-      defaultArea: 'units.default.area',
-      defaultVelocity: 'units.default.velocity',
-      defaultTemperature: 'units.default.temperature',
-      defaultAngle: 'units.default.angle',
-      defaultNotation: 'units.default.notation',
-      defaultPrecision: 'units.default.precision'
-    }
-  })) // Default options can be overriden from app config
-}
+import _ from 'lodash'
+import LocalSettingsService from './local-settings.service.js'
+import config from 'config'
+
+export { LocalSettingsService }
+
+export default function init () {
+  const api = this
+
+  // Declare the built-in services, others are optional
+  api.declareService('users')
+  api.declareService('authorisations')
+  api.declareService('tags', { context: true })
+  api.declareService('organisations')
+  api.declareService('members', { context: true })
+  api.declareService('groups', { context: true })
+  api.declareService('storage', { context: true })
+  // TODO we use createService because of the custom methods
+  // https://github.com/kalisio/kdk/issues/781
+  api.createService('account', { methods: ['create', 'verifyEmail']})
+
+  // Setup service for settings edition
+  api.createService('settings', _.merge(config.settings || {}, {
+    service: LocalSettingsService,
+    propertyMapping: {
+      shortTime: 'time.format.time.short',
+      longTime: 'time.format.time.long',
+      shortDate: 'time.format.date.short',
+      longDate: 'time.format.date.long',
+      shortYear: 'time.format.year.short',
+      longYear: 'time.format.year.long',
+      timezone: 'time.format.timezone',
+      timelineStep: 'time.step',
+      timelineInterval: 'time.interval',
+      timeseriesSpan: 'timeseries.span',
+      location: 'locationFormat',
+      restoreView: 'restore.view',
+      restoreLayers: 'restore.layers',
+      defaultLength: 'units.default.length',
+      defaultAltitude: 'units.default.altitude',
+      defaultArea: 'units.default.area',
+      defaultVelocity: 'units.default.velocity',
+      defaultTemperature: 'units.default.temperature',
+      defaultAngle: 'units.default.angle',
+      defaultNotation: 'units.default.notation',
+      defaultPrecision: 'units.default.precision'
+    }
+  })) // Default options can be overriden from app config
+}

package/core/client/services/local-settings.service.js

@@ -1,67 +1,67 @@
-import _ from 'lodash'
-import config from 'config'
-import { Store } from '../store.js'
-import { Events } from '../events.js'
-
-export default function (name, api, options) {
-  const mapping = options.propertyMapping
-  // We will emit also an event for all top level properties in case of nested ones
-  // This simplifies event management for some listeners instead of listening to all nested properties
-  const rootPaths = _.uniq(_.values(mapping).map(path => path.split('.')[0]))
-  const settingsKey = config.appName.toLowerCase() + '-' + (options.settingsKey || 'settings')
-  return {
-
-    async get (id) {
-      const data = {}
-      _.forOwn(mapping, (value, key) => {
-        if (value) {
-          _.set(data, key, Store.get(value))
-        }
-      })
-      return data
-    },
-
-    async patch (id, data) {
-      const previousRootValues = rootPaths.map(rootPath => Store.get(rootPath))
-      _.forOwn(data, (value, key) => {
-        if (_.get(mapping, key)) {
-          Store.set(mapping[key], value)
-        }
-      })
-      rootPaths.forEach((rootPath, index) => {
-        const eventName = _.kebabCase(`${rootPath}-changed`)
-        Events.emit(eventName, Store.get(rootPath), previousRootValues[index])
-      })
-      this.saveSettings()
-    },
-
-    saveSettings () {
-      const data = {}
-      _.forOwn(mapping, (value, key) => {
-        if (value && Store.has(value)) {
-          _.set(data, key, Store.get(value))
-        }
-      })
-      window.localStorage.setItem(settingsKey, JSON.stringify(data))
-    },
-
-    restoreSettings () {
-      let settings = window.localStorage.getItem(settingsKey)
-      if (!settings) return
-      settings = JSON.parse(settings)
-      // Backward compatibility when changed utc mode to timezone setting
-      if (_.get(settings, 'utc') && _.has(mapping, 'timezone') && !_.get(settings, 'timezone')) {
-        _.set(settings, 'timezone', 'UTC')
-      }
-      _.forOwn(mapping, (value, key) => {
-        if (value && _.has(settings, key)) {
-          Store.set(value, _.get(settings, key))
-        }
-      })
-    },
-
-    getSettingsMapping () {
-      return mapping
-    }
-  }
-}
+import _ from 'lodash'
+import config from 'config'
+import { Store } from '../store.js'
+import { Events } from '../events.js'
+
+export default function (name, api, options) {
+  const mapping = options.propertyMapping
+  // We will emit also an event for all top level properties in case of nested ones
+  // This simplifies event management for some listeners instead of listening to all nested properties
+  const rootPaths = _.uniq(_.values(mapping).map(path => path.split('.')[0]))
+  const settingsKey = config.appName.toLowerCase() + '-' + (options.settingsKey || 'settings')
+  return {
+
+    async get (id) {
+      const data = {}
+      _.forOwn(mapping, (value, key) => {
+        if (value) {
+          _.set(data, key, Store.get(value))
+        }
+      })
+      return data
+    },
+
+    async patch (id, data) {
+      const previousRootValues = rootPaths.map(rootPath => Store.get(rootPath))
+      _.forOwn(data, (value, key) => {
+        if (_.get(mapping, key)) {
+          Store.set(mapping[key], value)
+        }
+      })
+      rootPaths.forEach((rootPath, index) => {
+        const eventName = _.kebabCase(`${rootPath}-changed`)
+        Events.emit(eventName, Store.get(rootPath), previousRootValues[index])
+      })
+      this.saveSettings()
+    },
+
+    saveSettings () {
+      const data = {}
+      _.forOwn(mapping, (value, key) => {
+        if (value && Store.has(value)) {
+          _.set(data, key, Store.get(value))
+        }
+      })
+      window.localStorage.setItem(settingsKey, JSON.stringify(data))
+    },
+
+    restoreSettings () {
+      let settings = window.localStorage.getItem(settingsKey)
+      if (!settings) return
+      settings = JSON.parse(settings)
+      // Backward compatibility when changed utc mode to timezone setting
+      if (_.get(settings, 'utc') && _.has(mapping, 'timezone') && !_.get(settings, 'timezone')) {
+        _.set(settings, 'timezone', 'UTC')
+      }
+      _.forOwn(mapping, (value, key) => {
+        if (value && _.has(settings, key)) {
+          Store.set(value, _.get(settings, key))
+        }
+      })
+    },
+
+    getSettingsMapping () {
+      return mapping
+    }
+  }
+}

package/core/client/sorter.js

@@ -1,31 +1,31 @@
-import _ from 'lodash'
-import { Events } from './events.js'
-import { Store } from './store.js'
-
-// Export singleton
-export const Sorter = {
-  initialize () {
-    // This object is used to sort collections
-    Store.set('sorter', { field: 'name', order: '1', query: {} })
-    // Make filter react to external changes to update the query
-    Events.on('sorter-changed', () => this.updateSorterQuery())
-  },
-  get () {
-    return Store.get('sorter')
-  },
-  getField () {
-    return this.get().field
-  },
-  getOrder () {
-    return this.get().order
-  },
-  getQuery () {
-    return Store.get('sorter.query')
-  },
-  // Build sort query
-  updateSorterQuery () {
-    const query = { $sort: { [this.getField()]: this.getOrder() } }
-    // Avoid reentrance as we listen to other filter property changes
-    if (!_.isEqual(query, this.getQuery())) Store.patch('sorter', { query })
-  }
-}
+import _ from 'lodash'
+import { Events } from './events.js'
+import { Store } from './store.js'
+
+// Export singleton
+export const Sorter = {
+  initialize () {
+    // This object is used to sort collections
+    Store.set('sorter', { field: 'name', order: '1', query: {} })
+    // Make filter react to external changes to update the query
+    Events.on('sorter-changed', () => this.updateSorterQuery())
+  },
+  get () {
+    return Store.get('sorter')
+  },
+  getField () {
+    return this.get().field
+  },
+  getOrder () {
+    return this.get().order
+  },
+  getQuery () {
+    return Store.get('sorter.query')
+  },
+  // Build sort query
+  updateSorterQuery () {
+    const query = { $sort: { [this.getField()]: this.getOrder() } }
+    // Avoid reentrance as we listen to other filter property changes
+    if (!_.isEqual(query, this.getQuery())) Store.patch('sorter', { query })
+  }
+}

package/core/client/storage.js

@@ -1,102 +1,102 @@
-import _ from 'lodash'
-import config from 'config'
-import logger from 'loglevel'
-import { getClientService } from '@kalisio/feathers-s3/client.js'
-import { api } from './api.js'
-import { i18n } from './i18n.js'
-import { Events } from './events.js'
-import { Notify } from 'quasar'
-
-export const Storage = {
-  initialize () {
-    this.useProxy = _.get(config, 'storage.useProxy', false)
-  },
-  getService (context) {
-    // Even when service is not yet declared feathers returns a wraper
-    let service = api.getService('storage', context)
-    // So we check if it has the right methods to initialize on first call
-    if (!service.upload && !service.download) {
-      service = getClientService(api, {
-        servicePath: api.getServicePath('storage', context).substr(1),
-        transport: api.transporter,
-        fetch: window.fetch.bind(window),
-        useProxy: this.useProxy
-      })
-      service = api.createService('storage', {
-        service,
-        context,
-        methods: ['create', 'get', 'find', 'remove', 'createMultipartUpload', 'completeMultipartUpload', 'uploadPart', 'putObject']
-      })
-    }
-    return service
-  },
-  async upload (options, params) {
-    const { file, key, blob, context } = options
-    const service = this.getService(context)
-    const dismiss = Notify.create({
-      type: 'ongoing',
-      message: i18n.t('storage.UPLOADING_FILE', { file }),
-      timeout: 0
-    })
-    try {
-      const response = await service.upload(key, blob, { expiresIn: 60 }, params)
-      dismiss()
-      Events.emit('file-uploaded', { name: file, key, type: blob.type, context })
-      return response
-    } catch (error) {
-      dismiss()
-      logger.error(`Cannot upload ${key} on ${service.path}`, error)
-      throw error
-    }
-  },
-  async download (options, params) {
-    const { file, key, context, asDataUrl } = options
-    const service = this.getService(context)
-    const dismiss = Notify.create({
-      type: 'ongoing',
-      message: i18n.t('storage.DOWNLOADING_FILE', { file }),
-      color: 'info',
-      timeout: 0
-    })
-    try {
-      const response = await service.download(key, { expiresIn: 60 }, params)
-      Events.emit('file-downloaded', { name: file, key, type: response.type, context })
-      dismiss()
-      // Transform buffer into data url if required
-      return new Promise((resolve, reject) => {
-        if (asDataUrl) {
-          const reader = new FileReader()
-          reader.onload = (event) => {
-            delete response.buffer
-            response.uri = event.target.result
-            resolve(response)
-          }
-          reader.readAsDataURL(new Blob([response.buffer], { type: response.type }))
-        } else {
-          resolve(response)
-        }
-      })
-    } catch (error) {
-      dismiss()
-      logger.error(`Cannot download ${key} on ${service.path}`, error)
-      throw error
-    }
-  },
-  async getObjectUrl (options) {
-    const { key, context } = options
-    // Ensure service is created
-    const service = this.getService(context)
-    // Get proxy route to object storage
-    let url = api.getBaseUrl() + config.apiPath
-    if (service.context) url += `/${context}`
-    url += `/storage-objects/${key}`
-    // Handle extra query params
-    const query = _.get(options, 'query', {})
-    // Add the jwt to the query
-    const jwt = await api.get('storage').getItem(config.apiJwt)
-    query.jwt = jwt
-    // Transform the query params
-    url += `?${new URLSearchParams(query)}`
-    return url
-  }
-}
+import _ from 'lodash'
+import config from 'config'
+import logger from 'loglevel'
+import { getClientService } from '@kalisio/feathers-s3/client.js'
+import { api } from './api.js'
+import { i18n } from './i18n.js'
+import { Events } from './events.js'
+import { Notify } from 'quasar'
+
+export const Storage = {
+  initialize () {
+    this.useProxy = _.get(config, 'storage.useProxy', false)
+  },
+  getService (context) {
+    // Even when service is not yet declared feathers returns a wraper
+    let service = api.getService('storage', context)
+    // So we check if it has the right methods to initialize on first call
+    if (!service.upload && !service.download) {
+      service = getClientService(api, {
+        servicePath: api.getServicePath('storage', context).substr(1),
+        transport: api.transporter,
+        fetch: window.fetch.bind(window),
+        useProxy: this.useProxy
+      })
+      service = api.createService('storage', {
+        service,
+        context,
+        methods: ['create', 'get', 'find', 'remove', 'createMultipartUpload', 'completeMultipartUpload', 'uploadPart', 'putObject']
+      })
+    }
+    return service
+  },
+  async upload (options, params) {
+    const { file, key, blob, context } = options
+    const service = this.getService(context)
+    const dismiss = Notify.create({
+      type: 'ongoing',
+      message: i18n.t('storage.UPLOADING_FILE', { file }),
+      timeout: 0
+    })
+    try {
+      const response = await service.upload(key, blob, { expiresIn: 60 }, params)
+      dismiss()
+      Events.emit('file-uploaded', { name: file, key, type: blob.type, context })
+      return response
+    } catch (error) {
+      dismiss()
+      logger.error(`Cannot upload ${key} on ${service.path}`, error)
+      throw error
+    }
+  },
+  async download (options, params) {
+    const { file, key, context, asDataUrl } = options
+    const service = this.getService(context)
+    const dismiss = Notify.create({
+      type: 'ongoing',
+      message: i18n.t('storage.DOWNLOADING_FILE', { file }),
+      color: 'info',
+      timeout: 0
+    })
+    try {
+      const response = await service.download(key, { expiresIn: 60 }, params)
+      Events.emit('file-downloaded', { name: file, key, type: response.type, context })
+      dismiss()
+      // Transform buffer into data url if required
+      return new Promise((resolve, reject) => {
+        if (asDataUrl) {
+          const reader = new FileReader()
+          reader.onload = (event) => {
+            delete response.buffer
+            response.uri = event.target.result
+            resolve(response)
+          }
+          reader.readAsDataURL(new Blob([response.buffer], { type: response.type }))
+        } else {
+          resolve(response)
+        }
+      })
+    } catch (error) {
+      dismiss()
+      logger.error(`Cannot download ${key} on ${service.path}`, error)
+      throw error
+    }
+  },
+  async getObjectUrl (options) {
+    const { key, context } = options
+    // Ensure service is created
+    const service = this.getService(context)
+    // Get proxy route to object storage
+    let url = api.getBaseUrl() + config.apiPath
+    if (service.context) url += `/${context}`
+    url += `/storage-objects/${key}`
+    // Handle extra query params
+    const query = _.get(options, 'query', {})
+    // Add the jwt to the query
+    const jwt = await api.get('storage').getItem(config.apiJwt)
+    query.jwt = jwt
+    // Transform the query params
+    url += `?${new URLSearchParams(query)}`
+    return url
+  }
+}