zudello-integration-sdk 1.0.0

package/src/integrations/samples/intacct-zudello/expense-create.js

@@ -0,0 +1,156 @@
+const handler = async (providedData) => {
+  const { payload } = providedData
+
+  const model = payload?.resource?.model || null
+  const uuid = payload?.resource?.uuid || null
+
+  logger.log(payload)
+  logger.log(model)
+  logger.log(uuid)
+
+  if (model && uuid) {
+    const fetchedItem = await Zudello.fetch({ model, uuid })
+
+    logger.log(fetchedItem)
+
+    if (fetchedItem && fetchedItem.data) {
+      const data = fetchedItem.data
+      const today = moment().tz('Australia/Sydney').format('MM/DD/YYYY')
+      const todayHuman = moment().tz('Australia/Sydney').format('DD-MM-YYYY')
+      const todayZudello = moment().tz('Australia/Sydney').format('YYYY-MM-DD')
+
+      logger.log("----Begin Data----")
+      logger.log(JSON.stringify(data))
+      logger.log("----End Data----")
+      logger.log(JSON.stringify(_.get(data, "data.source_transactions")))
+
+      const milestones = _.get(data, "data.approvals.0.milestones", [])
+      let managementApprover = ''
+
+      milestones.forEach(milestone => {
+        milestone.steps.forEach(step => {
+          if (step.name === "Manager Approval") {
+            step.approver_responses.forEach(response => {
+              if (response.response === 'APPROVED') {
+                managementApprover += `${response.user.first_name} ${response.user.last_name}, `
+              }
+            })
+          }
+        })
+      })
+
+      managementApprover = managementApprover.trim()
+
+      const lines = _.flatten(_.map(_.get(data, "data.source_transactions"), transaction => {
+        return _.map(_.get(transaction, "lines"), line => {
+          let desc = _.get(transaction, "reference")
+          const type = _.get(transaction, "document_type")
+
+          if (type === "CLIENT_REIMBURSEMENT") {
+            desc = `${_.get(transaction, "reference")} ${_.get(transaction, "guests_names")} ${_.get(transaction, "custom.claim_number")}`
+          } else if (type === "ENTERTAINMENT") {
+            desc = `${_.get(transaction, "reference")} ${_.get(transaction, "guests_names")} ${_.get(transaction, "custom.guests_qty")}`
+          } else if (type === "EXPENSE_COPY1") {
+            desc = `${_.get(transaction, "reference")} ${_.get(transaction, "po_number")}`
+          }
+
+          return {
+            TAXTYPE: _.get(line, "tax_rate.external_id"),
+            ACCOUNTNO: _.get(line, "account.external_id"),
+            LOCATIONID: _.get(line, "location.external_id"),
+            DEPARTMENTID: _.get(line, "department.external_id"),
+            SUBSIDIARYID: _.get(line, "subsidiary.external_id"),
+            TRXAMOUNT: _.get(line, "total_exclusive"),
+            TAXAMOUNT: _.get(line, "tax_amount"),
+            ENTRYDESCRIPTION: desc
+          }
+        })
+      }))
+
+      logger.log(JSON.stringify(lines))
+
+      const lineResult = _(lines)
+        .groupBy(item => `${item.TAXTYPE}|${item.ACCOUNTNO}|${item.LOCATIONID}|${item.ENTRYDESCRIPTION}`)
+        .map(group => ({
+          TAXTYPE: _.head(group).TAXTYPE,
+          ACCOUNTNO: _.head(group).ACCOUNTNO,
+          LOCATIONID: _.head(group).LOCATIONID,
+          DEPARTMENTID: _.head(group).DEPARTMENTID,
+          SUBSIDIARYID: _.head(group).SUBSIDIARYID,
+          TRXAMOUNT: _.sumBy(group, 'TRXAMOUNT'),
+          TAXAMOUNT: _.sumBy(group, 'TAXAMOUNT'),
+          ENTRYDESCRIPTION: _.head(group).ENTRYDESCRIPTION
+        }))
+        .values()
+        .value()
+
+      logger.log(JSON.stringify(lineResult))
+
+      const docNumber = `${_.get(data, "data.employee.first_name")} ${_.get(data, "data.employee.last_name")} ${todayHuman} ${Date.now()}`
+
+      const customFields = [
+        { field_name: 'MANAGEMENT_APPROVAL', field_value: managementApprover },
+        { field_name: 'ZUDELLO_URL', field_value: _.get(data, "short_url") }
+      ]
+
+      const createPayload = {
+        ENTITYID: { isMap: false, value: _.get(data, "data.locations.0.external_id") },
+        VENDORID: { isMap: false, value: _.get(data, "data.employee.external_id") },
+        WHENCREATED: { isMap: false, value: today },
+        WHENPOSTED: { isMap: false, value: today },
+        WHENDUE: { isMap: false, value: today },
+        EXCH_RATE_DATE: { isMap: false, value: today },
+        RECORDID: { isMap: false, value: docNumber },
+        DOCNUMBER: { isMap: false, value: "" },
+        DESCRIPTION: { isMap: false, value: docNumber },
+        CURRENCY: { isMap: false, value: _.get(data, "data.currency.code") },
+        BASECURR: { isMap: false, value: _.get(data, "data.currency.code") },
+        TAXSOLUTIONID: { isMap: false, value: "Australia - GST" },
+        APBILLITEMS: { isMap: true, value: `{{${JSON.stringify(lineResult)}}}` },
+        customFields: { isMap: true, value: `{{${JSON.stringify(customFields)}}}` }
+      }
+
+      logger.log(JSON.stringify(createPayload))
+
+      const apBillResponse = await Intacct.apBill.create(createPayload)
+
+      logger.log(JSON.stringify(apBillResponse))
+
+      if (apBillResponse && apBillResponse.data) {
+        const apBillResponseData = apBillResponse.data
+
+        if (_.get(apBillResponseData, "data.0.operation.0.result.0.status.0") === "failure") {
+          logger.log(_.get(apBillResponseData, "data.0.operation.0.result.0.errormessage.0.error.0.description2.0"))
+          return
+        }
+
+        const zudelloUpdateResponse = await Zudello.update({
+          model,
+          data: {
+            module: "EXPENSES",
+            submodule: "CLAIM",
+            uuid,
+            document_number: docNumber,
+            date_issued: todayZudello,
+            status: "CLOSED",
+            external_id: _.get(apBillResponseData, "data.0.operation.0.result.0.data.0.apbill.0.RECORDNO.0")
+          }
+        })
+
+        logger.log(JSON.stringify(zudelloUpdateResponse))
+      
+        /*_.each(_.get(data, "data.source_transactions"), async (expense) => {
+          const updateResponse = await Zudello.update({
+            model,
+            data: {
+              uuid: _.get(expense, "uuid"),
+              status: "COMPLETE"
+            }
+          })
+
+          logger.log(updateResponse)
+        })*/
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/item.js

@@ -0,0 +1,64 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.item.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "ITEMID"),
+        "sku": _.get(result, "ITEMID"),
+        "barcode": _.get(result, "UPC"),
+        "country": _.get(result, "PRIMARYCOUNTRYOFORIGIN"),
+        "item_category": _.get(result, "CATEGORY"),
+        "item_type": _.get(result, "ITEMTYPE"),
+        "description": _.get(result, "NAME"),
+        "purchase_price": _.get(result, "STANDARD_COST"),
+        "short_description": _.get(result, "EXTENDED_DESCRIPTION"),
+        "subsidiaries": _.get(result, "MEGAENTITYID"),
+        "tax_rate": _.get(result, "TAXGROUP.NAME"),
+        // "unit_of_meaasure": _.get(result, "BASEUOM"),
+        // "warehouse": _.get(result, "DEFAULT_WAREHOUSE"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.item.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/itemCategory.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.productLine.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "PRODUCTLINEID"),
+        "code": _.get(result, "PRODUCTLINEID"),
+        "name": _.get(result, "DESCRIPTION"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.itemCategory.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/itemGroup.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.itemGroup.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "ID"),
+        "code": _.get(result, "ID"),
+        "name": _.get(result, "Name"),
+        "status": "ACTIVE"
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.itemGroup.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/location.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.location.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "LOCATIONID"),
+        "code": _.get(result, "LOCATIONID"),
+        "name": _.get(result, "NAME"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.location.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/paymentTerm.js

@@ -0,0 +1,56 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.apTerm.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "RECORDNO"),
+        "code": _.get(result, "ANEM"),
+        "name": _.get(result, "DESCRIPTION"),
+        "type": "DAYS_AFTER_DATE",
+        "unit": _.get(result, "DUEDATE"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.paymentTerm.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/project.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.project.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "PROJECTID"),
+        "code": _.get(result, "PROJECTID"),
+        "name": _.get(result, "NAME"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.project.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/projectGroup.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.projectGroup.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "ID"),
+        "code": _.get(result, "ID"),
+        "name": _.get(result, "Name"),
+        "status": "ACTIVE"
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.projectGroup.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/projectTask.js

@@ -0,0 +1,40 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.task.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "TASKID"),
+        "code": _.get(result, "TASKID"),
+        "name": _.get(result, "NAME"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const result = await Zudello.projectTask.updateOrCreate({ data })
+
+    logger.log(result)
+
+    if (result.success) {
+      const lastObject = _.last(items.data)
+      const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+      if (updatedLastModified) {
+        metadata.set('lastModified', updatedLastModified)
+      }
+    }
+  }
+}

