@kalisio/kdk 2.1.9 → 2.2.0

package/core/client/components/screen/KEndpointScreen.vue

@@ -1,80 +0,0 @@
-<template>
-  <KScreen title="KEndpointScreen.TITLE" :actions="actions">
-    <div class="column items-center q-gutter-y-md">
-      <KForm
-        ref="refForm"
-        class="full-width"
-        :schema="getFormSchema()"
-        @form-ready="onFormReady"
-      />
-      <div class="row full-width justify-around q-gutter-x-md">
-        <KAction
-          id="cancel-button"
-          label="KEndpointScreen.RESET_LABEL"
-          renderer="form-button"
-          :handler="onReset"
-        />
-        <KAction
-          id="apply-button"
-          label="KEndpointScreen.APPLY_LABEL"
-          renderer="form-button"
-          :handler="onApplied"
-        />
-      </div>
-    </div>
-  </KScreen>
-</template>
-
-<script setup>
-import _ from 'lodash'
-import config from 'config'
-import { ref } from 'vue'
-import { useRouter } from 'vue-router'
-import { api } from '../../api.js'
-import KScreen from './KScreen.vue'
-import KForm from '../form/KForm.vue'
-import KAction from '../KAction.vue'
-
-// Data
-const router = useRouter()
-const refForm = ref()
-const actions = ref(_.get(config, 'screens.endpoint.actions', []))
-
-// Functions
-function getFormSchema () {
-  return {
-    $schema: 'http://json-schema.org/draft-07/schema#',
-    $id: 'http://kalisio.xyz/schemas/change-endpoint.json#',
-    title: 'Change Endpoint form',
-    description: 'Change remote service URL form',
-    type: 'object',
-    properties: {
-      baseUrl: {
-        type: 'string',
-        format: 'uri',
-        field: {
-          component: 'form/KTextField',
-          label: 'KEndpointScreen.BASE_URL_FIELD_LABEL'
-        }
-      }
-    }
-  }
-}
-function onReset () {
-  api.setBaseUrl('')
-  router.push({ name: 'login' })
-  window.location.reload()
-}
-function onApplied (data) {
-  const result = refForm.value.validate()
-  if (result.isValid) {
-    api.setBaseUrl(result.values.baseUrl)
-    window.location.reload()
-  }
-}
-function onFormReady (form) {
-  refForm.value.fill({
-    baseUrl: api.getBaseUrl()
-  })
-}
-</script>

package/core/client/mixins/mixin.account.js

@@ -1,61 +0,0 @@
-export const account = {
-  methods: {
-    resendVerifySignup (email) {
-      return this.accountService.create({
-        action: 'resendVerifySignup',
-        value: { email }
-      })
-    },
-    verifySignup (token, email) {
-      return this.accountService.create({
-        action: 'verifySignupShort',
-        value: {
-          user: { email },
-          token
-        }
-      })
-    },
-    sendResetPassword (email) {
-      return this.accountService.create({
-        action: 'sendResetPwd',
-        value: { email }
-      })
-    },
-    resetPassword (email, token, password) {
-      return this.accountService.create({
-        action: 'resetPwdShort',
-        value: {
-          user: { email },
-          token,
-          password
-        }
-      })
-    },
-    changePassword (email, oldPassword, password) {
-      return this.accountService.create({
-        action: 'passwordChange',
-        value: {
-          user: { email },
-          oldPassword,
-          password
-        }
-      })
-    },
-    sendChangeIdentity (oldEmail, email, password) {
-      return this.accountService.create({
-        action: 'identityChange',
-        value: {
-          user: { email: oldEmail },
-          changes: { email },
-          password
-        }
-      })
-    },
-    changeIdentity (token) {
-      return this.verifySignup(token)
-    }
-  },
-  created () {
-    this.accountService = this.$api.getService('account')
-  }
-}

package/map/api/services/geocoder/geocoder.service.js

