Author: Chris Bahr, Created: 2025-12-03

Overview

The purpose of this article is to walk through how to embed the Component Workflow in a OneStream Dashboard to surface a workflow-oriented approach to providing parameters to a routine method.

In this example, we will showcase how to create an instance of the TrainingBankAccountMgmt Routine.

Finding the Routine Method

Viewing the Routine Documentation in SensibleAI Studio, we can see that the Training - Bank Account Mgmt Routine has an __init__ method that takes in some parameters.

In order to fully create our instance of the routine, we will need to create the Routine Instance and run the constructor. We will create the mechanism to allow a user to step through the parameter configuration in the UI using Component Workflow.

0. Pre-Req: Entrypoint and XBR Assembly Dependency

The overarching goal of this document is to embed Component Workflow into a OneStream Dashboard, thus allowing a user to execute a Routine via launching the Component Workflow from a button click, configuring the parameters, and submitting the Routine Run for execution.

To follow along, you can create a Workspace called “Component Workflow Test Workspace”. Within this Workspace, create a Maintenance Unit called “Solution Maintenance Unit”, a Dashboard Group called “Main”, and within it, a OneStream Dashboard with a single button on it that will serve as our main entrypoint into the exercise. This button should have the Selection Changed Server Task set to Execute Dashboard Extender Business Rule (General Server), and call a Business Rule containing the code derived in this article.

An Application Workspaces extract is provided at the end of this document.

Additionally, you will need to have the 'AIS Xperiflow Business Rules (XBR)' Workspace uploaded to your OneStream app, and the appropriate dependency added.

1. OneStream Setup

There is a small amount of OneStream Setup to do to get the Component Workflow to properly render along with some supporting action buttons. We will need:

1. A Dashboard Group with Dashboards
2. A Web Content Component
3. Cancel and Submit buttons
4. A blank Label
5. Two parameters

1.1 Dashboard Group and Dashboards

First, within your Maintenance Unit, create a Dashboard Group called Component Workflow. Within this Dashboard Group, create three Dashboards, and configure them as specified:

• CW_0_Frame

  • Dashboard Type: Top Level Without Parameter Prompts

  • Layout Type: Grid

  • Display Format: EnableSystemClose = False

  • Number of Rows: 2

  • Number of Columns: 1

    • Row 1 Type: Component
    • Row 1 Height: *
    • Row 2 Type: Component
    • Row 2 Height: Auto
    • Column 1 Type: Component
    • Column 1 Width: *

• CW_1_Row_wcv

  • Dashboard Type: (Use Default)
  • Layout Type: Uniform

• CW_2_Row_btns

  • Dashboard Type: (Use Default)

  • Layout Type: Grid

  • Number of Rows: 1

  • Number of Columns: 3

    • Row 1 Type: Component
    • Row 1 Height: Auto
    • Column 1 Type: Component
    • Column 1 Width: *
    • Column 2 Type: Component
    • Column 2 Width: Auto
    • Column 3 Type: Component
    • Column 3 Width: Auto

1.2 Web Content Viewer

Create a Web Content Component, and configure it as follows:

• Name: wcv_ComponentWorkflowViewer
• Web Content Type: Url
• Url Or Item Name: |!CW_WebDashboardUrl!|
• Open Content in New Tab (Web Only): False
• Show Borders: False
• Show Header: False
• Show Toggle Size Button: True

1.3 Cancel and Submit Buttons

We need to create two buttons to drive actions on our Dashboard. These buttons are simple, and can be formatted based on the preferences of the developer. A few key configurations:

• Submit Button

  • Name: btn_CW_Submit

  • Text: Submit

  • Selection Changed Server Task: Execute Dashboard Extender Business Rule (General Server)

  • Selection Changed Server Task Arguments:

    • {WSMU}{OnSubmitComponentWorkflowButtonClick}{}

• Cancel Button:

  • Name: btn_CW_Cancel

  • Text: Cancel

  • Selection Changed Server Task: Execute Dashboard Extender Business Rule (General Server)

  • Selection Changed Server Task Arguments:

    • {WSMU}{OnCancelComponentWorkflowButtonClick}{}

1.4 Label

Simply create a Label component with no text. You could name it “lbl_Blank1”. This will just be used for formatting.

1.5 Parameters

Create a Parameter called CW_RoutineInstanceId with a Parameter Type of Input Value.

Create a Parameter called CW_RoutineRunId with a Parameter Type of Input Value.

1.6 Putting it all together

We will build out the dashboards from the bottom up.

1. Navigate to the CW_2_Row_btns Dashboard

   1. Add the following Dashboard Components and order them as follows:

      1. lbl_Blank1
      2. btn_CW_Cancel
      3. btn_CW_Submit

