PLAT-DEV-210 Practice Questions

The most appropriate and explicit method to perform data type conversion within a DataRaptor is by using the Formulas tab. This tab is specifically designed for data transformation and manipulation. The TOINTEGER function is provided for this exact purpose: it takes an input value (in this case, a string) and converts it into an integer. The result of this formula can then be mapped in the Output tab, ensuring the data sent to the external service conforms to the required integer data type.

A. While the Output Data Type setting can cast a value, using a formula is the more robust and explicit method for data transformation, which is the primary purpose of the Formulas tab.

B. Setting a default value only applies if the source field is null. It does not convert the data type of an existing non-null string value (e.g., "123").

C. The Input Data Type on the Extract tab is used to define the data type for filter criteria (e.g., in a WHERE clause), not to transform the data that is retrieved and returned.

1. Salesforce Help

OmniStudio

DataRaptor Functions: The TOINTEGER function is documented as the standard method for data type conversion. "TOINTEGER(String/Number/Boolean): Converts a value to the Integer data type." This confirms that using a formula is the designated approach for this transformation.

2. Salesforce Help

OmniStudio

Define Formulas in a DataRaptor: "You can define formulas in a DataRaptor to add new

transformed

or calculated values to the data structure." This establishes the Formulas tab as the correct location for transformation logic.

3. Salesforce Help

OmniStudio

Map DataRaptor Extract Output to JSON Output: This document describes the Output tab's functionality. While it mentions the Output Data Type field for casting

the primary and more powerful tool for transforming data

including type conversion

is the Formulas tab with its extensive function library.

The objective is to transform a single JSON object into a JSON array containing that object. Both chosen options represent valid methods within a Salesforce OmniStudio DataRaptor Transform.

Option A utilizes the Formula tab. The LIST() function is specifically designed to take one or more elements and wrap them into a list (JSON array). By creating a formula LIST(Contact), the DataRaptor generates an array containing the Contact object, which can then be mapped to the desired output path in the Transform tab.

Option C uses a direct mapping in the Transform tab. By setting the Input Path to Contact, the Output Path to Contact, and crucially, the 'Output Data Type' to 'List', the DataRaptor is instructed to take the single input object and place it into an array in the output.

B. List(Contact) is a function syntax, not a valid JSON path to specify in the 'Input JSON Path' field.

D. List(Contact) is not a valid key name for a JSON object and cannot be used in the 'Output JSON Path' field.

1. Salesforce OmniStudio Developer Guide

"DataRaptor Formula Functions and Operators": This document details the LIST function. It states

"Creates a list of the specified elements." Applying LIST(Contact) to the input JSON would correctly produce [ { "Id": "003..."

"Name": "Stella" } ]. This supports the validity of option A.

2. Salesforce OmniStudio Developer Guide

"Define Transformations in a DataRaptor Transform": This guide describes the mapping fields in the Transform tab. The 'Output Data Type' field is documented as a way to cast the output data. Setting this to 'List' for a mapping is the standard method to group the input into a list structure in the output

which directly validates option C.

This behavior indicates a failure in passing the necessary record context from the FlexCard to the OmniScript's data-fetching mechanism.

1. (A) The Id Field in the FlexCard's action properties is responsible for passing the record's ID to the OmniScript. If this field is blank, the OmniScript launches without context. Consequently, the DataRaptor inside the OmniScript has no ID to use as a filter, so it returns no data.

2. (D) Even if the FlexCard sends the recordId, the OmniScript must correctly map it as an input for the DataRaptor. If the merge field for the filter value (e.g., %recordId%) is misspelled in the DataRaptor Action's Input Parameters, the DataRaptor receives a null value and cannot query for the correct records.

B. There is no active version of the Data Raptor Extract.

While an inactive DataRaptor would also result in no data, options A and D describe more specific configuration errors related to the flow of data context, a common and nuanced failure point.

C. There is no active version of the OmniScript.

This is incorrect because the question explicitly states that "the OmniScript displays." An OmniScript without an active version cannot be launched or rendered.

1. Salesforce OmniStudio Documentation

"FlexCard Actions": The configuration for launching an OmniScript from a FlexCard action requires specifying the context

typically by passing {recordId}. The documentation states

"To pass the record Id of the record the FlexCard is on

enter recordId." If this context-passing mechanism is not configured correctly (e.g.

the Id Field is blank)

the OmniScript will not receive the necessary identifier. (Reference: OmniStudio Documentation

Build a FlexCard

FlexCard Action Properties).

2. Salesforce OmniStudio Documentation

"OmniScript DataRaptor Extract Action": This documentation details the "Input Parameters" section for a DataRaptor Extract Action. It explains that you must map data from the OmniScript's data JSON to the DataRaptor. For example

mapping the Filter Value to %recordId% sends the context ID to the DataRaptor. A misspelling in this merge field breaks the mapping

causing the filter to fail. (Reference: OmniStudio Documentation

OmniScript Elements

DataRaptor Extract Action).

3. Salesforce OmniStudio Documentation

"Activate OmniStudio Components": This guide confirms that both OmniScripts and DataRaptors must have an active version to be executed in a runtime environment. This supports the reasoning that option C is impossible

