UnifyApps

https://www.unifyapps.com/docs
Admin
UnifyApps is a comprehensive platform offering solutions for building Agentic AI, no-code enterprise...
Tokens:135,795
Snippets:663
Trust Score:7.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Microsoft Graph API - OAuth Based Authentication Setup

Source: https://www.unifyapps.com/docs/unify-integrations/microsoft-graph-api

Step-by-step guide to setting up OAuth based authentication using the Microsoft Azure Portal.

```APIDOC
## Microsoft Graph API - OAuth Based Authentication Setup

### Description
Steps to configure OAuth based authentication by registering an application in the Microsoft Azure Portal.

### Steps
1. Log in to the Microsoft Azure Portal.
2. Search for `App Registration` and click on `New registration`.
3. Provide the application name, supported account types, and Redirect URIs.
4. Register your application.
5. Obtain `Client ID` and `Tenant ID` from the Overview tab.
6. Grant necessary permissions in the API Permissions tab.
7. Create a client secret in the Certificates & Secrets tab. Copy the `Value` and store it securely.
```

--------------------------------

### OAuth Based Authentication Setup

Source: https://www.unifyapps.com/docs/unify-integrations/microsoft-entra-id

Step-by-step guide to obtaining OAuth credentials from the Microsoft Azure Portal for your application.

```APIDOC
## OAuth Based Authentication

To get your OAuth credentials, follow the steps given below:

1.  Login into the Microsoft Azure Portal by clicking here.
2.  In the search Bar, search for `App Registration` and then click on `New registration`.
3.  Provide the name, supported account types, Redirect URIs and register your app.
4.  In the Overview tab, you can find the Client ID and Tenant ID. Required permissions can be granted in the API Permissions tab.
5.  To create a client secret, click on the `Certificates and Secrets` tab and click on New client secret. Copy the “`Value`” as the Client secret.
```

--------------------------------

### AES Encryption Example

Source: https://www.unifyapps.com/docs/unify-data/encryption

Demonstrates the input and expected encrypted output for a sample string using AES encryption. This is useful for verifying the encryption process.

```text
Input: Sample String
Encrypted Output: enhTmMxQS+2o1Oi1nvnpxA==
```

--------------------------------

### Install UnifyApps React Package with npm

Source: https://www.unifyapps.com/docs/embedded-integrations/platform-embed-react-sdk

This command installs the necessary @unifyapps/platform-react package using npm. Ensure you have a .npmrc file configured with authentication details if required.

```bash
npm install @unifyapps/platform-react
```

--------------------------------

### SFTP Private Key with Password Authentication Setup

Source: https://www.unifyapps.com/docs/unify-integrations/sftp

Configuration guide for SFTP authentication using a private key that is protected by a password. It follows the private key setup process and adds the step of providing the private key password during connection.

```text
1. Generate a key pair on your local machine. (https://dev.to/risafj/ssh-key-authentication-for-absolute-beginners-in-plain-english-2m3f)
2. Copy the public key to the remote server's authorized_keys file.
3. Configure your SSH client to use the private key.
4. When connecting, provide the password (refer **Connecting with SFTP Client section**).
5. Attempt to connect to the remote server.
6. If successful, you'll be logged in after providing your private key password.
```

--------------------------------

### Coupa OAuth 2.0 Client Configuration Example

Source: https://www.unifyapps.com/docs/unify-integrations/coupa

This snippet demonstrates the typical steps involved in configuring an OAuth 2.0 client within Coupa for integration. It outlines the navigation path and the essential action of selecting scopes for the integration. Note that this is a conceptual representation of the UI steps and not executable code.

```text
1. Login to Coupa: Access your Coupa instance at https://[your-instance-name].coupacloud.com/oauth2/clients.
2. Navigate to OAuth Setup: Go to `Setup` then `Integrations` and then OAuth2/OpenID Connect Clients in the menu.
3. Create a New OAuth Client: Select “`Create`” to configure a new OAuth client and fill in the necessary details:
4. Select all the scopes that you plan to provide to Unify Apps. Example: core.common.read
5. After adding all selections, click `Save`.
6. Coupa displays the OAuth connection details, including the Secret. Copy and store the Identifier and the Secret for use in Unify Apps.
```

--------------------------------

### Navigation Container Structure Example

Source: https://www.unifyapps.com/docs/unify-applications/navigation-container

Illustrates the hierarchical structure of a Navigation Container, showing nested components like forms, charts, and buttons within different navigation sections. This example helps visualize how to organize UI elements within a navigation layout.

```plaintext
NavigationContainer_2
├── Navigation_2
├── Home
│   └── Card_1
├── Active Projects
│   └── Form_1
├── Completed
│   └── Button_5
├── Analytics
│   └── Chart_1
├── Notifications
│   └── IconButton_1
├── Team
│   └── Image_1
└── Settings
    └── ButtonGroup_2
```

--------------------------------

### Timeline Component Description Configuration Example

Source: https://www.unifyapps.com/docs/unify-applications/timeline

Configuration example for the 'Description' property of the Timeline component. It shows how to combine multiple data fields and static text to create a detailed description of user activity.

```Unify Applications UI
`Description`: This field is used to display the description of user activity. Multiple data fields can be combined to create a meaningful description.  
For eg. , in the screenshot below, we are using a static text “USER_ID” and then appending actual “User Id” values to display in the description.
```

--------------------------------

### Prerequisites and Setup

