cozy-bar 1.17.1

package/src/lib/stack-client.js

@@ -0,0 +1,401 @@
+/* eslint-env browser */
+import compare from 'semver-compare'
+import { Intents } from 'cozy-interapp'
+import getIcon from 'lib/icon'
+import initializeRealtime from 'lib/realtime'
+
+import {
+  ForbiddenException,
+  ServerErrorException,
+  NotFoundException,
+  MethodNotAllowedException,
+  UnavailableSettingsException,
+  UnavailableStackException,
+  UnauthorizedStackException
+} from 'lib/exceptions'
+import { isMobileApp } from 'cozy-device-helper'
+
+const errorStatuses = {
+  '401': UnauthorizedStackException,
+  '403': ForbiddenException,
+  '404': NotFoundException,
+  '405': MethodNotAllowedException,
+  '500': ServerErrorException
+}
+
+/**
+ * Cozy client instance
+ * @private
+ */
+let cozyClient
+
+/**
+ * Get the client instance
+ *
+ * @private
+ * @function
+ * @returns {Object} cozy-client instance
+ */
+const getIntents = function() {
+  return new Intents({ client: cozyClient })
+}
+
+/**
+ * Get the stackClient from the cozy-client instance
+ *
+ * @private
+ * @function
+ * @returns {Object} cozy-stack-client instance
+ */
+const getStackClient = function() {
+  return cozyClient.getStackClient()
+}
+
+/**
+ * Logout and disconnect the user
+ * @function
+ * @TODO move this to cozy-stack-client
+ * @returns {Promise}
+ */
+const logout = function() {
+  return getStackClient()
+    .fetch('DELETE', '/auth/login')
+    .then(resp => {
+      if (resp.status === 401) {
+        throw new UnauthorizedStackException()
+      } else if (resp.status === 204) {
+        window.location.reload()
+      }
+      return true
+    })
+    .catch(() => {
+      throw new UnavailableStackException()
+    })
+}
+
+/**
+ * Get a cozy URL object
+ *
+ * @function
+ * @returns {URL}
+ */
+const getCozyURL = function() {
+  return new URL(getStackClient().uri)
+}
+
+/**
+ * Get a the cozy origin as an URL string
+ *
+ * @function
+ * @returns {string}
+ */
+const getCozyURLOrigin = function() {
+  return getCozyURL().origin
+}
+
+/**
+ * @deprecated
+ * @private
+ */
+const updateAccessToken = function() {
+  throw new Error(
+    'updateAccessToken should not be used with a cozy-client instance initialization'
+  )
+}
+
+/**
+ * Fetch a resource with cozy-client
+ *
+ * Utility to maintain the compatibility with the legacy
+ * standalone cozy-bar client
+ *
+ * @function
+ * @private
+ * @returns {Promise} the full raw JSON payload
+ */
+const fetchJSON = function(method, path, body, options = {}) {
+  // We mirror here a few lines from cozy-stack-client
+  // because we want a customized fetchJSON
+  const headers = (options.headers = options.headers || {})
+  headers['Accept'] = 'application/json'
+  if (method !== 'GET' && method !== 'HEAD' && body !== undefined) {
+    if (!headers['Content-Type']) {
+      headers['Content-Type'] = 'application/json'
+      body = JSON.stringify(body)
+    }
+  }
+
+  return getStackClient()
+    .fetch(method, path, body, options)
+    .then(resp => {
+      if (typeof errorStatuses[resp.status] === 'function') {
+        throw new errorStatuses[resp.status]()
+      }
+      const contentType = resp.headers.get('content-type')
+      const isJson = contentType.includes('json')
+      if (!isJson) {
+        throw new Error('Server response not in JSON')
+      }
+      return resp.json()
+    })
+}
+
+/**
+ * Test if an error is from an HTTP 404
+ *
+ * @function
+ * @private
+ * @param {Function} error - received from a fetch
+ * @returns {boolean}
+ */
+const is404 = function(error) {
+  return (
+    ['NotFoundException', 'NotFound', 'FetchError'].includes(error.name) &&
+    error.status &&
+    error.status === 404
+  )
+}
+
+/**
+ * Memoize the result of a function which does an HTTP fetch
+ *
+ * If a call throws an error because the
+ * underlying HTTP request returned a 404
+ * then this function returns a default value
+ *
+ * In the absence of any other error, the result is
+ * cached and reused in the next call to the function.
+ *
+ *
+ * @function
+ * @param {Function} fn - the function to memoize. It will be
+ *                        called without any parameter
+ * @param {Object} defaultValue - returned in case of 404
+ * @returns {Function} async function
+ */
+
+const withCache = function(fn, defaultValue) {
+  let cache = undefined
+  return async function() {
+    if (cache === undefined) {
+      try {
+        cache = await fn()
+      } catch (error) {
+        cache = is404(error) ? defaultValue : undefined
+      }
+    }
+    return cache
+  }
+}
+
+/**
+ * List all installed applications
+ *
+ * Returns only the `data` key of the
+ * whole JSON payload from the server
+ *
+ * @function
+ * @returns {Promise}
+ */
+const getApps = function() {
+  return fetchJSON('GET', '/apps/').then(json => {
+    if (json.error) {
+      throw new Error(json.error)
+    }
+    return json.data
+  })
+}
+
+/**
+ * Detail of an installed application by its slug
+ *
+ * Returns only the `data` key of the
+ * whole JSON payload from the server
+ *
+ * @function
+ * @param {string} slug
+ * @returns {Promise}
+ */
+const getApp = function(slug) {
+  if (!slug) {
+    throw new Error('Missing slug')
+  }
+  return fetchJSON('GET', `/apps/${slug}`).then(json => {
+    if (json.error) {
+      throw new Error(json.error)
+    }
+    return json.data
+  })
+}
+
+/**
+ * default value when no quota is provided
+ * @private
+ */
+const defaultQuota = 10 ** 12 // 1 Tera
+
+/**
+ * Get storage and quota usage
+ *
+ * When no quota is returned by the server
+ * the quota used is the larger between
+ * `defaultQuota` and 10 * usage
+ *
+ * @function
+ * @returns {Object} {usage, quota, isLimited}
+ */
+const getStorageData = function() {
+  return fetchJSON('GET', '/settings/disk-usage')
+    .then(json => {
+      // parseInt because responses from the server are in text
+      const usage = parseInt(json.data.attributes.used, 10)
+      const realQuota = parseInt(json.data.attributes.quota, 10)
+      // @TODO this is a workaround, we should certainly do smarter
+      // and either not requiring this attribute
+      // or set it to something more real
+      const quota = realQuota || Math.max(defaultQuota, 10 * usage)
+      const isLimited = json.data.attributes.is_limited
+      return { usage, quota, isLimited }
+    })
+    .catch(() => {
+      throw new UnavailableStackException()
+    })
+}
+
+/**
+ * Fetch an icon data from its path
+ *
+ * The purpose of this function is to be sent
+ * to AppIcon components for mobile devices.
+ *
+ * @private
+ * @function
+ * @param {string} iconPath - path of the icon in the stack
+ * @returns {Blob}
+ */
+const iconFetcher = function(iconPath) {
+  return getStackClient().fetch('GET', iconPath)
+}
+
+/**
+ * Get a props object that can be sent to an AppIcon component
+ *
+ * Mobile devices and web browsers need different props
+ *
+ * @function
+ * @returns {Object}
+ */
+const getAppIconProps = function() {
+  const mobileAppIconProps = {
+    fetchIcon: app => getIcon(iconFetcher, app, true)
+  }
+
+  const browserAppIconProps = {
+    // we mustn't give the protocol here
+    domain: getCozyURL().host,
+    secure: getCozyURL().protocol === 'https:'
+  }
+  return isMobileApp() ? mobileAppIconProps : browserAppIconProps
+}
+
+/**
+ * Get settings context
+ *
+ * @function
+ * @return {Promise}
+ * @see https://docs.cozy.io/en/cozy-stack/settings/#get-settingscontext
+ */
+const getContext = function() {
+  return fetchJSON('GET', '/settings/context')
+}
+
+/**
+ * Fetch a resource on the cozy stack
+ * with a prototype compatible with the legacy cozy-client-js
+ *
+ * @function
+ * @param {object} cozy - cozy-client-js
+ * @param {string} method - HTTP method
+ * @param {string} path
+ * @param {object} body
+ * @returns {Promise}
+ */
+const cozyFetchJSON = function(cozy, method, path, body) {
+  return fetchJSON(method, path, body).then(json => {
+    const responseData = Object.assign({}, json.data)
+    if (responseData.id) {
+      responseData._id = responseData.id
+    }
+    return responseData
+  })
+}
+
+const getSettingsAppURL = function() {
+  return getApp('settings').then(settings => {
+    if (!settings) {
+      throw new UnavailableSettingsException()
+    }
+    return settings.links.related
+  })
+}
+
+/**
+ *
+ * @param {cozyClient} forcedCozyClient only used to test purpose
+ *
+ * We can not read `version` from `import CozyClient from cozy-client`
+ * since in that case, we'll read version from the cozy-bar node modules
+ * and not from the app one.
+ *
+ * In order to avoid this issue, we get the instance passed by the app to the bar),
+ * then read the constructor and then read the version from it
+ */
+const compareClientVersion = function(targetVersion, forcedCozyClient = null) {
+  const usedClient = cozyClient ? cozyClient.constructor : {}
+  const cozyClientToUse =
+    forcedCozyClient !== null ? forcedCozyClient : usedClient
+
+  if (!cozyClientToUse.version) return false
+  const result = compare(cozyClientToUse.version, targetVersion)
+  return result >= 0
+}
+
+/**
+ * Initializes the functions to call the cozy stack
+ *
+ * @function
+ * @param {Object}  arg
+ * @param {Object}  arg.cozyClient - a cozy client instance
+ * @param {Function} arg.onCreate
+ * @param {Function} arg.onDelete
+ * @returns {Promise}
+ */
+const init = function({ cozyClient: client, onCreate, onDelete }) {
+  cozyClient = client
+  if (!cozyClient.isLogged) return
+  initializeRealtime({
+    getApp,
+    onCreate,
+    onDelete,
+    cozyClient
+  })
+}
+
+export { compareClientVersion }
+
+export default {
+  get: {
+    app: getApp,
+    apps: getApps,
+    context: withCache(getContext, {}),
+    storageData: getStorageData,
+    iconProps: getAppIconProps,
+    cozyURL: getCozyURLOrigin,
+    intents: getIntents,
+    settingsAppURL: getSettingsAppURL
+  },
+  updateAccessToken,
+  cozyFetchJSON,
+  logout,
+  init
+}

