@open-xchange/soap-client 0.0.1

package/.env.default

@@ -0,0 +1,16 @@
+# URL to the App Suite Middleware for e2e-provisioning via SOAP
+PROVISIONING_URL=https://appsuite-main.dev.oxui.de/
+
+# URL to the App Suite UI for e2e-tests
+LAUNCH_URL=https://core-ui-main.dev.oxui.de
+
+# admin credentials for e2e middleware
+E2E_ADMIN_USER=
+E2E_ADMIN_PW=
+
+# Flag to enable/disable debug output for SOAP requests
+DEBUG_SOAP=false
+
+MX_DOMAIN=box.ox.io
+
+PROVSIONING_API=common

package/bin/provision.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import { program } from 'commander'
+import dotenv from 'dotenv'
+import * as secondaryAccountService from '../services/secondaryAccount.js'
+import * as userService from '../services/common/user.js'
+import * as contextService from '../services/common/context.js'
+
+dotenv.config({ path: '.env' })
+dotenv.config({ path: '.env.defaults' })
+
+const contextAdmin = {
+  admin: {
+    name: 'oxadmin',
+    password: 'secret',
+    display_name: 'context admin',
+    sur_name: 'admin',
+    given_name: 'context',
+    email1: `oxadmin@${process.env.MX_DOMAIN}`,
+    primaryEmail: `oxadmin@${process.env.MX_DOMAIN}`,
+    login: 'oxadmin'
+  }
+}
+
+function checkEnvironmentVariables () {
+  const neededEnvironmentVariables = ['PROVISIONING_URL', 'E2E_ADMIN_USER', 'E2E_ADMIN_PW', 'MX_DOMAIN']
+  for (const envVar of neededEnvironmentVariables) {
+    if (!process.env[envVar]) {
+      console.error(`Environment variable ${envVar} is required`)
+      process.exit(1)
+    }
+  }
+}
+
+async function getOrCreateContext (data) {
+  const contextData = { ...{ maxQuota: -1 }, ...data }
+  let context
+  try {
+    const existingContext = await contextService.list(contextData.id || contextData.name)
+
+    if (existingContext?.length > 0) {
+      console.log('Context already exists, using existing one')
+      context = existingContext[0]
+    } else {
+      console.log('Creating new context')
+      context = await contextService.create(contextData)
+    }
+    return {
+      ...context,
+      ...contextAdmin
+    }
+  } catch (error) {
+    console.error('Error in context operation:', error)
+    throw error
+  }
+}
+
+async function getOrCreateUser (context, userData) {
+  try {
+    const existingUser = await userService.list(context, userData.display_name)
+    if (existingUser?.length > 0) {
+      console.log('User already exists, using existing one')
+      return existingUser[0]
+    }
+    console.log('Creating new user')
+    return await userService.create(context, userData)
+  } catch (error) {
+    console.error('Error in user operation:', error)
+    throw error
+  }
+}
+
+async function getOrCreateSecondaryAccount (accountData, context, users) {
+  try {
+    const existingAccounts = (await secondaryAccountService.list(context, users)).filter(acc => acc.name === accountData.name)
+    if (existingAccounts?.length > 0) {
+      const usersWithoutAccount = users.filter(user => {
+        const hasAccount = existingAccounts.some(acc => acc.userId === user.id)
+        return !hasAccount
+      })
+      if (usersWithoutAccount.length === 0) return existingAccounts[0]
+      return await secondaryAccountService.create(accountData, context, usersWithoutAccount)
+    }
+    console.log('Creating new secondary account')
+    return await secondaryAccountService.create(accountData, context, users)
+  } catch (error) {
+    console.error('Error in secondary account operation:', error)
+    throw error
+  }
+}
+
+async function provisionFromFile (configPath) {
+  checkEnvironmentVariables()
+  let config
+  const createdUsers = []
+
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+  } catch (err) {
+    console.error('Failed to read config file:', err)
+    process.exit(1)
+  }
+
+  for (const contexts of config.contexts || []) {
+    try {
+      const contextData = contexts.data
+      const context = await getOrCreateContext(contexts.data.name)
+
+      if (contextData.capabilities) {
+        try {
+          await contextService.changeCapabilities(context.id, contextData.capabilities, undefined)
+          console.log('Changed capabilities for context:', context.id)
+        } catch (capError) {
+          console.error('Error changing capabilities for context', context.id, capError)
+        }
+      }
+
+      if (contextData.config) {
+        try {
+          await contextService.change({ id: context.id, userAttributes: contextData.config })
+          console.log('Changed config for context:', context.id)
+        } catch (cfgError) {
+          console.error('Error changing config for context:', context.id, cfgError)
+        }
+      }
+
+      for (const userData of (contexts.users || [])) {
+        try {
+          const user = await getOrCreateUser(context, userData)
+          createdUsers.push(user)
+          console.log('Provisioned user:', user && user.id)
+        } catch (userError) {
+          console.error('Error provisioning user', userData.display_name, userError)
+        }
+      }
+
+      for (const secondaryAccount of (contexts.secondaryAccounts || [])) {
+        try {
+          const userIds = createdUsers.map(user => ({ id: user.id }))
+          const secAccount = await getOrCreateSecondaryAccount(secondaryAccount, context, userIds)
+          console.log('Provisioned secondary account:', secAccount?.primaryAddress)
+        } catch (accError) {
+          console.error('Error provisioning secondary account for context', context.id, accError)
+        }
+      }
+    } catch (ctxError) {
+      console.error('Error provisioning context', contexts.name, ctxError)
+    }
+  }
+}
+
+program
+  .version('1.0.0')
+  .description('OX Provisioning Tool')
+
+program
+  .option('-f, --file <path>', 'Path to provisioning JSON config file', './provisioning.json')
+  .action(async (options) => {
+    await provisionFromFile(options.file)
+  })
+
+program
+  .command('create <resourceType>')
+  .description('Create a resource (context, user, account)')
+  .option('-n, --name <name>', 'Name (for context, user or account)')
+  .option('-c, --context-id <id>', 'Context ID (for user or account)')
+  .option('-e, --email <email>', 'Email address (for user and account)')
+  .option('-q, --quota <quota>', 'Max quota in MB (for context)')
+  .option('--capabilities <capabilities>', 'Comma-separated capabilities (for context)')
+  .option('-p, --password <password>', 'Password (for user)', 'secret')
+  .option('-g, --given-name <name>', 'Given name (for user)', 'Test')
+  .option('-s, --sur-name <name>', 'Surname (for user)', 'User')
+  .option('-d, --display-name <name>', 'Display name (for user)')
+  .option('-u, --users <ids>', 'Comma-separated user IDs (for account)')
+  .action(async (resourceType, options) => {
+    checkEnvironmentVariables()
+
+    try {
+      switch (resourceType) {
+        case 'context': {
+          const contextData = {
+            name: options.name,
+            maxQuota: options.quota ? parseInt(options.quota) : -1
+          }
+          const context = await getOrCreateContext(contextData)
+
+          if (options.capabilities) {
+            console.log('Setting capabilities for context:', options.capabilities)
+            await contextService.changeCapabilities(context.id, options.capabilities, undefined)
+            console.log('Capabilities set for context:', context.id)
+          }
+          break
+        }
+        case 'user': {
+          if (!options.contextId || !options.email) {
+            console.error('--context-id and --email is required for user creation')
+            process.exit(1)
+          }
+
+          const userData = {
+            name: options.name,
+            primaryEmail: options.email,
+            email1: options.email,
+            given_name: options.givenName || 'Test',
+            sur_name: options.surName || 'User',
+            display_name: options.displayName || 'Test User',
+            password: options.password || 'secret'
+          }
+
+          const context = await getOrCreateContext({ id: options.contextId })
+          await getOrCreateUser(context, userData)
+
+          break
+        }
+        case 'account': {
+          if (!options.contextId || !options.name || !options.email || !options.users) {
+            console.error('--name, --email, --context-id, and --users are required for account creation')
+            process.exit(1)
+          }
+
+          const accountData = {
+            name: options.name,
+            login: options.email,
+            primaryAddress: options.email,
+            mailEndpointSource: 'primary',
+            transportEndpointSource: 'primary',
+            personal: options.name
+          }
+
+          const contextData = await contextService.get(options.contextId)
+          const context = { ...contextData, ...contextAdmin }
+          const userIds = options.users.split(',').map(id => ({ id }))
+          await getOrCreateSecondaryAccount(accountData, context, userIds)
+          break
+        }
+        default:
+          console.error('Unknown resource type. Must be one of: context, user, account')
+          process.exit(1)
+      }
+    } catch (error) {
+      console.error(`Error creating ${resourceType}:`, error)
+      process.exit(1)
+    }
+  })
+
+program
+  .command('delete <resourceType>')
+  .description('Delete a resource (context, user, account)')
+  .option('--id <id>', 'ID of the resource (for context or user)')
+  .option('-c, --context-id <id>', 'Context ID (for user or account)')
+  .option('-e, --email <email>', 'Primary address (for account)')
+  .option('-u, --users <ids>', 'Comma-separated user IDs (for account)')
+  .action(async (resourceType, options) => {
+    checkEnvironmentVariables()
+
+    try {
+      switch (resourceType) {
+        case 'context':
+          if (!options.id) {
+            console.error('--id is required for context deletion')
+            process.exit(1)
+          }
+          await contextService.remove(options.id)
+          console.log('Context deleted successfully:', options.id)
+          break
+
+        case 'user': {
+          if (!options.contextId || !options.id) {
+            console.error('--context-id and --id are required for user deletion')
+            process.exit(1)
+          }
+          const contextData = await contextService.get(options.contextId)
+          const context = { ...contextData, ...contextAdmin }
+          await userService.remove(context, options.id)
+          console.log('User deleted successfully:', options.id)
+          break
+        }
+        case 'account': {
+          if (!options.contextId || !options.email) {
+            console.error('--context-id and --primary-address are required for account deletion')
+            process.exit(1)
+          }
+          const contextData = await contextService.get(options.contextId)
+          const context = { ...contextData, ...contextAdmin }
+          const users = options.users ? options.users.split(',').map(id => ({ id })) : []
+          await secondaryAccountService.remove(options.email, context, users)
+          console.log('Secondary account deleted successfully:', options.primaryAddress)
+          break
+        }
+        default:
+          console.error('Unknown resource type. Must be one of: context, user, account')
+          process.exit(1)
+      }
+    } catch (error) {
+      console.error(`Error deleting ${resourceType}:`, error)
+      process.exit(1)
+    }
+  })
+
+program.parse(process.argv)