2. Navigate to the CW_1_Row_wcv Dashboard

   1. Add the wcv_ComponentWorkflowViewer Component

3. Navigate to your CW_0_Frame Dashboard

   1. Add the following Dashboard Components and order them as follows:

      1. Embedded CW_1_Row_wcv
      2. Embedded CW_2_Row_btns

---

2. Assembly Code

2.1 Creating the Routine Instance

info

We will assume that this code - with the exception of additonal methods defined below - is operating within a method called by some button click on a dashboard. Our example will use OnCreateBankAccountInstanceButtonClick. A full code example will help clarify at the end.

The first thing we will need is an instance of the TrainingBankAccountMgmt routine.

// Get the Routine Client
var routineClient = XBRApi.Routines.GetRoutineClient(si);
// Create the Routine Instance
var bankAccountInstance = routineClient.CreateRoutineInstanceAsync(
    routineTypename: "TrainingBankAccountMgmt",
    routineVersion: "1.0.0",
    name: null
).Result;

info

If you already have an instance of the routine you want to invoke a run for, you could instead Get the Routine Instance.

info

Additionally, we usenull for the name so that the resulting code produced in this document is re-runnable. If you want to maintain a more user-friendly Routine Instance Name, you can provide one - just know that Routine Instance names must be unique.

2.2 Creating the Routine Run

Component Workflow requires that we use an Invocation Method Type of InvocationMethodType.Workflow.

// Use our Routine Instance to create a Run
var bankAccountCtorRun = bankAccountInstance.CreateRunAsync(
  methodName: "__init__",
  runName: null,
  includeStatistics: false,
  includePreviews: false,
  invocationMethodType: InvocationMethodType.Workflow,
  inputParams: new JObject(),
  executionType: "background"
).Result;

// Now that we've created the Run, we need to get the WorkflowId of the Run
int workflowId = bankAccountCtorRun.InvocationMethod.WorkflowId;

Let’s break this code down:

• Line 2: Call CreateRunAsync() on the Routine Instance
• Line 3: Provide the name of the method we want to invoke: __init__
• Line 4: Provide null for the runName (one will be auto-generated, and we aren’t concerned with it)
• Lines 5-6: Don’t generate statistics or previews (this routine method doesn’t create an Artifact)
• Line 7: Use the Workflow Invocation Method Type (as opposed to Direct)
• Line 8: Provide an empty JObject - the parameters will be constructed as the user steps through the Component Workflow
• Line 9: We want to execute this routine run as background vs. as in-memory (notice how Allow In-Memory Execution is False for this routine method).
• Line 10: CreateRunAsync() returns a Task<Run>, so we use .Result to block the current thread until the asynchronous operation completes, and we assign the actual Run object to bankAccountCtorRun.
• Line 13: After we’ve created the run, we get the WorkflowId, which will allow us to load the appropriate workflow (parameter configuration) via Component Workflow (in subsequent steps)

info

So far, we have leveraged created the Bank RoutineInstance to *create* a Routine Run. We haven’t actually *started* the Run yet.

2.3 Displaying the Component Workflow

The first thing we need to do is construct our URL where the Web Dashboard is going to be served. There are a couple constants within Xperiflow Business Rules (XBR) and a Parameter we will leverage here.

// Create a helper method to construct the URL
public static string CreateComponentWorkflowUrl(SessionInfo si, int workflowId)
{
    // Get the WorkspaceId of the Xperiflow Business Rules Workspace
    var xbrWorkspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(
      si: si,
      isSystemLevel: false,
      workspaceName: XperiflowConstants.WorkspaceName
    );
    // Get the value of the BaseUrl_Xperiflow_XBR parameter within the 
    // Xperiflow Business Rules Workspace 
    var baseUrl = BRApi.Dashboards.Parameters.GetLiteralParameterValue(
      si: si,
      isSystemLevel: false,
      workspaceIDIfNotInName: xbrWorkspaceId,
      combinedWsAndParamName: XperiflowConstants.XperiflowBaseUriParameter
    );
    if (!baseUrl.EndsWith('/'))
        baseUrl += '/';

    string url = $"{baseUrl}dash/component-workflow/workflow-instances/{workflowId}/";
    return url;
}

With a helper method to construct the URL given the workflowId, we are ready to launch the Dialog in OneStream and load the Component Workflow within that Dialog.

// Create the XFSelectionChangedTaskResult
var taskResult = new XFSelectionChangedTaskResult();

// Construct the URL using the helper method
string webDashboardUrl = ComponentWorkflowUtil.CreateComponentWorkflowUrl(si, workflowId);