Source: https://www.unifyapps.com/docs/unify-data/quickbooks-as-source

Steps to obtain necessary credentials and configure your Intuit Developer application.

```APIDOC
## Prerequisites and Setup

Before configuring QuickBooks as your source, ensure you have the necessary credentials and have set up your Intuit Developer application.

### Client ID and Secret Setup

1.  **Log in to Intuit Developer**: Go to the [Intuit Developer Dashboard](https://developer.intuit.com/) and sign in.
2.  **Create or Select an App**: From the Dashboard, click '`Create an App`' or select an existing app. Choose the appropriate app type.
3.  **Navigate to Keys & Credentials**: In the app menu, select '`Keys & Credentials`'. Your Client ID and Client Secret will be available under the Development or Production environment.

### Set Redirect URI

1.  **Access App Settings**: Go to the '`Settings`' tab in your Intuit Developer app.
2.  **Configure Redirect URIs**: Select '`Redirect URIs`' and add your application's callback URL (e.g., `https://your-app.com/callback`). Ensure it matches your application's endpoint exactly.
3.  **Save Changes**: Click 'Save' to apply the redirect URI configuration.
```

--------------------------------

### Zoom Authentication: Client Credentials Setup

Source: https://www.unifyapps.com/docs/unify-integrations/zoom

This section guides users through setting up Client Credentials for Zoom API authentication. It involves creating a server-to-server app on the Zoom App Marketplace, obtaining credentials like account ID, client ID, and client secret, and configuring app information and features. The process requires adding necessary scopes to grant the app permissions to specific Zoom API endpoints.

```text
1. Go to the **Zoom App Marketplace**. Click Develop in the dropdown menu in the top-right corner of the page and select Build Server-to-Server App.
2. Add a name for your app and click `Create`.
3. On the left navigation menu, within the App credentials section your account ID, client ID and client secret would be visible.
4. `Information`: Add information about your app, such as a short description, company name, and developer contact information (name and email address are required for app activation).
5. `Features`: within the Add feature section, you'll have the secret token required for authentication.
6. `Scopes`: Add any scopes that are needed for your app. Scopes define the API methods this app is allowed to call, and thus which information and capabilities are available on Zoom. Choose Add Scopes to search for and add scopes.
```

--------------------------------

### Setting Up Zoom Webhook

Source: https://www.unifyapps.com/docs/unify-integrations/zoom

Step-by-step guide on how to set up a webhook in your Zoom App to trigger automations.

```APIDOC
## How to setup up Webhook in your Zoom App

  1.  `Click` on the zoom trigger in your automation and copy the webhook URL from the setup section.
  2.  `Login` into Zoom Marketplace and select the app that you have created.
  3.  Navigate to the “`Feature`” section in the left navigation menu
  4.  Under the general feature section, enable the “`Event Subscription`” toggle.
  5.  Provide the subscription name and select “`Webhook`” as method
  6.  In “`Event notification endpoint URL`”, provide the Webhook URL and click on the `validate` button.
  7.  In the Add event section, select the event for which you want to trigger your automation.
  8.  Now, Click on the “`Save`” button.
```

--------------------------------

### Timeline Component User Configuration Example

Source: https://www.unifyapps.com/docs/unify-applications/timeline

Example demonstrating the configuration of the 'User' property for the Timeline component. It involves fetching user information from 'Timeline -> Context -> User' and potentially combining it with other data pills for display, such as user email IDs.

```Unify Applications UI
`User`: This field is used to display the Username for the user who has performed the action. This needs to be fetched from the Datapills “Timeline -> Context -> User” Datafield and is visible under Input properties. This can also be combined with other datapills to get meaningful outputs. For e.g., in the screenshot,we are displaying the user Email Id in this field
```

--------------------------------

### Timeline Component Data Configuration Example

Source: https://www.unifyapps.com/docs/unify-applications/timeline

Example illustrating how to configure the 'Data' property for the Timeline component by fetching audit logs from a data source. This data source typically runs an Automation that fetches audit trails.

```Unify Applications UI
`Data`: This is the main parameter which will be fetched to track and show changes in the TIMELINE view. For e.g. in the screenshot below, we are fetching the DATA for Timeline from a data source called “Data -> Fetch Audit Logs”. This data source runs on an Automation which fetches audit trails for every user using the standard “Audit by UnifyApps” node.
```

--------------------------------

### Parent Automation Setup for Parallel Order Processing

Source: https://www.unifyapps.com/docs/unify-automations/signals-by-unifyapps

Illustrates the setup within a parent automation to handle parallel order processing. It involves creating a list to track order signals, looping through orders to start child automations, and configuring a 'Wait Signal' node to collect responses.

```unifyapps-logic
1. First, we get the list of 1000 orders
2. Create an empty list '`orderSignals`' to track our processing
3. Start a loop for these orders:
   * For each order, add "`Index`" to orderSignals list
   * Start child automation for order processing
4. Use Wait Signal node:
   * Map our orderSignals list to Signal IDs
   * Define what response we expect (order status, processing time)