package/example-provisioning.json

@@ -0,0 +1,55 @@
+{
+  "contexts": [
+    {
+      "data": {
+        "name": "test",
+        "capabilities": "switchboard,ai-service,spreadsheet,text,document_preview,presentation,presenter,remote_presenter",
+        "config": {
+          "entries": [{
+            "key": "config",
+            "value": {
+              "entries": [
+                { "key": "io.ox/core//ai/openai/useAzure", "value": "false" }
+              ]
+            }
+          }]
+        }
+      },
+      "users": [
+        {
+          "name": "testuser",
+          "primaryEmail": "testuser-123@box.ox.io",
+          "display_name": "Test User",
+          "imapLogin": "testuser-123",
+          "imapServer": "main-dovecot",
+          "smtpServer": "main-postfix",
+          "email1": "testuser-123@box.ox.io",
+          "password": "secret",
+          "sur_name": "User",
+          "given_name": "Test"
+        },
+        {
+          "name": "testuser124",
+          "primaryEmail": "testuser-124@box.ox.io",
+          "display_name": "Test User",
+          "imapLogin": "testuser-124",
+          "imapServer": "main-dovecot",
+          "smtpServer": "main-postfix",
+          "email1": "testuser-124@box.ox.io",
+          "password": "secret",
+          "sur_name": "User",
+          "given_name": "Test124"
+        }
+      ],
+      "secondaryAccount":
+        {
+          "name": "info123",
+          "login": "info123@box.ox.io",
+          "primaryAddress": "info123@box.ox.io",
+          "mailEndpointSource": "primary",
+          "transportEndpointSource": "primary",
+          "personal": "Info 123"
+        }
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@open-xchange/soap-client",
+  "version": "0.0.1",
+  "description": "SOAP client for OX App Suite",
+  "main": "index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/openxchange/appsuite/web-foundation/tools",
+    "directory": "packages/soap-client"
+  },
+  "exports": {
+    "./common": "./services/common/index.js",
+    "./reseller": "./services/reseller/index.js"
+  },
+  "bin": {
+    "provision": "./bin/provision.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "AGPL-3.0-or-later",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.5",
+    "p-retry": "^6.2.1",
+    "soap": "^1.1.10"
+  },
+  "devDependencies": {
+    "@open-xchange/lint": "0.2.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "provision": "node ./bin/provision.js"
+  }
+}

package/services/common/context.js

@@ -0,0 +1,157 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync, logSoapError } from '../../soap.js'
+
+const OXContextService = createClientAsync('OXContextService').then(client => client)
+
+/**
+ * This function retrieves the default context from the OXContextService.
+ * @returns {Promise<Object>} The first result from the listAsync method call.
+ */
+export async function getDefault () {
+  return (await (await OXContextService).listAsync({ search_pattern: 'defaultcontext' }))[0]
+}
+
+/**
+ * This function removes the context with the specified ID.
+ * @param {number} id The ID of the context to remove.
+ * @returns {Promise<Boolean>} Returns true if it could remove the context and false if it could not
+ */
+export async function remove (id) {
+  return !!await (await OXContextService).deleteAsync({ ctx: { id } }).then(() => true).catch(logSoapError)
+}
+
+/**
+ * This function creates a new context.
+ * @param {Object} ctx The context to create.
+ * @param {Object} adminUser The admin user of the context.
+ *    Defaults to:
+ *    ```JSON
+ *    {
+        name: 'oxadmin',
+        password: 'secret',
+        display_name: 'context admin',
+        sur_name: 'admin',
+        given_name: 'context',
+        email1: `oxadmin@${process.env.MX_DOMAIN}`,
+        primaryEmail: `oxadmin@${process.env.MX_DOMAIN}`
+      }
+      All properties are needed and will be inserted if not provided.
+      ```
+ * @returns {Promise<Object>} The created context.
+ */
+export async function create (ctx = {}, adminUser = {}) {
+  return await (await OXContextService)
+    .createAsync({
+      ctx,
+      admin_user: Object.assign({
+        name: 'oxadmin',
+        password: 'secret',
+        display_name: 'context admin',
+        sur_name: 'admin',
+        given_name: 'context',
+        email1: `oxadmin@${process.env.MX_DOMAIN}`,
+        primaryEmail: `oxadmin@${process.env.MX_DOMAIN}`
+      }, adminUser)
+    })
+    .then(async context => {
+      await changeModuleAccessByName(context.id, 'all')
+      return context
+    })
+    .catch(e => {
+      logSoapError(e)
+      throw e
+    })
+}
+
+/**
+ * This function changes the module access of the specified context.
+ * @param {number} id The ID of the context.
+ * @param {string} access_combination_name The name of the access combination to set.
+ * @returns {Promise<void>}
+ */
+// eslint-disable-next-line camelcase
+export async function changeModuleAccessByName (id, access_combination_name) {
+  // eslint-disable-next-line camelcase
+  return await (await OXContextService).changeModuleAccessByNameAsync({ ctx: { id }, access_combination_name })
+}
+
+/**
+ * This function changes the capabilities of the specified context.
+ * @param {number} id The ID of the context.
+ * @param {string} capsToAdd The capabilities to add.
+ * @param {string} capsToRemove The capabilities to remove.
+ * @returns {Promise<void>}
+ */
+export async function changeCapabilities (id, capsToAdd, capsToRemove) {
+  const data = {}
+  if (capsToAdd) data.capsToAdd = capsToAdd
+  if (capsToRemove) data.capsToRemove = capsToRemove
+  return await (await OXContextService).changeCapabilitiesAsync({ ctx: { id }, ...data })
+}
+
+/**
+ * This function retrieves the module access of the specified context.
+ * @param {number} id The ID of the context.
+ * @returns {Promise<Object>} The module access of the specified context.
+ */
+export async function getModuleAccess (id) {
+  return await (await OXContextService).getModuleAccessAsync({ ctx: { id } })
+}
+/**
+ * This function changes the module access of the specified context.
+ * @param {number} id The ID of the context.
+ * @param {Object} moduleAccess The module access to set.
+ * @returns {Promise<void>}
+ */
+export async function changeModuleAccess (id, moduleAccess) {
+  const currentAccess = await getModuleAccess(id)
+  return await (await OXContextService).changeModuleAccessAsync({ ctx: { id }, access: { ...currentAccess, ...moduleAccess } })
+}
+
+/**
+ * Search for contexts.
+ * @param {String} searchPattern The pattern to search for
+ * @param {Object} options Additional options
+ * @param {Boolean} options.excludeDisabled Exclude disabled contexts from the search results (default: true)
+ * @returns {Promise<Array<Object>>} The list of contexts that match the search pattern.
+ */
+export async function list (searchPattern, { excludeDisabled } = { excludeDisabled: true }) {
+  return await (await OXContextService).listAsync({ search_pattern: searchPattern, exclude_disabled: excludeDisabled })
+}
+
+/**
+ * This function retrieves the context with the specified ID.
+ * @param {number} id The ID of the context to retrieve.
+ * @returns {Promise<Object>} The context with the specified ID.
+ */
+export async function get (id) {
+  return await (await OXContextService).getDataAsync({ ctx: { id } })
+}
+
+/**
+ * This function changes the context with the specified ID.
+ * @param {Object} ctx The context to change.
+ * @returns {Promise<void>}
+ */
+export async function change (ctx) {
+  return await (await OXContextService).changeAsync({ ctx })
+}