package/src/integrations/samples/intacct-zudello/subsidiary.js

@@ -0,0 +1,54 @@
+const handler = async (providedData) => {
+  const lastModified = metadata.get('lastModified')
+  const fetchData = { pageSize: 2000, offset: 0, include: ['WHENMODIFIED'], orderBy: 'WHENMODIFIED' }
+
+  if (lastModified) {
+    fetchData.filters = [{
+      fName: { value: 'WHENMODIFIED' },
+      operator: { value: 'greaterthan' },
+      fValue: { value: lastModified }
+    }]
+  }
+
+  logger.log(fetchData)
+
+  for await (const items of Intacct.entity.autoPaginationList(fetchData)) {
+    logger.log(items)
+
+    const data = _.map(items.data, (result) => {
+      return {
+        "external_id": _.get(result, "LOCATIONID"),
+        "code": _.get(result, "LOCATIONID"),
+        "name": _.get(result, "NAME"),
+        "status": _.get(result, "STATUS", "ACTIVE").toUpperCase()
+      }
+    })
+
+    const batchSize = 100
+
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize)
+
+      logger.log(batch)
+
+      const result = await Zudello.subsidiary.updateOrCreate({ data: batch })
+
+      logger.log(result)
+      logger.log(`Processed batch ${Math.ceil((i + batchSize) / batchSize)} of ${Math.ceil(data.length / batchSize)}`)
+
+      if (result.success) {
+        const lastObject = _.last(items.data)
+        const updatedLastModified = lastObject ? lastObject.WHENMODIFIED : null
+
+        if (updatedLastModified) {
+          metadata.set('lastModified', updatedLastModified)
+        }
+      }
+
+      // Introduce a delay of 3 seconds (3000 milliseconds) after each batch
+      if (i + batchSize < data.length) {
+        await new Promise(resolve => setTimeout(resolve, 3000))
+      }
+    }
+  }
+}