5. After receiving all signals, it moves to subsequent step
```

--------------------------------

### Timeline Component Title Configuration Example

Source: https://www.unifyapps.com/docs/unify-applications/timeline

Example of configuring the 'Title' property for the Timeline component. It shows fetching data from 'Timeline -> Context -> Title' and combining it with static text for a meaningful display, such as showing when a user logged in.

```Unify Applications UI
`Title`: This field is used to display the Title of the action which has been performed. This needs to be fetched from the Datapills “Timeline -> Context -> Title” Datafield and is visible under Input properties. This can also be combined with other datapills to get meaningful outputs. For e.g., in the screenshot, for displaying the title , we want to display when a user has logged in and hence used the datapill “UserName” with static text “LoggedIn”.
```

--------------------------------

### Timeline Component Timestamp Configuration Example

Source: https://www.unifyapps.com/docs/unify-applications/timeline

Example for configuring the 'Timestamp' property in the Timeline component. It shows fetching the action timestamp from 'Timeline -> Context -> Timestamp', useful for displaying event times like login times.

```Unify Applications UI
`Timestamp`: This field is used to display the timestamp at which the action was taken. This needs to be fetched from the Datapills “Timeline -> Context -> Timestamp” Datafield and is visible under Input properties. For. eg, in the screenshot below, we are fetching values from datapill “LOGIN TIME” as we are displaying the login activity.
```

--------------------------------

### Database Log-Based Extraction Examples

Source: https://www.unifyapps.com/docs/unify-data/core-concepts

Illustrates examples of log files used for data extraction from databases. This method allows for minimal performance impact on source systems while ensuring comprehensive data capture.

```text
MySQL's binlog
Oracle's redo logs
```

--------------------------------

### Sendspark Webhook Setup Guide

Source: https://www.unifyapps.com/docs/unify-integrations/sendspark

Steps to configure webhooks in Sendspark to receive data from your external application. This involves specifying a webhook URL and selecting events to trigger the webhook.

```text
1. Navigate to Sendspark platform and log in.
2. Select 'Webhooks' from the 'Integrations' section.
3. Click 'Create New Webhook' or 'Add Webhook'.
4. Enter a 'Webhook Name'.
5. In the 'Webhook URL' field, enter your application's URL.
6. Select events that will trigger the webhook and click 'Connect Campaign'.
```

--------------------------------

### Coupa Authentication and OAuth

Source: https://www.unifyapps.com/docs/unify-integrations/coupa

Information on how to authenticate with Coupa using OAuth 2.0 and set up OAuth credentials.

```APIDOC
## Coupa Authentication and OAuth

### Description
This section details the authentication process for integrating with Coupa, focusing on OAuth 2.0.

### Authentication Types
- **OAuth 2.0**: Recommended for integrations, enabling secure, controlled access to Coupa's APIs.

### OAuth Authentication Steps
1. **Login to Coupa**: Access your Coupa instance at `https://[your-instance-name].coupacloud.com/oauth2/clients`.
2. **Navigate to OAuth Setup**: Go to `Setup` > `Integrations` > `OAuth2/OpenID Connect Clients`.
3. **Create New OAuth Client**: Select 'Create' and fill in the required details.
4. **Select Scopes**: Choose all necessary scopes for Unify Apps (e.g., `core.common.read`).
5. **Save Configuration**: Click 'Save' after selecting scopes.
6. **Obtain Credentials**: Copy and securely store the generated `Identifier` and `Secret` for use in Unify Apps.
```

--------------------------------

### AES Decryption Example

Source: https://www.unifyapps.com/docs/unify-data/encryption

Shows the encrypted input and the corresponding decrypted output for a sample social security number using AES decryption. This helps in validating the decryption process.

```text
Encrypted Input: enhTmMxQS+2o1Oi1nvnpxA==
Decrypted Output: 123-45-6789
```

--------------------------------

### Example Manifest JSON for Unify Component

Source: https://www.unifyapps.com/docs/unify-applications/add-custom-component

An example JSON structure for the manifest.json file, which configures custom components within Unify Applications. It includes properties like name, type, entry point, keywords for searching, and styling information.

```json
{
  "name": "SuperButton",
  "type": "SuperButton",
  "entry": "./src/index.jsx",
  "keywords": "SuperButton",
  "style": "./src/style.css",
  "icon": "https://assets.unifyapps.com/user-uploads/theme/unify.svg"
}
```

--------------------------------

### Manually Enter Static Array Data Source Example

Source: https://www.unifyapps.com/docs/unify-applications/using-repeatable

This example demonstrates how to manually define a static array for the Data Source property of the Repeatable component for prototyping purposes. It shows the expected format of an array of objects, each with an 'id' and 'name'.

```javascript
{
  "id": "1",
  "name": "Item 1"
},
{
  "id": "2",
  "name": "Item 2"
}
```

--------------------------------

### Coupa Actions

Source: https://www.unifyapps.com/docs/unify-integrations/coupa

A comprehensive list of available actions that can be performed on Coupa resources through the integration.

```APIDOC
## Coupa Actions

### Description
Actions represent the specific operations you can perform on Coupa resources via the integration.