package/services/common/index.js

@@ -0,0 +1,11 @@
+import * as contextService from './context.js'
+import * as userService from './user.js'
+import { getFilestorageId } from './util.js'
+import * as secondaryAccountService from '../secondaryAccount.js'
+
+export {
+  contextService,
+  userService,
+  secondaryAccountService,
+  getFilestorageId
+}

package/services/common/user.js

@@ -0,0 +1,121 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync, logSoapError } from '../../soap.js'
+
+const OXUserService = createClientAsync('OXUserService').then(client => client)
+
+/**
+ * This function removes the user with the specified context and user ID.
+ * @param {Object} context The context of the user to be removed.
+ * @param {number} userId The ID of the user to be removed.
+ * @returns {Promise<Boolean>} Returns true if it could remove the user and false if it could not
+ */
+export async function remove (context, userId) {
+  return !!await (await OXUserService).deleteAsync({
+    ctx: { id: context.id },
+    user: { id: userId },
+    auth: context.admin
+  }).then(() => true).catch(logSoapError)
+}
+
+/**
+ * This function creates a new user.
+ * @param {Object} context The context of the user to be created.
+ * @param {Object} usrdata The user to create.
+ * @returns {Promise<Object>} The created user.
+ */
+export async function create (context, usrdata) {
+  return await (await OXUserService).createAsync({
+    ctx: { id: context.id },
+    usrdata,
+    auth: context.admin
+  })
+}
+
+/**
+ * This function changes the context with the specified ID.
+ * @param {Object} context The context of the user to be changed.
+ * @param {Object} usrdata The user to change.
+ * @returns {Promise<void>}
+ */
+export async function change (context, usrdata) {
+  return await (await OXUserService).changeAsync({
+    ctx: { id: context.id },
+    usrdata,
+    auth: context.admin
+  })
+}
+
+export async function changeByModuleAccess (context, userId, currentAccess, moduleAccess) {
+  return await (await OXUserService).changeByModuleAccessAsync({
+    ctx: { id: context.id },
+    moduleAccess: Object.assign({}, currentAccess, moduleAccess),
+    user: { id: userId },
+    auth: context.admin
+  })
+}
+
+export async function changeByModuleAccessName (context, userId, accessCombinationName) {
+  return await (await OXUserService).changeByModuleAccessNameAsync({
+    ctx: { id: context.id },
+    access_combination_name: accessCombinationName,
+    user: { id: userId },
+    auth: context.admin
+  }).catch(error => console.error('Module access change error:', error))
+}
+
+export async function getModuleAccess (context, userId) {
+  return await (await OXUserService).getModuleAccessAsync({
+    ctx: { id: context.id },
+    user: { id: userId },
+    auth: context.admin
+  }).then(
+    (res) => res
+  )
+}
+
+export async function changeCapabilities (context, userId, capsToAdd, capsToRemove) {
+  const data = {
+    ctx: { id: context.id },
+    user: { id: userId },
+    auth: context.admin
+  }
+  if (capsToAdd) data.capsToAdd = capsToAdd
+  if (capsToRemove) data.capsToRemove = capsToRemove
+  return await (await OXUserService).changeCapabilitiesAsync(data)
+}
+
+export async function exists (context, userId) {
+  return await (await OXUserService).existsAsync({
+    ctx: { id: context.id },
+    user: { id: userId },
+    auth: context.admin
+  })
+}
+
+export async function list (context, searchPattern, includeGuests = false) {
+  return await (await OXUserService).listAsync({
+    ctx: { id: context.id },
+    search_pattern: searchPattern,
+    include_guests: includeGuests,
+    auth: context.admin
+  })
+}

