rename folder extensions -> services

Signed-off-by: Christian Richter <crichter@owncloud.com>

services/settings/ui/app.js

@@ -0,0 +1,44 @@
+import 'regenerator-runtime/runtime'
+import SettingsApp from './components/SettingsApp.vue'
+import store from './store'
+import translations from './../l10n/translations.json'
+
+// just a dummy function to trick gettext tools
+function $gettext(msg) {
+  return msg
+}
+
+const appInfo = {
+  name: $gettext('Settings'),
+  id: 'settings',
+  icon: 'settings-4',
+  isFileEditor: false
+}
+
+const routes = [
+  {
+    name: 'settings',
+    path: '/:extension?',
+    component: SettingsApp
+  }
+]
+
+const navItems = [
+  {
+    name: $gettext('Settings'),
+    icon: appInfo.icon,
+    route: {
+      name: 'settings',
+      path: `/${appInfo.id}/`
+    },
+    menu: 'user'
+  }
+]
+
+export default {
+  appInfo,
+  store,
+  routes,
+  navItems,
+  translations
+}

services/settings/ui/client/settings/index.js

@@ -0,0 +1,719 @@
+/* eslint-disable */
+import axios from 'axios'
+import qs from 'qs'
+let domain = ''
+export const getDomain = () => {
+  return domain
+}
+export const setDomain = ($domain) => {
+  domain = $domain
+}
+export const request = (method, url, body, queryParameters, form, config) => {
+  method = method.toLowerCase()
+  let keys = Object.keys(queryParameters)
+  let queryUrl = url
+  if (keys.length > 0) {
+    queryUrl = url + '?' + qs.stringify(queryParameters)
+  }
+  // let queryUrl = url+(keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+  if (body) {
+    return axios[method](queryUrl, body, config)
+  } else if (method === 'get') {
+    return axios[method](queryUrl, config)
+  } else {
+    return axios[method](queryUrl, qs.stringify(form), config)
+  }
+}
+/*==========================================================
+ *
+ ==========================================================*/
+/**
+ *
+ * request: RoleService_AssignRoleToUser
+ * url: RoleService_AssignRoleToUserURL
+ * method: RoleService_AssignRoleToUser_TYPE
+ * raw_url: RoleService_AssignRoleToUser_RAW_URL
+ * @param body -
+ */
+export const RoleService_AssignRoleToUser = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/assignments-add'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const RoleService_AssignRoleToUser_RAW_URL = function() {
+  return '/api/v0/settings/assignments-add'
+}
+export const RoleService_AssignRoleToUser_TYPE = function() {
+  return 'post'
+}
+export const RoleService_AssignRoleToUserURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/assignments-add'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: RoleService_ListRoleAssignments
+ * url: RoleService_ListRoleAssignmentsURL
+ * method: RoleService_ListRoleAssignments_TYPE
+ * raw_url: RoleService_ListRoleAssignments_RAW_URL
+ * @param body -
+ */
+export const RoleService_ListRoleAssignments = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/assignments-list'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const RoleService_ListRoleAssignments_RAW_URL = function() {
+  return '/api/v0/settings/assignments-list'
+}
+export const RoleService_ListRoleAssignments_TYPE = function() {
+  return 'post'
+}
+export const RoleService_ListRoleAssignmentsURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/assignments-list'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: RoleService_RemoveRoleFromUser
+ * url: RoleService_RemoveRoleFromUserURL
+ * method: RoleService_RemoveRoleFromUser_TYPE
+ * raw_url: RoleService_RemoveRoleFromUser_RAW_URL
+ * @param body -
+ */
+export const RoleService_RemoveRoleFromUser = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/assignments-remove'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const RoleService_RemoveRoleFromUser_RAW_URL = function() {
+  return '/api/v0/settings/assignments-remove'
+}
+export const RoleService_RemoveRoleFromUser_TYPE = function() {
+  return 'post'
+}
+export const RoleService_RemoveRoleFromUserURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/assignments-remove'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: BundleService_GetBundle
+ * url: BundleService_GetBundleURL
+ * method: BundleService_GetBundle_TYPE
+ * raw_url: BundleService_GetBundle_RAW_URL
+ * @param body -
+ */
+export const BundleService_GetBundle = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/bundle-get'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const BundleService_GetBundle_RAW_URL = function() {
+  return '/api/v0/settings/bundle-get'
+}
+export const BundleService_GetBundle_TYPE = function() {
+  return 'post'
+}
+export const BundleService_GetBundleURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/bundle-get'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: BundleService_SaveBundle
+ * url: BundleService_SaveBundleURL
+ * method: BundleService_SaveBundle_TYPE
+ * raw_url: BundleService_SaveBundle_RAW_URL
+ * @param body -
+ */
+export const BundleService_SaveBundle = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/bundle-save'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const BundleService_SaveBundle_RAW_URL = function() {
+  return '/api/v0/settings/bundle-save'
+}
+export const BundleService_SaveBundle_TYPE = function() {
+  return 'post'
+}
+export const BundleService_SaveBundleURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/bundle-save'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: BundleService_AddSettingToBundle
+ * url: BundleService_AddSettingToBundleURL
+ * method: BundleService_AddSettingToBundle_TYPE
+ * raw_url: BundleService_AddSettingToBundle_RAW_URL
+ * @param body -
+ */
+export const BundleService_AddSettingToBundle = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/bundles-add-setting'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const BundleService_AddSettingToBundle_RAW_URL = function() {
+  return '/api/v0/settings/bundles-add-setting'
+}
+export const BundleService_AddSettingToBundle_TYPE = function() {
+  return 'post'
+}
+export const BundleService_AddSettingToBundleURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/bundles-add-setting'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: BundleService_ListBundles
+ * url: BundleService_ListBundlesURL
+ * method: BundleService_ListBundles_TYPE
+ * raw_url: BundleService_ListBundles_RAW_URL
+ * @param body -
+ */
+export const BundleService_ListBundles = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/bundles-list'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const BundleService_ListBundles_RAW_URL = function() {
+  return '/api/v0/settings/bundles-list'
+}
+export const BundleService_ListBundles_TYPE = function() {
+  return 'post'
+}
+export const BundleService_ListBundlesURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/bundles-list'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: BundleService_RemoveSettingFromBundle
+ * url: BundleService_RemoveSettingFromBundleURL
+ * method: BundleService_RemoveSettingFromBundle_TYPE
+ * raw_url: BundleService_RemoveSettingFromBundle_RAW_URL
+ * @param body -
+ */
+export const BundleService_RemoveSettingFromBundle = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/bundles-remove-setting'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const BundleService_RemoveSettingFromBundle_RAW_URL = function() {
+  return '/api/v0/settings/bundles-remove-setting'
+}
+export const BundleService_RemoveSettingFromBundle_TYPE = function() {
+  return 'post'
+}
+export const BundleService_RemoveSettingFromBundleURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/bundles-remove-setting'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: PermissionService_GetPermissionByID
+ * url: PermissionService_GetPermissionByIDURL
+ * method: PermissionService_GetPermissionByID_TYPE
+ * raw_url: PermissionService_GetPermissionByID_RAW_URL
+ * @param body -
+ */
+export const PermissionService_GetPermissionByID = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/permissions-get-by-id'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const PermissionService_GetPermissionByID_RAW_URL = function() {
+  return '/api/v0/settings/permissions-get-by-id'
+}
+export const PermissionService_GetPermissionByID_TYPE = function() {
+  return 'post'
+}
+export const PermissionService_GetPermissionByIDURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/permissions-get-by-id'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: PermissionService_ListPermissionsByResource
+ * url: PermissionService_ListPermissionsByResourceURL
+ * method: PermissionService_ListPermissionsByResource_TYPE
+ * raw_url: PermissionService_ListPermissionsByResource_RAW_URL
+ * @param body -
+ */
+export const PermissionService_ListPermissionsByResource = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/permissions-list-by-resource'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const PermissionService_ListPermissionsByResource_RAW_URL = function() {
+  return '/api/v0/settings/permissions-list-by-resource'
+}
+export const PermissionService_ListPermissionsByResource_TYPE = function() {
+  return 'post'
+}
+export const PermissionService_ListPermissionsByResourceURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/permissions-list-by-resource'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: RoleService_ListRoles
+ * url: RoleService_ListRolesURL
+ * method: RoleService_ListRoles_TYPE
+ * raw_url: RoleService_ListRoles_RAW_URL
+ * @param body -
+ */
+export const RoleService_ListRoles = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/roles-list'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const RoleService_ListRoles_RAW_URL = function() {
+  return '/api/v0/settings/roles-list'
+}
+export const RoleService_ListRoles_TYPE = function() {
+  return 'post'
+}
+export const RoleService_ListRolesURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/roles-list'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: ValueService_GetValue
+ * url: ValueService_GetValueURL
+ * method: ValueService_GetValue_TYPE
+ * raw_url: ValueService_GetValue_RAW_URL
+ * @param body -
+ */
+export const ValueService_GetValue = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/values-get'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const ValueService_GetValue_RAW_URL = function() {
+  return '/api/v0/settings/values-get'
+}
+export const ValueService_GetValue_TYPE = function() {
+  return 'post'
+}
+export const ValueService_GetValueURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/values-get'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: ValueService_GetValueByUniqueIdentifiers
+ * url: ValueService_GetValueByUniqueIdentifiersURL
+ * method: ValueService_GetValueByUniqueIdentifiers_TYPE
+ * raw_url: ValueService_GetValueByUniqueIdentifiers_RAW_URL
+ * @param body -
+ */
+export const ValueService_GetValueByUniqueIdentifiers = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/values-get-by-unique-identifiers'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const ValueService_GetValueByUniqueIdentifiers_RAW_URL = function() {
+  return '/api/v0/settings/values-get-by-unique-identifiers'
+}
+export const ValueService_GetValueByUniqueIdentifiers_TYPE = function() {
+  return 'post'
+}
+export const ValueService_GetValueByUniqueIdentifiersURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/values-get-by-unique-identifiers'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: ValueService_ListValues
+ * url: ValueService_ListValuesURL
+ * method: ValueService_ListValues_TYPE
+ * raw_url: ValueService_ListValues_RAW_URL
+ * @param body -
+ */
+export const ValueService_ListValues = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/values-list'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const ValueService_ListValues_RAW_URL = function() {
+  return '/api/v0/settings/values-list'
+}
+export const ValueService_ListValues_TYPE = function() {
+  return 'post'
+}
+export const ValueService_ListValuesURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/values-list'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}
+/**
+ *
+ * request: ValueService_SaveValue
+ * url: ValueService_SaveValueURL
+ * method: ValueService_SaveValue_TYPE
+ * raw_url: ValueService_SaveValue_RAW_URL
+ * @param body -
+ */
+export const ValueService_SaveValue = function(parameters = {}) {
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  const config = parameters.$config
+  let path = '/api/v0/settings/values-save'
+  let body
+  let queryParameters = {}
+  let form = {}
+  if (parameters['body'] !== undefined) {
+    body = parameters['body']
+  }
+  if (parameters['body'] === undefined) {
+    return Promise.reject(new Error('Missing required  parameter: body'))
+  }
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    });
+  }
+  return request('post', domain + path, body, queryParameters, form, config)
+}
+export const ValueService_SaveValue_RAW_URL = function() {
+  return '/api/v0/settings/values-save'
+}
+export const ValueService_SaveValue_TYPE = function() {
+  return 'post'
+}
+export const ValueService_SaveValueURL = function(parameters = {}) {
+  let queryParameters = {}
+  const domain = parameters.$domain ? parameters.$domain : getDomain()
+  let path = '/api/v0/settings/values-save'
+  if (parameters.$queryParameters) {
+    Object.keys(parameters.$queryParameters).forEach(function(parameterName) {
+      queryParameters[parameterName] = parameters.$queryParameters[parameterName]
+    })
+  }
+  let keys = Object.keys(queryParameters)
+  return domain + path + (keys.length > 0 ? '?' + (keys.map(key => key + '=' + encodeURIComponent(queryParameters[key])).join('&')) : '')
+}