@@ -1,79 +0,0 @@
-import _ from 'lodash'
-import NodeGeocoder from 'node-geocoder'
-import makeDebug from 'debug'
-
-const debug = makeDebug('kdk:map:geocoder:service')
-
-export default function (name, app, options) {
-  // Keep track of config
-  Object.assign(options, app.get('geocoder'))
-  debug('geocoder created with config ', options)
-  let geocoders = []
-  // Single provider ?
-  if (options.providers) {
-    geocoders = options.providers.map(geocoderOptions => NodeGeocoder(geocoderOptions))
-  } else {
-    geocoders.push(NodeGeocoder(options))
-  }
-  return {
-    async geocode (geocoder, address) {
-      let results = []
-      try {
-        results = await geocoder.geocode(address)
-      } catch (error) {
-        app.logger.error(error)
-      }
-      return results
-    },
-    async reverse (geocoder, lon, lat) {
-      let results = []
-      try {
-        results = await geocoder.reverse({ lat, lon })
-      } catch (error) {
-        app.logger.error(error)
-      }
-      return results
-    },
-    async create (data, params) {
-      // We limit results to the N best ones from the different providers
-      const nbResults = _.get(this, 'paginate.default', 10)
-      debug('geocoder service called for create', data)
-      const aggregatedResults = await Promise.all(geocoders.map(async geocoder => {
-        // We want to wait for all responses ever if some fail
-        // FIXME: when definitely available in JS spec should be replaced by Promise.allSettled
-        try {
-          let results = []
-          if (data.address) {
-            results = await this.geocode(geocoder, data.address)
-          } else if (geocoder.reverse) { // All geocoders cannot do reverse geocoding
-            // We support GeoJson feature for reverse geocoding
-            const lon = _.get(data, 'lon', _.get(data, 'longitude', _.get(data, 'geometry.coordinates[0]')))
-            const lat = _.get(data, 'lat', _.get(data, 'latitude', _.get(data, 'geometry.coordinates[1]')))
-            results = await this.reverse(geocoder, lon, lat)
-          }
-          return { results }
-        } catch (error) {
-          return { error }
-        }
-      }))
-      const results = []
-      let processing = true
-      // Iterate to take best results for each provider in same order
-      while (processing) {
-        const previousCount = results.length
-        aggregatedResults.forEach(provider => {
-          if (provider.error) {
-            app.logger.error(provider.error)
-          } else {
-            // Take current best result if any
-            const bestResultForProvider = provider.results.shift()
-            if (bestResultForProvider) results.push(bestResultForProvider)
-          }
-        })
-        // Stop when no more results to be added or pagination exceeded
-        if ((previousCount === results.length) || (nbResults <= results.length)) processing = false
-      }
-      return results.splice(0, nbResults)
-    }
-  }
-}

package/map/client/components/KCaptureToolbar.vue

