> For the complete documentation index, see [llms.txt](https://tsanet.gitbook.io/connect/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://tsanet.gitbook.io/connect/documentation/salesforce-app/installation-guide/package-configuration.md).
# Package Configuration
This section provides detailed instructions for configuring the TSANet Connect 2.0 Salesforce package after installation. It includes credential setup, permission assignments, component placement, and developer tooling.
TSANet Credentials Setup
TSANet Connect uses **Basic Authentication** via an API user created on the Member account.
#### Steps:
1. Create a new credential record.
2. Enter the provided credentials.
3. Set the environment: `DEVELOPER`, `BETA`, or `PRODUCTION`.
4. Mark the credential as **Primary**.
5. Set an **Integration User** (used for automated processes).
Assigning Permission Sets
Assign users to one of the following permission sets:
* `TSANet Connect Permissions (Admin)`
* `TSANet Connect Permissions (Employee)`
**Assign Users to TSANet Connect Permission Set:** Go to Setup → Permission Sets → search and select TSANet Connect Permissions (Admin) or TSANet Connect Permissions (Employee) → click Manage Assignments → click Add Assignment → select users → click Next → select an expiration option for assigned users → click Assign → Done.
Component & Layout Configuration - Lightning Web Component
The TSANet Connect LCW can be used and has all finctionality. Other Page customization options are available with Actions and related lists for Members also. See the **Customization Options section below**
* **Add TSANet Cases List to Service Console**: Go to the Service Console → List dropdown → Edit → Add More Items → add TSANet Cases list → Add More Items → add TSANet Cases list.
* **Add TSANetApplication Component to Case Record Page**: Go to the Case record page → click Gear Icon → Edit Page → find TSANetApplication component → drag and drop to the appropriate place → click Save.
Note: Other options for Case page customizations are available using flows and actions. See the Case Customization section at the end of this document for details.
Click the Activate button → select APP DEFAULT tab → click Assign as App Default → choose your app → click Next and assign desktop and phone version → click Next and Save.
* **Add TSANetCase Related List to Case Page Layout**: Go to Setup → Object Manager → Case → Page Layout → select your page layout → scroll to Related List section → drag and drop TSANetCase related list to layout → Save.
Component & Layout Configuration - Dynamic Actions
Use **Dynamic Actions configuration in Lightning App Builder:**
* **Click the Gear Icon → Edit Page**
* **Select the Highlights Panel**
* In the right-hand panel, under **Page > Highlights Panel**, click the section that controls the header buttons (where Edit / Delete are).
* **Modify Actions**
* In the **Actions** section on the right:
* Click **Add Action**
* Use the search bar and type **tsa**
***
```
- You’ll see categories like:
- Standard Actions
- Object-Specific Quick Actions
- Global Quick Actions
- Find **Create New TSANet Case** under **Object-Specific Quick Actions**
```
* **Add the Action**
* Select **Create New TSANet Case** and add it to the Actions list
* Arrange it in the order you want (drag & drop)
* **Save and Activate**
* Click **Save**
* Click **Activation** (if required)
* The action appears in the **Highlights Panel** dropdown
* Clicking the action opens the member search modal:
* Then the user completes the form:
Component & Layout Configuration - Customization Options
For members who do not want to include the Lightning Web Component on the Case page, it is possible to integrate actions, lists, and flows into your existing case form. Below is an example of this approach, showing a Member adding this to the section of the case page that already includes actions and related links.
**There are two options how to add 'Collaborate (TSANet)' or 'Create Collaboration Case':**
**Option 1:**
* **Click the Gear Icon → Edit Page**
* You’ve already done this and are in the Lightning App Builder.
* **Select the Highlights Panel**
* In the right-hand panel, under **Page > Highlights Panel**, click the section that controls the header buttons (where Edit/Delete are).
* **Modify Actions**
* In the **Actions** section on the right:
* Click **Override the predefined actions** if it’s not already overridden.
* You’ll see categories like:
* Standard Actions
* Object-Specific Actions
* Global Quick Actions
* Find **Create Collaboration Case** under **Object-Specific Actions**.
* **Add Create Collaboration Case**
* Drag **TSANet Case Menu** into the list of actions (where “Create Collaboration Case” is).
* Arrange it in the order you want.
* **Save and Activate**
* Click **Save**.
* If prompted, click **Activate** to make sure this page is assigned to the correct app/profile.
* **Refresh the Case Page**
* Go back to a Case record and check the dropdown. The button should now appear.
**Option 2:**
* **Go to Setup**
* Click the gear icon → **Setup**.
* **Open Object Manager**
* Search for **Case** and click it.
* **Edit Page Layout**
* Go to **Page Layouts**.
* Select the layout used for your Case records.
* **Locate the Lightning Actions Section**
* Scroll down to **Salesforce Mobile and Lightning Experience Actions**.
* If you don’t see it, click the **override the predefined actions** link.
* **Add the TSANet Case Menu Action**
* In the palette at the top, find your existing action (TSANet Case Menu).
* Drag it into the **Actions** section where other actions like “Create Collaboration Case” are listed.
* **Save the Layout**
* Click **Save**.
* Refresh your Case record page and check the dropdown.
**Steps to Create a Related List with Actions**
**1. Identify the Custom Action**
* Determine the action you want users to perform from the related list (e.g., send note, attachment).
* Ensure the action is compatible with the object and its layout.
**2. Modify the Page Layout**
* Go to **Setup** → **Object Manager** → Select the object.
* Open the **Page Layouts** section.
* Add the related list to the layout where the action should be accessible.
**3. Configure the Related List**
* Use standard related list settings to include the relevant custom object or record type.
* Make sure the related list supports **action buttons** or **quick actions**.
**4. Avoid Lightning Web Components (if not required)**
* If the goal is simplicity or client preference, use traditional related list configurations.
* Only use Lightning Web Components when their functionality is explicitly needed.
**5. Test the Setup**
* Preview the layout to confirm the related list appears correctly.
* Test the action to ensure it performs as expected.
* Validate that the user experience is intuitive and meets business requirements.
Add an action button or pulldown for **New TSANet Case**
**Show how to add this button**
Add a related list to show **TSANet Cases.**
**Show how to add the list**
Add a button to the related list for **Note** and **Attachment**
**Show hot to add Note and Attachment to the list (for sending new note or attachment)**
**Note**: Flows for further automation and customization can be found in the following section
Webhooks
This guide explains how to configure a **Salesforce Site**, grant the correct **Guest User permissions**, and create a **TSANet Webhook** so that external TSANet events (for example collaboration requests and notes) can be delivered into Salesforce via an Apex REST endpoint.
TSANet webhooks require:
1. A **publicly accessible Salesforce Site**
2. A **guest user with explicit permissions**
3. A **TSANet Credential** record
4. A **TSANet Webhook** record pointing to the site’s Apex REST endpoint
```
TSANet Platform
↓
Salesforce Site URL
↓
Apex REST Endpoint (/services/apexrest/tsanetconnect/webhook)
↓
TSANet Package Logic
```
### Step 1: Register or Verify Salesforce Sites Domain
1. Go to **Setup**
2. In Quick Find, search for **Sites**
3. If no domain is registered:
* Check **“I have read and accepted the Salesforce Sites Terms of Use”**
* Click **Register My Salesforce Site Domain**
* Save the domain\
Example:
```
companyoneinc-dev-ed.develop.my.salesforce-sites.com
```
* Activate the site
Most orgs already have a registered site domain. If so, reuse it.
### Step 2: Create a Salesforce Site (Webhook Endpoint)
1. From **Setup → Sites**
2. Click **New**
3. Fill in the form:
4. Click **Save**
5. Click **Activate**
The site URL is now generated, for example:
```
https://companyoneinc-dev-ed.develop.my.salesforce-sites.com
```
### Step 3: Verify Site Availability
Paste the site URL into a browser.
* If active → page loads
* If inactive → “Site is down for maintenance” message appears
Either state is acceptable; the webhook endpoint remains callable
### Step 4: Assign Guest User Permissions
#### 4.1 Assign Permission Set
A permission set is included with the package:
**Permission Set Name**
```
TSANet Webhook Guest Access
```
Steps:
1. Go to **Setup → Permission Sets**
2. Open **TSANet Webhook Guest Access**
3. Click **Manage Assignments**
4. Click **Add Assignment**
5. Select the **Site Guest User** (for example: `TSANetWebhook1 Site Guest User`)
6. Save
#### 4.3. Customize Guest User Permission Set
When configuring the webhook, you must clone the existing Guest User permission set and update it.
**Steps:**
* Clone the existing permission set **TSANet Webhook Guest Access**
* Update object permissions:
* **Case -> Object permissions -> edit**
* Grant **Read** and/or **Create** access
* Configure **Record Type access**:
* Enable only the record types that should be used by TSANet
> ⚠️ This step is required to allow webhook requests to create or read Case records.
#### 4.4 Locate the Guest User
1. Go to **Setup → Sites**
2. Click **Site Label** (e.g., `TSANetWebhook1`)
3. Click Public Access Settings -> View users -> Site Guest User, TSANetWebhook
4. Permission Set Assignments - edit - TSANet Webhook Guest Access
#### 4.5 Encrypted Data Permission for Super User
> **Note:** This permission should only be granted to authorized users because it provides access to sensitive information.
1. Go to **Setup → Permission Sets** and click **New**.
2. Create a permission set:
* **Label:** `Encrypted Data Permission`
* **License:** `--None--`
3. Open the permission set and search for **Encryption**.
4. Under **System Permissions**, select **View Encrypted Data**.
5. Click **Edit**, enable **View Encrypted Data**, and **Save**.
1. Click **Manage Assignments**.
2. Select the users who require access and click **Assign**.
> **Note:** Grant this permission only to authorized users, as it allows viewing encrypted field values in plain text.
### Step 5: Verify User Management Settings
Ensure the new UI is enabled so assignments work correctly:
1. Go to **Setup → User Management Settings**
2. Enable:
* Enhanced Profile User Interface
***
3. Save
### Step 6: Create the TSANet Webhook
1. Navigate to **App Launcher → TSANet Credentials**
2. Open an existing credential
3. Scroll to the **TSANet Webhooks** related list
4. Click **New**
#### Webhook Configuration Fields
| Field | Value |
| ----------------- | ------------------------------------ |
| TSANet Credential | Existing credential (e.g., NC‑00001) |
| Active | ✅ Checked |
| Callback URL | See below |
| Event Types | Select both |
#### Callback URL Format (Critical)
Use:
```
/services/apexrest/tsanetconnect/webhook
```
Example:
```
https://companyoneinc-dev-ed.develop.my.salesforce-sites.com/services/apexrest/tsanetconnect/webhook
```
> This endpoint is implemented inside the TSANet package.\
> Do **not** change the Apex REST path.
5. Click **Save**
A Webhook record (for example `WH-00001`) is created and active.
### Troubleshooting & Debugging
#### Enable Debug Logs
1. **Setup → Debug Logs**
2. Add a new Trace Flag:
* Traced Entity Type: **User**
* Traced Entity Name: Integration User
* Debug Level: `SFDC_DevConsole`
3. Save
This helps diagnose:
* Permission issues
* Apex execution errors
* Payload parsing failures
### Common Issues & Fixes
| Issue | Cause | Resolution |
| ---------------------------- | --------------------------- | ------------------------------------ |
| 403 / Authorization Required | Missing guest permissions | Assign `TSANet Webhook Guest Access` |
| Site URL unreachable | Site not active | Activate the Site |
| Webhook not firing | No event types selected | Select events |
| Apex errors | Object/field access missing | Verify permission set |
### Summary Checklist
* [ ] Salesforce Site domain registered
* [ ] Salesforce Site created and active
* [ ] Guest User assigned **TSANet Webhook Guest Access**
* [ ] TSANet Credential exists
* [ ] Webhook created with correct callback URL
* [ ] Event types configured
### Automation and Flows:
TSANet uses Salesforce Flows to define the business logic for TSANet Connect. Several flows are provided and members can clone and modify as needed.
Navigate to flows
You can navigate to Flows as follows:
Go to Setup → type “flows” in Quick Find (path: Process Automation → Flows).
From there, you can:
* Create a new Flow using Flow Trigger Explorer or by clicking New Flow.
* View available packaged flows by searching for “TSANet” in field Search Lists under Flow Definitions to see all TSANet-related flows available for activation.
TSANetScheduledJob
The TSANetScheduledJob is a background job that synchronizes data between Salesforce and TSANet.
By default, it is scheduled to run every 15 minutes, ensuring that case updates and notes are regularly exchanged.
You may adjust the cron expression if your organization requires a different sync interval: Go to Setup → type “Scheduled Jobs” in Quick Find (path: Environments → Jobs → Scheduled Jobs) → search for *TSANetScheduledJob* → click *Manage* → update cron expression → Save.
**Examples:**
**A) Every 15 minutes (create 4 schedules)**
Use these **four** schedules:
1. **Job Name:** `TSANetScheduledJob – Every 15 (00)`\
**Cron Expression:**
```
0 0 * * * ?
```
2. **Job Name:** `TSANetScheduledJob – Every 15 (15)`\
**Cron Expression:**
```
0 15 * * * ?
```
3. **Job Name:** `TSANetScheduledJob – Every 15 (30)`\
**Cron Expression:**
```
0 30 * * * ?
```
4. **Job Name:** `TSANetScheduledJob – Every 15 (45)`\
**Cron Expression:**
```
0 45 * * * ?
```
B) **Every 10 minutes** (create **6** schedules)
1. `TSANetScheduledJob – Every 10 (00)`
```
0 0 * * * ?
```
2. `TSANetScheduledJob – Every 10 (10)`
```
0 10 * * * ?
```
3. `TSANetScheduledJob – Every 10 (20)`
```
0 20 * * * ?
```
4. `TSANetScheduledJob – Every 10 (30)`
```
0 30 * * * ?
```
5. `TSANetScheduledJob – Every 10 (40)`
```
0 40 * * * ?
```
6. `TSANetScheduledJob – Every 10 (50)`
```
0 50 * * * ?
```
C) **Every 5 minutes** (create **12** schedules)
1. `TSANetScheduledJob – Every 5 (00)`
```
0 0 * * * ?
```
2. `TSANetScheduledJob – Every 5 (05)`
```
0 5 * * * ?
```
3. `TSANetScheduledJob – Every 5 (10)`
```
0 10 * * * ?
```
4. `TSANetScheduledJob – Every 5 (15)`
```
0 15 * * * ?
```
5. `TSANetScheduledJob – Every 5 (20)`
```
0 20 * * * ?
```
6. `TSANetScheduledJob – Every 5 (25)`
```
0 25 * * * ?
```
7. `TSANetScheduledJob – Every 5 (30)`
```
0 30 * * * ?
```
8. `TSANetScheduledJob – Every 5 (35)`
```
0 35 * * * ?
```
9. `TSANetScheduledJob – Every 5 (40)`
```
0 40 * * * ?
```
10. `TSANetScheduledJob – Every 5 (45)`
```
0 45 * * * ?
```
11. `TSANetScheduledJob – Every 5 (50)`
```
0 50 * * * ?
```
12. `TSANetScheduledJob – Every 5 (55)`
```
0 55 * * * ?
```
{% hint style="info" %}
Note: `0 5 * * * ?` — that would run **once per hour at minute 5**, not every 5 minutes
{% endhint %}
{% hint style="info" %}
* Salesforce **does not support `*/X` or `0/X` increments** like Linux cron. You must explicitly list the minutes (**not** allow shorthand like `*/15`)
* Use **explicit values** (comma-separated) or ranges.
* Use `?` for **Day of Month or Day of Week** when the other is specified.
{% endhint %}
Invocable Actions
* Create Case, Approve Request
* Get Companies, Get Company Form
* Create Note, Attach File
**Inbound Flows:** These flows are used in the inbound process
TSANet: Inbound: Accept Collaboration Request (Automation)
This is an **autolaunched Salesforce Flow** that automates the process of accepting a TSANet collaboration request.
The flow:
* Retrieves the related TSANet case record
* Invokes a subflow to gather approval details
* Executes an Apex action to accept the collaboration request
This automation handles the acceptance of TSANet collaboration requests in a consistent and automated manner.
TSANet: Inbound: Accept Collaboration Request (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to accept a TSANet collaboration request through a guided interface.
The flow:
* Retrieves the related TSANet case record
* Evaluates whether the Salesforce case is already assigned
* Displays a required assignment screen if the case is not assigned
* Displays a screen to capture acceptance notes
* Invokes an automation subflow to accept the TSANet collaboration request
* Evaluates the result and displays an error screen if the acceptance fails
This automation handles the acceptance of TSANet collaboration requests through a user‑driven, guided flow with validation and error handling.
TSANet: Inbound: Auto Accept Collaboration Request
This is a **record-triggered Salesforce Flow** that automates the acceptance of inbound TSANet collaboration requests.
The flow is triggered when a **TSANet Case record is created** and runs immediately after creation, based on defined entry conditions.
The flow:
* Evaluates newly created **TSANet Case records** against configured conditions
* Invokes a **subflow (TSANet Accept – Automation)** to process the collaboration request
* Executes the acceptance logic without requiring user interaction
This automation ensures that eligible inbound collaboration requests are accepted consistently and automatically, improving response time and reducing manual effort.
TSANet: Inbound: Auto Accept Collaboration Request (Future)
This is a **record-triggered Salesforce Flow** that automates the acceptance of incoming TSANet collaboration requests.
The flow is triggered when a **TSANet Case record is created** and is configured to run **asynchronously using a scheduled path**.
The flow:
* Monitors newly created **TSANet Case records** based on defined entry conditions
* Executes a **subflow (TSANet Accept)** via a scheduled path to automatically accept the collaboration request
* Processes the acceptance without requiring user interaction
This automation ensures that eligible inbound collaboration requests are accepted automatically, improving response time and reducing manual effort while maintaining consistent processing.
TSANet: Inbound: Collaboration Request Trigger Handler
This is a **record‑triggered Salesforce Flow** that runs automatically when a TSANet Case record is created.
The flow:
* Creates a corresponding Salesforce Case record
* Updates the TSANet case with the linked Salesforce case information
* Invokes a subflow to accept the TSANet collaboration request
* Sends a notification after successful processing
This automation handles the acceptance and processing of incoming TSANet collaboration requests.
TSANet: Inbound: Collaboration Request Trigger Handler (Asset)
This is a **record‑triggered Salesforce Flow** that runs automatically when a TSANet Case record is created.
The flow:
* Retrieves the related asset record
* Evaluates whether a matching asset is found
* If no asset is found, triggers an automation to reject the collaboration request
* If an asset is found, creates a Salesforce case, updates the TSANet case, triggers the accept automation, and sends a notification
This automation handles the evaluation and processing of incoming TSANet collaboration requests based on asset availability.
TSANet: Inbound: Find Parent Case (Template)
This is a **record-triggered Salesforce Flow** that automates the identification and linking of related parent cases for TSANet inbound and outbound scenarios.
The flow is triggered when a **TSANet Case record is created** and runs immediately after creation.
The flow:
* Evaluates the **case direction (Inbound or Outbound)** using a decision element
* Retrieves related **Salesforce Case records** based on the submitter or receiver case number
* Performs **matching logic** to determine whether a corresponding parent case is found
* Executes an **assignment** to stamp and populate data from the matched parent case
* Applies the logic separately for **Submitter (Outbound)** and **Receiver (Inbound)** flows
This automation ensures that TSANet cases are properly linked to their corresponding parent cases, improving data consistency and enabling accurate tracking across inbound and outbound collaboration scenarios.
TSANet: Inbound: Note Notification
This is a **record-triggered Salesforce Flow** that automates the process of sending notifications when a new TSANet note is created.
The flow is triggered when a **TSANet Note record is created** and runs immediately after creation.
The flow:
* Evaluates whether the note meets the criteria to be treated as a **new note** using a decision element
* Retrieves the related **TSANet Case record** associated with the note
* Invokes a **subflow** to send a notification based on the note and case details
* Updates the TSANet Note record to mark it as **notified**, preventing duplicate notifications
This automation ensures that notifications for newly created TSANet notes are handled consistently and efficiently, improving communication and reducing manual effort.
TSANet: Inbound: Note Trigger Handler
This is a **record‑triggered Salesforce Flow** that runs automatically when a TSANet Note record is created.
The flow:
* Evaluates the newly created TSANet Note
* Updates the related TSANet case if required
* Assigns note details for processing
* Retrieves the associated TSANet case record
* Executes an Apex action to create and sync the TSANet note
This automation handles the processing of newly created TSANet notes and ensures they are correctly linked to related cases.
TSANet: Inbound: Reject Collaboration Request (Automation)
This is an **autolaunched Salesforce Flow** that automates the process of rejecting a TSANet collaboration request.
The flow:
* Retrieves the related TSANet case record
* Invokes a subflow to gather the rejection collaboration request details
* Executes an Apex action to process and submit the TSANet rejection
This automation handles the rejection of TSANet collaboration requests in a consistent and automated manner.
TSANet: Inbound: Reject Collaboration Request (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to reject a TSANet collaboration request through a guided interface.
The flow:
* Displays a screen to capture the rejection reason
* Invokes a subflow to submit the rejection request
* Evaluates the result of the operation
* Displays an error screen if the rejection fails
This automation handles the rejection of TSANet collaboration requests through a user‑driven, guided flow.
TSANet: Inbound: Request More Information (Trigger)
This is a **record-triggered Salesforce Flow** that automates the process of requesting additional information for a newly created TSANet case.
The flow is triggered when a **TSANet Case record is created** and runs immediately after creation.
The flow:
* Retrieves and evaluates the newly created TSANet Case record based on defined entry conditions
* Invokes a **subflow** to load and prepare the Request Information form
* Executes an **Apex action** to send or process the request for additional information
This automation ensures that requests for more information on TSANet cases are handled consistently, efficiently, and without manual intervention, improving data completeness and reducing processing delays.
**Outbound Flows:** These flows are used in the outbound process
TSANet: Outbound: Create Collaboration Case
This is a **screen Salesforce Flow** that guides users through the process of creating a TSANet collaboration case and automates related data preparation and submission.
The flow is initiated manually by the user and provides a step-by-step interface to gather and process the required information.
The flow:
* Retrieves the **TSANet Case record** to establish the context for the collaboration
* Presents **interactive screens** to capture TSANet details and allow the user to search and select a partner company
* Executes **Apex actions** to search for companies and retrieve relevant customer data
* Uses **assignments and loops** to process and map the selected company and customer data into the required format
* Displays a **collaboration form** for the user to review and complete additional details
* Performs **field assignments** and presents a **verification screen** for final confirmation
* Executes an **Apex action** to create the collaboration case in TSANet
* Displays a **result screen** confirming the creation of the collaboration case
This automation streamlines the creation of TSANet collaboration cases by guiding users through a structured process, ensuring data accuracy, and reducing manual effort.
TSANet: Outbound: Create Collaboration Case (LWC)
This is a **screen Salesforce Flow** that provides a user interface for creating a TSANet collaboration case using a Lightning Web Component.
The flow is initiated manually by the user and guides the process through a structured interface.
The flow:
* Retrieves the related **Salesforce Case record** to establish the context
* Displays a **screen (CreateTSANetScreen)** leveraging a Lightning Web Component to capture and present collaboration details
* Allows users to review and input the required information before submitting the request
This automation provides a streamlined and user-friendly interface for creating TSANet collaboration cases, ensuring accurate data entry and improving the overall user experience.
TSANet: Outbound: Create Note (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to create a TSANet note for a specific case through a guided interface.
The flow:
* Retrieves the related TSANet case record
* Displays a screen to capture note details
* Invokes an automation subflow to create the note
* Evaluates the result with a decision element
* Displays an error screen if the note creation fails
This automation handles the creation of TSANet notes for cases through a user‑driven, guided flow.
**Other Flows:** These flows are common to both inbound and outbound process
TSANet: Case Link Change Sync
This is a **record-triggered Salesforce Flow** that automates synchronization when a TSANet Case record is updated.
The flow is triggered when a **TSANet Case record is updated** and runs immediately after the update, based on defined entry conditions.
The flow:
* Monitors updates to the **TSANet Case record**, including changes to key fields such as case links
* Evaluates the defined **trigger conditions** to determine if synchronization is required
* Executes an **Apex action (Notify TSANet)** to propagate the update and synchronize data with TSANet
This automation ensures that changes to TSANet case links are consistently communicated and synchronized, reducing manual intervention and maintaining data alignment between systems.
TSANet: Case Owner Change Handler
This is a **record-triggered Salesforce Flow** that automates the handling of TSANet-related updates when a Case owner is changed.
The flow is triggered when a **Case record is updated** and runs immediately after the update, based on defined entry conditions.
The flow:
* Retrieves related **TSANet Case records** associated with the updated Case
* Iterates through the retrieved records using a **loop** to process each TSANet Case individually
* Evaluates whether each record meets the criteria to trigger a notification using a **decision element**
* Executes an **Apex action (Change TSANet Owner)** for records that meet the criteria to update the owner in TSANet
* Skips records that do not meet the conditions and continues processing the remaining records
This automation ensures that ownership changes on Cases are consistently propagated to TSANet, maintaining alignment between systems and reducing manual updates.
TSANet: Close Collaboration Request (Automation)
This is an **autolaunched Salesforce Flow** that automates the process of closing a TSANet collaboration request.
The flow is triggered programmatically and runs without user interaction.
The flow:
* Retrieves the related **TSANet Case record** to identify the collaboration request
* Executes an **Apex action (Close Collaboration Request)** to close the request in TSANet
This automation ensures that collaboration requests are closed in a consistent and automated manner, reducing manual effort and maintaining synchronization between Salesforce and TSANet.
TSANet: Close Collaboration Request (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to close a TSANet collaboration request through a guided interface.
The flow:
* Displays a verification screen to confirm the close action
* Invokes an automation subflow to close the TSANet collaboration request
* Evaluates the result of the operation
* Displays an error screen if the close operation fails
This automation handles the closure of TSANet collaboration requests through a user‑driven, guided flow.
TSANet: Create Note (Automation)
This is an **autolaunched Salesforce Flow** that automates the creation of a TSANet note for a specific case.
The flow:
* Retrieves the related TSANet case record
* Invokes a subflow to load the note creation form
* Executes an Apex action to create the TSANet note
This automation handles the creation of TSANet notes and ensures they are associated with the correct cases.
TSANet: Get Approve Collaboration Request Form
This is an **autolaunched Salesforce Flow** that automates the preparation of the approval form for a TSANet collaboration request.
The flow is triggered programmatically and runs without user interaction.
The flow:
* Retrieves the related **Salesforce Case record** to gather the necessary data for the approval process
* Performs an **assignment** to generate and structure the TSANet approval form data
This automation standardizes the preparation of approval forms for TSANet collaboration requests, ensuring consistency and reducing manual effort in the approval process.
TSANet: Get Note Form
This is an **autolaunched Salesforce Flow** that automates the preparation of a TSANet note form based on an existing case.
The flow is triggered programmatically and runs without user interaction.
The flow:
* Retrieves the related **Salesforce Case record** to obtain the necessary context and data
* Performs an **assignment** to construct and populate the TSANet note form
This automation standardizes the creation of TSANet note forms, ensuring consistency and reducing manual effort when preparing note-related data.
TSANet: Get Reject Collaboration Request Form
This is an **autolaunched Salesforce Flow** that automates the preparation of a rejection form for a TSANet collaboration request.
The flow is triggered programmatically and runs without user interaction.
The flow:
* Retrieves the related **Salesforce Case record** to gather the required data for the rejection process
* Performs an **assignment** to create and structure the TSANet reject form
This automation ensures that rejection forms for collaboration requests are generated in a consistent and standardized manner, reducing manual effort and supporting a streamlined rejection process.
TSANet: Get Request Information Form
This is an **autolaunched Salesforce Flow** that automates the preparation of a request information form for a TSANet case.
The flow is triggered programmatically and runs without user interaction.
The flow:
* Performs an **assignment** to populate and structure the Request Information form data
This automation standardizes the preparation of request information forms, ensuring consistency and reducing manual effort when requesting additional information for TSANet cases.
TSANet: New Collaboration Case Notification
This is a **record-triggered Salesforce Flow** that automates the notification process when a new TSANet collaboration case is created.
The flow is triggered when a **TSANet Case record is created** and runs immediately after creation.
The flow:
* Monitors newly created **TSANet Case records** based on defined entry conditions
* Invokes a **subflow (Send Notification)** to trigger the appropriate notification process
* Ensures the notification is sent without requiring user interaction
This automation ensures that stakeholders are promptly notified about new collaboration cases, improving communication and reducing manual effort.
TSANet: Refresh Collaboration Requests
This is a **screen‑based Salesforce Flow** that allows users to manually refresh TSANet collaboration requests.
The flow:
* Executes an Apex action to refresh TSANet case data
* Evaluates the result of the refresh operation
* Displays a success or error message to the user based on the outcome
This automation handles the refresh and validation of TSANet collaboration requests and provides feedback on the operation result.
TSANet: Request Information (Automation)
This is an **autolaunched Salesforce Flow** that automates the process of requesting additional information for a TSANet case.
The flow:
* Retrieves the related TSANet case record
* Invokes a subflow to load the request information form
* Executes an Apex action to process the information request
This automation handles the process of requesting additional information for TSANet cases in a consistent and automated manner.
TSANet: Request Information (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to request information for a specific TSANet case through a guided interface.
The flow:
* Retrieves the related TSANet case record
* Displays a screen to capture the information request details
* Invokes a subflow to prepare the request information form
* Executes an Apex action to submit the information request
* Evaluates the result and displays an error screen if the request fails
This automation handles the submission of information requests for TSANet cases through a user‑driven, guided flow.
TSANet: Request More Information (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to request additional information for a TSANet case through a guided interface.
The flow:
* Displays a screen to capture the information request details
* Invokes an automation subflow to submit the request
* Evaluates the result of the operation
* Displays an error screen if the request fails
This automation handles the requesting of additional information for TSANet cases through a user‑driven, guided flow.
TSANet: Send Information (Automation)
This is an **autolaunched Salesforce Flow** that automates the process of sending requested information for a TSANet case.
The flow:
* Retrieves the related TSANet case record
* Invokes a subflow to load the request information form
* Executes an Apex action to send the requested information
This automation handles the sending of requested information for TSANet cases in a consistent and automated manner.
TSANet: Send Information (Screen Flow)
This is a **screen‑based Salesforce Flow** that allows users to send requested information for a TSANet case through a guided interface.
The flow:
* Displays a screen to capture the requested information
* Invokes an automation subflow to send the entered information
* Evaluates the result of the operation
* Displays an error message if the submission fails
This automation handles the sending of requested information for TSANet cases through a user‑driven, guided flow.
TSANet: Send Notification (Subflow)
This is an **autolaunched Salesforce Flow** designed to standardize and automate the notification process for TSANet-related events.
The flow is invoked as a **subflow from other flows** and runs without user interaction.
The flow:
* Retrieves the related **Salesforce Case record** to establish context for the notification
* Retrieves the **notification type configuration** to determine how and to whom the notification should be sent
* Performs an **assignment** to compile and structure the list of notification recipients
* Executes an **action** to send the notification based on the prepared data
This subflow centralizes notification logic, ensuring consistent communication across TSANet processes while reducing duplication and simplifying maintenance.
TSANet Collaboration Request Trigger Handler (Custom)
This flow automates the handling of Inbound TSANet Collaboration Requests in Salesforce. When a new TSANet Case record is created, the flow:
* Retrieves related Asset and Contact records
* Creates a Salesforce Case
* Updates the Collaboration Request with the Case ID
* Assigns variables for TSANet processing
* Approves the collaboration request via Apex
* Sends a custom notification to the case owner
**Flow Details:**
* **Flow Label:** TSANet Collaboration Request Trigger Handler (Custom)
* **Flow Type:** Record-Triggered After Save
* **Trigger Object:** TSANet Case
* **Trigger Condition:** A record is created
* **Activation Status:** Activated
### Step-by-Step Configuration
#### Step 1: Configure Start
**Object:** TSANet Case
**Trigger:** A record is created
**Conditions:**
* Case is Null = True
* Direction = Inbound
* Serial Number is Null = False
#### Step 2: Get Asset by Serial Number
**Object:** Asset
**Filter:**
Serial Number = TSANet Case → Serial Number
#### Step 3: Decision – Asset Record Found
**Outcome:**
Asset Found if Asset record exists
#### Step 4: Get Contact
**Object:** Contact
**Filter:**
* Email = TSANet Case → Customer Email
#### Step 5: Decision – Is Contact Found
**Outcome:**
* Contact Found if Contact record exists
#### Step 6: Create Salesforce Case Record
**Object:** Case
**Fields Mapped:**
* Asset ID → Asset record
* Contact ID → Contact record
* Description → TSANet Case Description
* Case Origin → Web
* Priority → CasePriority
* Subject → TSANet Case Summary
* Case Type → Other
#### Step 7: Update Collaboration Request
Attach Case ID to TSANet Case record
#### Step 8: Get Salesforce Case
Retrieve Case details for variable assignment
#### Step 9: Assignment – TSANetCaseRequest
**Assign variables:**
* caseNumber
* engineerEmail
* engineerName
* engineerPhone
* nextSteps
#### Step 10: Apex Action – Approve Incoming Collaboration Request
**Inputs:**
* caseRecord = TSANet Case
* request = TSANetCaseRequest
#### Step 11: Get Notification Type
**Object:** Custom Notification Type
**Filter:**
* Name = TSANet\_Notification
#### Step 12: Assignment – Add Recipient
* Add Case Owner User ID to `recipientIds` variable
#### Step 13: Send Custom Notification
* **Notification Title:** TSANetCase Confirmed Successfully
* **Notification Body:** Your case has been successfully confirmed
* **Recipient IDs:** recipientIds
* **Target ID:** TSANet Case Record ID
### Flow Diagram
```
Start
→ Get Asset
→ Decision (Asset Found?)
→ Get Contact
→ Decision (Contact Found?)
→ Create Case
→ Update TSANet Case
→ Get Case
→ Assignment
→ Apex Action
→ Get Notification Type
→ Assignment (Recipient)
→ Send Notification
→ End
```
### Notes
* Ensure Apex class `ApproveIncomingCollaborationRequest` is deployed
* Custom Notification Type `TSANet_Notification` must exist
### References
Video Tutorial
### Package Overview
Package Objects, related lists to objects
* **TSANet Case -** A collaboration case within the TSANet framework that serves as the primary record for tracking collaboration between member organizations during a support issue.
**Key attributes may include:**
* TSANet CaseID
* Case (lookup field)
* Status \[ACCEPTED, OPEN, INFORMATION, CLOSED, REJECTED]
* Type \[INBOUND, OUTBOUND]
* Priority \[LOW, MEDIUM, HIGH]
* Priority Note
* Summary
* Description
* Request Date
* Response SLA (Datetime)
* Token (ExternalID)
**Member Information:**
* Company Name (Submitted)
* Name
* Email
* Phone
* Company Name (Received)
* Engineer Name
* Engineer Email
* Engineer Phone
* **Key attributes may include:**
* TSANet CaseID
* Case (lookup field)
* Status \[ACCEPTED, OPEN, INFORMATION, CLOSED, REJECTED]
* Type \[INBOUND, OUTBOUND]
* Priority \[LOW, MEDIUM, HIGH]
* Priority Note
* Summary
* Description
* Request Date
* Response SLA (Datetime)
* Token (ExternalID)
**Member Information:**
* Company Name (Submitted)
* Name
* Email
* Phone
* Company Name (Received)
* Engineer Name
* Engineer Email
* Engineer Phone
* Other Information (custom fields)
* **TSANet Note** – the object is used for logging and managing communications or updates related to a TSANet Case. It allows members to document important information about the case in real-time
**Key attributes include:**
* TSANet Case (lookup)
* Summary
* Description
* Creator Name
* Status
* Priority \[LOW, MEDIUM, HIGH]
* Created At
* Token (ExternalID)
* **TSANet Response** - object captures formal replies or actions taken with an inbound TSANet Case.
**Key attributes include:**
* TSANet Response ID (ExternalID)
* TSANet Case (lookup)
* Type
* Note
* Created At
* Engineer Email
* Engineer Phone
* **TSANet Credentials** - object stores and manages secure access information within the TSANet framework. This object ensures member organizations have the necessary authentication details for collaborative support.
*\* you can have only one credential marked as primary.*
**Key attributes may include:**
* UserName
* Password
* Environment \[DEVELOPER, BETA, PRODUCTION]
* isPrimary (mark as true)
**Add a Related List to an Object:**
Many of the Workforce Engagement features rely on related lists to associate information. During your initial configuration, you may need to add related lists to objects.
**To add a related list to an object:**
1. Open **Setup** | **Object Manager** | **{select the object}** | **Page Layouts** | **{object name} Layout**.
2. Select **Related Lists** from the {object name} Layout menu at the top of the page.
3. Drag and drop a related list into the related lists section of the page. Repeat this step for each related list that you want to add.
4. Save your changes.