Forge DataManagement API: new Item or Version creation

upload.js

/////////////////////////////////////////////////////////////////
// Upload file to create new item or new version
//
/////////////////////////////////////////////////////////////////
upload (token, projectId, folderId, file) {

  return new Promise(async(resolve, reject) => {

    try {

      var displayName = file.originalname

      // Step 1: create a storage location on OSS
      // to upload the file. The DM service will 
      // decides what bucketKey objectKey 
      // you need to use 
      var storage = await this.createStorage(
        token, projectId, folderId, displayName)

      var ossSvc = ServiceManager.getService('OssSvc')

      var objectId = ossSvc.parseObjectId(storage.data.id)

      // Step 2: upload file to OSS using provided 
      // bucketKey and objectKey
      var object = await ossSvc.putObject(
        token,
        objectId.bucketKey,
        objectId.objectKey,
        file)

      // look for items with the same displayName
      var items = await this.findItemsWithAttributes(
        token,
        projectId,
        folderId, {
          displayName
        })

      // If items found, create a new version
      if(items.length > 0) {

        const item = items[0]

        const version = await this.createVersion(
          token,
          projectId,
          item.id,
          storage.data.id,
          displayName)

        const response = {
          version: version.data,
          storage: storage.data,
          item: item,
          object
        }

        resolve(response)

      // no item found, create new item  
      } else {

        const item = await this.createItem(
          token, projectId, folderId,
          storage.data.id,
          displayName)

        const versions = await this.getItemVersions(
          token, projectId, item.data.id)

        const response = {
          version: versions.data[0],
          storage: storage.data,
          item: item.data,
          object
        }

        resolve(response)
      }

    } catch (ex) {

      reject(ex)
    }
  })
}

/////////////////////////////////////////////////////////////////
// Returns Items matching search criteria
//
/////////////////////////////////////////////////////////////////
findItemsWithAttributes (
  token, projectId, folderId, attributes, recursive = false) {

  return new Promise(async(resolve, reject) => {

    try {

      var folderItems = await this.getFolderContent(
        token, projectId, folderId)

      var tasks = folderItems.data.map((folderItem) => {

        if(folderItem.type === 'items') {

          var match = true

          for (var key in attributes) {

            if(attributes[key] !== folderItem.attributes[key]){

              match = false
            }
          }

          if(match) {

            return Promise.resolve(folderItem)

          } else {

            return Promise.resolve(null)
          }

        } else if (folderItem.type === 'folders' && recursive) {

          return findItemsWithAttributes (
            token,
            projectId,
            folderItem.id,
            recursive)

        } else {

          return Promise.resolve(null)
        }
      })

      var items = await Promise.all(tasks)

      items = items.filter((item) => {
        return item !== null
      })

      resolve(items)

    } catch (ex) {

      reject(ex)
    }
  })
}