@@ -1,155 +0,0 @@
-<template>
-  <div class="q-pl-sm q-pr-xs row justify-center items-center no-wrap q-gutter-x-xs">
-    <q-select
-      v-model="resolution"
-      :options="getResolutions()"
-      dense
-      borderless>
-      <template v-slot:option="scope">
-        <q-item v-bind="scope.itemProps">
-          <q-item-section>
-            <q-item-label v-html="scope.opt.label" />
-          </q-item-section>
-          <q-item-section side>
-            <q-item-label caption>{{ scope.opt.description }}</q-item-label>
-          </q-item-section>
-        </q-item>
-      </template>
-    </q-select>
-    <q-input
-      v-model.number="width"
-      type="number"
-      min="256" max="4000"
-      mask="(#)###"
-      borderless
-      dense
-      input-class="text-center"
-      style="max-width: 54px"
-    />
-    <span>x</span>
-    <q-input
-      v-model.number="height"
-      type="number"
-      min="256" max="4000"
-      mask="(#)###"
-      borderless
-      dense
-      input-class="text-center"
-      style="max-width: 54px"
-    />
-    <k-action
-      id="capture-button"
-      icon="las la-camera"
-      tooltip="KCaptureToolbar.CAPTURE_ACTION"
-      :handler="() => this.capture()"
-    />
-  </div>
-</template>
-
-<script>
-import _ from 'lodash'
-import KAction from '../../../core/client/components/KAction.vue'
-import { Events, Time } from '../../../core/client'
-import { exportFile } from 'quasar'
-
-export default {
-  name: 'k-capture-toolbar',
-  components: {
-    KAction
-  },
-  inject: ['kActivity'],
-  data () {
-    return {
-      width: 1280,
-      height: 720,
-      resolution: undefined
-    }
-  },
-  watch: {
-    resolution: {
-      immediate: true,
-      handler (value) {
-        if (!value) this.resolution = this.getResolutions()[1]
-        else {
-          const size = _.split(this.resolution.value, 'x')
-          this.width = size[0]
-          this.height = size[1]
-        }
-      }
-    },
-    width: {
-      handler (value) {
-        if (value < 256) this.width = 256
-        if (value > 4000) this.width = 4000
-      }
-    },
-    height: {
-      handler (value) {
-        if (value < 256) this.height = 256
-        if (value > 4000) this.height = 4000
-      }
-    }
-  },
-  methods: {
-    getResolutions () {
-      return [
-        { label: this.$t('KCaptureToolbar.SD_LABEL'), description: this.$t('KCaptureToolbar.SD_DESCRIPTION'), value: '640x480' },
-        { label: this.$t('KCaptureToolbar.HD_LABEL'), description: this.$t('KCaptureToolbar.HD_DESCRIPTION'), value: '1280x720' },
-        { label: this.$t('KCaptureToolbar.FHD_LABEL'), description: this.$t('KCaptureToolbar.FHD_DESCRIPTION'), value: '1920x1080' },
-        { label: this.$t('KCaptureToolbar.QHD_LABEL'), description: this.$t('KCaptureToolbar.QHD_DESCRIPTION'), value: '2560x1440' },
-        { label: this.$t('KCaptureToolbar.2K_LABEL'), description: this.$t('KCaptureToolbar.2K_DESCRIPTION'), value: '2048x1080' },
-        { label: this.$t('KCaptureToolbar.4K_LABEL'), description: this.$t('KCaptureToolbar.4K_DESCRIPTION'), value: '3840x2160' }
-      ]
-    },
-    async capture () {
-      // Retrieve the layers
-      const layers = this.kActivity.getContextParameters('layers').layers
-      // Retrieve the extension
-      const bbox = this.kActivity.getContextParameters('view')
-      // Setup the request url options
-      const endpoint = this.$store.get('capabilities.api.gateway') + '/capture'
-      const options = {
-        method: 'POST',
-        mode: 'cors',
-        body: JSON.stringify({
-          activity: this.kActivity.is3D() ? 'globe' : 'map',
-          layers,
-          bbox: [bbox.west, bbox.south, bbox.east, bbox.north],
-          size: { width: +this.width, height: +this.height },
-          time: Time.getCurrentTime().toISOString()
-        }),
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      }
-      // Add the Authorization header if jwt is defined
-      const jwt = await this.$api.get('storage').getItem(this.$config('gatewayJwt'))
-      if (jwt) options.headers.Authorization = 'Bearer ' + jwt
-      // Perform the request
-      let dismiss = null
-      try {
-        dismiss = this.$q.notify({
-          group: 'capture',
-          icon: 'las la-hourglass-half',
-          message: this.$t('KCaptureToolbar.CAPTURING_VIEW'),
-          color: 'primary',
-          timeout: 0,
-          spinner: true
-        })
-        const response = await fetch(endpoint, options)
-        dismiss()
-        if (response.ok) {
-          const arrayBuffer = await response.arrayBuffer()
-          exportFile('capture.png', new Uint8Array(arrayBuffer))
-        } else {
-          Events.emit('error', { message: this.$t('errors.' + response.status) })
-        }
-      } catch (error) {
-        // Network error
-        dismiss()
-        Events.emit('error', { message: this.$t('errors.NETWORK_ERROR') })
-      }
-    }
-  }
-}
-</script>