package/services/common/util.js

@@ -0,0 +1,35 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync } from '../../soap.js'
+
+/**
+ * This function retrieves the ID of the first filestorage.
+ * @returns {Promise<number>} The ID of the first filestorage.
+ */
+let fileStoreId
+
+export async function getFilestorageId () {
+  const OXUtilService = createClientAsync('OXUtilService').then(client => client)
+
+  if (fileStoreId) return fileStoreId
+  fileStoreId = (await (await OXUtilService).listFilestoreAsync())[0]?.id
+  return fileStoreId
+}

package/services/reseller/index.js

@@ -0,0 +1,11 @@
+import * as oxaasService from './oxaas.js'
+import * as resellerContextService from './resellerContext.js'
+import * as resellerUserService from './resellerUser.js'
+import * as secondaryAccountService from '../secondaryAccount.js'
+
+export {
+  oxaasService,
+  resellerContextService,
+  resellerUserService,
+  secondaryAccountService
+}

package/services/reseller/oxaas.js

@@ -0,0 +1,31 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync } from '../../soap.js'
+
+const OXaaSService = createClientAsync('OXaaSService').then(client => client)
+
+export async function setMailQuota (data) {
+  return await (await OXaaSService).setMailQuotaAsync(data)
+}
+
+export async function createSharedDomain (data) {
+  return await (await OXaaSService).createSharedDomain(data)
+}

