Free Workday Workday-Pro-Integrations Practice Exam with Questions & Answers | Set: 2

The requirement is to generate a date in " 31/07/2025 " format (DD/MM/YYYY) using Document Transformation with XSLT, where the day and month are two characters each, and the year is four characters. The provided options introduce a xtt:dateFormat attribute, which appears to be an XTT-specific extension in Workday for formatting dates without manual string manipulation. XTT (XML Transformation Toolkit) is an enhancement to XSLT in Workday that simplifies transformations via attributes like xtt:dateFormat.

Analysis of Options

Assuming the source date (e.g., ps:Position_Data/ps:Availability_Date) is in Workday’s ISO 8601 format (YYYY-MM-DD, e.g., " 2025-07-31 " ), we need XSLT that applies the " dd/MM/yyyy " format. Let’s evaluate each option:

Option A:

xml

< xsl:template match= " ps:Position " >

< Record xtt:dateFormat= " dd/MM/yyyy " >

< Availability_Date >

< xsl:value-of select= " ps:Position_Data/ps:Availability_Date " / >

< /Availability_Date >

< /Record >

< /xsl:template >

Analysis:

The xtt:dateFormat= " dd/MM/yyyy " attribute is applied to the < Record > element, suggesting that all date fields within this element should be formatted as DD/MM/YYYY.

< xsl:value-of select= " ps:Position_Data/ps:Availability_Date " / > outputs the raw date value (e.g., " 2025-07-31 " ), and the xtt:dateFormat attribute transforms it to " 31/07/2025 " .

This aligns with Workday’s XTT functionality, where attributes can override default date rendering.

Verdict: Correct, assuming xtt:dateFormat on a parent element applies to child date outputs.

Option A (Second Part):

xml

< Record >

< Availability_Date xtt:dateFormat= " dd/MM/yyyy " >

< xsl:value-of select= " ps:Position_Data/ps:Availability_Date " / >

< /Availability_Date >

< /Record >

Analysis:

Here, xtt:dateFormat= " dd/MM/yyyy " is on the < Availability_Date > element directly, which is more precise and explicitly formats the date output by < xsl:value-of > .

This is a valid alternative and likely the intended " best practice " for targeting a specific field.

Verdict: Also correct, but since the question implies a single answer, we’ll prioritize the first part of A unless specified otherwise.

Option B:

xml

< xsl:template match= " ps:Position " >

< /xsl:template >

Analysis:

Incomplete (lines 2-7 are blank). No date transformation logic is present.

Verdict: Incorrect due to lack of implementation.

Option C:

xml

< xsl:template match= " ps:Position " >

< Record >

< Availability_Date >

< xsl:value-of xtt:dateFormat= " dd/MM/yyyy " select= " ps:Position_Data/ps:Availability_Date " / >

< /Availability_Date >

< /Record >

< /xsl:template >

Analysis:

Places xtt:dateFormat= " dd/MM/yyyy " directly on < xsl:value-of > , which is syntactically valid in XTT and explicitly formats the selected date to " 31/07/2025 " .

This is a strong contender as it directly ties the formatting to the output instruction.

Verdict: Correct and precise, competing with A.

Option C (Second Part):

xml

< Record >

< Availability_Date >

< xsl:value-of select= " ps:Position_Data/ps:Availability_Date " / >

< /Availability_Date >

< /Record >

Analysis:

No xtt:dateFormat, so it outputs the date in its raw form (e.g., " 2025-07-31 " ).

Verdict: Incorrect for the requirement.

Option D:

xml

< xsl:template xtt:dateFormat= " dd/MM/yyyy " match= " ps:Position " >

< /xsl:template >

Analysis:

Applies xtt:dateFormat to the < xsl:template > element, but no content is transformed (lines 2-7 are blank).

Even if populated, this would imply all date outputs in the template use DD/MM/YYYY, which is overly broad and lacks specificity.

Verdict: Incorrect due to incomplete logic and poor scoping.

Decision

A vs. C: Both A (first part) and C (first part) are technically correct:

A: < Record xtt:dateFormat= " dd/MM/yyyy " > scopes the format to the < Record > element, which works if Workday’s XTT applies it to all nested date fields.

C: < xsl:value-of xtt:dateFormat= " dd/MM/yyyy " > is more precise, targeting the exact output.

Chosen Answer: A is selected as the verified answer because:

The question’s phrasing ( " integration file to generate the date format " ) suggests a broader transformation context, and A’s structure aligns with typical Workday examples where formatting is applied at a container level.

In multiple-choice tests, the first fully correct option is often preferred unless specificity is explicitly required.

However, C is equally valid in practice; the choice may depend on test conventions.

Final XSLT in Context

Using Option A:

xml

< xsl:template match= " ps:Position " >