| Action Name                 | Description                                                |
|-----------------------------|------------------------------------------------------------|
| `Cancel purchase order`     | Cancels purchase order in Coupa                            |
| `Clone account type`        | Clones a chart of accounts in Coupa                        |
| `Close purchase order`      | Closes purchase order in Coupa                             |
| `Create account type`       | Creates a chart of accounts in Coupa                       |
| `Create budget line`        | Creates a budget line in Coupa                             |
| `Create item`               | Creates an item in Coupa                                   |
| `Create supplier`           | Creates a supplier in Coupa                                |
| `Create task`               | Creates a task in Coupa                                    |
| `Delete task`               | Deletes a task in Coupa                                    |
| `Get account type by id`    | Retrieves a chart of accounts by ID in Coupa               |
| `Get budget line by id`     | Retrieves a budget line by ID in Coupa                     |
| `Get item by id`            | Retrieves an item by ID in Coupa                           |
| `Get supplier information site`| Retrieves supplier information sites by supplier ID in Coupa|
| `Get task by id`            | Retrieves task by ID in Coupa                              |
| `Grant approval`            | Perform approve action on an approval in Coupa             |
| `Reject approval`           | Perform reject action on an approval in Coupa              |
| `Update budget line`        | Updates a budget line record in Coupa                      |
| `Update item`               | Updates an item in Coupa                                   |
| `Update task`               | Updates a task in Coupa                                    |
```

--------------------------------

### Delighted API Authentication Example

Source: https://www.unifyapps.com/docs/unify-integrations/delighted

This example demonstrates how to authenticate with the Delighted API using HTTP Basic Auth. Your private API key should be used as the username, and the password field should be left blank. All requests must be made over HTTPS.

```bash
curl -u YOUR_API_KEY:https://api.delighted.com/v1/metrics.json
```

```python
import requests

api_key = "YOUR_API_KEY"
url = "https://api.delighted.com/v1/metrics.json"

response = requests.get(url, auth=(api_key, ""))

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
```

```javascript
const apiKey = "YOUR_API_KEY";
const url = "https://api.delighted.com/v1/metrics.json";

fetch(url, {
  method: 'GET',
  headers: {
    'Authorization': 'Basic ' + btoa(apiKey + ':')
  }
})
.then(response => {
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return response.json();
})
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```

--------------------------------

### Install UnifyApps React SDK using npm

Source: https://www.unifyapps.com/docs/embedded-integrations/application-embed-react-sdk

This command installs the UnifyApps React SDK package from npm, making it available for use in your React project. Ensure you have Node.js and npm installed.

```bash
npm install @unifyapps/sdk-react
```

--------------------------------

### OAuth Authentication Setup

Source: https://www.unifyapps.com/docs/unify-data/snowflake-as-destination

Steps and commands for setting up OAuth authentication for Snowflake connections.

```APIDOC
## OAuth Authentication Setup

### Description
This section details the process of setting up OAuth authentication for secure, token-based Snowflake connections.

### Method
SQL commands

### Endpoint
Not Applicable (Snowflake SQL)

### Prerequisites
- ACCOUNTADMIN or SECURITYADMIN role access in Snowflake.
- A configured Callback URL for your UnifyApps instance.

### Setup Steps
1. **Create Security Integration:**
   ```sql
   USE ROLE ACCOUNTADMIN;
   CREATE SECURITY INTEGRATION <integration_name>
     TYPE = OAUTH
     ENABLED = TRUE
     OAUTH_CLIENT = CUSTOM
     OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'
     OAUTH_REDIRECT_URI = '<https://your-callback-uri>'
     OAUTH_ISSUE_REFRESH_TOKENS = TRUE
     OAUTH_REFRESH_TOKEN_VALIDITY = 7776000;
   ```

2. **Get OAuth Client Credentials:**
   ```sql
   SELECT SYSTEM$SHOW_OAUTH_CLIENT_SECRETS('<integration_name>');
   ```
   This command will return the `Client ID`, `Client Secret`, and `Client Secret 2` values.

3. **Retrieve OAuth Information:**
   ```sql
   DESCRIBE SECURITY INTEGRATION <integration_name>;
   ```
   This command displays details including the `Client ID` (OAUTH_CLIENT_ID), configuration parameters, and OAuth Endpoint URLs (Authorization, Token, Revoke URLs).

### Response Example (from `SYSTEM$SHOW_OAUTH_CLIENT_SECRETS`)
```json
{
  "CLIENT_ID": "your_client_id_here",
  "CLIENT_SECRET": "your_client_secret_here",
  "CLIENT_SECRET_2": "your_client_secret_2_here"
}
```

### Response Example (from `DESCRIBE SECURITY INTEGRATION` - relevant parts)
```json
{
  "property": "OAUTH_CLIENT_ID", "value": "your_client_id_here", "type": "VARCHAR"
}
{
  "property": "OAUTH_AUTHORIZATION_ENDPOINT", "value": "https://your-account.snowflakecomputing.com/oauth/authorize", "type": "VARCHAR"
}
{
  "property": "OAUTH_TOKEN_ENDPOINT", "value": "https://your-account.snowflakecomputing.com/oauth/token", "type": "VARCHAR"
}
```
```

--------------------------------

### Coupa Scopes

Source: https://www.unifyapps.com/docs/unify-integrations/coupa

A list of available scopes for Coupa integration, detailing the level of access each scope provides.

```APIDOC
## Coupa Scopes

### Description
Scopes define the permissions granted to your integration when accessing Coupa data.