as an inactive OmniScript would not display. (Reference: OmniStudio Documentation

OmniStudio Basics

Activate OmniStudio Components).

To display a FlexCard on an Experience Cloud (Community) page, the standard and required method is to use the FlexCard Player component. This component is a standard Lightning Web Component that acts as a host or container for the FlexCard. Within the Experience Builder, the developer drags the FlexCard Player onto the page canvas. Then, in the component's property panel, the developer must specify the API name of the created FlexCard in the "FlexCard Name" attribute. This configuration links the player to the specific FlexCard, enabling it to be rendered on the page.

A. The FlexCard designer's "Card Configuration" section does not contain a "Deployment" property to target specific environments like a Community.

C. The "Publish Options" within the FlexCard designer are used for settings like custom permissions or OmniScript support, not for setting a deployment target like "CommunityPage".

D. Component Visibility is a standard feature in the Experience Builder to control which users can see a component; it is configured after the component is already on the page, not for the initial deployment of the FlexCard itself.

1. Salesforce Official Documentation

OmniStudio: Add a FlexCard to a Lightning or Experience Page. The documentation explicitly states: "To add a FlexCard to a Lightning or Experience page

add the FlexCard Player component to the page in the Lightning App Builder or Experience Builder. In the component's properties

enter the name of the FlexCard..." This directly supports the correct answer.

2. Salesforce Official Documentation

OmniStudio: FlexCards. Under the "Activate and Deploy FlexCards" section

the process described involves activating the card and then placing it on a page using the appropriate builder (Experience Builder for communities)

which utilizes the FlexCard Player component.

The Formula element is the best practice for this scenario as it is specifically designed to perform real-time, client-side calculations within an OmniScript step. It can evaluate functions like COUNTIF based on user input from other elements in the same step and display the result immediately without requiring a server roundtrip. This provides the instant feedback the user needs. The element's value updates dynamically as the user interacts with the OmniScript, fulfilling the requirement to display the output immediately in the current step.

A. Set Values element: This element is primarily used to manipulate the OmniScript's data JSON, often runs server-side by default, and is not designed for immediate UI display of a calculation's result.

C. Range element: This is a user input control, similar to a slider, used for selecting a value within a specified range. It does not execute functions or perform calculations.

1. Salesforce OmniStudio Documentation

"Formula Element": "Formula elements perform calculations in real time on the client side. The result of a calculation can be used in the OmniScript's data JSON. For example

a Formula element can calculate the sum of two Currency elements and display the result." This confirms its use for real-time

client-side calculations and display.

2. Salesforce OmniStudio Documentation

"OmniScript Functions Reference": The COUNTIF function is listed as a supported function that can be used within OmniScript elements like the Formula element to "count the number of items in a list that meet a specified criteria."

3. Salesforce OmniStudio Documentation

"Set Values Element": "The Set Values element enables you to set static values or values from a data source in the data JSON." This highlights its primary purpose as data manipulation

not immediate UI calculation and display.

In OmniStudio Integration Procedures, merge codes are used to reference data from the procedure's data JSON within element properties, such as an HTTP Action's URL. The syntax for these merge codes is %Node%. To access nested data within a JSON object, dot notation is used. The syntax %SetValues.Date% correctly references a Date node that exists within a SetValues JSON object at the root of the data tree. This is a common design pattern where the output of a step is namespaced under a parent node to prevent data conflicts.

A. t 'SetValues' ] [ 'Date' ]: This is not a valid merge code syntax in Salesforce or OmniStudio. It resembles incorrect JavaScript or JSON path notation.

B. {{SetValues.Date}}: This double curly brace syntax is used for data binding in other frameworks, such as Lightning Web Components or Handlebars.js, not for Integration Procedure merge fields.

D. %SetValues: Date%: The colon syntax (%ElementName:Node%) is used to reference the direct, unfiltered output of a specific element by its name. While a valid syntax, the dot notation is the standard for navigating the final, merged data JSON tree, which is the more common scenario implied by the question's structure.

1. Salesforce OmniStudio Developer Guide

"Access Data in the Data JSON". The guide specifies the use of merge fields with percent signs (%...%) to access data. It explicitly states

"To access a nested value

use dot notation." This supports the %ParentNode.ChildNode% structure. For example

to access a City node within an Address node

the syntax would be %Address.City%. This directly validates the structure used in option C.

2. Salesforce OmniStudio Developer Guide

"Integration Procedure Actions". In the section for the HTTP Action

the documentation shows examples of parameterizing the URL and other fields using merge codes. It reinforces that data from the JSON is accessed via the %...% syntax.

Within an Integration Procedure, a Data Raptor/Data Mapper Extract action exposes a Limit property. Setting this property constrains the underlying SOQL query and the JSON returned by the Extract to the specified number of rows—1 in this case—without altering the Data Mapper definition itself. Filters in the Extract definition can restrict which rows qualify, but only the action-level Limit governs how many rows are finally returned.

B. Filters restrict records by conditions, not by count; the Extract definition has no “LIMIT” keyword.