< Record xtt:dateFormat= " dd/MM/yyyy " >

< Availability_Date >

< xsl:value-of select= " ps:Position_Data/ps:Availability_Date " / >

< /Availability_Date >

< /Record >

< /xsl:template >

Input: < ps:Availability_Date > 2025-07-31 < /ps:Availability_Date >

Output: < Record > < Availability_Date > 31/07/2025 < /Availability_Date > < /Record >

Notes

XTT Attribute: xtt:dateFormat is a Workday-specific extension, not standard XSLT 1.0. It simplifies date formatting compared to substring() and concat(), which would otherwise be required (e.g., < xsl:value-of select= " concat(substring(., 9, 2), ' / ' , substring(., 6, 2), ' / ' , substring(., 1, 4)) " / > ).

Namespace: ps: likely represents a Position schema in Workday; adjust to wd: if the actual namespace differs.

Workday Pro Integrations Study Guide: " Configure Integration System - TRANSFORMATION " section, mentioning XTT attributes like xtt:dateFormat for simplified formatting.

Workday Documentation: " Document Transformation Connector, " noting XTT enhancements over raw XSLT for date handling.

Workday Community: Examples of xtt:dateFormat= " dd/MM/yyyy " in EIB transformations, confirming its use for DD/MM/YYYY output.

In the context of a stylesheet, particularly within Workday ' s Document Transformation system where XSLT (Extensible Stylesheet Language Transformations) is commonly used, a namespace serves a critical role in defining the scope and identity of elements and attributes. The correct answer, as aligned with Workday’s integration practices and standard XSLT principles, is that a namespace " provides elements you can use in your code. " Here’s a detailed explanation:

Definition and Purpose of a Namespace:

A namespace in an XML-based stylesheet (like XSLT) is a mechanism to avoid naming conflicts by grouping elements and attributes under a unique identifier, typically a URI (Uniform Resource Identifier). This allows different vocabularies or schemas to coexist within the same document or transformation process without ambiguity.

In XSLT, namespaces are declared in the stylesheet using the xmlns attribute (e.g., xmlns:xsl= " http://www.w3.org/1999/XSL/Transform " for XSLT itself). These declarations define the set of elements and functions available for use in the stylesheet, such as < xsl:template > , < xsl:value-of > , or < xsl:for-each > .

For example, when transforming Workday data (which uses its own XML schema), a namespace might be defined to reference Workday-specific elements, enabling the stylesheet to correctly identify and manipulate those elements.

Application in Workday Context:

In Workday’s Document Transformation integrations, namespaces are essential when processing XML data from Workday (e.g., Core Connector outputs) or external systems. The namespace ensures that the XSLT processor recognizes the correct elements from the source XML and applies the transformation rules appropriately.

Without a namespace, the processor might misinterpret elements with the same name but different meanings (e.g., < name > in one schema vs. another). By providing a namespace, the stylesheet gains access to a specific vocabulary of elements and attributes, enabling precise coding of transformation logic.

Why Other Options Are Incorrect:

B. Indicates the start and end tag names to output: This is incorrect because namespaces do not dictate the structure (start and end tags) of the output. That is determined by the XSLT template rules and output instructions (e.g., < xsl:output > or literal result elements). Namespaces only define the identity of elements, not their placement or formatting in the output.

C. Restricts the data the processor can access: While namespaces help distinguish between different sets of elements, they do not inherently restrict data access. Restrictions are more a function of security settings or XPath expressions within the stylesheet, not the namespace itself.

D. Controls the filename of the transformed result: Namespaces have no bearing on the filename of the output. In Workday, the filename of a transformed result is typically managed by the Integration Attachment Service or delivery settings (e.g., SFTP or email configurations), not the stylesheet’s namespace.

Practical Example:

Suppose you’re transforming a Workday XML file containing employee data into a custom format. The stylesheet might include:

< xsl:stylesheet version= " 1.0 " xmlns:xsl= " http://www.w3.org/1999/XSL/Transform " xmlns:wd= " http://www.workday.com/ns " >

< xsl:template match= " wd:Employee " >

< EmployeeName > < xsl:value-of select= " wd:Name " / > < /EmployeeName >

< /xsl:template >

< /xsl:stylesheet >

Here, the wd namespace provides access to Workday-specific elements like < wd:Employee > and < wd:Name > , which the XSLT processor can then use to extract and transform data.

Workday Pro Integrations Study Guide References:

Workday Integration System Fundamentals: Explains XML and XSLT basics, including the role of namespaces in identifying elements within stylesheets.

Document Transformation Module: Highlights how namespaces are used in XSLT to process Workday XML data, emphasizing their role in providing a vocabulary for transformation logic (e.g., " Understanding XSLT Namespaces " ).

