Adobe AD0-E902 Exam Questions

Understanding the Scenario:

The issue involves end users inputting inconsistent date and currency formats that result in errors in a Workfront Fusion scenario.

The default behavior of Fusion stops the scenario after three retries due to input mismatches or invalid formats.

Why Option A is Correct:

Storing Incomplete Executions: In Adobe Workfront Fusion, enabling 'Store incomplete executions' in the scenario settings allows administrators to capture incomplete runs without fully stopping the entire process. This feature stores all relevant data, even from incomplete runs, allowing administrators to identify and correct input issues manually.

Error Troubleshooting: By reviewing incomplete executions, admins can pinpoint where the scenario failed, resolve the issue, and potentially reprocess those incomplete records, preventing complete scenario stoppage.

Why Option B is Incorrect:

The 'switch module' can handle specific input variations, but it is not a comprehensive solution for handling unexpected or inconsistent formats entered by end users. While it might mitigate some errors, it does not address the root cause and can miss unanticipated input patterns.

Why Option C is Incorrect:

Setting up an error handling path to notify users and request corrections adds an additional manual step for users but does not resolve the problem efficiently within Fusion. Moreover, this solution does not prevent the scenario from halting after retries.

Steps to Enable Storing Incomplete Executions:

Navigate to the scenario in Adobe Workfront Fusion.

Open the Scenario Settings by clicking the gear icon.

Enable the option Store Incomplete Executions under Execution settings.

Save the settings and activate the scenario.

How This Solves the Problem:

Enabling this setting ensures that no data is lost when the scenario fails due to inconsistent inputs. Admins can access the incomplete executions through the scenario execution history, apply necessary corrections, and retry specific records or steps as needed.

Reference and Supporting Documentation:

Adobe Workfront Fusion Official Documentation: Scenario Settings

Workfront Community: Handling Incomplete Executions

Understanding the Expression:

The provided expression uses the ifempty function:

ifempty(2.data:types[]; 'No Type')

Structure of the Expression:

The first parameter, 2.data:types[], is an array being checked for content.

The second parameter, 'No Type', is the fallback value returned if the array is empty or undefined.

Purpose of ifempty: This function checks if the given value is empty or undefined. If the value is not empty, it returns the value. If the value is empty, it returns the fallback text ('No Type').

Expected Module Outputs:

A . Non-empty array:

If 2.data:types[] is a non-empty array, the function returns the array as-is.

C . Text value 'No Type':

If 2.data:types[] is empty or undefined, the function returns the fallback text value 'No Type'.

Why the Other Options are Incorrect:

Option B ('An empty field'):

The ifempty function does not return an empty field. If the value is empty, it substitutes it with the fallback text ('No Type').

Option D ('Collections comma separated'):

The function operates on arrays, but it does not format the output as comma-separated collections. The raw array is returned if non-empty.

Key Use Cases:

This type of function is frequently used in Workfront Fusion to handle situations where data might be missing or incomplete, ensuring scenarios continue to run smoothly without errors caused by undefined or empty fields.

Example Outputs:

If 2.data:types[] = ['Type1', 'Type2']: The function returns ['Type1', 'Type2'].

If 2.data:types[] = [] or undefined: The function returns 'No Type'.

Reference and Supporting Documentation:

Adobe Workfront Fusion Functions Reference

Workfront Community: Handling Empty Fields with ifempty

Understanding the Image and Context:

The image provided represents an HTTP module in Workfront Fusion with a URL that dynamically references various data points (e.g., parameterID, customer.domain, emailAddr).

The structure of the URL indicates a call to the Workfront API (/api/v1.0/), using parameters to pass dynamic data such as parameterID, username, and password.

Why Option A ('Custom API Call') is Correct:

The HTTP module shown in the image is a custom API call because it interacts with Workfront's API endpoints by passing dynamic parameters through the URL.

Custom API Call modules allow users to manually configure requests to endpoints in cases where no predefined Workfront Fusion module exists for the operation. This is evident in the example, where specific fields like parameterID, customer.domain, and others are manually mapped to the API URL.

Example Use Case: Dynamically creating custom form field options by sending a POST/PUT request to the Workfront API with specific parameters (like label and value) for each environment.

Why the Other Options are Incorrect:

Option B ('Misc Action'): This refers to predefined actions in Workfront Fusion for handling simple tasks. The HTTP module is not categorized under Misc Actions as it involves direct API interaction.

Option C ('Read Related Records'): This module is used to fetch data related to Workfront objects (e.g., related tasks or documents). It doesn't allow dynamic parameter passing or URL customization as seen here.

Option D ('Search'): The Search module is used for querying Workfront objects based on specific criteria but does not involve making direct API calls or sending HTTP requests with custom parameters.

Steps to Configure a Custom API Call in Workfront Fusion:

Add the HTTP Module to your scenario.

Select the appropriate HTTP method (e.g., GET, POST, PUT). In this case, a POST or PUT method would be used to create or update custom form fields.

Enter the API endpoint in the URL field, as shown in the image.

Map dynamic values to the parameters by referencing fields from previous modules in the scenario. For instance:

customer.domain: Extracted from prior steps.

parameterID, label, and value: Dynamically passed based on input data.

Authenticate the request using a username and password or an API token.

Test the module to ensure the API call works as expected.

How This Solves the Problem:

By using a Custom API Call (via the HTTP module), the user can dynamically interact with the Workfront API to create or modify custom form field options across multiple customer environments, passing the required parameters programmatically.

Reference and Supporting Documentation:

Adobe Workfront Fusion HTTP Module Documentation

Workfront API Documentation

Workfront Fusion Community Forum: Using HTTP Module for API Calls

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

Step by Step Comprehensive Detailed Explanation:

Best Practices for Scenario Clarity:

Workfront Fusion scenarios can become complex. Adopting practices that enhance readability, shareability, and understanding ensures the scenario can be maintained and used effectively by others.

Option Analysis:

A . Naming all modules by providing short but relevant labels:

Correct. Proper naming helps identify the function of each module at a glance. For example, instead of generic names like 'Project Search,' use 'Search High Priority Projects.'

This makes it easier to debug, share, and update the scenario.

B . Insert Note Modules at the beginning of the scenario:

Incorrect. While notes are useful, inserting a Note module at the beginning is not always necessary unless clarification is required for the initial step. Adding notes throughout the scenario (Option C) is more beneficial.

C . Add notes where applicable to clarify what is happening:

Correct. Adding comments or notes helps explain the purpose of certain steps, making the scenario easier to understand for collaborators or when revisiting it in the future.

D . Attach the requirements document using the scenario settings:

Incorrect. Attaching a requirements document might be useful for reference but does not directly contribute to scenario readability or understanding within the interface.

Implementation Tips:

Use descriptive names for modules that clearly indicate their purpose (e.g., 'Update Project Status' instead of 'Update Record').

Add comments or notes at decision points or complex mapping expressions to explain logic.