C. Output Type controls JSON structure, not record count.

D. The Filter() formula tests values but cannot cap the total number of returned rows.

1. Salesforce Help

“Integration Procedure Reference – DataRaptor Extract Action Properties

” Winter ’24

section “Limit” (Default 2000; set to restrict returned rows).

2. Salesforce Help

“Create a DataRaptor Extract

” Winter ’24

section “Filter Records” (lists filter operators—no record-count limiter).

In a Salesforce Industries Calculation Procedure, data is passed between steps using a single JSON data structure. For the result of any step, including a calculation step, to be accessible to a subsequent step like an aggregation, it must be written into this JSON. This is achieved by specifying a key in the "Output JSON Path" field of the calculation step. The aggregation step can then reference this key in its "Input JSON Path" to retrieve the value(s) for processing. Without being included in the output, the result is transient and unavailable to other steps.

A. It must be included in constants.

Constants are static, predefined values for the entire procedure, not the dynamic output of a specific calculation step.

B. It must be a matrix lookup step.

The requirement to map an output to the data JSON applies to all step types, not just matrix lookups.

C. It must be a calculation step.

This is a tautology. The question already presumes the output originates from a calculation step.

1. Salesforce Help

OmniStudio Documentation

"Calculation Procedures": This document explains the fundamental data flow. It states

"Each step in a Calculation Procedure can add data to the data JSON. The data JSON is available to all subsequent steps." This confirms that a step's output must be added to the central data structure to be used later. (Refer to the section on "How Calculation Procedures Work").

2. Salesforce Help

OmniStudio Documentation

"Calculation Procedure Step Properties": This page details the configuration of steps. It describes the "Output JSON Path" property as the mechanism to "specify the node in the data JSON that stores the output of the step." This directly supports the answer that the output must be included in the calculation's data structure. (Refer to the "Common Step Properties" table).

The OmniScript element BlkContacts is configured as a Repeat Block. A Repeat Block is designed to iterate over a list of items and requires its input data to be a JSON array. The name of the JSON node containing the array must match the name of the Repeat Block element. Option A provides the correct structure: a root JSON object with a key named BlkContacts, whose value is an array of objects ([...]). Each object inside the array contains the key-value pairs that directly map to the input elements (FirstName, LastName, etc.) within the BlkContacts block, enabling the OmniScript to populate the fields correctly.

B: The BlkContacts node is a single JSON object, not an array. A Repeat Block cannot iterate over a single object and requires an array structure.

C: This JSON structure is a flat object and completely lacks the required BlkContacts parent node, so the OmniScript cannot find the data for the block.

D: The root of the JSON is an array, and the BlkContacts node is nested inside it. The OmniScript expects a root object with a BlkContacts array, not this nested structure.

1. Salesforce Help

OmniStudio Documentation

"Pass Data to an OmniScript": This document explicitly states

"To pass a list of items into an OmniScript

the JSON must have a node that is an array... The OmniScript element that receives the data must have the same name as the array node." This directly validates that a Repeat Block named BlkContacts requires a JSON structure of {"BlkContacts": [...]}.

2. Salesforce Help

OmniStudio Documentation

"OmniScript Block Element": In the properties table for the Block element

the "Repeat" checkbox description clarifies that enabling it "repeats the Block for each item in an array." This confirms the fundamental requirement of an array for the Repeat Block functionality.

3. Trailhead

OmniStudio Documentation

"OmniScript Data JSON": This module provides examples of the data structure OmniScripts expect. For repeatable blocks

the examples consistently show a named node that contains an array of objects

matching the structure in Option A. For instance

a repeatable block named Account would expect {"Account": [{"Name": "Acme"}

{"Name": "Global"}]}.

Linked Mapping is the correct feature used in a DataRaptor Load for this scenario. It enables a multi-step process within a single transaction: first, it creates a new sObject record (the Engagement Manager as a Contact), and second, it uses the Salesforce ID of that newly created record to populate a lookup field on another sObject (the Primary Contact field on the Account). This creates the new record and establishes the relationship simultaneously.

A. Relationship Query: This is a feature of DataRaptor Extracts used to query and retrieve data from related objects, not for loading or updating records.

C. Lookup Mapping: This is used to find the ID of an existing record based on a secondary key to populate a lookup field, not for creating a new record first.

D. Lookup Key: This term refers to the field used to perform a lookup (e.g., an external ID), but it is not a type of DataRaptor mapping itself.

---

1. Salesforce Help

OmniStudio Documentation: DataRaptors > Link sObjects in a DataRaptor Load. This section explicitly states

"To link sObjects

you map the ID of one sObject to a lookup field in another sObject. For example

you can create a Contact and link it to an existing Account." This directly describes the process of creating a new record and using its ID to update a related record.

2. Salesforce Trailhead: OmniStudio DataRaptors > Load Data with DataRaptors. The unit "Create Related Salesforce Records" demonstrates this concept. It explains how to map the ID of a newly created object (e.g.

Contact:Id) to a lookup field on another object (e.g.

Account:PrimaryContactc) within the same DataRaptor Load

which is the definition of Linked Mapping.