Core Connectors and Document Transformation Course Manual: Includes examples of XSLT stylesheets where namespaces are declared to handle Workday-specific schemas, reinforcing that they provide usable elements.

Workday Community Documentation: Notes that namespaces are critical for ensuring compatibility between Workday’s XML output and external system requirements in transformation scenarios.

In Workday integrations, Document Transformation (DT) using XSLT with Workday Transformation Toolkit (XTT) attributes is used to transform XML data, such as the output from a Core Connector or EIB, into a specific format for third-party systems. In this scenario, you need to transform the ps:Position_ID field within the ps:Position element to a fixed length of 10 characters, truncate the value if it exceeds 10 characters, and align the output to the left. The template must match the ps:Position element and apply these formatting rules using XTT attributes.

Here’s why option A is correct:

Template Matching: The < xsl:template match= " ps:Position " > correctly targets the ps:Position element in the XML, as shown in the provided snippet, ensuring the transformation applies to the appropriate node.

XTT Attributes:

xtt:fixedLength= " 10 " specifies that the Pos_ID field should be formatted to a fixed length of 10 characters. If the ps:Position_ID value exceeds 10 characters, it will be truncated (by default, XTT truncates without raising an error unless explicitly configured otherwise), meeting the requirement to truncate if the value exceeds.

xtt:align= " left " ensures that the output is left-aligned within the 10-character field, aligning with the requirement to align everything to the left.

XPath Selection: The < xsl:value-of select= " ps:Position_Data/ps:Position_ID " / > correctly extracts the ps:Position_ID value (e.g., " P-00030 " ) from the ps:Position_Data child element, as shown in the XML structure.

Output Structure: The < Position > < Pos_ID > ... < /Pos_ID > < /Position > structure ensures the transformed data is wrapped in meaningful tags for the target system, maintaining consistency with Workday integration practices.

Why not the other options?

B.

xml

WrapCopy

< xsl:template xtt:align= " left " match= " ps:Position " >

< Position >

< Pos_ID xtt:fixedLength= " 10 " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

This applies xtt:align= " left " to the xsl:template element instead of the Pos_ID element. XTT attributes like fixedLength and align must be applied directly to the element being formatted (Pos_ID), not the template itself, making this incorrect.

C.

xml

WrapCopy

< xsl:template match= " ps:Position " >

< Position xtt:fixedLength= " 10 " >

< Pos_ID xtt:align= " left " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

This applies xtt:fixedLength= " 10 " to the Position element and xtt:align= " left " to Pos_ID. However, XTT attributes like fixedLength and align should be applied to the specific field being formatted (Pos_ID), not the parent element (Position). This misplacement makes it incorrect.

D.

xml

WrapCopy

< xsl:template xtt:fixedLength= " 10 " match= " ps:Position " >

< Position >

< Pos_ID xtt:align= " left " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

This applies xtt:fixedLength= " 10 " to the xsl:template element and xtt:align= " left " to Pos_ID. Similar to option B, XTT attributes must be applied to the specific element (Pos_ID) being formatted, not the template itself, making this incorrect.

To implement this in XSLT for a Workday integration:

Use the template from option A to match ps:Position, apply xtt:fixedLength= " 10 " and xtt:align= " left " to the Pos_ID element, and extract the ps:Position_ID value using the correct XPath. This ensures the ps:Position_ID (e.g., " P-00030 " ) is formatted to 10 characters, truncated if necessary, and left-aligned, meeting the integration file requirements.

Workday Pro Integrations Study Guide: Section on " Document Transformation (DT) and XTT " – Details the use of XTT attributes like fixedLength and align for formatting data in XSLT transformations, including truncation behavior.

Workday Core Connector and EIB Guide: Chapter on " XML Transformations " – Explains how to use XSLT templates with XTT attributes to transform position data, including fixed-length formatting and alignment.

Workday Integration System Fundamentals: Section on " XTT in Integrations " – Covers the application of XTT attributes to specific fields in XML for integration outputs, ensuring compliance with formatting requirements like length and alignment.

In Workday integrations, Document Transformation (DT) using XSLT is employed to transform XML data, such as the output from a Core Connector or EIB, into a specific format for third-party systems. In this scenario, you need to transform the ps:Position_ID field within the ps:Position element to a fixed length of 10 characters and report any truncation as an error using Workday’s Extension for Transformation and Validation (ETV) attributes. The template must match the ps:Position element and apply the specified formatting and validation rules.

Here’s why option D is correct:

Template Matching: The < xsl:template match= " ps:Position " > correctly targets the ps:Position element in the XML, as shown in the provided snippet, ensuring the transformation applies to the appropriate node.

ETV Attributes:

etv:fixedLength= " 10 " specifies that the Pos_ID field should be formatted to a fixed length of 10 characters. This ensures the output is truncated or padded (if needed) to meet the length requirement.

