We have categorised all our functions into key areas that will assist you in your scripting journey.

Communication
Current Event Context
Files
Logs
Payments
Portals
Records
Search Filters
Xero and Myob

Communication

Communication functions are functions related to communication within the system. These relate to emails, SMS, notifications and other functions that assist/relate to these communication types.

addRelationship

This function creates SMS/email logs as a relationship to entries. Once created this will display in the Communication Log on Entries

It supports two types: SMS and Email.

This function can be used along with mergeSmsTemplate and sendSms.

Input Parameters	Returns
`messageData.to`: Recipient of the SMS. `messageData.body`: Content of the SMS. `messageData.messageId`: Unique identifier for the message. `type`: Set to sms. `linkedEntries`: Entries to be linked with the message. It can be a table (`recordId`) or a specific entry (`entryId`). `options.logMessageToCurrentEntry` (Optional): `true` by default. If you want to disable logging the message to the current entry, make this option `false`.	SMS logs.

Input Parameters

Returns

messageData.to: Recipient of the SMS.
messageData.body: Content of the SMS.
messageData.messageId: Unique identifier for the message.
type: Set to sms.
linkedEntries: Entries to be linked with the message. It can be a table (recordId) or a specific entry (entryId).
options.logMessageToCurrentEntry (Optional): true by default. If you want to disable logging the message to the current entry, make this option false.

SMS logs.

C.addRelationship({
  messageData: {
    to: sendSmsResponse.success[0].to,
    body: sendSmsResponse.success[0].messageSentStatus.body,
    messageId: "messageId"
  },
  type: "sms",
  linkedEntries: [{ recordId: 233450, entryId: 2715083 }], 
  options: {
    logMessageToCurrentEntry: true 
  }
});

mergeEmailTemplate

Merges an email template.

Input Parameters	Returns
An object containing various data attributes such as: `entryId`: An identifier with a specific entry of a record. `recordInternalId`: Subrecord's internal id. `templateId`: Template ID to use. `options`: An object that contains additional settings for the email merging operation.	`Email template.

Input Parameters

Returns

An object containing various data attributes such as:

entryId: An identifier with a specific entry of a record.
recordInternalId: Subrecord's internal id.
templateId: Template ID to use.
options: An object that contains additional settings for the email merging operation.