package/src/lib/stack.js

@@ -0,0 +1,79 @@
+/**
+ * This file served as a proxy between the old internal stack client from the
+ * bar and the new stack-client included in cozy-client. It is no longer
+ * necessary as there is no more internal-client. It is there only temporarily
+ * and should be removed as soon as possible.
+ *
+ * @TODO remove this and update the tests.
+ */
+
+import client from 'lib/stack-client'
+
+/**
+ * Reference to the current client depending
+ * on which one has been initialized
+ *
+ * @private
+ */
+let stack
+
+/**
+ * Get the current stack client (legacy or cozy-client based)
+ * based on which one has been initialized
+ *
+ * @returns {Object} functions to call the stack
+ */
+const current = function() {
+  if (!stack) {
+    throw new Error('client not initialized in cozy-bar')
+  }
+  return stack
+}
+
+/**
+ * Initializes the functions to call the cozy stack
+ *
+ * It can be initialized either with a cozy-client instance
+ * or a { cozyURL, ssl, token } tupple.
+ *
+ * @function
+ * @param {Object}  arg
+ * @param {Object}  arg.cozyClient - a cozy client instance
+ * @param {string}  arg.cozyURL - URL or domain of the stack
+ * @param {boolean} arg.ssl     - Tells if we should use a secure protocol
+ *                            required if cozyURL does not have a protocol
+ * @param {string}  arg.token   - Access token for the stack
+ * @param {Function} arg.onCreateApp
+ * @param {Function} arg.onDeleteApp
+ * @param {Boolean} arg.isPublic
+ * @returns {Promise}
+ */
+const init = function(options) {
+  stack = client
+  return stack.init(options)
+}
+
+const get = {
+  app: (...args) => current().get.app(...args),
+  apps: (...args) => current().get.apps(...args),
+  context: (...args) => current().get.context(...args),
+  storageData: (...args) => current().get.storageData(...args),
+  iconProps: (...args) => current().get.iconProps(...args),
+  cozyURL: (...args) => current().get.cozyURL(...args),
+  settingsAppURL: (...args) => current().get.settingsAppURL(...args)
+}
+
+const stackProxy = {
+  init,
+  get,
+  updateAccessToken: (...args) => current().updateAccessToken(...args),
+  logout: (...args) => current().logout(...args),
+  cozyFetchJSON: (...args) => current().cozyFetchJSON(...args),
+  // useful to connect some getters outside of this file without exposing
+  // directly the private stack variable
+  getStack: current,
+  getIntents: () => current().get.intents()
+}
+
+export default stackProxy
+export const { cozyFetchJSON, getIntents } = stackProxy