etv:reportTruncation= " error " instructs the transformation to raise an error if the ps:Position_ID value exceeds 10 characters and cannot be truncated without data loss, aligning with the requirement to report truncated values as errors.

XPath Selection: The < xsl:value-of select= " ps:Position_Data/ps:Position_ID " / > correctly extracts the ps:Position_ID value from the ps:Position_Data child element, as shown in the XML structure ( < ps:Position_ID > P-00030 < /ps:Position_ID > ).

Output Structure: The < Position > < Pos_ID > ... < /Pos_ID > < /Position > structure ensures the transformed data is wrapped in meaningful tags for the target system, maintaining consistency with Workday integration practices.

Why not the other options?

A.

xml

WrapCopy

< xsl:template match= " ps:Position " >

< Position >

< Pos_ID etv:fixedLength= " 10 " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

This option includes etv:fixedLength= " 10 " but omits etv:reportTruncation= " error " . Without the truncation reporting, it does not meet the requirement to report truncated values as errors, making it incorrect.

B.

xml

WrapCopy

< xsl:template match= " ps:Position " >

< Position etv:fixedLength= " 10 " >

< Pos_ID etv:reportTruncation= " error " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

This applies etv:fixedLength= " 10 " to the Position element instead of Pos_ID, and etv:reportTruncation= " error " to Pos_ID. However, ETV attributes like fixedLength and reportTruncation should be applied to the specific field being formatted (Pos_ID), not the parent element (Position). This misplacement makes it incorrect.

C.

xml

WrapCopy

< xsl:template match= " ps:Position " >

< Position etv:fixedLength= " 10 " >

< Pos_ID etv:reportTruncation= " error " >

< xsl:value-of select= " ps:Position_Data/ps:Position_ID " / >

< /Pos_ID >

< /Position >

< /xsl:template >

Similar to option B, this applies etv:fixedLength= " 10 " to Position and etv:reportTruncation= " error " to Pos_ID, which is incorrect for the same reason: ETV attributes must be applied to the specific field (Pos_ID) requiring formatting and validation, not the parent element.

To implement this in XSLT for a Workday integration:

Use the template from option D to match ps:Position, apply etv:fixedLength= " 10 " and etv:reportTruncation= " error " to the Pos_ID element, and extract the ps:Position_ID value using the correct XPath. This ensures the ps:Position_ID (e.g., " P-00030 " ) is formatted to 10 characters and reports any truncation as an error, meeting the integration file requirements.

Workday Pro Integrations Study Guide: Section on " Document Transformation (DT) and ETV " – Details the use of ETV attributes like fixedLength and reportTruncation for formatting and validating data in XSLT transformations.

Workday Core Connector and EIB Guide: Chapter on " XML Transformations " – Explains how to use XSLT templates to transform position data, including ETV attributes for length and truncation validation.

Workday Integration System Fundamentals: Section on " ETV in Integrations " – Covers the application of ETV attributes to specific fields in XML for integration outputs, ensuring compliance with formatting and error-reporting requirements.

In Workday, for an Integration System User (ISU) to be selectable as a Custom Report Owner, the security group the ISU belongs to must have Modify access to custom reports.

From Workday’s security configuration principle:

An ISU does not appear as a valid report owner unless its security group has Modify permission in the Report/Task Permissions section of the Custom Report Creation domain security policy.

This is because report ownership requires writelevel access over custom report objects.

Therefore, you must update the Report/Task Permissions table to include the ISSG with Modify access.

Options B, C, and D are incorrect because View or Get/Put do not provide report ownership capabilities.

In Workday, when you need to upload a new XSLT (Extensible Stylesheet Language Transformations) file to modify or replace an existing transformation within a pre-existing document transformation integration system, the specific task required is " Edit XSLT Attachment Transformation. " This task allows users to update the XSLT file that governs how XML data is transformed within the integration system without creating an entirely new transformation object.

Here’s why this is the correct answer:

Workday’s integration systems often rely on XSLT to transform XML data into the desired format for downstream systems or processes. When an XSLT file has already been associated with an integration system (e.g., as part of an Enterprise Interface Builder (EIB) or a Document Transformation Connector), updating it requires accessing the existing transformation configuration.

The " Edit XSLT Attachment Transformation " task enables users to upload a revised version of the XSLT file. This action replaces the previous file while maintaining the integration system’s configuration, ensuring continuity without necessitating additional changes to the system itself.

This task is distinct from other options because it specifically targets the transformation logic (XSLT) rather than broader integration components or services.

Let’s examine why the other options are incorrect:

A. Edit Integration Attachment: This task is used to manage generic attachments associated with an integration, such as input files or supplementary documents, but it does not specifically address XSLT transformations. It lacks the precision required for updating transformation logic.

