summaryrefslogblamecommitdiffstats
path: root/server/lib/external-backends/backendhelper.js
blob: 6892f7c04d872347a301d08ca1323089c78d72a8 (plain) (tree)
1
2
3
4
5
6


                                                                                 

                                                           
 



























                                                                                                      
     






                                                                                                                 
     



































                                                                                                                                                                                                                     
     



                                                                                  
   

















                                                                                                                               
 












                                                                              
 
/* global __appdir */
const path = require('path')
const ExternalBackends = require(path.join(__appdir, 'lib', 'external-backends'))
const db = require(path.join(__appdir, 'lib', 'sequelize'))
const log = require(path.join(__appdir, 'lib', 'log'))

module.exports = { addClient, updateClient, deleteClients, uploadFiles }

async function addClient (client) {
  // Get all backends and call addClient for each instance.
  var backends = await db.backend.findAll({ include: ['mappedGroups', 'mappedClients'] })
  var result = []

  for (var b in backends) {
    var backend = backends[b]
    const ba = new ExternalBackends()
    const instance = ba.getInstance(backend.type)
    var tmpClient = JSON.parse(JSON.stringify(client))

    // Convert the parent group ids to the external backend parentIds. If multiple -> conflict
    if (client.parents) {
      const elements = backend.mappedGroups.filter(x => client.parents.includes(x.id))
      if (elements.length > 1) {
        // Conflict occured!
        const conflict = await db.conflict.create({ description: 'Multiple parents found' })

        // Add backend to the conflict.
        conflict.createObject({ objectType: 'BACKEND', objectId: backend.id })

        // Add the groups to the conflict.
        for (let element of elements) {
          conflict.createObject({ objectType: 'GROUP', objectId: element.id })
        }
      } else if (elements.length === 1) tmpClient['parentId'] = elements[0].backend_x_group.externalId
    }

    let addClient = await instance.addClient(backend.credentials, tmpClient)
    addClient.backendId = backend.id
    if (addClient.succes) {
      // If the object was created we need to make the objectid / external id mapping.
      const clientDb = await db.client.findOne({ where: { id: client.id } })
      backend.addMappedClients(clientDb, { through: { externalId: addClient.id, externalType: addClient.type } })
    }
    if (addClient.error && addClient.error !== 'NOT_IMPLEMENTED_EXCEPTION') log({ category: 'BACKEND_ERROR', description: `[${addClient.backendId}] ${addClient.error}: ${addClient.message}`, clientId: client.id })
    result.push(addClient)
  }
  return result
}

async function updateClient (client) {
  // Get all backends and call addClient for each instance.
  const backends = await db.backend.findAll({ include: ['mappedGroups', 'mappedClients'] })
  let result = []

  for (let b in backends) {
    const backend = backends[b]
    const ba = new ExternalBackends()
    const instance = ba.getInstance(backend.type)
    var tmpClient = JSON.parse(JSON.stringify(client))

    // Get the external clientid.
    var exid = backend.mappedClients.find(y => y.id === parseInt(client.id))
    if (exid) tmpClient.id = exid.backend_x_client.externalId

    // Convert the parent group ids to the external backend parentIds. If multiple -> conflict
    if (client.parents) {
      const elements = backend.mappedGroups.filter(x => client.parents.includes(x.id))
      if (elements.length > 1) {
        // Conflict occured!
        const conflict = await db.conflict.create({ description: 'Multiple parents found' })

        // Add backend to the conflict.
        conflict.createObject({ objectType: 'BACKEND', objectId: backend.id })

        // Add the groups to the conflict.
        for (let element of elements) {
          conflict.createObject({ objectType: 'GROUP', objectId: element.id })
        }
      } else if (elements.length === 1) tmpClient['parentId'] = elements[0].backend_x_group.externalId
    }

    let updateClient = await instance.updateClient(backend.credentials, tmpClient)
    updateClient.backendId = backend.id
    result.push(updateClient)
  }
  return result
}

async function deleteClients (clientids) {
  // Get all backends and call deleteClient for each instance.
  const backends = await db.backend.findAll({ where: { '$clientMappings.clientid$': clientids }, include: ['clientMappings'] })

  backends.forEach(backend => {
    const ba = new ExternalBackends()
    const instance = ba.getInstance(backend.type)
    var objectsToDelete = []
    backend.clientMappings.forEach(mapping => {
      objectsToDelete.push(mapping.externalId)
    })
    // If there are objects to delete -> delete them.
    if (objectsToDelete.length > 0) instance.deleteObjects(backend.credentials, objectsToDelete)
  })
}

async function uploadFiles (clientId, files) {
  const backends = await db.backend.findAll({ include: ['mappedClients'] })
  let results = []
  for (let b in backends) {
    const backend = backends[b]
    const ba = new ExternalBackends()
    const instance = ba.getInstance(backend.type)

    let exid = backend.mappedClients.find(y => y.id === parseInt(clientId))
    if (exid) exid = exid.backend_x_client.externalId
    results.push(await instance.uploadFiles(backend.credentials, exid, files))
  }
  return results
}