package/src/lib/store/index.js

@@ -0,0 +1,54 @@
+/* global __DEVELOPMENT__ */
+
+import { createStore as createReduxStore, applyMiddleware } from 'redux'
+import appsI18nMiddleware from 'lib/middlewares/appsI18n'
+import thunkMiddleware from 'redux-thunk'
+import { persistStore, persistCombineReducers } from 'redux-persist'
+import { reducers } from 'lib/reducers'
+import { createLogger } from 'redux-logger'
+import storage from 'redux-persist/lib/storage'
+import persistWhitelist from 'config/persistWhitelist'
+import logger from '../logger'
+
+const config = {
+  storage,
+  key: 'cozy-bar',
+  whitelist: persistWhitelist
+}
+
+// copied and changed from https://github.com/LogRocket/redux-logger/blob/3ca9f2c1ecf17a7acf18c6fa0bbf4b6b239738f1/src/core.js#L25
+function barTitleFormatter(action, time) {
+  const parts = ['[COZY-BAR]']
+
+  parts.push(`${String(action.type)}`)
+  if (time) parts.push(`@ ${time}`)
+
+  return parts.join(' ')
+}
+
+const loggerMiddleware = createLogger({
+  titleFormatter: barTitleFormatter,
+  logger
+})
+
+const reducer = persistCombineReducers(config, { ...reducers })
+
+const middlewares = [appsI18nMiddleware, thunkMiddleware]
+
+if (__DEVELOPMENT__) middlewares.push(loggerMiddleware)
+
+export const createStore = () => {
+  store = createReduxStore(reducer, applyMiddleware.apply(null, middlewares))
+  persistStore(store)
+  return store
+}
+
+let store
+const getOrCreateStore = () => {
+  if (!store) {
+    store = createStore()
+  }
+  return store
+}
+
+export default getOrCreateStore