services/settings/ui/components/SettingsApp.vue

@@ -0,0 +1,158 @@
+<template>
+  <div class="oc-p">
+    <main class="oc-flex oc-flex-column" id="settings-app">
+      <template v-if="initialized">
+        <oc-alert v-if="extensions.length === 0" variation="primary" no-close>
+          <p class="oc-flex oc-flex-middle">
+            <oc-icon name="information" class="oc-mr-s" />
+            <translate>No settings available</translate>
+          </p>
+        </oc-alert>
+        <template v-else>
+          <template v-if="selectedExtensionName">
+            <div class="oc-flex oc-flex-between oc-flex-middle">
+              <h1 class="oc-page-title">
+                {{ selectedExtensionName }}
+              </h1>
+            </div>
+            <hr />
+          </template>
+          <template v-if="settingsValuesLoaded">
+            <settings-bundle
+              v-for="bundle in selectedBundles"
+              :key="'bundle-' + bundle.id"
+              :bundle="bundle"
+              class="oc-mt"
+            />
+          </template>
+          <div class="oc-mt" v-else>
+            <oc-loader :aria-label="$gettext('Loading personal settings')" />
+            <oc-alert :aria-hidden="true" variation="primary" no-close>
+              <p v-translate>Loading personal settings...</p>
+            </oc-alert>
+          </div>
+        </template>
+      </template>
+      <oc-loader v-else />
+    </main>
+  </div>
+</template>
+
+<script>
+import { mapActions, mapGetters, mapMutations } from 'vuex'
+import SettingsBundle from './SettingsBundle.vue'
+
+export default {
+  name: 'SettingsApp',
+  components: { SettingsBundle },
+  data () {
+    return {
+      loading: true,
+      selectedExtension: undefined
+    }
+  },
+  computed: {
+    ...mapGetters(['settingsValuesLoaded', 'getNavItems']),
+    ...mapGetters('Settings', [
+      'extensions',
+      'initialized',
+      'getBundlesByExtension'
+    ]),
+    extensionRouteParam () {
+      return this.$route.params.extension
+    },
+    selectedExtensionName () {
+      return this.getExtensionName(this.selectedExtension)
+    },
+    selectedBundles () {
+      if (this.selectedExtension) {
+        return this.getBundlesByExtension(this.selectedExtension)
+      }
+      return []
+    }
+  },
+  methods: {
+    ...mapActions('Settings', ['initialize']),
+    ...mapMutations(['ADD_NAV_ITEM']),
+    resetSelectedExtension () {
+      if (this.extensions.length > 0) {
+        if (
+          this.extensionRouteParam &&
+          this.extensions.includes(this.extensionRouteParam)
+        ) {
+          this.selectedExtension = this.extensionRouteParam
+        } else {
+          this.selectedExtension = this.extensions[0]
+        }
+      }
+    },
+    resetMenuItems () {
+      this.extensions.forEach((extension) => {
+        /*
+         * TODO:
+         * a) set up a map with possible extensions and icons?
+         * or b) let extensions register app info like displayName + icon?
+         * https://github.com/owncloud/ocis/settings/issues/27
+         */
+        const navItem = {
+          name: this.getExtensionName(extension),
+          icon: this.getExtensionIcon(extension),
+          route: {
+            name: 'settings',
+            path: `/settings/${extension}`
+          },
+          menu: 'user'
+        }
+        this.ADD_NAV_ITEM({
+          extension: 'settings',
+          navItem
+        })
+      })
+    },
+    getExtensionName (extension) {
+      extension = extension || ''
+      switch (extension) {
+        case 'ocis-accounts':
+          return this.$gettext('Account')
+        case 'ocis-hello':
+          return this.$gettext('Hello')
+        default: {
+          const shortenedName = extension.replace('ocis-', '')
+          return shortenedName.charAt(0).toUpperCase() + shortenedName.slice(1)
+        }
+      }
+    },
+    getExtensionIcon (extension) {
+      extension = extension || ''
+      switch (extension) {
+        case 'ocis-accounts':
+          return 'team'
+        case 'ocis-hello':
+          return 'tag_faces'
+        default:
+          return 'application'
+      }
+    }
+  },
+  created () {
+    this.initialize()
+  },
+  watch: {
+    '$language.current': {
+      handler () {
+        this.resetMenuItems()
+      }
+    },
+    initialized: {
+      handler () {
+        this.resetMenuItems()
+        this.resetSelectedExtension()
+      },
+      immediate: true
+    },
+    extensionRouteParam () {
+      this.resetSelectedExtension()
+    }
+  }
+}
+</script>