`Email template.

Example

async function script(C) {
    const { entryId, recordId, recordInternalId } = C.getEvent();
    
    // Email input configuration
    const emailInput = {
        entryId,
        recordInternalId: "leads",
        templateId: 10001340,
    };

    // Merge the email template
    const response = await C.mergeEmailTemplate(emailInput);
    const subject = response.subject;
    const body = response.body.replace(
        "{custom_data}",
        "Hello world! This was changed"
    );

    const sendEmailResponse = await C.sendEmail({
        entryId,
        recordInternalId,
        from: {
            email: "test@clevero.com",
            name: "test",
        },
        to: ["demo@clevero.co"],
        subject,
        body,
    });
    
    return C.addJsonToSummary(
        { response, sendEmailResponse }, 
        { "enableCopy": true }
    );
}

mergeSmsTemplate

Merges an SMS template.

Input Parameters	Returns
`smsInput` object containing various data attributes such as: `entryId`: An identifier with a specific entry of a record. `recordInternalId`: Subrecord's internal id. `templateId`: Template ID to use.	SMS Template.

Input Parameters

Returns

smsInput object containing various data attributes such as:

entryId: An identifier with a specific entry of a record.
recordInternalId: Subrecord's internal id.
templateId: Template ID to use.

SMS Template.

Example

async function script(C) {
    const { entryId, recordInternalId, recordId } = C.getEvent();
    const currentEntry = await C.getCurrentEntry();

    // SMS Variables
    let baseUrl = "https://api.tallbob.com/v2/sms/send";
    let from = "639171234567";
    let to = "639171234567"; 
    let templateId = 10014504;

    // SMS Inputs
    let smsInput = {
        entryId,
        recordInternalId,
        templateId,
    };

    const response = await C.mergeSmsTemplate(smsInput);
    const body = response.body;

    C.addJsonToSummary(response, { "enableCopy": true });

    return;
}

Output

{
  "response": {
    "body": "Hi, this is a test SMS."
  }
}

addRedirect

Redirects the user to the specified URL/path.

Input Parameters	Returns
URL or destination path.	No return value is specified.

Here are two kinds of redirect functions that you can use:

1️⃣ Redirect in the current tab

C.addRedirect("/app/records/233450/view/1137725");

2️⃣ Redirect page into a new tab

Pass true in the second argument to open the URL in a new tab

C.addRedirect("<https://www.clevero.co/">, true);

sendEmail

Sends an email from a workflow.

Input Parameters	Returns
`entryId`: Identifier for the email entry. `recordInternalId`: Internal ID of the related record. `from`: Sender’s email and name. `to`: Recipient email address(es). `subject`: Email subject line. `body`: Email body in HTML format. *`templateId`: ID of the email template to use.	`string` — A response indicating the email was sent.

*Use either subject and body or templateId in a single request. Avoid using both at the same time.

Example

const response = await C.sendEmail({
    entryId: 12345678,
    recordInternalId: "record-abc123",
    from: {
        email: "notifications@example.com",
        name: "Example Notifications",
    },
    to: ["recipient@example.com"],
    subject: "Sample Subject",
    body: "<p>This is a sample email.</p>",
});

📘
Info
See the sendEmail examples here.

sendNotification

Sends a notification to the user when a certain event occurs within the system.

Input Parameters	Returns
`message`: The main message content of the notification. `redirectUrl`: The URL to which the recipient will be redirected when interacting with the notification. `topic`: The general topic of the notification. `subTopic`: A more specific topic related to the notification. `audience`: The target recipients, or those who will receive the notification.	A notification with a message.

Example

C.sendNotification({
         payload: {
            message: `Version 1.0.0 is out now`,
            metadata: {
                redirectUrl: `/app/records/${currentEntry.recordId}/view/${currentEntry.recordValueId}`,
            },
            topic: "COMMUNICATIONS",
            subTopic: "EMAIL_REPLY",
        },
        audience: "USER",
    })

sendSms

Sends SMS from the workflow.

Input Parameters	Returns
`entryId`: The ID of the entry/record. `to`: An array of phone numbers to which the SMS will be sent. `body`: The message content of the SMS. It may include placeholders for dynamic content. `recordInternalId`: The internal ID of the record.	Message sent status.

Example

C.sendSms({
        entryId: entry.recordValueId,
        to: ["9860722217", "489921018"],
        // templateId: 2224398,
        body:
            " {{[title]}} due date: {{[due-date]}} status: {{[status].[value]}}",
        recordInternalId: "backlog-items",
    });

shortenUrl

Shortens a long URL.

Input Parameters	Returns
`url`: A long URL to shorten.	Shortened URL.

Example

C.shortenUrl({url});

C.addRelationship({
  messageData: {
    from: emailInput.from,
    to: emailInput.to,
    bcc: emailInput.bcc,
    cc: emailInput.cc,
    attachments: [...(emailInput.attachments || [])],
  },
  type: "email",
  linkedEntries: [{ recordId: 233450, entryId: 2715083 }]
});

Current Event Context

These function relate to retrieving information about the current execution of the script. Whether it be the user, their role, information about the Entry, these functions will assist in getting you the information you need.

getCompanySettings

Gets company settings. This will usually obtain information like Company Name, timezone, address that may want to be used inside scripts.

Input Parameters	Returns
-	Company settings.

Example

let companySettings = C.getCompanySettings();
C.addJsonToSummary(companySettings);

getEvent

Retrieves the current event context at the time the script is executed. This includes details such as the event type, the user who triggered it, and other relevant information.

Input Parameters	Returns
-	`stateEvent`

Example

async function script(C){
    const eventData = C.getEvent();
    C.log(eventData);
    C.addJsonToSummary(eventData, {enableCopy: true});
}

getEventMetadata

getEventMetadata retrieves contextual information about the current event, including the user who triggered it, their role, and the entry being acted upon.

Input Parameters	Returns
-	JSON payload.

Example

async function script(C) {
    const eventMetadata = await C.getEventMetadata();
    C.log("Event Metadata:", eventMetadata);

    C.addJsonToSummary(eventMetadata, { enableCopy: true });
}

getScriptReturnValue

Returns whatever was returned from the specified script ID.

Input Parameters	Returns
`scriptId`: Another script ID that you can get from the "Manage Script" page.	Any string.

Example

async function script(C){
    const scriptValue = C.getScriptReturnValue(10013942);
    return {
        response
    }
}

Output

{
    "response": {
        "success": [
            {
                "index": 0,
                "updateObject": {
                    "recordInternalId": "appointments",
                    "entryId": 200739979,
                    "value": {
                        "uuid": "fdf9a8ab-6f82-4efd-92f0-4a4f5a57b202"
                    }
                },
                "recordId": 100407
            }
        ]
    }
}

getScriptState

Retrieves the state of the script with the provided ID.

Input Parameters	Returns
`scriptId`: The script ID that you can get from the "Manage Script" page.	`pending`, `in_progress`, `success`, or `error`.

Example

async function script(C) {
    let scriptState = await C.getScriptState("<input_another_scriptId_here>");
  	
  	C.addJsonToSummary({scriptState, { enableCopy: true });
}

Output

{
  "scriptState": {
    "status": "success",
    "scriptIndex": 0,
    "result": {
      "success": true,
      "payload": {
        "returnValue": {
          "response": { /* ... */ },
          "sendEmailResponse": {
            "message-id": "ChMJ8xMmQQWiLMlXloyDdA",
            "emailLogs": {
              "emailEntryCreated": {
                "entryId": 200740165,
                "recordId": 15169
              },
              "linkedEntries": [
                {
                  "recordId": 578177,
                  "entryId": 1310518
                }
              ],
              "relationshipEntryCreated": {
                "entryId": 200740166,
                "recordId": 15172
              }
            }
          }
        },
        "redirects": [],
        "downloadState": [],
        "scriptSummary": [],
        "updatedEntries": []
      }
    }
  }
}

getScriptStateBasedOnIndex

Retrieves the state of the script at the specified index.

Input Parameters	Returns
`index`: The index of the script that you are querying.	`pending`, `in_progress`, `success`, or `error`.

Example

async function script(C) {
    let scriptState = await C.getScriptState("<input_another_scriptId_here>");
    let scriptStateBasedOnIndex = await C.getScriptStateBasedOnIndex(
        scriptState.scriptIndex
    );

    C.addJsonToSummary(scriptStateBasedOnIndex, { enableCopy: true });
}

Output

{
  "scriptStateBasedOnIndex": {
    "status": "success",
    "scriptIndex": 0,
    "result": {
      "success": true,
      "payload": {
        "returnValue": {
          "response": { /* ... */ },
          "sendEmailResponse": {
            "message-id": "xSTz0pleQeyfHzU8DOEedQ",
            "emailLogs": {
              "emailEntryCreated": {
                "entryId": 200740167,
                "recordId": 15169
              },
              "linkedEntries": [
                {
                  "recordId": 578177,
                  "entryId": 1310518
                }
              ],
              "relationshipEntryCreated": {
                "entryId": 200740168,
                "recordId": 15172
              }
            }
          }
        },
        "redirects": [],
        "downloadState": [],
        "scriptSummary": [],
        "updatedEntries": []
      }
    }
  }
}

getScriptStatus

The ID of the script to retrieve the status.

Input Parameters	Returns
`scriptId`: The script ID to check.	`pending`, `in_progress`, `success`, or `error`.

Example

async function script(C) {
    let scriptStatus = await C.getScriptStatus("<input_another_scriptId_here>");
    C.addJsonToSummary(scriptStatus, {"enableCopy": true}) 
}

Output

{
  "scriptStatus": "success"
}

isScriptSuccess

Check whether the script executed successfully.

Input Parameters	Returns
`scriptId`: The script ID to check.	A boolean value indicating whether the script was successful (`true`) or not (`false`).

Example

async function script(C) {
    let scriptSuccess = await C.isScriptSuccess("<input_another_scriptId_here>");
    C.addJsonToSummary(scriptSuccess, {"enableCopy": true}) 
}

Output

{
  "scriptSuccess": true
}

Files

These functions relate to files and attachments.

attachFileToFormData

Attaches a file to a FormData object. This can be used to send attachments/files via a formData object through API.

Input Parameters	Returns
`formData`: An object of `FormData` class that is to be used as a multipart form data body. `formDataKey`: The key in the `FormData` in which a file is to be attached. `fileKey`: The key of the file kept in AWS s3 bucket.	Any string.

Example

C.attachFileToFormData({
  formData: form,
  formDataKey: "attachment",
  fileKey: fileKey,
});

downloadFiles

Download files from the specific entry. This will download files immediately for the user.

Input Parameters	Returns
`downloadConfig`: An object used to configure a file download like the name, the record's internal ID, the specific fields to download files from, and an optional entry ID for targeting a specific entry.	ZIP file or download link.

Example

C.downloadFiles(downloadConfig);

generateFile

This will generate a file based on content passed. This will automatically store the file and allow you to email, download or store it with an entry in the system.

Input Parameters	Returns
`filename`: The name of the file to be generated. `extension`: The file extension. `contentType`: The content type of the file. `content`: The actual content of the file.	An attachment to add to any file or file bucket type field. You can also send it directly in the sendEmail function.

Permitted File Extensions

"txt", "csv", "json", "xml", "yaml", "yml", "html", "md", "ini", "toml"

Example

let myFile = C.generateFile({
        filename: "test12",
        extension: "xml",
        contentType: "application/xml",
        content: xmlString,
    });

getPdfFromGoogleDocsTemplate

Generates a PDF from a Google Docs template.

Input Parameters	Returns
`entryId`: An identifier with a specific entry of a record. `recordInternalId`: includeSubrecord's internal id. `templateId`: Template ID to use. `generatedFileDestinationField`: A destination field where the file is generated. `uuidFieldForPdfFile`: A UUID of a field associated with a PDF file is stored.	PDF.

Example

C.getPdfFromGoogleDocsTemplate({
        entryId,
        recordInternalId,
        templateId: 841760,
        generatedFileDestinationField: "signed-contract",
        uuidFieldForPdfFile: "title"
});

Logs

Keen to know what out put certain functions are producing? Use our log functions to assist.

addHtmlToSummary

Adds HTML code to the summary. This is really useful if you need want to show a more professional display back to the end user.

Input Parameters	Returns
HTML code.	HTML in the summary.

Example

C.addHtmlToSummary(
    "Click here to start your journey with Clevero: <a href='https://clevero.co'>clevero.co</a>"
);

Output

addJsonToSummary

Adds a JSON object to the summary.

Input Parameters	Returns
`json`: A JSON object. `enableCopy`: `false` by default. If `true`, it displays an icon to copy values from the JSON object. `collapsed`: The levels of the object you want to be open. `name`: The name of the root JSON object.	JSON data in the summary.

Example

const currentEntry = await C.getCurrentEntry();
C.addJsonToSummary({ currentEntry: currentEntry });

Output

addListsToSummary

Adds an array of items to the summary.

Input Parameters	Returns
An array of items: `value`: The value of an item. `valueColor`: Hex colour value of the text (optional). `iconColor`: Hex colour value of the icon (optional). `icon`: The icon to display in the list (optional).	A list in the summary.

Input Parameters

Returns

An array of items:

value: The value of an item.
valueColor: Hex colour value of the text (optional).
iconColor: Hex colour value of the icon (optional).
icon: The icon to display in the list (optional).

A list in the summary.

Example

C.addListsToSummary(
    [
        {
           value: "Client Created successfully",
           valueColor: "#220010", 
           iconColor: "#220010", 
           icon: "fa-duotone fa-check"
         },
    ]
);

Output

addTextToSummary

Adds text to the summary.

Input Parameters	Returns
Text.	Text in the summary.

Example

C.addTextToSummary("New quotation successfully created");

Output

Payments

These function relate to payment gateways like Pin Payments and Zai. Whether you're taking a charge or providing a refund, these functions will help.

createCharge

Creates a payment charge on a credit card through Pin Payments.

Input Parameters	Returns
`cardInfo`: The card information. `cardToken`: A token of a customer's card. `customerToken`: A token associated with a customer's profile. `amount`: The amount to be charged. `description`: The description of the charge. `email`: The email address associated with the charge. `options`: Additional options such as the payment mode (test or live), surcharge inclusion, and surcharge pricing if applicable.	Information related to the payment transaction.

Input Parameters

Returns

cardInfo: The card information.
cardToken: A token of a customer's card.
customerToken: A token associated with a customer's profile.
amount: The amount to be charged.
description: The description of the charge.
email: The email address associated with the charge.
options: Additional options such as the payment mode (test or live), surcharge inclusion, and surcharge pricing if applicable.

Information related to the payment transaction.

❗️
Info:
One of cardInfo, cardToken or customerToken is required.

Example

C.createCharge({
        cardInfo: {
            number: "5520000000000000",
            expiry_month: "11",
            expiry_year: "2023",
            cvc: "123",
            name: "test",
            address_line1: "ad1",
            address_city: "ad2",
            address_postcode: "123",
            address_country: "Australia",
            address_line2: "ad2",
            address_state: "st1",
        },

        // cardToken: cardToken.cardResponse.token, 
        // customerToken: "customer_token",

        amount: 200,
        description: "test charge",
        email: "test@clevero.co",
        options: {
            testOrLive: "test",
            addSurcharge: true,
            surchargePricing: {
                domestic: { percent: 0.2, constantAmount: 1.6 },
            },
        },
    });

createZaiCharge

Creates a payment charge on a credit card through Zai Payments.

Input Parameters	Returns
`data`: An object that holds essential information like the charge's name, amount, currency, and user-related information.	Zai charge in JSON payload.

Example

await C.createZaiCharge({
        data: {
            name: "Charge from workflow",
            account_id: "0ac944f0-e32c-013b-725d-0a58a9feac03",
            amount: 4200,
            email: "test@clevero.co",
            zip: 3000,
            country: "AUS",
            currency: "AUD",
            user_id: "demo-user",
            custom_descriptor: "229",
        },
});

refundZaiCharge

Process a refund through Zai Payments.

Input Parameters	Returns
`itemId`: The ID you get after creating a Zai charge. `params`: An optional parameter to control the refunded amount. `refundAmount`: Pass this if you need partial refunds. If this is not passed, the full amount will be refunded. `refundMessage`: A message associated with the refund. `accountId`: The account where the refunded funds should be credited.	Refund details in JSON payload.

Example

C.refundZaiCharge({
        itemId: "aeb114f9-bb86-4702-984d-f518df52d4d0",
				params: { // Optional
        		refundAmount: 1050; 
        		refundMessage: "Your booking for course: C122 has been cancelled. Amount $10.50 has been refunded";
        		accountId: "0ac944f0-e32c-013b-725d-0a58a9feac03"; 
    		}
});

Portals

Our portal functions assist in providing, restricting or removing access to Portals quickly and easily.

createPortalUser

Creates a portal user.

Input Parameters	Returns
`email`: The email used for creating a portal user, which the user can use to log in to the portals. `portalContactId`: Entry ID of the contact record. `portalRoleId`: The portal role for which we are creating a portal user. `dataScopeEntryId`: Entry ID of the datascope record. `portalIdentifier`: The portal type for which we are creating a portal user.	New portal user details.

📘
Info:
If the portal configures the same record for datascope and contact, both dataScopeEntryId and portalContactId can use the same entry ID.

Example

const payload1 = {
        email: email1,
        portalContactId: 1185813,
        portalRoleId: 1185799,
        dataScopeEntryId: 25254,
        portalIdentifier: "portal-1",
    };
const response = await C.createPortalUser(payload1);

disablePortalAccess

Disables the user's portal access.

Input Parameters	Returns
`portalUserIds`: An array containing the IDs of the portal users for whom access will be disabled.	Any string.

Example

C.disablePortalAccess({
  portalUserIds: []
});

enablePortalAccess

Enables the user's portal access.

Input Parameters	Returns
`portalUserIds`: An array containing the IDs of the portal users for whom access will be enabled.	Any string.

Example

C.enablePortalAccess({
  portalUserIds: []
});

removePortalAccess

Deletes the portal access.

Input Parameters	Returns
`portalUserIds`: An array of portal-employee IDs.	Removal status.

Example

C.removePortalAccess({
  portalUserIds: [],
})

updatePortalAccess

Updates the portal access.

Input Parameters	Returns
`portalUserIds`: An array of portal-employee IDs. `type`: The action to be performed. If set to `enable`, the portal access is enabled. Otherwise, `disable`.	Update status.

Example

C.updatePortalAccess({
  portalUserIds: [], 
  type: "enable"
})

Record

These functions relate specifically to records. Here you'll find functions to create entries, update entry data, delete entries and many other useful functions.

createEntries

Creates one or more entries for a record.

Input Parameters	Returns
`values`: An individual data entry, each with a name, a parent identifier, and an index within a collection of values. `recordInternalId`: Record internal id.	Entry details.

Example

await C.createEntries({
    recordInternalId: 'customers',
    values: [
        {
            firstName: 'test',
            lastName: 'clevero',
            email: 'test@clevero.co',
            phone: '123-456-7890'
        },
        {
            firstName: 'demo',
            lastName: 'clevero',
            email: 'demo@clevero.co',
            phone: '987-654-3210'
        }
    ]
});

createEntry

Creates a single entry for a record.

Input Parameters	Returns
`values`: A data object with attributes like a name, a parent identifier, and an index. `recordInternalId`: Record internal id.	Entry details.

Example

await C.createEntry({
    recordInternalId: 'customers',
    value: {
        firstName: 'test',
        lastName: 'clevero',
        email: 'test@clevero.co',
        phone: '123-456-7890'
    }
});

deleteEntries

This will delete entries from the system. Use with caution.

❗️
If used, this will delete the data completely. There is no recovery process once executed!

Input Parameters	Returns
`entryIds`: An identifier from a specific entry of a record. `recordInternalId`: Record internal id.	Any string.

Example

C.deleteEntries({
        deletes: [
            {
                entryIds: [562940, 556889],
                recordInternalId: 'backlog-items',
            },
        ],
    });

getCurrentEntry

Gets the current entry. To be used with real time scripts only.

Input Parameters	Returns
-	`currentEntry`.

Example

let currentEntry = await C.getCurrentEntry();
C.addJsonToSummary(currentEntry);

getCurrentEntryAssociations

Gets association data for the current entry. Only available for Real Time Scripts. E.g get all Invoices on a Customer.

Input Parameters	Returns
`associationsId`: Associations ID.	Associations data.

Example

let customerInvoices = await C.getCurrentEntryAssociations("invoices");
C.addJsonToSummary(customerInvoices)

getCurrentEntrySubrecords

Gets subrecords data for the current entry.

Input Parameters	Returns
`subrecordsId`: Subrecord ID.	Subrecords data.

Example

C.getCurrentEntrySubrecords("clevero-dependencies")

getEntry

Gets an entry by its ID. Useful when you want to retrieve a specific entry where you know the record and id of the entry.

Input Parameters	Returns
`entryId`: An identifier with a specific entry of a record. `recordInternalId`: Record internal id.	Any string.

Example

async function script(C) {
    try {
        const result = await C.getEntry({
            entryIds: 760176,
            recordInternalId: "organisations",
        });
        C.log("Fetched Entry:", result);

        C.addJsonToSummary(result, { enableCopy: true });

        return {
            result,
        };
    } catch (error) {
        C.error("Error fetching entry:", error);
    }
}

Output

[
  {
    "name": "Company Name – Location",
    "date-added": "2022-08-29T03:20:20.739Z",
    "stage": [
      465013
    ],
    "lead-source": [
      589984
    ],
    "main-email": "test@clevero.co",
    "status": [
      579263
    ],
    "type": [
      92912
    ],
    "first-name": "test",
    "last-name": "clevero",
    "currency": [
      589861
    ],
    "sales-rep": [
      590528
    ],
    "xero-id": "e486459c-7485-44b1-97f2-015202cfa664",
    "xero-updated-date-utc": "2022-08-24T15:12:45.000Z",
    "total-invoiced": 1669.8,
    "recordValueId": 760176,
    "createdAt": "2022-08-24T09:03:17.404Z",
    "updatedAt": "2024-07-29T10:57:50.724Z",
    "autoId": "58",
    "autoIdNum": 58,
    "internalOwner": 463874,
    "formId": 558944,
    "recordId": 464166
  }
]

getEntries

Will retrieve multiple entries based on ids passed in.

Input Parameters	Returns
`entryIds`: An array that contains multiple entry IDs. `recordInternalId`: Record internal id.	An array of entries.

Example

async function script(C) {
    const result = await C.getEntries({
        entryIds: [760176, 1342638],
        recordInternalId: 'organisations',
    });

    C.addJsonToSummary(result, { enableCopy: true });

    return {
        result
    };
}

Output

[
  {
    "name": "Sample Company - Perth",
    "date-added": "2022-08-29T03:20:20.739Z",
    "stage": [
      465013
    ],
    "lead-source": [
      589984
    ],
    "main-email": "test@clevero.co",
    "status": [
      579263
    ],
    "type": [
      92912
    ],
    "first-name": "test",
    "last-name": "clevero",
    "currency": [
      589861
    ],
    "sales-rep": [
      590528
    ],
    "xero-id": "e486459c-7485-44b1-97f2-015202cfa664",
    "xero-updated-date-utc": "2022-08-24T15:12:45.000Z",
    "total-invoiced": 1669.8,
    "recordValueId": 760176,
    "createdAt": "2022-08-24T09:03:17.404Z",
    "updatedAt": "2024-07-29T10:57:50.724Z",
    "autoId": "58",
    "autoIdNum": 58,
    "internalOwner": 463874,
    "formId": 558944,
    "recordId": 464166
  },
  {
    "name": "Sample Company - Brisbane",
    "date-added": "2024-08-29T06:58:55.880Z",
    "stage": [
      465012
    ],
    "lead-source": [
      589985
    ],
    "status": [
      579254
    ],
    "type": [
      92912
    ],
    "parent": [
      593962
    ],
    "sales-rep": [
      764269
    ],
    "logo": null,
    "total-invoiced": 98,
    "primary-contact": [
      764456
    ],
    "client-name": "John Doe",
    "recordValueId": 1342638,
    "createdAt": "2023-01-15T05:08:54.967Z",
    "updatedAt": "2024-08-29T06:58:56.252Z",
    "autoId": "59",
    "autoIdNum": 59,
    "internalOwner": 463874,
    "formId": 558944,
    "recordId": 464166
  }
]

updateEntries

Updates entries.

Input Parameters	Returns
`value`: An object containing data updates to apply to a specific entry, including new values for various fields. `entryId`: Identifier for the entry. `recordInternalId`: Subrecord's internal id.	Any string.

Example

async function script(C) {
    const currentEntry = await C.getCurrentEntry();

    await C.updateEntries({
        updates: [
            {
                value: { "date-added": C.moment().toISOString() },
                recordInternalId: "leads",
                entryId: currentEntry.recordValueId,
            },
        ],
    });

    C.addJsonToSummary(currentEntry, { enableCopy: true });

    // Return the current entry
    return currentEntry;
}

Output

{
  "date-added": "2024-09-06T09:50:41.880Z",
  "status": [
    578998
  ],
  "enquiry-source": [
    1629571
  ],
  "contact": [
    744408
  ],
  "name": "test clevero",
  "assigned-to": [
    1311762
  ],
  "enquiry-details": "PRD SRS",
  "recordValueId": 200740514,
  "createdAt": "2024-09-06T09:50:41.705Z",
  "updatedAt": "2024-09-06T09:50:41.906Z",
  "autoId": "65",
  "autoIdNum": 65,
  "internalOwner": 463874,
  "formId": 579014,
  "recordId": 578177
}

Search Filters

Our search function allows you to retrieve multiple entries by passing it specific search criteria that is needed.

filterEntries

Filters existing entries. This is commonly used in Scheduled Scripts when wanting to iterate through multiple entries. E.g send an email to customers with an overdue Invoice

Input Parameters	Returns
`filter`: A set of criteria used to refine a data query, such as the target attribute, request type, the filter operator, and any value from the specified array. `recordInternalId`: Record internal id.	`array of objects`.

Example

let invoices = await C.filterEntries({
        filter: [
            {
                subject: "overdue",
                requestType: "i",
                type: "checkbox",
                operator: "is_true"
            },
        ],
        recordInternalId: "invoices",
});

C.addJsonToSummary(invoices);

Xero and MYOB

If you're looking to build your own custom integration with Xero and MYOB, you can do so using our functions here.

myobGetApiCred

Obtains a valid token to be used with the MYOB API.

Example

async function script(C) {
     // Fetch MYOB API credentials 
     const myobCredResponse = await C.myobGetApiCred("<myobClientId>");
}

xeroGet

Get information from Xero with the requested correspondingRecordType.

Valid valued for correspondingRecordType include:

account
brandingTheme
contact
creditNote
currency
invoice
item
manualJournal
purchaseOrder
payment
trackingCategory

Input Parameters	Returns
`xeroTenantId`: Identifier for the Xero tenant. `correspondingRecordType`: The type of record or data you want to retrieve from Xero.	`xeroGet`

Example

C.xeroGet({
        xeroTenantId: tenantId,
        correspondingRecordType: "invoice",
});

xeroUpsert

Upserts data to Xero.

Valid valued for correspondingRecordType include:

invoice
item
bill
contact
purchaseOrder
payment
creditNote
trackingOption
trackingCategory
payrollEmployee
payrollTimesheet
manualJournal

Input Parameters	Returns
`recordId`: Identifier for the record. `entryId`: Identifier for the entry. `xeroTenantId`: Identifier for the Xero tenant. `correspondingRecordType`: The type of record being handled in the upsert operation. `xeroEntryData`: An object or data that contains information to be updated in Xero.	`xeroClient`

Example

C.xeroUpsert({
        recordId: 591600,
        entryId: 698937,
        xeroTenantId: tenantId,
        correspondingRecordType: "item",
        xeroEntryData: data,
});

xeroUtility

Performs utility operations with Xero. The main utility used here is sending of an email.

Input Parameters	Returns
`recordId`: Identifier for the record. `entryId`: Identifier for the entry. `xeroTenantId`: Identifier for the Xero tenant. `correspondingRecordType`: The type of record or data the utility operation processes. `xeroUtilityData`: An object containing specific data or parameters related to the utility operation.	`tenantId`

Example

C.xeroUtility({
  recordId: 1234, // <-- pass number value here
	entryId: "invoice",
	xeroTenantId: "<YourTenantId>",
	correspondingRecordType: "emailInvoice",
	xeroUtilityData: {
		invoiceID: "<invoiceId>", // Xero's id
	},
});

xeroGetToken

Obtains a valid token to be used with the Xero API.

Example

const accessToken = await C.xeroGetToken(); 
const URL = "https://api.xero.com/api.xro/2.0/Invoices"
const options = {
    headers: {
        Authorization: `Bearer ${accessToken}`,
        "xero-tenant-id": ""
    },
};
// Perform API request
const {data} = await axios.get(URL, options);
C.addJsonToSummary(data)

📌 Need Help?

If you require assistance or encounter any issues, please don't hesitate to contact us for further support.