// Provide the Web Dashboard Url and Workflow Id to the Dialog
taskResult.ChangeCustomSubstVarsInLaunchedDashboard = true;
taskResult.ModifiedCustomSubstVarsForLaunchedDashboard.Add("CW_WebDashboardUrl", webDashboardUrl);

// Set the Dashboard to Display and appropriate Selection Changed UI Action Info
taskResult.ChangeSelectionChangedUIActionInDashboard = true;
taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.OpenDialogWithNoButtonsApplyChangesAndRefresh;
taskResult.ModifiedSelectionChangedUIActionInfo.DashboardForDialog = "CW_0_Frame";

// Use a Dashboard Parameter to provide the Routine Instance Id and the Routine Run Id to the dialog
string dataRuleMgrInstanceId = bankAccountInstance.InstanceIdentifier;
string bankAccountCtorRunId = bankAccountCtorRun.RunIdentifier;

// Set the Literal Parameter Value
var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", dataRuleMgrInstanceId);
BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", bankAccountCtorRunId);

return taskResult;

Breaking this code down:

• Line 2: Create our XFSelectionChangedTaskResult that will be returned.
• Line 5: Construct the Web Dashboard Url where the Component Workflow web dashboard is served
• Line 8: Allow us to modify the CustomSubstVars in the Dialog
• Line 9: Set the Component Workflow Web Dashboard Url Parameter Value to the Url we just constructed
• Line 12: Override the SelectionChangedUIActionInDashboard setting on the dialog
• Line 13: Set the SelectionChangedUIActionType to Open the Dialog with No Buttons, Apply Changes, and Refresh
• Line 14: Set the Dashboard to Display in the dialog to our CW_0_Frame, the dashboard that contains the Web Content Component and Buttons
• Line 17: Get the Instance Id from our bankAccountInstance
• Line 18: Get the Run Id from our bankAccountCtorRun that we created
• Line 21: Get the workspaceId to provide in the BRApi call
• Line 22-23: Set the values for the CW_RoutineInstanceId and CW_RoutineRunId dashboard parameters

info

At this point, we would be able to step through the parameter configuration for our Routine Run within the Component Workflow dialog. We still have not yet provided a way to *start* the Run. We will do that next.

2.4 The Submit and Cancel Buttons

In Step 1.3, we created two buttons to execute Assembly code. Here, we’ll write the code for those buttons that allows us to either start the Run we’ve created if a user were to click Submit, or delete the Run if they click Cancel. We’ll define two new methods to achieve this.

Reminder that in the previous step, we used XBR’s CacheUtil to cache the Routine Instance Id and Routine Run Id.

The Submit Button

Now that we’ve got a helper method to retrieve the Run, we can implement the functionality to start the routine method.

public static XFSelectionChangedTaskResult OnSubmitComponentWorkflowButtonClick(SessionInfo si, DashboardExtenderArgs args)
{
    var taskResult = new XFSelectionChangedTaskResult();

    // Get the Literal Parameter Value
    var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
    string instanceId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId");
    string runId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId");

    if (string.IsNullOrEmpty(instanceId) || string.IsNullOrEmpty(runId))
    {
        throw new XFUserMsgException(si, string.Empty, string.Empty, "InstanceId or RunId is empty");
    }
    // Get the Routine Client
    var routineClient = XBRApi.Routines.GetRoutineClient(si);

    // Get the Routine Instance using the Routine Client
    var routineInstance = routineClient.GetRoutineInstanceAsync(instanceIdentifier: instanceId).Result;

    // Get the Routine Run using the Routine Instance
    var routineRun = routineInstance.GetRunByIdentifierAsync(runIdentifier: runId).Result;

    // Start the Routine Run
    routineRun.StartAsync().Wait();

    // Set the Literal Parameter value back to an empty string
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", string.Empty);
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", string.Empty);

    // Modify the UI Action for the dialog
    taskResult.ChangeSelectionChangedUIActionInDashboard = true;
    taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.CloseDialog;

    return taskResult;
}

We use the Dashboard Parameters to now get the Routine Instance Id and Routine Run Id that we set when we launched the dialog. We:

1. Get the RoutineClient using XBRApi →
2. Get the RoutineInstance using the RoutineClient →
3. Get the Run using the RoutineInstance

Once we get the Run object, we call the StartAsync() method with .Wait().

We then “clear” the Ids by resetting them to an empty string, and set the SelectionChangedUIActionType to close the dialog.

Note that the OnSubmitComponentWorkflowButtonClick method is named as such because that is what we used when we configured the SelectionChanged Server Task Arguments in Step 1.3.