| Scope Code                      | Description                                     |
|---------------------------------|-------------------------------------------------|
| `core.common.read`              | Basic read access for Coupa data                |
| `core.common.write`             | Basic edit access for Coupa data                |
| `core.account_type.read`        | Access to view account types                    |
| `core.account_type.write`       | Access to create and update account types       |
| `core.budget_line.read`         | Access to view budget lines                     |
| `core.budget_line.write`        | Access to create and update budget lines        |
| `core.item.read`                | Access to view items                            |
| `core.item.write`               | Access to create and update items               |
| `core.task.read`                | Access to view tasks                            |
| `core.task.write`               | Access to create and update tasks               |
| `core.supplier.read`            | Access to view suppliers                        |
| `core.supplier.write`           | Access to create and update suppliers           |
| `core.supplier_information_site.read` | Access to view supplier information sites       |
| `core.supplier_information_site.write`| Access to create and update supplier information sites|
| `core.approval.read`            | Access to view approvals                        |
| `core.approval.write`           | Access to create and update approvals           |
| `core.purchase_order.read`      | Access to view purchase orders                  |
| `core.purchase_order.write`     | Access to create and update purchase orders     |
```

--------------------------------

### Interface-based Callables

Source: https://www.unifyapps.com/docs/unify-automations/callable

Create standardized interfaces for your automations, enabling dynamic selection and execution of different automation logic based on runtime conditions.

```APIDOC
## Interface-based Callables

### Description
Interface-based callables allow you to define a standard interface (input and output schema) for a group of related automations. This enables dynamic selection and execution of a specific automation within that group at runtime, based on defined conditions or input parameters.

### Method
Dynamic Execution based on Interface

### Endpoint
N/A (Managed within the UnifyApps interface)

### Parameters
#### Interface Definition Parameters
*   **interface_name** (string) - Required - A name for the callable interface.
*   **input_schema** (object) - Required - Defines the expected input structure for any automation implementing this interface.
    *   **field1** (string) - Required - Description of interface input field 1.
*   **output_schema** (object) - Required - Defines the expected output structure for any automation implementing this interface.
    *   **field1** (string) - Description of interface output field 1.

#### Runtime Selection Parameters
*   **runtime_condition** (expression) - Defines the logic for selecting which specific automation to execute based on input or other variables.

### Request Example (Conceptual within Workflow Builder)
When a parent automation needs to execute an interface-based callable:

1.  **Select Interface:** Choose the desired callable interface.
2.  **Provide Input:** Supply values for the `input_schema` fields.
3.  **Conditional Logic:** The system evaluates `runtime_condition` to determine which underlying automation to trigger.

### Response
#### Success Response (200)
*   **status** (string) - Indicates the success or failure of the executed automation.
*   **result** (object) - Contains the output data adhering to the `output_schema` of the executed automation.

#### Response Example
```json
{
  "status": "success",
  "result": {
    "field1": "dynamic_output_data"
  }
}
```
```

--------------------------------

### HubSpot OAuth Authentication Configuration

Source: https://www.unifyapps.com/docs/unify-data/hubspot-as-source

Configuration example for authenticating with HubSpot using OAuth. This method involves setting up a HubSpot Developer account and app, and providing a callback URL.

```json
{
  "connectionName": "MyAppHubSpotIntegration",
  "authenticationMethod": "oauth",
  "callbackUrl": "https://webhooks-global.ext-alb.uat.unifyapps.com/api/connector-auth-callback/oauth"
}
```

--------------------------------

### SFTP Basic Authentication Setup

Source: https://www.unifyapps.com/docs/unify-integrations/sftp

Instructions for setting up basic authentication for an SFTP server, including creating a user account and obtaining credentials. It also outlines how to connect using an SFTP client with host address, port, username, and password.

```text
1. Log into your server or hosting platform
2. Navigate to the SFTP settings or user management area
3. Create a new user account specifically for SFTP access
4. Assign necessary permissions and set up the home directory
5. Obtain the SFTP credentials (username and password)

Connecting with SFTP Client:
1. Open the client and add a new connection
2. Enter the connection details:
   * `Host address`
   * `Port` (usually 22)
   * `Username`
   * `Password`