package/services/reseller/resellerContext.js

@@ -0,0 +1,55 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync, logSoapError } from '../../soap.js'
+
+const OXResellerContextService = createClientAsync('OXResellerContextService').then(client => client)
+
+export async function create (data) {
+  return await (await OXResellerContextService).createAsync(data)
+}
+
+export async function remove (contextId) {
+  return !!await (await OXResellerContextService).deleteAsync({
+    ctx: { id: contextId }
+  }).then(() => true).catch(logSoapError)
+}
+
+export async function change (ctx) {
+  return await (await OXResellerContextService).changeAsync({ ctx })
+}
+
+export async function get (id) {
+  return await (await OXResellerContextService).getDataAsync({ ctx: { id } })
+}
+
+export async function getModuleAccess (id) {
+  return await (await OXResellerContextService).getModuleAccessAsync({ ctx: id })
+}
+
+export async function changeModuleAccess (id, access) {
+  const currentAccess = await getModuleAccess(id)
+
+  return await (await OXResellerContextService).changeModuleAccessAsync({ ctx: { id }, access: { ...currentAccess, ...access } })
+}
+
+export async function listAll (data) {
+  return await (await OXResellerContextService).listAllAsync(data)
+}

package/services/reseller/resellerUser.js

@@ -0,0 +1,89 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { createClientAsync, logSoapError } from '../../soap.js'
+
+const OXResellerUserService = createClientAsync('OXResellerUserService').then(client => client)
+
+export async function remove (contextId, userId) {
+  return !!await (await OXResellerUserService).deleteAsync({
+    ctx: { id: contextId },
+    user: { id: userId }
+  }).then(() => true).catch(logSoapError)
+}
+
+/**
+ * This function changes the context with the specified ID.
+ * @param {Object} context The context of the user to be changed.
+ * @param {Object} usrdata The user to change.
+ * @returns {Promise<void>}
+ */
+export async function change (context, usrdata) {
+  return await (await OXResellerUserService).changeAsync({
+    ctx: { id: context.id },
+    usrdata,
+    auth: { login: context.admin.name, password: context.admin.password }
+  })
+}
+
+export async function get (data) {
+  return await (await OXResellerUserService).getDataAsync(data)
+}
+
+export async function getModuleAccess (context, userId) {
+  return await (await OXResellerUserService).getModuleAccessAsync({
+    ctx: { id: context.id },
+    user: { id: userId },
+    auth: { login: context.admin.name, password: context.admin.password }
+  }).then(
+    (res) => res
+  )
+}
+
+export async function changeByModuleAccess (context, userId, currentAccess, moduleAccess) {
+  return await (await OXResellerUserService).changeByModuleAccessAsync({
+    ctx: { id: context.id },
+    moduleAccess: Object.assign({}, currentAccess, moduleAccess),
+    user: { id: userId },
+    auth: { login: context.admin.name, password: context.admin.password }
+  })
+}
+
+export async function changeByModuleAccessName (context, userId, accessCombinationName) {
+  return await (await OXResellerUserService).changeByModuleAccessNameAsync({
+    ctx: { id: context.id },
+    access_combination_name: accessCombinationName,
+    user: { id: userId },
+    auth: { login: context.admin.name, password: context.admin.password }
+  }).catch(error => console.error('Module access change error: ', error))
+}
+
+export async function createByModuleAccessName (context, usrdata) {
+  return await (await OXResellerUserService).createByModuleAccessNameAsync({
+    ctx: { id: context.id },
+    usrdata,
+    access_combination_name: 'all',
+    auth: { login: context.admin.name, password: context.admin.password }
+  })
+}
+
+export async function listAll (data) {
+  return await (await OXResellerUserService).listAllAsync(data)
+}