So, when a user clicks Submit, the Routine Run is started, and the dialog will close.

The Cancel Button

The logic for the cancel button will be very similar, except instead of starting the Run, we want to delete it. We want to delete the Run because we create a Run each time the user clicks a button that launches this Component Workflow dialog. If we are not going to start it, we don’t want to leave unused Runs lying around.

public static XFSelectionChangedTaskResult OnCancelComponentWorkflowButtonClick(SessionInfo si, DashboardExtenderArgs args)
{
    var taskResult = new XFSelectionChangedTaskResult();

    // Get the Literal Parameter Value
    var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
    string instanceId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId");
    string runId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId");

    if (string.IsNullOrEmpty(instanceId) || string.IsNullOrEmpty(runId))
    {
        throw new XFUserMsgException(si, string.Empty, string.Empty, "InstanceId or RunId is empty");
    }
    // Get the Routine Client
    var routineClient = XBRApi.Routines.GetRoutineClient(si);

    // Get the Routine Instance using the Routine Client
    var routineInstance = routineClient.GetRoutineInstanceAsync(instanceIdentifier: instanceId).Result;

    // Delete the Routine Run
    routineInstance.DeleteRunAsync(runIdentifier: runId).Wait();

    // Set the Literal Parameter value back to an empty string
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", string.Empty);
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", string.Empty);

    // Modify the UI Action for the dialog
    taskResult.ChangeSelectionChangedUIActionInDashboard = true;
    taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.CloseDialogAsCancel;

    return taskResult;
}

The differences to call out between the Submit logic and the Cancel logic are:

• We call the DeleteRunAsync() method using the RoutineInstance, and
• We set the SelectionChangedUIActionType to CloseDialogAsCancel instead of just CloseDialog.

info

At this point we have everything we need to create a new RoutineInstance when a button is clicked, launch Component Workflow in a Dialog to allow a user to configure the Routine Run parameters, and start the Run upon submission, or delete the Run on cancel.

2.5 Putting it All Together

Full Code Example760

using Workspace.XBR.Xperiflow;
using Workspace.XBR.Xperiflow.Core;
using Workspace.XBR.Xperiflow.Routines.Runs;
using Workspace.XBR.Xperiflow.Utilities.Cache;
using Newtonsoft.Json.Linq;

// Method that fires on a Dashboard Button Click to Create a Routine Instance, 
// and launch the Dialog to surface Component Workflow
public static XFSelectionChangedTaskResult OnCreateBankAccountInstanceButtonClick(SessionInfo si)
{
    // Get the Routine Client
    var routineClient = XBRApi.Routines.GetRoutineClient(si);
    // Create the Routine Instance
    var bankAccountInstance = routineClient.CreateRoutineInstanceAsync(
        routineTypename: "TrainingBankAccountMgmt",
        routineVersion: "1.0.0",
        name: null
    ).Result;

    // Use our Routine Instance to create a Run
    var bankAccountCtorRun = bankAccountInstance.CreateRunAsync(
      methodName: "__init__",
      runName: null,
      includeStatistics: false,
      includePreviews: false,
      invocationMethodType: InvocationMethodType.Workflow,
      inputParams: new JObject(),
      executionType: "background"
    ).Result;

    // Now that we've created the Run, we need to get the WorkflowId of the Run
    int workflowId = bankAccountCtorRun.InvocationMethod.WorkflowId;

    // Create the XFSelectionChangedTaskResult
    var taskResult = new XFSelectionChangedTaskResult();

    // Construct the URL using the helper method
    string webDashboardUrl = ComponentWorkflowUtil.CreateComponentWorkflowUrl(si, workflowId);

    // Provide the Web Dashboard Url and Workflow Id to the Dialog
    taskResult.ChangeCustomSubstVarsInLaunchedDashboard = true;
    taskResult.ModifiedCustomSubstVarsForLaunchedDashboard.Add("CW_WebDashboardUrl", webDashboardUrl);

    // Set the Dashboard to Display and appropriate Selection Changed UI Action Info
    taskResult.ChangeSelectionChangedUIActionInDashboard = true;
    taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.OpenDialogWithNoButtonsApplyChangesAndRefresh;
    taskResult.ModifiedSelectionChangedUIActionInfo.DashboardForDialog = "CW_0_Frame";

    // Use a Dashboard Parameter to provide the Routine Instance Id and the Routine Run Id to the dialog
    string dataRuleMgrInstanceId = bankAccountInstance.InstanceIdentifier;
    string bankAccountCtorRunId = bankAccountCtorRun.RunIdentifier;

    // Set the Literal Parameter Value
    var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", dataRuleMgrInstanceId);
    BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", bankAccountCtorRunId);

    return taskResult;
}