services/settings/ui/components/SettingsBundle.vue

@@ -0,0 +1,80 @@
+<template>
+  <div class="oc-width-1-1 oc-width-2-3@m oc-width-1-2@l oc-width-1-3@xl">
+    <h2 class="oc-mb-s">
+      <translate>{{ bundle.displayName }}</translate>
+    </h2>
+    <oc-grid gutter="small">
+      <template>
+        <div
+          class="oc-width-1-1"
+          v-for="setting in bundle.settings"
+          :key="setting.id"
+        >
+          <label class="oc-label" :for="setting.id">{{
+            setting.displayName
+          }}</label>
+          <div
+            class="oc-position-relative"
+            :is="getSettingComponent(setting)"
+            :id="setting.id"
+            :bundle="bundle"
+            :setting="setting"
+            :persisted-value="getValue(setting)"
+            @onSave="onSaveValue"
+          />
+        </div>
+      </template>
+    </oc-grid>
+  </div>
+</template>
+
+<script>
+import assign from 'lodash-es/assign'
+import { mapGetters, mapActions } from 'vuex'
+import SettingBoolean from './settings/SettingBoolean.vue'
+import SettingMultiChoice from './settings/SettingMultiChoice.vue'
+import SettingNumber from './settings/SettingNumber.vue'
+import SettingSingleChoice from './settings/SettingSingleChoice.vue'
+import SettingString from './settings/SettingString.vue'
+import SettingUnknown from './settings/SettingUnknown.vue'
+export default {
+  name: 'SettingsBundle',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    }
+  },
+  computed: mapGetters(['getSettingsValue']),
+  methods: {
+    ...mapActions('Settings', ['saveValue']),
+    getSettingComponent (setting) {
+      return 'Setting' + setting.type[0].toUpperCase() + setting.type.slice(1)
+    },
+    getValue (setting) {
+      return this.getSettingsValue({ settingId: setting.id })
+    },
+    async onSaveValue ({ bundle, setting, payload }) {
+      payload = assign({}, payload, {
+        bundleId: bundle.id,
+        settingId: setting.id,
+        accountUuid: 'me',
+        resource: setting.resource
+      })
+      await this.saveValue({
+        bundle,
+        setting,
+        payload
+      })
+    }
+  },
+  components: {
+    SettingBoolean,
+    SettingMultiChoice,
+    SettingNumber,
+    SettingSingleChoice,
+    SettingString,
+    SettingUnknown
+  }
+}
+</script>