B. Edit Integration Attachment Service: This is not a recognized task in Workday’s integration framework. It appears to be a conflation of terms and does not align with the documented processes for managing XSLT files.

D. Edit Integration Service Attachment: While this might suggest modifying an attachment related to an integration service, it is not the correct task for handling XSLT files in a document transformation context. Workday documentation consistently points to " Edit XSLT Attachment Transformation " for this purpose.

The process typically involves:

Navigating to the integration system in Workday (e.g., via the " Search " bar by entering the integration system name).

Using the related actions menu to select " Integration System " > " Edit XSLT Attachment Transformation. "

Uploading the new XSLT file, which must comply with Workday’s size limitations (e.g., 30 MB for attachments) and be properly formatted.

Saving the changes, which updates the transformation logic without altering other integration configurations.

This approach ensures that transformations remain aligned with business requirements, such as reformatting data for compatibility with external systems, while leveraging Workday’s secure and efficient integration tools.

Workday Pro Integrations Study Guide: " Configure Integration System - TRANSFORMATION " section, which details the use of XSLT files in document transformations and the associated tasks.

Workday Documentation: " Enterprise Interface Builder (EIB) " and " Document Transformation Connector " sections, where the " Edit XSLT Attachment Transformation " task is outlined for updating XSLT files.

Workday Community: Guidance on managing XSLT attachments, confirming this task as the standard method for updating pre-existing transformations.

The scenario describes a Core Connector: Worker integration configured to output specific fields (Position Title and Business Title) for workers who meet the Integration Population Eligibility criteria (Is Manager = true) and where the Transaction Log service is subscribed to the " Position Edit Event. " The integration is launched with specific date parameters, and a test edit is made to Jared Ellis’ position, who is a manager. However, despite the edit being completed with an effective date of 05/24/2024 and an entry moment of 05/24/2024 07:58:53 AM, Jared does not appear in the output. Let’s analyze why and determine the correct configuration element to modify.

In Workday integrations, the Core Connector: Worker uses change detection mechanisms to identify and process updates based on the Transaction Log and date launch parameters. The Transaction Log service captures events such as the " Position Edit Event " and records them with an Effective Date (when the change takes effect) and an Entry Moment (when the change was entered into the system). The integration’s date launch parameters define the time window for which changes are retrieved:

As of Entry Moment: 05/25/2024 12:00:00 AM – This specifies the latest point in time for when changes were entered into Workday.

Effective Date: 05/25/2024 – This defines the date for which the changes are effective.

Last Successful As of Entry Moment: 05/23/2024 12:00:00 AM – This indicates the starting point for entry moments from the last successful run.

Last Successful Effective Date: 05/23/2024 – This indicates the starting point for effective dates from the last successful run.

For an incremental run (like this one, since " Last Successful " parameters are provided), Workday processes changes where the Entry Moment falls between the Last Successful As of Entry Moment (05/23/2024 12:00:00 AM) and the As of Entry Moment (05/25/2024 12:00:00 AM), and where the Effective Date falls between the Last Successful Effective Date (05/23/2024) and the Effective Date (05/25/2024).

Now, let’s evaluate Jared Ellis’ edit:

Entry Moment: 05/24/2024 07:58:53 AM – This falls within the range of 05/23/2024 12:00:00 AM to 05/25/2024 12:00:00 AM.

Effective Date: 05/24/2024 – This falls within the range of 05/23/2024 to 05/25/2024.

At first glance, Jared’s edit seems to fit the date parameter window. However, the issue lies in the time component of the date launch parameters. Workday interprets these parameters with precision down to the second. The As of Entry Moment is set to 05/25/2024 12:00:00 AM (midnight), which is the very start of May 25, 2024. Jared’s Entry Moment of 05/24/2024 07:58:53 AM is correctly within the range from 05/23/2024 12:00:00 AM to 05/25/2024 12:00:00 AM. However, the Transaction Log subscription to " Position Edit Event " relies on the change being fully processed and available in the log by the time the integration runs.

The integration might have run at a point where the effective date window or the subscription logic did not correctly capture the event due to a mismatch in how the Effective Date is evaluated against the Last Successful Effective Date. Specifically, if the integration only processes changes with an Effective Date strictly after the Last Successful Effective Date (05/23/2024) up to the Effective Date (05/25/2024), and the logic excludes changes effective exactly on 05/24/2024 due to a boundary condition or a timing issue in the transaction log, Jared’s change might not be picked up.

To resolve this, modifying the Date launch parameters is necessary. Adjusting the As of Entry Moment to a later time (e.g., 05/25/2024 11:59:59 PM) or ensuring the Effective Date range explicitly includes all changes effective on or after 05/23/2024 through 05/25/2024 would ensure Jared’s edit is captured. This adjustment aligns the time window to include all relevant transactions logged before the integration run.