3. Connect to the server and begin transferring files securely
```

--------------------------------

### Example URL Structure for UnifyApps Interface

Source: https://www.unifyapps.com/docs/embedded-integrations/application-embed-zendesk

This example illustrates the expected URL structure for accessing an UnifyApps interface within Zendesk. It highlights the dynamic parts like Subdomain, Interface ID, and Page ID that need to be correctly configured for seamless integration. Ensure these parameters match your application's specific setup.

```plaintext
https://Subdomain.unifyapps.com/p/0/interfaces/interface-ID/builder/page-Id
```

--------------------------------

### SFTP Private Key Authentication Setup

Source: https://www.unifyapps.com/docs/unify-integrations/sftp

Steps for setting up private key authentication for SFTP. This involves generating a key pair, copying the public key to the server, and configuring the SSH client to use the private key for passwordless login.

```text
1. Generate a key pair on your local machine. (https://dev.to/risafj/ssh-key-authentication-for-absolute-beginners-in-plain-english-2m3f)
2. Copy the public key to the remote server's authorized_keys file.
3. Configure your SSH client to use the private key.
4. Attempt to connect to the remote server.
5. If successful, you'll be logged in without needing a password.
```

--------------------------------

### Airtable Access Token Authentication Setup

Source: https://www.unifyapps.com/docs/embedded-integrations/airtable

This guide outlines the steps to generate a Personal Access Token for authenticating with Airtable. This token is essential for enabling your application to perform actions within your Airtable account. Treat this token as confidential.

```text
1. Login into Airtable account and click on the profile icon at the top right corner.
2. Navigate to the builder hub.
3. In the Personal Access token section, click on the “Create new token” button.
4. Provide the name and the required scopes for performing actions based on your use case and click on “Create Token”.
5. Treat this token with high confidentiality, as it allows access to your Airtable account.
```

--------------------------------

### Client-Side SDK Initialization (React)

Source: https://www.unifyapps.com/docs/embedded-integrations/authentication

This example shows how to initialize the UnifyApps React SDK to embed an application. It takes the SESSION_ID and other parameters to render the UnifyApps component within a React application. Ensure the SDK is properly installed and configured.

```javascript
import React, { useEffect, useRef } from 'react';
import { UnifyEmbed } from '@unifyapps/react-sdk'; // Assuming this is the import path

function UnifyAppEmbed({ sessionId, applicationId, pageId, pageInputs }) {
  const containerRef = useRef(null);

  useEffect(() => {
    // The UnifyEmbed component likely handles initialization internally
    // You might pass props directly or use a ref for imperative initialization if needed
    console.log('UnifyEmbed component rendered');
  }, [sessionId, applicationId, pageId, pageInputs]);

  return (
    <div ref={containerRef} style={{ width: '100%', height: '500px' }}>
      <UnifyEmbed
        applicationId={applicationId}
        sessionToken={sessionId}
        pageId={pageId} // Optional
        pageInputs={pageInputs} // Optional, should be a stringified JSON object
      />
    </div>
  );
}

export default UnifyAppEmbed;

// Usage example:
// const App = () => {
//   const [sessionToken, setSessionToken] = useState(null);
//   // ... logic to fetch sessionToken from backend ...

//   return (
//     <div>
//       {sessionToken ? (
//         <UnifyAppEmbed
//           sessionId={sessionToken}
//           applicationId="your_app_id"
//           pageId="home"
//           pageInputs={JSON.stringify({ userId: '123' })}
//         />
//       ) : (
//         <p>Loading Unify App...</p>
//       )}
//     </div>
//   );
// };
```

--------------------------------

### Configure Named Credentials for UnifyApps in Salesforce

Source: https://www.unifyapps.com/docs/embedded-integrations/application-embed-salesforce

This section describes how to configure Named Credentials in Salesforce for UnifyApps. It involves setting the authentication protocol to OAuth 2.0, specifying the authentication provider, and enabling the 'Start Authentication Flow on Save' option.

```text
1. Search for Named Credentials in Setup.
2. Edit unifyapps named credentials
3. Choose `OAuth 2.0` as Authentication Protocol.
4. Choose unifyapps as Authentication Provider.
5. Select “`Start Authentication Flow on Save`”
6. Click on `Save` Button
```

--------------------------------

### Airtable OAuth 2.0 Authentication Setup

Source: https://www.unifyapps.com/docs/unify-data/airtable

Steps to register a new OAuth 2.0 integration in Airtable. This process involves providing integration details and a redirect URL, and then noting down the Client ID and generating a client secret for secure authorization.

```text
1. Login into Airtable account and click on the profile icon at the top right corner.
2. Navigate to the developer hub.
3. In Oauth Integrations section, click on the “Register New OAuth integration” button.
4. Provide the “Name” and the “OAuth Redirect URL”. The OAuth Redirect URL is the destination to which users will be redirected after authorizing their integration.
   Note: Use the following callback URL to complete the OAuth flow with UnifyApps. For example If you are accessing through qa.unifyapps.com the callback URL would be this: http://webhooks-golbal.ext-alb.qa.unifyapps.com/api/connector-auth-callback/oauth
5. Then click on the “Register integration” button.
6. After registration fill out the details as mentioned. Note down the Client ID and also generate a client secret by clicking on the “Generate client secret” and save it to form a connection.
7. Then select the scopes you wish to expose through this connection.
```

--------------------------------

### Connection Configuration

Source: https://www.unifyapps.com/docs/unify-data/quickbooks-as-source

Configuration parameters required to establish a connection to QuickBooks Online.

```APIDOC
## Connection Configuration

This section details the parameters required to set up a new connection to QuickBooks Online.

### Parameters

#### Request Body

- **Connection Name** (string) - Required - Descriptive identifier for your connection
- **Authentication Method** (string) - Required - OAuth authentication type (OAuth or OAuth with Client Credentials)
- **Client ID** (string) - Required - Application identifier from Intuit Developer
- **Client Secret** (string) - Required - Application secret from Intuit Developer
- **Redirect URI** (string) - Required - OAuth callback URL
- **Company ID** (string) - Required - QuickBooks company identifier

### Request Example

```json
{
  "Connection Name": "Production QuickBooks Accounting",
  "Authentication Method": "OAuth",
  "Client ID": "your_client_id",
  "Client Secret": "your_client_secret",
  "Redirect URI": "https://your-app.com/callback",
  "Company ID": "123456789012345"
}
```
```

--------------------------------

### Airtable OAuth 2.0 Authentication Setup

Source: https://www.unifyapps.com/docs/embedded-integrations/airtable

This guide explains how to register a new OAuth 2.0 integration with Airtable to enable authenticated access. It covers obtaining Client ID and Client Secret, and setting up the redirect URL for the OAuth flow. Ensure you use the correct callback URL provided by UnifyApps.

```text
1. Login into Airtable account and click on the profile icon at the top right corner.
2. Navigate to the developer hub.
3. In Oauth Integrations section, click on the “Register New OAuth integration” button.
4. Provide the “Name” and the “OAuth Redirect URL". The OAuth Redirect URL is the destination to which users will be redirected after authorizing their integration.
   Note: Use the following callback URL to complete the OAuth flow with UnifyApps. For example, If you are accessing through qa.unifyapps.com the callback URL would be: http://webhooks-golbal.ext-alb.qa.unifyapps.com/api/connector-auth-callback/oauth
5. Then click on the “Register integration” button.
6. After registration fill out the details as mentioned. Note down the Client ID and also generate a client secret by clicking on the “Generate client secret” and save it to form a connection.
7. Then select the scopes you wish to expose through this connection.
```

--------------------------------

### Configure QuickBooks Connection Parameters

Source: https://www.unifyapps.com/docs/unify-data/quickbooks-as-source

These are the essential parameters required to establish a connection to QuickBooks Online as a data source. Ensure you provide accurate details for each field to enable successful data extraction and synchronization.

```text
Connection Name: "Production QuickBooks Accounting"
Authentication Method: OAuth or OAuth with Client Credentials
Client ID: "your_client_id"
Client Secret: "your_client_secret"
Redirect URI: "https://your-app.com/callback"
Company ID: "123456789012345"
```

--------------------------------

### Zoom Webhook Setup for Event Subscriptions

Source: https://www.unifyapps.com/docs/unify-integrations/zoom

This guide explains how to configure a webhook in your Zoom app to trigger automations based on specific events. It involves copying a webhook URL from your automation tool, enabling 'Event Subscription' in the Zoom Marketplace, providing the webhook URL for endpoint validation, and selecting the desired events for subscription.

```text
1. Click on the zoom trigger in your automation and copy the webhook URL from the setup section.
2. Login into Zoom Marketplace and select the app that you have created.
3. Navigate to the “`Feature`” section in the left navigation menu
4. Under the general feature section, enable the “`Event Subscription`” toggle.
5. Provide the subscription name and select “`Webhook`” as method
6. In “`Event notification endpoint URL`”, provide the Webhook URL and click on the `validate` button.
7. In the Add event section, select the event for which you want to trigger your automation.
8. Now, Click on the “`Save`” button.
```

--------------------------------

### Formula Syntax and Functions in Unify Automations

Source: https://www.unifyapps.com/docs/unify-automations/formula-suggestions

Formulas in Unify Automations start with an equals sign (=) and can include operators (+, -, *, /), node field references, and built-in functions. These functions perform calculations, manipulate data, and enable logical operations. Examples include NOW() for current date/time, INT() for integer conversion, LEN() for string length, and CONCAT() for text combination.

```Unify Automations Formulas
NOW()
INT()
LEN()
CONCAT()
```

--------------------------------

### Klaviyo Source Connection Configuration

Source: https://www.unifyapps.com/docs/unify-data/klaviyo-as-source

Configuration parameters for establishing a connection to Klaviyo as a data source.

```APIDOC
## Connection Configuration

### Parameters

#### Request Body

- **Connection Name** (string) - Required - Descriptive identifier for your connection
- **Revision** (string) - Required - API revision date to use (e.g., "15/06/2024")

### Request Example

```json
{
  "Connection Name": "MyAppKlaviyoIntegration",
  "Revision": "15/06/2024"
}
```
```

--------------------------------

### Compiling a Template in Automation - UnifyApps

Source: https://www.unifyapps.com/docs/platform-tools/build-your-first-template

Shows how to integrate a UnifyApps template into an automation workflow using the 'Template by UnifyApps' node. This involves selecting the template and configuring input parameters.

```unifyapps-automation
1. Add Node: 'Template by UnifyApps'
2. Select Template: 'Daily update email'
3. Configure Inputs:
   - Name: 'John Doe'
   - ErrorMessage: 'N/A'
4. Use Output in next step.
```

--------------------------------

### API Best Practices

Source: https://www.unifyapps.com/docs/unify-automations/api

Guidelines and recommendations for developing robust and efficient API endpoints.

```APIDOC
## Best Practices

### Description
Recommended practices for designing and implementing effective API endpoints.

### Practices
1.  **Naming Conventions:** Use clear and descriptive names for endpoints (e.g., `/fetchUsers`).
2.  **Version Your APIs:** Include version numbers in endpoint paths (e.g., `/api/v1/users`).
3.  **Performance Optimization:** Utilize caching judiciously for GET requests to enhance response times.
```

--------------------------------

### Repeatable Component Data Format Example

Source: https://www.unifyapps.com/docs/unify-applications/using-repeatable

Demonstrates the correct array of objects format required for the Repeatable component. Each object represents an item in a list or grid. Ensure your Data Source property is bound to a source that resolves to this structure.

```javascript
[
  {"id":1, "name":"Item A"},
  {"id":2, "name":"Item B"}
]
```

--------------------------------

### Check OpenSSL Installation (macOS/Linux)

Source: https://www.unifyapps.com/docs/unify-automations/salesforce

Verifies if OpenSSL is installed on macOS or Linux systems by checking its executable path. This is a prerequisite for generating keys and certificates.

```shell
which openssl
```

--------------------------------

### Hashing Example: De-duplication of Records

Source: https://www.unifyapps.com/docs/unify-data/hashing

This example demonstrates how hashing can be used for de-duplicating records. By hashing product descriptions, even with minor formatting differences, duplicate entries can be identified.

```text
Input 1 : "Blue cotton t-shirt, size L"
Input 2 : "Blue Cotton T-Shirt, Size L"
Output (both hash to the same value when normalized)
```

--------------------------------

### Hashing Example: Data Validation (CRC32)

Source: https://www.unifyapps.com/docs/unify-data/hashing

This example illustrates using the CRC32 algorithm for data validation and integrity checks. The hash value can be compared against a known value to ensure data has not been altered.

```text
Input : "Important financial transaction data"
Output (CRC32): 2d8adaf2
```

--------------------------------

### Adding Template Variables - UnifyApps

Source: https://www.unifyapps.com/docs/platform-tools/build-your-first-template

Illustrates the process of adding custom variables to templates. These variables can then be populated with specific data when the template is used in an automation.

```unifyapps-config
+ Add Fields
  - Name: "{{Name}}"
  - Type: "Text"
  - Variable Name: "User Name"

+ Add Fields
  - Name: "{{ErrorMessage}}"
  - Type: "Text"
  - Variable Name: "Error Details"
```

--------------------------------

### Run Component in Development Mode with Block CLI

Source: https://www.unifyapps.com/docs/unify-applications/add-custom-component

Starts a local development server for the custom component, allowing for live preview and instant reloads. It hosts the manifest at a local URL for easy integration during the testing phase.

```bash
pnpx @unifyapps/block-cli dev
```

--------------------------------

### Hashing Example: Anonymize Customer Email (MD5)

Source: https://www.unifyapps.com/docs/unify-data/hashing

This example demonstrates how to hash a customer's email address using the MD5 algorithm for data anonymization. The output is a 32-character hexadecimal string.

```text
Input : john.doe@example.com
Output (MD5): 9e66d708a7803f24a2521a1d3487d127
```

--------------------------------

### Active MQ Broker URL Example

Source: https://www.unifyapps.com/docs/unify-integrations/jms

Example configuration for connecting to an ActiveMQ broker. This includes the broker URL and settings for message redelivery, such as maximum redeliveries, initial redelivery delay, redelivery delay, and back-off multiplier.

```text
Broker Url: `tcp://broker.example.com:61616` or `ssl://broker.example.com:61617`.
Maximum Redeliveries: Configures the maximum number of retries for message delivery.
Initial Redelivery Delay: Sets the delay in seconds before the first redelivery attempt (e.g., `Set initialRedeliveryDelay = 5`).
Redelivery Delay: Sets the maximum delay in seconds between consecutive redelivery attempts (e.g., `redeliveryDelay = 300`).
BackOff Multiplier: Multiplier for calculating redelivery delay between retries (e.g., `backOffMultiplier = 2.0`).
```

--------------------------------

### Hashing Example: Create Unique Identifier (SHA-2)

Source: https://www.unifyapps.com/docs/unify-data/hashing

This example shows how to generate a unique identifier by hashing a combination of name and timestamp using the SHA-2 algorithm. This ensures consistency for creating unique case identifiers.

```text
Input : "JohnDoe_2025-04-15T14:32:10"
Output (SHA-2): 8f5e9c7b4a3d2e1f0c9b8a7d6e5f4c3b2a1d0e9f8c7b6a5d4e3f2c1b0a9d8e7f
```

--------------------------------

### Generic Layout and Visibility Attributes for Components

Source: https://www.unifyapps.com/docs/unify-applications/video

This snippet lists generic layout and visibility attributes applicable to components in Unify Applications. It covers spacing, sizing, and positioning properties like Padding, Height, Min-Height, Max-Height, Gap, and Margin.

```markdown
Attributes| Properties  
---|---  
`Padding`| Add space inside an element's border to create separation between the content and the border.  
`Height`| Set the height of an element to control its vertical size.  
`Min-Height`| Define the minimum height an element can be, ensuring it doesn't shrink below this value.  
`Max-Height`| Specify the maximum height an element can reach, preventing it from growing too tall.  
`Gap`| Set the space between rows and columns in a grid or flex container to create consistent spacing.  
`Margin`| Set the outer space around an element to create distance between it and surrounding elements.  
```

--------------------------------

### MySQL Source Connection Configuration

Source: https://www.unifyapps.com/docs/unify-data/mysql-as-source

This section details the parameters required to establish a connection to a MySQL database as a data source in UnifyApps.

```APIDOC
## MySQL Source Connection Configuration

### Description
Configure your MySQL database as a data source by providing the following connection details.

### Method
POST

### Endpoint
/connections/mysql

### Parameters
#### Request Body
- **Connection Name** (string) - Required - Descriptive identifier for your connection
- **Project** (string) - Optional - Project categorization
- **Host Address** (string) - Required - MySQL server hostname or IP address
- **Port Number** (integer) - Required - Database listener port (default: 3306)
- **User** (string) - Required - Database username with read permissions
- **Password** (string) - Required - Authentication credentials
- **Database Name** (string) - Required - Name of your MySQL database
- **Server Time Zone** (string) - Required - Database server's timezone (e.g., "UTC")
- **Connection** (string) - Required - Method of connecting to the database (Direct or Via SSH)

### Request Example
```json
{
  "Connection Name": "Production MySQL Web App",
  "Project": "E-commerce Platform",
  "Host Address": "mysql.example.com",
  "Port Number": 3306,
  "User": "unify_reader",
  "Password": "your_password",
  "Database Name": "ecommerce_db",
  "Server Time Zone": "UTC",
  "Connection": "Direct"
}
```

### Response
#### Success Response (201)
- **message** (string) - Confirmation message indicating successful connection setup.

#### Response Example
```json
{
  "message": "MySQL connection created successfully."
}
```
```
Tokens:
Raw