Adobe AD0-E902 Exam Dumps

Understanding the Scenario:

The image represents a Workfront Fusion scenario with a Workfront module, HTTP modules, and routers splitting the execution path.

The goal is to reuse multiple fields from the Workfront module (e.g., data extracted or processed earlier in the flow) as mapped expressions in HTTP PUT requests located in the bottom paths.

Why Option A is Correct:

Set Multiple Variables Module: This module allows you to define and store multiple variables at a single point in the scenario (e.g., after the Workfront module). These variables can then be reused throughout subsequent steps in the scenario.

Get Multiple Variables Module: By placing this module between the Text Parser and the bottom Router, you can retrieve all previously stored variables, ensuring consistent access across all branches of the flow. This avoids redundancy and ensures the data is easily accessible for each HTTP request in the bottom paths.

Why the Other Options are Incorrect:

Option B ('Set Multiple Variables after Workfront, Get Variables before each HTTP module'): This is partially correct but less efficient. Adding multiple Get Variable modules before each HTTP request results in repetitive configuration and increases maintenance complexity.

Option C ('Set Variable and Get Variable for each HTTP module'): Using individual Set and Get Variable modules increases duplication. This approach requires separate variables for each data point, which is inefficient compared to using the Set/Get Multiple Variables module for multiple fields at once.

Steps to Configure the Solution:

After the Workfront module:

Add a Set Multiple Variables module.

Define all the fields required for the HTTP PUT requests as variables, mapping them from the Workfront module outputs.

Between the Text Parser and the bottom Router:

Add a Get Multiple Variables module.

Retrieve the previously stored variables, ensuring they are accessible for all paths.

In the HTTP modules on each bottom path:

Use the retrieved variables for mapping in the PUT requests.

How This Solves the Problem:

This approach centralizes variable management, making it easier to access and modify data as needed.

It avoids redundancy, as variables are defined once and reused across all paths, reducing the risk of errors and ensuring consistency.

Reference and Supporting Documentation:

Adobe Workfront Fusion: Variables Module Overview

Workfront Community: Efficient Use of Variables in Fusion

Understanding the Date Transformation:

Input: March 3, 2021, 10:34 AM

Output: March 1, 2021, 10:34 AM

The transformation subtracts 2 days from the input date without altering the time.

Why Option A is Correct:

subDays(now,2) subtracts exactly 2 days from the given date and time.

It preserves the time component of the input (10:34 AM) while shifting the date backward by 2 days, which matches the given output.

Why the Other Options are Incorrect:

Option B ('addHours(now; -48)'): While subtracting 48 hours also results in a 2-day difference, this approach directly modifies the time. The resulting time could shift if the operation crosses daylight saving changes or edge cases with leap seconds. It is less reliable compared to subDays.

Option C ('addDays(today; -4)'): This would subtract 4 days, which does not match the transformation shown in the example.

Reference and Supporting Documentation:

Adobe Workfront Fusion: Date and Time Functions

Workfront Community: Using Date and Time Expressions

In Adobe Workfront Fusion, error handling directives are used to manage and respond to errors during scenario execution. These directives allow the implementation of conditional or nested error handling mechanisms, ensuring workflows can adapt and recover from unexpected issues efficiently. Among the features and modules provided by Fusion:

Filters:

Filters are essential components in Workfront Fusion. They allow you to define specific conditions to control the flow of data between modules.

They enable conditional processing by allowing or restricting the passage of data based on defined criteria, which is fundamental for creating dynamic and conditional workflows.

When used with error handling, filters can evaluate whether certain data meets criteria to determine alternative pathways, thus enabling conditional error handling.

Routers:

Routers split the execution of a scenario into multiple branches based on specific conditions.

Each branch can be configured to handle different error types or conditions, allowing nested error handling and custom error recovery paths.

They are particularly useful when you need to define distinct responses for various error cases within a single scenario.

Eliminated Options:

A . Text Parser: While text parsers process and extract data from strings, they are not directly involved in error handling within scenarios.

C . Workfront App: The Workfront app is primarily for interacting with Workfront features and functionalities, not directly related to error handling within Fusion scenarios.

Adobe Workfront Fusion Documentation: Error Handling Directives Overview

Adobe Workfront Community: Filters and Routers in Conditional Logic Workflows

Experience League Documentation: https://experienceleague.adobe.com

Understanding the Requirement:

The input is an array containing objects, and the goal is to extract all the stat.name values into a comma-separated string.

Example Input:

[

{

'base_stat': 48,

'effort': 1,

'stat': {

'name': 'hp',

'url': 'https://pokeapi.co/api/v2/stat/1/'

}

},

{

'base_stat': 48,

'effort': 0,

'stat': {

'name': 'attack',

'url': 'https://pokeapi.co/api/v2/stat/2/'

}

}

]

Example Output: 'hp, attack'

Why Option B is Correct:

The expression join(map(2.data: stats[]; stats.stat.name); ', '):

map: Iterates through each object in the array (2.data: stats[]) and extracts the stat.name field.

join: Combines the extracted values into a single string, separated by a comma and space (', ').

Breaking it down:

map(2.data: stats[]; stats.stat.name) Creates an array of names: ['hp', 'attack'].

join(...; ', ') Converts the array into the string 'hp, attack'.

Why the Other Options are Incorrect:

Option A: join(2.data: stats[]; stat.name; ', ')

This syntax is incorrect because it attempts to directly access stat.name within the join function without first mapping the values.

Option C: join(map(2.data: stats[]; stat.name); ', ')

The mapping references stat.name directly but does not account for the nested structure (stats.stat.name).

Option D: join(flatten(2.data: stats[]); ', ')

The flatten function is unnecessary here as the data is already structured. It would not properly extract the stat.name values.

Steps to Implement in Workfront Fusion:

Add a Mapping/Transformation Module.

Use the join(map(...)) function as described to transform the input array into a comma-separated string.

Test the output to ensure it correctly generates the desired format.

How This Solves the Problem:

The map function ensures the proper extraction of nested stat.name values.

The join function combines these values into the desired format efficiently.

Reference and Supporting Documentation:

Adobe Workfront Fusion Functions Documentation

Workfront Community: Using Map and Join Functions

The combination of map and join ensures that the stat names are extracted and formatted into a single comma-separated string, as required.

Understanding the Requirement:

The desired output format for the project name in ServiceNow is: Two-Digit Year - Reference Number - Project Name

This requires dynamically constructing a string by combining:

The current year in a two-digit format.

The referenceNumber (a variable or input).

The name (a variable or input, likely the project name).

Why Option C is Correct:

The concat function combines multiple strings into a single string.

Expression:

concat(formatDate(now;YY), ' - ', referenceNumber, ' - ', name)

This ensures proper formatting with hyphens and spaces between the elements.

Breaking Down the Components:

formatDate(now;YY): Retrieves the current year in a two-digit format (e.g., '23' for 2023).

' - ': Adds the required separator.

referenceNumber: Dynamically adds the reference number.

name: Dynamically adds the project name.

Why the Other Options are Incorrect:

Option A ('formatDate(now;YY) - referenceNumber - name'):

This is not valid because it does not explicitly use a string concatenation function.

Option B ('join(formatDate(now;YY) - referenceNumber - name'):

The join function is used for concatenating elements of an array, not individual strings. Since the inputs are not in an array, this function will not work.

How This Solves the Problem:

The concat function correctly constructs the string with the desired format, dynamically generating the project name for ServiceNow based on the given inputs.

Reference and Supporting Documentation:

Adobe Workfront Fusion Functions Documentation

Workfront Community: Using the concat Function