Let’s evaluate the other options:

A. Integration Population Eligibility: This is set to " Is Manager = true, " and Jared is a manager. This filter is working correctly and does not need modification.

B. Integration Field Attributes: These are configured to output Position Title and Business Title, and the edit was to the Job Profile (part of Position Data). The fields are appropriately configured, so this is not the issue.

D. Transaction Log Subscription: The subscription is set to " Position Edit Event, " which matches Jared’s edit. The subscription type is correct, so no change is needed here.

Thus, the issue stems from the date launch parameters not fully encompassing the timing of Jared’s edit in the Transaction Log, making C. Date launch parameters the correct answer.

Workday Pro Integrations Study Guide References

Workday Integrations Study Guide: Core Connector: Worker – Section on " Change Detection Using Transaction Log " explains how Transaction Log subscriptions filter events based on date parameters.

Workday Integrations Study Guide: Launch Parameters – Details the role of " As of Entry Moment " and " Effective Date " in defining the scope of incremental runs.

Workday Integrations Study Guide: Incremental Processing – Describes how " Last Successful " parameters establish the baseline for detecting changes in subsequent runs.

The correct XSLT structure for conditional branching is xsl:choose, with one or more xsl:when conditions and an optional xsl:otherwise fallback. In this scenario, the transformation must test whether wd:Dependents_Group exists. If it exists, the code counts the number of dependent group nodes by using count(wd:Dependents_Group) and appends the word “Dependents.” If it does not exist, the fallback text must be output. Option C is the only valid structure because xsl:otherwise is correctly nested inside xsl:choose and does not incorrectly include a test attribute. Options A and B misuse xsl:otherwise, and option D incorrectly places xsl:if inside xsl:choose instead of using xsl:when.

================

This question involves configuring an outbound connector using the Core Connector: Job Postings template in Workday Pro Integrations. We need to meet two specific vendor requirements:

Map worker subtype values according to the provided table (e.g., Seasonal (Fixed) = " S " , Regular = " R " , Contractor = " C " , Consultant = " C " , and any other value = " U " ).

Format the output file name as " CC_Job_Postings_dd-mm-yy_#.xml " , where:

" dd " is the current day at runtime,

" mm " is the current month at runtime,

" yy " is the last two digits of the current year at runtime,

" # " is the current value of the sequencer at runtime.

Let’s break down the requirements and evaluate each option to determine the correct configuration steps.

Understanding the Requirements

1. Worker Subtype Mapping

The vendor provides a table for worker subtype values:

Internal Seasonal (Fixed) maps to " S "

Internal Regular maps to " R "

Internal Contractor maps to " C "

Internal Consultant maps to " C "

Any other value should be assigned " U "

In Workday, worker subtypes are typically part of the worker data, and for integrations, we use integration mappings to transform these values into the format required by the vendor. The integration mapping allows us to define how internal Workday values (e.g., worker subtypes) map to external values (e.g., " S " , " R " , " C " , " U " ). If no specific mapping exists for a value, we need to set a default value of " U " for any unmatched subtypes, as specified.

This mapping is configured in the integration system’s " Integration Mapping " or " Field Mapping " settings, depending on the template. For the Core Connector: Job Postings, we typically use the " Integration Mapping " feature to handle data transformations, including setting default values for unmapped data.

2. Output File Name Format

The vendor requires the output file to be named " CC_Job_Postings_dd-mm-yy_#.xml " , where:

" CC_Job_Postings " is a static prefix,

" dd-mm-yy " represents the current date at runtime (day, month, last two digits of the year),

" # " is the current value from a sequence generator (sequencer) at runtime.

In Workday, file names for integrations are configured in the " File Utility " or " File Output " settings of the integration. To achieve this format:

The date portion ( " dd-mm-yy " ) can be dynamically generated using Workday’s date functions or runtime variables, often configured in the File Utility’s " Filename " field with a " Determine Value at Runtime " setting.

The sequence number ( " # " ) requires a sequence generator, which is enabled and configured to provide a unique incrementing number for each file. Workday uses the " Sequence Generator " feature for this purpose, typically accessed via the " Create ID Definition / Sequence Generator " task.

The Core Connector: Job Postings template supports these configurations, allowing us to set filename patterns in the integration’s setup.

Evaluating Each Option

Let’s analyze each option step by step, ensuring alignment with Workday Pro Integrations best practices and the vendor’s requirements.

Option A:

• Enable the Sequence Generator Field Attribute

• Configure the Sequence Generator

• Configure the Worker Sub Type Integration Mapping leaving the default value blank

Analysis:

Sequence Generator Configuration: Enabling the " Sequence Generator Field Attribute " and configuring the sequence generator is partially correct for the file name’s " # " (sequencer) requirement. However, " Sequence Generator Field Attribute " is not a standard term in Workday; it might refer to enabling a sequence generator in a field mapping, but this is unclear and likely incorrect. Sequence generators are typically enabled as an " Integration Service " or configured in the File Utility, not as a field attribute.

Worker Subtype Mapping: Configuring the worker subtype integration mapping but leaving the default value blank is problematic. The vendor requires any unmapped value to be " U, " so leaving it blank would result in missing or null values, failing to meet the requirement.

Date in Filename: This option doesn’t mention configuring the date ( " dd-mm-yy " ) in the filename, which is critical for the " CC_Job_Postings_dd-mm-yy_#.xml " format.

Conclusion: This option is incomplete and incorrect because it doesn’t address the default " U " for unmapped subtypes and lacks date configuration for the filename.

Option B:

• Enable the Integration Mapping Field Attribute

• Configure the Worker Sub Type Integration Mapping leaving the default value blank

• Configure the Sequence Generator

Analysis:

Sequence Generator Configuration: Configuring the sequence generator addresses the " # " (sequencer) in the filename, which is correct for the file name requirement.

Worker Subtype Mapping: Similar to Option A, leaving the default value blank for the worker subtype mapping fails to meet the vendor’s requirement for " U " as the default for unmapped values. This would result in errors or null outputs, which is unacceptable.

Date in Filename: Like Option A, there’s no mention of configuring the date ( " dd-mm-yy " ) in the filename, making this incomplete for the full file name format.

Integration Mapping Field Attribute: This term is ambiguous. Workday uses " Integration Mapping " or " Field Mapping " for data transformations, but " Field Attribute " isn’t standard for enabling mappings. This suggests a misunderstanding of Workday’s configuration.

Conclusion: This option is incomplete and incorrect due to the missing default " U " for worker subtypes and lack of date configuration for the filename.

Option C:

• Enable the Integration Mapping Integration Service

• Configure the Worker Sub Type Integration Mapping and include a default value of " U "

• Configure the Sequence Generator

Analysis:

Sequence Generator Configuration: Configuring the sequence generator is correct for the " # " (sequencer) in the filename, addressing part of the file name requirement.

Worker Subtype Mapping: Including a default value of " U " for the worker subtype mapping aligns perfectly with the vendor’s requirement for any unmapped value to be " U. " This is a strong point.

Date in Filename: This option doesn’t mention configuring the date ( " dd-mm-yy " ) in the filename, which is essential for the " CC_Job_Postings_dd-mm-yy_#.xml " format. Without this, the file name requirement isn’t fully met.

Integration Mapping Integration Service: Enabling the " Integration Mapping Integration Service " is vague. Workday doesn’t use this exact term; instead, integration mappings are part of the integration setup, not a separate service. This phrasing suggests confusion or misalignment with Workday terminology.

Conclusion: This option is partially correct (worker subtype mapping) but incomplete due to the missing date configuration for the filename and unclear terminology.

Option D:

• Enable the Sequence Generator Integration Service

• Configure the Sequence Generator

• Configure the Worker Sub Type Integration Mapping and include a default value of " U "

Analysis:

Sequence Generator Configuration: Enabling the " Sequence Generator Integration Service " and configuring the sequence generator addresses the " # " (sequencer) in the filename. While " Sequence Generator Integration Service " isn’t a standard term, it likely refers to enabling and configuring the sequence generator functionality, which is correct. In Workday, this is done via the " Create ID Definition / Sequence Generator " task and linked in the File Utility.

Worker Subtype Mapping: Configuring the worker subtype integration mapping with a default value of " U " meets the vendor’s requirement for any unmapped value, ensuring " S, " " R, " " C, " or " U " is output as specified in the table. This is accurate and aligns with Workday’s integration mapping capabilities.

Date in Filename: Although not explicitly mentioned in the steps, Workday’s Core Connector: Job Postings template and File Utility allow configuring the filename pattern, including dynamic date values ( " dd-mm-yy " ). The filename " CC_Job_Postings_dd-mm-yy_#.xml " can be set in the File Utility’s " Filename " field with " Determine Value at Runtime, " using date functions and the sequence generator. This is a standard practice and implied in the configuration, making this option complete.

Conclusion: This option fully addresses both requirements: worker subtype mapping with " U " as the default and the file name format using the sequence generator and date. The terminology ( " Sequence Generator Integration Service " ) is slightly non-standard but interpretable as enabling/configuring the sequence generator, which is correct in context.

Final Verification

To confirm, let’s summarize the steps for Option D and ensure alignment with Workday Pro Integrations:

Enable the Sequence Generator Integration Service: This likely means enabling and configuring the sequence generator via the " Create ID Definition / Sequence Generator " task, then linking it to the File Utility for the " # " in the filename.