public static class ComponentWorkflowUtil
{

    // Helper Method to create the Web Dashboard Url
    public static string CreateComponentWorkflowUrl(SessionInfo si, int workflowId)
    {
        // Get the WorkspaceId of the Xperiflow Business Rules Workspace
        var xbrWorkspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(
          si: si,
          isSystemLevel: false,
          workspaceName: XperiflowConstants.WorkspaceName
        );
        // Get the value of the BaseUrl_Xperiflow_XBR parameter within the 
        // Xperiflow Business Rules Workspace 
        var baseUrl = BRApi.Dashboards.Parameters.GetLiteralParameterValue(
          si: si,
          isSystemLevel: false,
          workspaceIDIfNotInName: xbrWorkspaceId,
          combinedWsAndParamName: XperiflowConstants.XperiflowBaseUriParameter
        );
        if (!baseUrl.EndsWith('/'))
            baseUrl += '/';

        string url = $"{baseUrl}dash/component-workflow/workflow-instances/{workflowId}/";
        return url;
    }

    // Method to Start the Routine Run on Submit
    public static XFSelectionChangedTaskResult OnSubmitComponentWorkflowButtonClick(SessionInfo si, DashboardExtenderArgs args)
    {
        var taskResult = new XFSelectionChangedTaskResult();

        // Get the Literal Parameter Value
        var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
        string instanceId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId");
        string runId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId");

        if (string.IsNullOrEmpty(instanceId) || string.IsNullOrEmpty(runId))
        {
            throw new XFUserMsgException(si, string.Empty, string.Empty, "InstanceId or RunId is empty");
        }
        // Get the Routine Client
        var routineClient = XBRApi.Routines.GetRoutineClient(si);

        // Get the Routine Instance using the Routine Client
        var routineInstance = routineClient.GetRoutineInstanceAsync(instanceIdentifier: instanceId).Result;

        // Get the Routine Run using the Routine Instance
        var routineRun = routineInstance.GetRunByIdentifierAsync(runIdentifier: runId).Result;

        // Start the Routine Run
        routineRun.StartAsync().Wait();

        // Set the Literal Parameter value back to an empty string
        BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", string.Empty);
        BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", string.Empty);

        // Modify the UI Action for the dialog
        taskResult.ChangeSelectionChangedUIActionInDashboard = true;
        taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.CloseDialog;

        return taskResult;
    }

    // Method to Delete the Routine Run on Cancel
    public static XFSelectionChangedTaskResult OnCancelComponentWorkflowButtonClick(SessionInfo si, DashboardExtenderArgs args)
    {
        var taskResult = new XFSelectionChangedTaskResult();

        // Get the Literal Parameter Value
        var workspaceId = BRApi.Dashboards.Workspaces.GetWorkspaceIDFromName(si, false, "Component Workflow Test Workspace");
        string instanceId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId");
        string runId = BRApi.Dashboards.Parameters.GetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId");

        if (string.IsNullOrEmpty(instanceId) || string.IsNullOrEmpty(runId))
        {
            throw new XFUserMsgException(si, string.Empty, string.Empty, "InstanceId or RunId is empty");
        }
        // Get the Routine Client
        var routineClient = XBRApi.Routines.GetRoutineClient(si);

        // Get the Routine Instance using the Routine Client
        var routineInstance = routineClient.GetRoutineInstanceAsync(instanceIdentifier: instanceId).Result;

        // Delete the Routine Run
        routineInstance.DeleteRunAsync(runIdentifier: runId).Wait();

        // Set the Literal Parameter value back to an empty string
        BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineInstanceId", string.Empty);
        BRApi.Dashboards.Parameters.SetLiteralParameterValue(si, false, workspaceId, "CW_RoutineRunId", string.Empty);

        // Modify the UI Action for the dialog
        taskResult.ChangeSelectionChangedUIActionInDashboard = true;
        taskResult.ModifiedSelectionChangedUIActionInfo.SelectionChangedUIActionType = XFSelectionChangedUIActionType.CloseDialogAsCancel;

        return taskResult;
    }

}

---

3. View the Component Workflow

Navigate to the Dashboard containing the button that launches the Component Workflow to create the Routine Instance. Click your button and view the Component Workflow:

Enter values for the parameters, and click the right-arrow icon to proceed through all required steps. Once complete, click Submit.

Navigate to the Runs Page of SensibleAI Studio, and view your created Routine Instance and Routine Run:

---

Appendix

An Application Workspaces Extract containing the example walked through in this document.