package/src/locales/de.json

@@ -0,0 +1,57 @@
+{
+  "drawer": "Menü anzeigen",
+  "profile": "Profile",
+  "connectedDevices": "Verbundene Geräte",
+  "storage": "Speicher",
+  "storage_phrase": "%{diskUsage} GB von %{diskQuota} GB benutzt",
+  "view_offers": "View offers",
+  "view_my_offer": "My offer",
+  "help": "Hilfe",
+  "logout": "Ausloggen",
+  "soon": "Später",
+  "error_UnavailableStack": "Der Stapel ist nicht erreichbar (Verbindung Zeitüberschreitung).",
+  "error_UnauthorizedStack": "Einige Berechtigungen fehlen, die Anwendung kann nicht auf die angeforderte Ressource auf dem Stapel zugreifen.",
+  "no_apps": "Keine Anwendungen für Cozy gefunden.",
+
+  "menu": {
+    "apps": "Anwendungen",
+    "settings": "Einstellungen",
+    "home_mobile": "Back to home...",
+    "home": "Back to home",
+    "home_title": "Home"
+  },
+
+  "Categories": {
+    "cozy": "Cozy Anwendungen",
+    "partners": "Partner Anwendungen",
+    "ptnb": "expPTNB",
+    "others": "Andere Anwendungen"
+  },
+
+  "claudy": {
+    "title": "Wie willst du dein Cozy steuern?"
+  },
+
+  "searchbar": {
+    "placeholder": "Alle Dateien durchsuchen",
+    "empty": "Es wurde kein Ergebnis für die Suche \"%{query}\" gefunden"
+  },
+
+  "permsModal": {
+    "title": "Greife von deiner Anwendung aus auf dein komplettes Cozy zu",
+    "description": "Erlaube %{app} den Zugriff auf deine Cozy Anwendungen auf diesem Gerät",
+    "button": "Erlaube Zugriff"
+  },
+  "comingSoon": {
+    "store": {
+      "title": "Die Store Anwendung wird in deinem Cozy bald verfügbar sein.",
+      "description": "Dank Cozy Store wird es bald möglich sein gewünschte Anwendungen in dein Cozy zu installieren."
+    }
+  },
+  "banner": {
+    "tos-updated": {
+      "description": "To comply with the GDPR, Cozy Cloud has updated its Terms of Services that have taken effect on May 25, 2018",
+      "CTA": "Jetzt lesen"
+    }
+  }
+}