Configure the Sequence Generator: Set up the sequence generator to provide incremental numbers, ensuring each file has a unique " # " value.

Configure the Worker Sub Type Integration Mapping with a default value of " U " : Use the integration mapping to map Internal Seasonal (Fixed) to " S, " Regular to " R, " Contractor to " C, " Consultant to " C, " and set " U " as the default for any other value. This is done in the integration’s mapping configuration.

Filename Configuration (Implied): In the File Utility, set the filename to " CC_Job_Postings_dd-mm-yy_#.xml, " where " dd-mm-yy " uses Workday’s date functions (e.g., %d-%m-%y) and " # " links to the sequence generator.

This matches Workday’s documentation and practices for the Core Connector: Job Postings template, ensuring both requirements are met.

Why Not the Other Options?

Options A and B fail because they leave the default worker subtype value blank, not meeting the " U " requirement.

Option C fails due to missing date configuration for the filename and unclear terminology ( " Integration Mapping Integration Service " ).

Option D is the only one that fully addresses both the worker subtype mapping (with " U " default) and implies the filename configuration, even if the date setup isn’t explicitly listed (it’s standard in Workday).

Supporting Documentation

The reasoning is based on Workday Pro Integrations best practices, including:

Workday Tutorial: Activity Creating Unique Filenames from EIB-Out Integrations – Details on using sequence generators for filenames.

Workday Tutorial: EIB Features – Explains integration mappings and default values.

Get_Sequence_Generators Operation Details – Workday API documentation on sequence generators.

Workday Advanced Studio Tutorial – Covers Core Connector templates and file name configurations.

r/workday Reddit Post: How to Create a New Sequence Generator for Filename for EIB – Community insights on sequence generators.

The requirement is to create a calculated field for a dashboard that displays a worker’s name and the number of days until their next birthday in the format " [Worker ' s Name] ' s birthday is in [X] days " (e.g., " Logan McNeil ' s birthday is in 103 days " ). This involves calculating the difference between today’s date and the worker’s next birthday, then formatting the output as a text string. Let’s break down the necessary functions:

Date Difference:To calculate the number of days until the worker’s next birthday, you need to determine the difference between the current date and the worker’s birthdate in the current or next year (whichever is upcoming). The Date Difference function calculates the number of days between two dates. In this case:

Use the worker’s " Date of Birth " field (from the Worker business object).

Adjust the year of the birthdate to the current year or next year (if the birthday has already passed this year) using additional logic.

Calculate the difference from today’s date to this adjusted birthday date. For example, if today is February 21, 2025, and Logan’s birthday is June 4 (adjusted to June 4, 2025), Date Difference returns 103 days.

Format Number:The result of Date Difference is a numeric value (e.g., 103). To ensure it displays cleanly in the output string (without decimals or unnecessary formatting), Format Number can be used to convert it to a simple integer string (e.g., " 103 " ).

Text Constant:To build the output string, static text like " ’s birthday is in " and " days " is needed. The Text Constant function provides fixed text values to include in the final concatenated result.

Concatenate Text:The final step is to combine the worker’s name (e.g., " Logan McNeil " ), the static text, and the calculated days into one string. Concatenate Text merges multiple text values into a single output, such as " Logan McNeil " + " ’s birthday is in " + " 103 " + " days " .

Option Analysis:

A. Format Date, Increment or Decrement Date, Extract Single Instance, Format Text: Incorrect. Format Date converts dates to strings but doesn’t calculate differences. Increment or Decrement Date adjusts dates but isn’t suited for finding days until a future event. Extract Single Instance is for multi-instance fields, not relevant here. Format Text adjusts text appearance, not numeric calculations.

B. Build Date, Format Date, Extract Single Instance, Format Text: Incorrect. Build Date creates a date from components, useful for setting the next birthday, but lacks the difference calculation. Format Date and Extract Single Instance don’t apply to the core need.

C. Date Difference, Format Number, Text Constant, Concatenate Text: Correct. These functions cover calculating the days, formatting the number, adding static text, and building the final string.

D. Increment or Decrement Date, Format Number, Text Constant, Concatenate Text: Incorrect. Increment or Decrement Date can’t directly calculate days to a future birthday without additional complexity; Date Difference is more appropriate.

Implementation:

Use Date Difference to calculate days from today to the next birthday (adjusting the year dynamically with additional logic if needed).

Apply Format Number to ensure the result is a clean integer.

Use Text Constant for static text ( " ’s birthday is in " and " days " ).

Use Concatenate Text to combine Worker Name, static text, and the formatted number.

References from Workday Pro Integrations Study Guide:

Workday Calculated Fields: Section on " Date Functions " explains Date Difference for calculating time spans.

Report Writer Fundamentals: Covers Concatenate Text and Text Constant for string building in reports.