package/services/secondaryAccount.js

@@ -0,0 +1,48 @@
+import { createClientAsync } from '../soap.js'
+
+const OXSecondaryAccountService = createClientAsync('OXSecondaryAccountService').then(client => client)
+
+/**
+ * Creates a secondary account using the OX Secondary Account Service
+ * @async
+ * @param {Object} accountData - The data for the secondary account to be created
+ * @param {Object} context - The context object where the account will be created
+ * @param {Array<Object>} users - Array of users to associate with the secondary account
+ * @param {Array<Object>} groups - Array of groups to associate with the secondary account
+ * @returns {Promise<Object>} The created secondary account object
+ * @throws {Error} If the account creation fails
+ */
+export async function create (accountData, context, users = [], groups = []) {
+  return await (await OXSecondaryAccountService).createAsync({
+    accountDataOnCreate: accountData,
+    context: { id: context.id },
+    users: users || [],
+    auth: context.admin
+  })
+}
+
+export async function list (context) {
+  return await (await OXSecondaryAccountService).listAsync({
+    context: { id: context.id },
+    auth: context.admin
+  })
+}
+export async function remove (primaryAddress, context, users, groups) {
+  return await (await OXSecondaryAccountService).deleteAsync({
+    primaryAddress,
+    context: { id: context.id },
+    users,
+    auth: context.admin
+  })
+}
+
+export async function update (primaryAddress, accountData, context, users, groups) {
+  return await (await OXSecondaryAccountService).updateAsync({
+    primaryAddress,
+    accountDataUpdate: accountData,
+    context: { id: context.id },
+    users,
+    groups,
+    auth: context.admin
+  })
+}