services/settings/ui/components/settings/SettingBoolean.vue

@@ -0,0 +1,55 @@
+<template>
+  <div>
+    <oc-checkbox v-model="value" :label="setting.boolValue.label" @change="applyValue" />
+  </div>
+</template>
+
+<script>
+import isNil from 'lodash-es/isNil'
+export default {
+  name: 'SettingBoolean',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  },
+  data () {
+    return {
+      value: null
+    }
+  },
+  methods: {
+    async applyValue () {
+      const payload = {
+        boolValue: this.value
+      }
+      if (!isNil(this.persistedValue)) {
+        payload.id = this.persistedValue.id
+      }
+      await this.$emit('onSave', {
+        bundle: this.bundle,
+        setting: this.setting,
+        payload
+      })
+      // TODO: show a spinner while the request for saving the value is running!
+    }
+  },
+  mounted () {
+    if (!isNil(this.persistedValue)) {
+      this.value = this.persistedValue.boolValue
+    }
+    if (isNil(this.value) && !isNil(this.setting.boolValue.default)) {
+      this.value = this.setting.boolValue.default
+    }
+  }
+}
+</script>

services/settings/ui/components/settings/SettingMultiChoice.vue

@@ -0,0 +1,106 @@
+<template>
+  <oc-select
+      v-model="selectedOptions"
+      :clearable="false"
+      :options="displayOptions"
+      @input="onSelectedOption"
+      multiple
+  />
+</template>
+
+<script>
+import isNil from 'lodash-es/isNil'
+export default {
+  name: 'SettingMultiChoice',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  },
+  data () {
+    return {
+      selectedOptions: []
+    }
+  },
+  computed: {
+    displayOptions () {
+      return this.setting.multiChoiceValue.options.map(val => val.displayValue)
+    }
+  },
+  methods: {
+    async onSelectedOption () {
+      const values = []
+      if (!isNil(this.selectedOptions)) {
+        this.selectedOptions.forEach(displayValue => {
+          const option = this.setting.multiChoiceValue.options.find(val => val.displayValue === displayValue)
+
+          if (option.value.intValue) {
+            values.push({ intValue: option.value.intValue })
+          }
+          if (option.value.stringValue) {
+            values.push({ stringValue: option.value.stringValue })
+          }
+        })
+      }
+      const payload = {
+        listValue: {
+          values
+        }
+      }
+      if (!isNil(this.persistedValue)) {
+        payload.id = this.persistedValue.id
+      }
+      await this.$emit('onSave', {
+        bundle: this.bundle,
+        setting: this.setting,
+        payload
+      })
+      // TODO: show a spinner while the request for saving the value is running!
+    }
+  },
+  mounted () {
+    if (!isNil(this.persistedValue) && !isNil(this.persistedValue.listValue)) {
+      const selectedValues = []
+      if (this.persistedValue.listValue.values) {
+        this.persistedValue.listValue.values.forEach(value => {
+          if (value.intValue) {
+            selectedValues.push(value.intValue)
+          }
+          if (value.stringValue) {
+            selectedValues.push(value.stringValue)
+          }
+        })
+      }
+      if (selectedValues.length === 0) {
+        this.selectedOptions = []
+      } else {
+        this.selectedOptions = this.setting.multiChoiceValue.options.filter(option => {
+          if (option.value.intValue) {
+            return selectedValues.includes(option.value.intValue)
+          }
+          if (option.value.stringValue) {
+            return selectedValues.includes(option.value.stringValue)
+          }
+          return false
+        }).map(val => val.displayValue)
+      }
+    }
+    // TODO: load the settings value of the authenticated user and set it in `selectedOptions`
+    // if not set, yet, apply defaults from settings bundle definition
+    if (this.selectedOptions === null) {
+      this.selectedOptions = this.setting.multiChoiceValue.options
+        .filter(option => option.default)
+        .map(val => val.displayValue)
+    }
+  }
+}
+</script>

services/settings/ui/components/settings/SettingNumber.vue

