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


                                                                                 

                                                           

                  
                                      
                                                             

                                                                                           
 




                                                        
 
                                                                                                    
                                                                      

                               
                                                                                        
                                  
                              









                                                                                                        

       
                                                                              
                                      




                                                                                                                   
                                                                                                                                                                                                                       
                            





                                                             

                                                                                             
 

                                 













                                                                                        
                                                                                    

                                         

                 

    
                                             
                                                                







                                                                                                                                 
        

                                                                                                  
      


                                                 



                                                                             


                                                   
                                                                             
                                                       
                                                                                
     
                  
   
 
 
/* 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: async function (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))

      // Add client has no support for update anymore.. use update method.. maybe call conflict here
      // Convert the parent group id to the external backend parentId.
      // if (client.parentId) {
      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
  },

  updateClient: async function (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 id to the external backend parentId.
      if (client.parentId) {
        var element = backend.mappedGroups.find(x => x.id === parseInt(client.parentId))
        if (element) tmpClient['parentId'] = element.backend_x_group.externalId
      }

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

  deleteClients: async function (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)
    })
  },

  uploadFiles: async function (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
  }

}