package/soap.js

@@ -0,0 +1,171 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+import { performance, PerformanceObserver } from 'node:perf_hooks'
+import * as SOAP from 'soap'
+import dotenv from 'dotenv'
+import pRetry, { AbortError as RetryAbortError } from 'p-retry'
+
+// Set AbortError correctly
+const AbortError = RetryAbortError
+
+dotenv.config({ path: '.env' })
+dotenv.config({ path: '.env.defaults' })
+
+// This flag enables debug output including timing information.
+const debug = process.env.DEBUG_SOAP === 'true'
+
+// This URL is used to create the SOAP client.
+const provisioningUrl = String(process.env.PROVISIONING_URL).replace(/\/$/, '')
+
+// This user is used to authenticate against the provisioning API.
+const provisioningAuth = {
+  auth: {
+    login: process.env.E2E_ADMIN_USER,
+    password: process.env.E2E_ADMIN_PW
+  }
+}
+
+/**
+ * This code creates a PerformanceObserver instance which asynchronously observes
+ * performance measurement events. It logs the name of the event (which is the name
+ * of the SOAP method in this context) and the time it took to execute in milliseconds.
+ *
+ * This is used for performance tracking of the SOAP methods.
+ * @see https://nodejs.org/api/perf_hooks.html
+ * @params {PerformanceObserverEntryList} items The list of performance entries.
+ * @returns {void}
+ */
+const obs = new PerformanceObserver((items) => {
+  items.getEntries().forEach((entry) => {
+    if (debug) console.log(`${entry.name} took ${Math.round(entry.duration)}ms`)
+  })
+})
+obs.observe({ entryTypes: ['measure'] })
+
+async function logSoapError (e) {
+  console.error(e?.originalError?.root?.Envelope?.Body?.Fault?.faultstring || e.message)
+}
+
+/**
+ * This function checks if the specified error should abort the retry.
+ * @param {Error} error The error to check.
+ * @returns {boolean} True if the error should abort the retry, false otherwise.
+ **/
+function shouldAbortRetry (error) {
+  try {
+    const fault = error.root.Envelope.Body.Fault
+    const details = fault.detail
+    const blockedFaultStrings = [
+      /Context \d+ already exists/,
+      /Authentication failed/,
+      /Context \d+ does not exist/,
+      /CloudPluginException: username .* already exists/,
+      /CloudPluginException: context name must begin/,
+      /The displayname is already used/,
+      /already exists in this context/,
+      /Shared Domain already exists/,
+      /Shared Domain already in use/,
+      /No such user/,
+      /Mandatory fields in context not set/,
+      /A mapping with login info .* already exists/,
+      /Id must not be set if pre-assembled context should be used/,
+      /Unmarshalling Error/
+    ]
+    const blockedExceptions = [
+      'ContextExistsException',
+      'InvalidCredentialsException',
+      'NoSuchContextException'
+    ]
+    // return "details object contains any of the blocked items"
+    return blockedFaultStrings.some(msg => msg.test(fault.faultstring)) ||
+      blockedExceptions.some(exception => Object.hasOwnProperty.call(details, exception))
+  } catch (e) {
+    // some other error which is never blocked
+    return false
+  }
+}
+
+/**
+ * This function creates a SOAP client for the specified service type.
+ * @param {string} type The name of the service type.
+ * @returns {Promise<Object>} The SOAP client.
+ */
+async function createClientAsync (type) {
+  const startMark = `${type}-start`
+  const endMark = `${type}-end`
+  performance.mark(startMark)
+  const endpoint = `${provisioningUrl}/webservices/${type}`
+  const url = `${endpoint}/?wsdl`
+  const client = await SOAP.createClientAsync(url, {
+    endpoint,
+    suppressStack: true,
+    wsdl_options: {
+      forever: true
+    },
+    gzip: true
+  })
+
+  // https://stackoverflow.com/questions/30740415/namespace-for-array-field-in-node-soap-client-node-js
+  client.wsdl.definitions.xmlns.ns1 = 'http://dataobjects.soap.admin.openexchange.com/xsd'
+  client.wsdl.xmlnsInEnvelope = client.wsdl._xmlnsMap()
+  performance.mark(endMark)
+  performance.measure(`  ⏱ SOAP: ${type} -> createClientAsync`, startMark, endMark)
+
+  // This proxy effectively adds error handling, authentication and performance measurements to all methods of the SOAP client.
+  return new Proxy(client, {
+    get (target, prop, receiver) {
+      const origMethod = Reflect.get(target, prop, receiver)
+      if (typeof origMethod === 'function') {
+        return async function (options, clientOptions, ...args) {
+          const startMark = `${prop}-start`
+          const endMark = `${prop}-end`
+          performance.mark(startMark)
+          const soapOptions = { ...provisioningAuth, ...options }
+          if (soapOptions.auth) {
+            // only send login and password instead of complete admin object.
+            // this can fail because of ambiguous namespacing
+            soapOptions.auth = { login: soapOptions.auth.login, password: soapOptions.auth.password }
+          }
+
+          const result = await pRetry(() => origMethod.apply(this, [soapOptions, { timeout: 10000, ...clientOptions }, ...args]), {
+            retries: 3,
+            onFailedAttempt: async error => {
+              if (shouldAbortRetry(error)) throw new AbortError(error)
+              console.log(`Attempt ${error.attemptNumber} failed. There are ${error.retriesLeft} retries left.`)
+            }
+          }).catch(e => {
+            const soapError = e?.originalError?.root?.Envelope?.Body?.Fault
+            throw new Error(soapError?.faultstring || e.message)
+          })
+          performance.mark(endMark)
+          performance.measure(`  ⏱ SOAP: ${type} -> ${String(prop)}`, startMark, endMark)
+          // Return only the first result from the SOAP method call, as we don't need the SOAP envelope and other stuff.
+          if (!result || !result[0]) return
+          return result[0]?.return
+        }
+      } else {
+        return origMethod
+      }
+    }
+  })
+}
+
+export { createClientAsync, logSoapError }