@@ -0,0 +1,97 @@
+<template>
+  <oc-grid flex>
+    <div class="oc-width-expand">
+      <oc-text-input
+        type="number"
+        v-model="value"
+        v-bind="inputAttributes"
+        :placeholder="setting.intValue.placeholder"
+        :label="setting.description"
+        @keydown.enter="applyValue"
+        @keydown.esc="cancel"
+      />
+    </div>
+    <div v-if="isChanged">
+      <oc-button @click="cancel" class="oc-ml-s">
+        <translate>Cancel</translate>
+      </oc-button>
+      <oc-button @click="applyValue" class="oc-ml-s" variation="primary">
+        <translate>Save</translate>
+      </oc-button>
+    </div>
+  </oc-grid>
+</template>
+
+<script>
+import isNil from 'lodash-es/isNil'
+export default {
+  name: 'SettingNumber',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  },
+  data () {
+    return {
+      initialValue: null,
+      value: null
+    }
+  },
+  computed: {
+    isChanged () {
+      return this.initialValue !== this.value
+    },
+    inputAttributes () {
+      const attributes = {}
+      if (!isNil(this.setting.intValue.min)) {
+        attributes.min = this.setting.intValue.min
+      }
+      if (!isNil(this.setting.intValue.max)) {
+        attributes.max = this.setting.intValue.max
+      }
+      if (!isNil(this.setting.intValue.step)) {
+        attributes.step = this.setting.intValue.step
+      }
+      return attributes
+    }
+  },
+  methods: {
+    cancel () {
+      this.value = this.initialValue
+    },
+    async applyValue () {
+      const payload = {
+        intValue: this.value
+      }
+      if (!isNil(this.persistedValue)) {
+        payload.id = this.persistedValue.id
+      }
+      await this.$emit('onSave', {
+        bundle: this.bundle,
+        setting: this.setting,
+        payload
+      })
+      // TODO: show a spinner while the request for saving the value is running!
+      this.initialValue = this.value
+    }
+  },
+  mounted () {
+    if (!isNil(this.persistedValue)) {
+      this.value = this.persistedValue.intValue
+    }
+    if (isNil(this.value) && !isNil(this.setting.intValue.default)) {
+      this.value = this.setting.intValue.default
+    }
+    this.initialValue = this.value
+  }
+}
+</script>

services/settings/ui/components/settings/SettingSingleChoice.vue

@@ -0,0 +1,92 @@
+<template>
+  <div>
+    <oc-select
+        v-model="selectedOption"
+        :clearable="false"
+        :options="displayOptions"
+        @input="onSelectedOption"
+       />
+  </div>
+</template>
+
+<script>
+import isNil from 'lodash-es/isNil'
+export default {
+  name: 'SettingSingleChoice',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  },
+  data () {
+    return {
+      selectedOption: null
+    }
+  },
+  computed: {
+    displayOptions () {
+      return this.setting.singleChoiceValue.options.map(val => val.displayValue)
+    }
+  },
+  methods: {
+    async onSelectedOption () {
+      const values = []
+      if (!isNil(this.selectedOption)) {
+        const option = this.setting.singleChoiceValue.options.find(val => val.displayValue === this.selectedOption)
+
+        if (option.value.intValue) {
+          values.push({ intValue: option.value.intValue })
+        }
+        if (option.value.stringValue) {
+          values.push({ stringValue: option.value.stringValue })
+        }
+      }
+      const payload = {
+        listValue: {
+          values
+        }
+      }
+      if (!isNil(this.persistedValue)) {
+        payload.id = this.persistedValue.id
+      }
+      await this.$emit('onSave', {
+        bundle: this.bundle,
+        setting: this.setting,
+        payload
+      })
+      // TODO: show a spinner while the request for saving the value is running!
+    }
+  },
+  mounted () {
+    if (!isNil(this.persistedValue) && !isNil(this.persistedValue.listValue)) {
+      const selected = this.persistedValue.listValue.values[0]
+      const filtered = this.setting.singleChoiceValue.options.filter(option => {
+        if (selected.intValue) {
+          return option.value.intValue === selected.intValue
+        } else {
+          return option.value.stringValue === selected.stringValue
+        }
+      })
+      if (filtered.length > 0) {
+        this.selectedOption = filtered[0].displayValue
+      }
+    }
+    // if not set, yet, apply default from settings bundle definition
+    if (isNil(this.selectedOption)) {
+      const defaults = this.setting.singleChoiceValue.options.filter(option => option.default)
+      if (defaults.length === 1) {
+        this.selectedOption = defaults[0].displayValue
+      }
+    }
+  }
+}
+</script>

services/settings/ui/components/settings/SettingString.vue

@@ -0,0 +1,82 @@
+<template>
+  <oc-grid flex>
+    <div class="oc-width-expand">
+      <oc-text-input
+        v-model="value"
+        :placeholder="setting.stringValue.placeholder"
+        :label="setting.description"
+        @keydown.enter="applyValue"
+        @keydown.esc="cancel"
+      />
+    </div>
+    <div v-if="isChanged">
+      <oc-button @click="cancel" class="oc-ml-s">
+        <translate>Cancel</translate>
+      </oc-button>
+      <oc-button @click="applyValue" class="oc-ml-s" variation="primary">
+        <translate>Save</translate>
+      </oc-button>
+    </div>
+  </oc-grid>
+</template>
+
+<script>
+import isNil from 'lodash-es/isNil'
+export default {
+  name: 'SettingString',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  },
+  data () {
+    return {
+      initialValue: null,
+      value: null
+    }
+  },
+  computed: {
+    isChanged () {
+      return this.initialValue !== this.value
+    }
+  },
+  methods: {
+    async applyValue () {
+      const payload = {
+        stringValue: this.value
+      }
+      if (!isNil(this.persistedValue)) {
+        payload.id = this.persistedValue.id
+      }
+      await this.$emit('onSave', {
+        bundle: this.bundle,
+        setting: this.setting,
+        payload
+      })
+      // TODO: show a spinner while the request for saving the value is running!
+      this.initialValue = this.value
+    },
+    cancel () {
+      this.value = this.initialValue
+    }
+  },
+  mounted () {
+    if (!isNil(this.persistedValue)) {
+      this.value = this.persistedValue.stringValue
+    }
+    if (isNil(this.value) && !isNil(this.setting.stringValue.default)) {
+      this.value = this.setting.stringValue.default
+    }
+    this.initialValue = this.value
+  }
+}
+</script>