package/src/locales/en.json

@@ -0,0 +1,57 @@
+{
+  "drawer": "Show menu drawer",
+  "profile": "Profile",
+  "connectedDevices": "Connected devices",
+  "storage": "Storage",
+  "storage_phrase": "%{diskUsage} GB of %{diskQuota} GB used",
+  "view_offers": "View offers",
+  "view_my_offer": "My offer",
+  "help": "Help",
+  "logout": "Sign out",
+  "soon": "soon",
+  "error_UnavailableStack": "The stack is unreachable (connection timed-out).",
+  "error_UnauthorizedStack": "Some permissions are missing, the application can't access the requested resource on the stack.",
+  "no_apps": "No applications found on the Cozy.",
+
+  "menu": {
+    "apps": "Apps",
+    "settings": "Settings",
+    "home_mobile": "Back to home...",
+    "home": "Back to home",
+    "home_title": "Home"
+  },
+
+  "Categories": {
+    "cozy": "Cozy apps",
+    "partners": "Partners apps",
+    "ptnb": "expPTNB",
+    "others": "Other apps"
+  },
+
+  "claudy": {
+    "title": "How to drive your Cozy?"
+  },
+
+  "searchbar": {
+    "placeholder": "Search anything",
+    "empty": "No result has been found for the query “%{query}”"
+  },
+
+  "permsModal": {
+    "title": "Access your whole Cozy from your application",
+    "description": "Authorize %{app} to display your Cozy applications on this device",
+    "button": "Authorize access"
+  },
+  "comingSoon": {
+    "store": {
+      "title": "The Store application will be available soon in your Cozy.",
+      "description": "Thanks to Cozy Store you will be able to install the applications that you want in your Cozy."
+    }
+  },
+  "banner": {
+    "tos-updated": {
+      "description": "To comply with the GDPR, Cozy Cloud has updated its Terms of Services that have taken effect on May 25, 2018",
+      "CTA": "Read now"
+    }
+  }
+}

package/src/locales/es.json

@@ -0,0 +1,57 @@
+{
+  "drawer": "Mostrar el menu lateral",
+  "profile": "Perfil",
+  "connectedDevices": "Aparatos conectados",
+  "storage": "Espacio en el disco",
+  "storage_phrase": "%{diskUsage} Go de %{diskQuota} Go",
+  "view_offers": "Ver ofertas",
+  "view_my_offer": "Mi oferta",
+  "help": "Ayuda",
+  "logout": "Desconectar",
+  "soon": "pronto",
+  "error_UnavailableStack": "Conexión a la stack imposible ( se agotó el tiempo para la conexión ).",
+  "error_UnauthorizedStack": "Faltan algunos permisos, la aplicación no puede acceder a los recursos solicitados.",
+  "no_apps": "No se han encontrado aplicaciones en su Cozy.",
+
+  "menu": {
+    "apps": "Aplicaciones",
+    "settings": "Parámetros",
+    "home_mobile": "Regresar a Inicio...",
+    "home": "Regresar a Inicio",
+    "home_title": "Inicio"
+  },
+
+  "Categories": {
+    "cozy": "Aplicaciones Cozy",
+    "partners": "Aplicaciones de asociados",
+    "ptnb": "expPTNB",
+    "others": "Otras aplicaciones"
+  },
+
+  "claudy": {
+    "title": "¿Cómo utilizar su Cozy?"
+  },
+
+  "searchbar": {
+    "placeholder": "Buscar",
+    "empty": "No se ha encontrado ningún resultado para su consulta “%{query}”"
+  },
+
+  "permsModal": {
+    "title": "Acceder a su Cozy desde su aplicación",
+    "description": "Autorizar a %{app} para mostrar sus aplicaciones Cozy en este aparato",
+    "button": "Autorizar el acceso"
+  },
+  "comingSoon": {
+    "store": {
+      "title": "En breve, la aplicación Store estará disponible en su Cozy",
+      "description": "Gracias a Cozy Store usted podrá instalar en su Cozy las aplicaciones que desee."
+    }
+  },
+  "banner": {
+    "tos-updated": {
+      "description": "Para cumplir con el RGPD, Cozy Cloud ha actualizado sus Condiciones de utilización que entraron en vigor desde el 25 de mayo de 2018.",
+      "CTA": "Leerlo ahora"
+    }
+  }
+}