services/settings/ui/components/settings/SettingUnknown.vue

@@ -0,0 +1,25 @@
+<template>
+  <div>
+    <translate :translate-params="{ type: setting.type }">Settings type not implemented: %{type}</translate>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'SettingUnknown',
+  props: {
+    bundle: {
+      type: Object,
+      required: true
+    },
+    setting: {
+      type: Object,
+      required: true
+    },
+    persistedValue: {
+      type: Object,
+      required: false
+    }
+  }
+}
+</script>

services/settings/ui/dictionary.js

@@ -0,0 +1,14 @@
+/**
+ * This file contains strings that should be synced to transifex but not exist in the UI directly,
+ * moreover, they get loaded for example by API requests
+ */
+
+// just a dummy function to trick gettext tools
+function $gettext (msg) {
+  return msg
+}
+
+// eslint-disable-next-line no-unused-vars
+const dictionary = [
+  $gettext('Language')
+]

services/settings/ui/store/index.js

@@ -0,0 +1,125 @@
+import {
+  // eslint-disable-next-line camelcase
+  BundleService_ListBundles,
+  // eslint-disable-next-line camelcase
+  ValueService_SaveValue
+} from '../client/settings'
+import axios from 'axios'
+import keyBy from 'lodash-es/keyBy'
+
+const state = {
+  initialized: false,
+  bundles: {}
+}
+
+const getters = {
+  initialized: state => state.initialized,
+  extensions: state => {
+    return [...new Set(Object.values(state.bundles).map(bundle => bundle.extension))].sort()
+  },
+  getBundlesByExtension: state => extension => {
+    return Object.values(state.bundles)
+      .filter(bundle => bundle.extension === extension)
+      .sort((b1, b2) => {
+        return b1.name.localeCompare(b2.name)
+      })
+  },
+  getServerForJsClient: (state, getters, rootState, rootGetters) => rootGetters.configuration.server.replace(/\/$/, '')
+}
+
+const mutations = {
+  SET_INITIALIZED (state, value) {
+    state.initialized = value
+  },
+  SET_BUNDLES (state, bundles) {
+    state.bundles = keyBy(bundles, 'id')
+  }
+}
+
+const actions = {
+  async initialize ({ commit, dispatch }) {
+    await dispatch('fetchBundles')
+    commit('SET_INITIALIZED', true)
+  },
+
+  async fetchBundles ({ commit, dispatch, getters, rootGetters }) {
+    injectAuthToken(rootGetters)
+    try {
+      const response = await BundleService_ListBundles({
+        $domain: getters.getServerForJsClient,
+        body: {}
+      })
+      if (response.status === 201) {
+        // the settings markup has implicit typing. inject an explicit type variable here
+        const bundles = response.data.bundles
+        if (bundles) {
+          bundles.forEach(bundle => {
+            bundle.settings.forEach(setting => {
+              if (setting.intValue) {
+                setting.type = 'number'
+              } else if (setting.stringValue) {
+                setting.type = 'string'
+              } else if (setting.boolValue) {
+                setting.type = 'boolean'
+              } else if (setting.singleChoiceValue) {
+                setting.type = 'singleChoice'
+              } else if (setting.multiChoiceValue) {
+                setting.type = 'multiChoice'
+              } else {
+                setting.type = 'unknown'
+              }
+            })
+          })
+          commit('SET_BUNDLES', bundles)
+        } else {
+          commit('SET_BUNDLES', [])
+        }
+      }
+    } catch (err) {
+      dispatch('showMessage', {
+        title: 'Failed to fetch bundles.',
+        status: 'danger'
+      }, { root: true })
+    }
+  },
+
+  async saveValue ({ commit, dispatch, getters, rootGetters }, { setting, payload }) {
+    injectAuthToken(rootGetters)
+    try {
+      const response = await ValueService_SaveValue({
+        $domain: getters.getServerForJsClient,
+        body: {
+          value: payload
+        }
+      })
+      if (response.status === 201 && response.data.value) {
+        commit('SET_SETTINGS_VALUE', response.data.value, { root: true })
+      }
+    } catch (e) {
+      dispatch('showMessage', {
+        title: `Failed to save »${setting.displayName}«.`,
+        status: 'danger'
+      }, { root: true })
+    }
+  }
+}
+
+export default {
+  namespaced: true,
+  state,
+  getters,
+  actions,
+  mutations
+}
+
+function injectAuthToken (rootGetters) {
+  axios.interceptors.request.use(config => {
+    if (typeof config.headers.Authorization === 'undefined') {
+      const token = rootGetters.user.token
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`
+      }
+    }
+    return config
+  })
+}

services/settings/ui/tests/acceptance/features/settings.feature

@@ -0,0 +1,46 @@
+Feature: Set user specific settings
+	As a user
+	I want to set user specific settings
+	So that I can customize my OCIS experience to my liking
+
+	Background:
+		Given these users have been created with default attributes and without skeleton files in the server:
+			| username |
+			| user1    |
+			| user2    |
+		And user "user1" has created folder "simple-folder" in the server
+
+	Scenario: Check the default settings
+		Given user "user1" has logged in using the webUI
+		And the user browses to the settings page
+		Then the setting "Language" should have value "English"
+		When the user browses to the files page
+		Then the files menu should be listed in language "English"
+
+	Scenario: changing the language (reactive and with page reload)
+		Given user "user1" has logged in using the webUI
+		And the user browses to the settings page
+		When the user changes the language to "Deutsch"
+		Then the setting "Language" should have value "Deutsch"
+		When the user browses to the files page
+		Then the files menu should be listed in language "Deutsch"
+		And the account menu should be listed in language "Deutsch"
+		And the files header should be displayed in language "Deutsch"
+		When the user reloads the current page of the webUI
+		Then the files menu should be listed in language "Deutsch"
+		And the account menu should be listed in language "Deutsch"
+		And the files header should be displayed in language "Deutsch"
+		When the user browses to the settings page
+		And the user changes the language to "English"
+		And the user browses to the files page
+		Then the files menu should be listed in language "English"
+
+	Scenario: changing the language only affects one user
+		Given user "user2" has logged in using the webUI
+		And the user browses to the settings page
+		When the user changes the language to "Español"
+		Then the setting "Language" should have value "Español"
+		When the user browses to the files page
+		Then the files menu should be listed in language "Español"
+		When the user re-logs in as "user1" using the webUI
+		Then the files menu should be listed in language "English"

services/settings/ui/tests/acceptance/helpers/language.js

@@ -0,0 +1,108 @@
+const filesMenu = {
+  English: [
+    'Personal',
+    'Shares',
+    'Spaces\nbeta',
+    'Deleted files'
+  ],
+  Deutsch: [
+    'Persönlich',
+    'Geteilt',
+    'Spaces\nbeta',
+    'Gelöschte Dateien'
+  ],
+  Español: [
+    'Personal',
+    'Shares',
+    'Spaces\nbeta',
+    'Archivos borrados'
+  ],
+  Français: [
+    'Personal',
+    'Shares',
+    'Spaces\nbeta',
+    'Fichiers supprimés'
+  ]
+}
+
+const accountMenu = {
+  English: [
+    'N\nnull\nuser1@example.com',
+    'Settings',
+    'Log out',
+    'Personal storage (0.2% used)\n5.06 GB of 2.85 TB used'
+  ],
+  Deutsch: [
+    'N\nnull\nuser1@example.com',
+    'Einstellungen',
+    'Abmelden',
+    'Persönlicher Speicher (0.2% benutzt)\n5.06 GB von 2.85 TB benutzt'
+  ],
+  Español: [
+    'N\nnull\nuser1@example.com',
+    'Configuración',
+    'Salir',
+    'Personal storage (0.2% used)\n5.06 GB of 2.85 TB used'
+  ],
+  Français: [
+    'N\nnull\nuser1@example.com',
+    'Settings',
+    'Se déconnecter',
+    'Personal storage (0.2% used)\n5.06 GB of 2.85 TB used'
+  ]
+}
+
+const filesListHeaderMenu = {
+  English: [
+    'Name',
+    'Shares',
+    'Size',
+    'Modified',
+    'Actions'
+  ],
+  Deutsch: [
+    'Name',
+    'Geteilt',
+    'Größe',
+    'Bearbeitet',
+    'Aktionen'
+  ],
+  Español: [
+    'Nombre',
+    'Shares',
+    'Tamaño',
+    'Modificado',
+    'Acciones'
+  ],
+  Français: [
+    'Nom',
+    'Shares',
+    'Taille',
+    'Modifié',
+    'Actions'
+  ]
+}
+
+exports.getFilesMenuForLanguage = function (language) {
+  const menuList = filesMenu[language]
+  if (menuList === undefined) {
+    throw new Error(`Menu for language ${language} is not available`)
+  }
+  return menuList
+}
+
+exports.getUserMenuForLanguage = function (language) {
+  const menuList = accountMenu[language]
+  if (menuList === undefined) {
+    throw new Error(`Menu for language ${language} is not available`)
+  }
+  return menuList
+}
+
+exports.getFilesHeaderMenuForLanguage = function (language) {
+  const menuList = filesListHeaderMenu[language]
+  if (menuList === undefined) {
+    throw new Error(`Menu for language ${language} is not available`)
+  }
+  return menuList
+}

services/settings/ui/tests/acceptance/pageobjects/filesPageSettingsContext.js

@@ -0,0 +1,79 @@
+module.exports = {
+  commands: {
+    getMenuList: async function () {
+      const menu = []
+      await this.isVisible('@openNavigationBtn', (res) => {
+        if (res.value) {
+          this.click('@openNavigationBtn')
+        }
+      })
+      await this.waitForElementVisible('@fileSidebarNavItem')
+      await this.api
+        .elements('@fileSidebarNavItem', result => {
+          result.value.map(item => {
+            this.api.elementIdText(item.ELEMENT, res => {
+              menu.push(res.value)
+            })
+          })
+        })
+      return menu
+    },
+    getUserMenu: async function () {
+      const menu = []
+      await this
+        .waitForElementVisible('@userMenuBtn')
+        .click('@userMenuBtn')
+        .waitForElementVisible('@userMenuContainer')
+      await this.api
+        .elements('@userMenuItem', result => {
+          result.value.map(item => {
+            this.api.elementIdText(item.ELEMENT, res => {
+              menu.push(res.value)
+            })
+          })
+        })
+      await this
+        .click('@userMenuBtn')
+        .waitForElementNotPresent('@userMenuContainer')
+      return menu
+    },
+    getFileHeaderItems: async function () {
+      const menu = []
+      await this.waitForElementVisible('@fileTableHeaderItems')
+      await this.api
+        .elements('@fileTableHeaderItems', result => {
+          result.value.map(item => {
+            this.api.elementIdText(item.ELEMENT, res => {
+              menu.push(res.value)
+            })
+          })
+        })
+      return menu
+    }
+  },
+
+  elements: {
+    pageHeader: {
+      selector: '.oc-page-title'
+    },
+    fileSidebarNavItem: {
+      selector: '.oc-sidebar-nav-item'
+    },
+    openNavigationBtn: {
+      selector: '.oc-app-navigation-toggle'
+    },
+    userMenuBtn: {
+      selector: '#_userMenuButton'
+    },
+    userMenuItem: {
+      selector: '#account-info-container li'
+    },
+    userMenuContainer: {
+      selector: '#account-info-container'
+    },
+    fileTableHeaderItems: {
+      selector: '//*[@id="files-personal-table"]//th[not(.//div)]',
+      locateStrategy: 'xpath'
+    }
+  }
+}

services/settings/ui/tests/acceptance/pageobjects/settingsPage.js

@@ -0,0 +1,82 @@
+const { client } = require('nightwatch-api')
+
+module.exports = {
+  url: function () {
+    return this.api.launchUrl + '/settings'
+  },
+
+  commands: {
+    navigateAndWaitTillLoaded: async function () {
+      const url = this.url()
+      await await this.navigate(url)
+      while (true) {
+        let found = false
+        await this.waitForElementVisible('@pageHeader', 2000, 500, false)
+        await this.api
+          .elements('@pageHeader', result => {
+            if (result.value.length) {
+              found = true
+            }
+          })
+        if (found) {
+          break
+        }
+        await client.refresh()
+      }
+      return this.waitForElementVisible('@pageHeader')
+    },
+
+    getSettingsValue: async function (key) {
+      let output
+      switch (key) {
+        case 'Language':
+          let elemfound = true
+
+          // Language value is set to empty at beginning
+          // In that case just return false
+          await this.api.element('@languageValue', result => {
+            if (result.status < 0) {
+              elemfound = false
+            }
+          })
+          if (!elemfound) {
+            output = false
+            break
+          }
+          await this.waitForElementVisible('@languageValue')
+            .getText('@languageValue', (result) => {
+              output = result.value
+            })
+          break
+        default:
+          throw new Error('failed to find the setting')
+      }
+      return output
+    },
+    changeSettings: async function (key, value) {
+      switch (key) {
+        case 'Language':
+          await this
+            .waitForElementVisible('@languageInput')
+            .setValue('@languageInput', value + '\n')
+          break
+        default:
+          throw new Error('failed to find the setting')
+      }
+    }
+  },
+
+  elements: {
+    pageHeader: {
+      selector: '.oc-page-title'
+    },
+    languageValue: {
+      selector: "//label[.='Language']/..//span[@class='vs__selected']",
+      locateStrategy: 'xpath'
+    },
+    languageInput: {
+      selector: "//label[.='Language']/..//input",
+      locateStrategy: 'xpath'
+    }
+  }
+}

services/settings/ui/tests/acceptance/stepDefinitions/settingsContext.js

@@ -0,0 +1,40 @@
+const assert = require('assert')
+const { client } = require('nightwatch-api')
+const { Given, When, Then } = require('@cucumber/cucumber')
+const languageHelper = require('../helpers/language')
+
+Given('the user browses to the settings page', function () {
+  return client.page.settingsPage().navigateAndWaitTillLoaded()
+})
+
+Then('the setting {string} should have value {string}', async function (setting, result) {
+  const actual = await client.page.settingsPage().getSettingsValue(setting)
+  assert.strictEqual(actual, result, 'The setting value doesnt matches to ' + result)
+})
+
+Then('the setting {string} should not have any value', async function (setting) {
+  const actual = await client.page.settingsPage().getSettingsValue(setting)
+  assert.strictEqual(actual, false, 'The setting value was expected not to be present but was')
+})
+
+When('the user changes the language to {string}', async function (value) {
+  await client.page.settingsPage().changeSettings('Language', value)
+})
+
+Then('the files menu should be listed in language {string}', async function (language) {
+  const menu = await client.page.filesPageSettingsContext().getMenuList()
+  const expected = languageHelper.getFilesMenuForLanguage(language)
+  assert.deepStrictEqual(menu, expected, 'the menu list were not same')
+})
+
+Then('the account menu should be listed in language {string}', async function (language) {
+  const menu = await client.page.filesPageSettingsContext().getUserMenu()
+  const expected = languageHelper.getUserMenuForLanguage(language)
+  assert.deepStrictEqual(menu, expected, 'the menu list were not same')
+})
+
+Then('the files header should be displayed in language {string}', async function (language) {
+  const items = await client.page.filesPageSettingsContext().getFileHeaderItems()
+  const expected = languageHelper.getFilesHeaderMenuForLanguage(language)
+  assert.deepStrictEqual(items, expected, 'the menu list were not same')
+})

services/settings/ui/tests/run-acceptance-test.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+if [ -z "$WEB_PATH" ]
+then
+	echo "WEB_PATH env variable is not set, cannot find files for tests infrastructure"
+	exit 1
+fi
+
+if [ -z "$WEB_UI_CONFIG" ]
+then
+	echo "WEB_UI_CONFIG env variable is not set, cannot find web config file"
+	exit 1
+fi
+
+if [ -z "$1" ]
+then
+	echo "Features path not given, exiting test run"
+	exit 1
+fi
+
+trap clean_up SIGHUP SIGINT SIGTERM
+
+if [ -z "$TEST_INFRA_DIRECTORY" ]
+then
+	cleanup=true
+	testFolder=$(mktemp -d -p .)
+	printf "creating folder $testFolder for Test infrastructure setup\n\n"
+	export TEST_INFRA_DIRECTORY=$(realpath $testFolder)
+fi
+
+clean_up() {
+	if $cleanup
+	then
+		if [ -d "$testFolder" ]; then
+			printf "\n\n\n\nDeleting folder $testFolder Test infrastructure setup..."
+			rm -rf "$testFolder"
+		fi
+	fi
+}
+
+trap clean_up SIGHUP SIGINT SIGTERM EXIT
+
+cp -r $(ls -d "$WEB_PATH"/tests/acceptance/* | grep -v 'node_modules') "$testFolder"
+
+export SERVER_HOST=${SERVER_HOST:-https://localhost:9200}
+export BACKEND_HOST=${BACKEND_HOST:-https://localhost:9200}
+export TEST_TAGS=${TEST_TAGS:-"not @skip"}
+
+yarn run acceptance-tests "$1"
+
+status=$?
+exit $status