26 Testing and Deploying Flexfields

This chapter discusses how to test your flexfield business components in Oracle Fusion applications using Integrated WebLogic Server, how to deploy your flexfield application to an instance of Oracle WebLogic Server (WebLogic Server) in order to test the full lifecycle, how to regenerate flexfield business components programmatically, and how to make flexfield setup task flows accessible from Oracle Fusion Functional Setup Manager.

This chapter includes the following sections:

Section 26.1, "Testing Flexfields"
Section 26.2, "Deploying Flexfields in a Standalone WebLogic Server Environment"
Section 26.3, "Using the WLST Flexfield Commands"
Section 26.4, "Regenerating Flexfield Business Components Programmatically"
Section 26.5, "Integrating Flexfield Task Flows into Oracle Fusion Functional Setup Manager"

26.1 Testing Flexfields

After your flexfields are available for testing, you can generate test business components and use a Metadata Archive (MAR) profile to run the application.

26.1.1 How to Make Flexfields Available for Testing

Before testing a flexfield in your application, you must ensure that the ADF Business Components model underlying the flexfield is complete. All required entities, view links, application modules, and so on must exist either in your project, or in a library that is included in your project. Ensure that the ApplicationDB connection points to the database that contains the metadata for the flexfield that you want to test.

You can make a flexfield available for testing by doing one of the following:

Import the flexfield business components from an existing library.
Generate the flexfield business components that you want to test.

If you use the Create Flexfield Business Components wizard, select the Tester role on the Role page of the wizard, and specify a location for the generated business components. For more information about using the Create Flexfield Business Components wizard, see the appropriate section for the type of flexfield that want to test:

26.1.2 How to Test Flexfields

To test a flexfield, run the application using a MAR profile. The MAR profile that you use points to the test business component artifacts.

Before you begin:

Create the test business component artifacts for the flexfield, as described in Section 26.1.1, "How to Make Flexfields Available for Testing."

To test a flexfield:

From the Application menu, choose Application Properties.
In the Application Properties dialog, click the Deployment navigation tab and click New to create a new deployment profile.
Select MAR File from the Archive Type dropdown list.
Enter a name for the profile, and click OK.
In the panel on the left-hand side of the Edit MAR Deployment Profile Properties dialog, under MAR Options, select Metadata File Groups and click New.
In the Create File Group dialog, enter a name for the user metadata group, as shown in Figure 26-1, and click OK.

Figure 26-1 New File Group in MAR Profile Properties
In the User Metadata Group section, add a contributor, enter the path to your test components (a directory or archive), and click OK.
In the panel on the left-hand side of the Edit MAR Deployment Profile Properties dialog, under MAR Options, expand Metadata File Groups, expand the user metadata group that you just added, and select the Directories node.
In the Directories section, select the root package directory of the flexfield to be tested, as shown in Figure 26-2, and click OK.

Figure 26-2 Root Package of the Flexfield to be Tested

Caution:

Ensure that you select the correct item. You must select the directory of the root package of the flexfield to be tested, such that only the objects that are below the level of that package come from the test directory. The root package should match the package that you previously registered with the business component's usage.

As soon as you select the package, Oracle JDeveloper automatically selects the parents all the way to the top of the folder hierarchy, but that does not mean everything under oracle is registered with Oracle Metadata Services (MDS).
In the Application Properties dialog, expand Run and click the MDS navigation tab.
Select the MAR profile that you created earlier, and click OK
Test your application with the MAR profile.

Note:

If you want to run the Business Component Browser with the business components that you created for testing, you must create a temporary user library that points to the test components, and include the library in your project as the first library. This is because the flexfield view objects are generated into a temporary directory outside the scope of the application workspace.

26.2 Deploying Flexfields in a Standalone WebLogic Server Environment

After you have completed the ADF Business Components models underlying the flexfields, and all required entities, view links, application modules, and so on exist either in your project, or in a library that is included in your project, and you have tested your flexfields, you are ready to package and deploy the application to a standalone Oracle WebLogic Server (WebLogic Server) environment for full lifecycle testing.

To complete the deployment process for an application that has flexfields:

Package the application.
Deploy the application.
Configure the flexfields and test the application.

26.2.1 How to Package a Flexfield Application for Deployment

Just as with other Oracle Fusion applications, you must generate an enterprise archive (EAR) file for deployment to an instance of WebLogic Server. Before generating the EAR file, you must enable the flexfield packaging plugin.

26.2.1.1 Enabling the Flexfield Packaging Plugin

The flexfield packaging plugin is required to package flexfields from either JDeveloper or the command line. This plugin maps namespaces to the Oracle Metadata Services (MDS) partition.

You enable the flexfield packaging plugin for your working environment by setting the FLEX_DEPLOY_ADDIN_ENABLED environment variable set to true. For example, in a C shell environment you would run the following command:

setenv FLEX_DEPLOY_ADDIN_ENABLED true

26.2.1.2 Generating an EAR File for the Application

To make the flexfield artifacts available at runtime, package them into the application's EAR file, which subsequently can be installed on the target server.

Before you begin:

Enable the flexfield packaging plugin as described in Section 26.2.1.1, "Enabling the Flexfield Packaging Plugin."

To generate an EAR file:

From an environment in which the FLEX_DEPLOY_ADDIN_ENABLED environment variable has been set to true, complete one of the following steps:
- From the Application Navigator in JDeveloper, right-click the application and choose Deploy > deployment profile > to EAR file. When the generation process is done, you can find the path to the generated EAR file in the deployment log message window.
  
  Note:
  
  You might need to restart JDeveloper to ensure that the FLEX_DEPLOY_ADDIN_ENABLED environment variable has taken effect and that the flexfield packaging plugin is enabled.
  
  When the plugin is enabled in JDeveloper, you will see log entries with a Flexfield prefix, such as [09:25:01 PM] Flexfield: Search library "Applications Core"...
  
  For more information about generating EAR files from JDeveloper, see the "Deploying Fusion Web Applications" chapter in the Oracle Fusion Middleware Fusion Developer's Guide for Oracle Application Development Framework (Oracle Fusion Applications Edition).
- From the command line, run the following ojdeploy command:
```
jdev_install\jdeveloper\jdev\bin\ojdeploy -profile deployment-profile \
-forcerewrite -workspace application-jws-path
```

Optionally, unzip the EAR file and inspect the adf-config.xml file to verify that the flexfield packaging plugin added the flexfield packages to the sessiondef-config tag and mapped all the flexfield ADF Business Components packages to a metadata-store-usages tag. Example 26-1 shows sample tag entries.

Example 26-1 adf-config.xml Flexfield Tag Entries

<adf-config 
xmlns="http://xmlns.oracle.com/adf/config" 
xmlns:adf="http://xmlns.oracle.com/adf/config/properties" ... >
...
<mdsC:sessiondef-config>
<mdsC:package
value=
"oracle.apps.fnd.applcore.crmdemo.crma.model.view.link.flex;oracle.apps.fnd.applcore.flex.test.model.entity.flex"/>
</mdsC:sessiondef-config>
...
<mds:mds-config version="11.1.1.000">
<mds:persistence-config>
<mds:metadata-store-usages>
<mds:metadata-store-usage 
default-cust-store="true" 
deploy-target="true" 
id="WebCenterFileMetadataStore">
</mds:metadata-store>
</mds:metadata-store-usage>
</mds:metadata-store-usages>
</mds:persistence-config>
...
</adf-config>

26.2.2 How to Deploy a Flexfield Application

Deploying a flexfield application to an instance of WebLogic Server requires additional steps to ensure that all the flexfields' customization metadata is stored in the proper MDS partition.

The process for deploying a flexfield application includes the following tasks:

Create an MDS partition to store flexfield customization metadata.
Map the product application's EAR file to the MDS partition.
Map the Oracle Fusion Middleware Extensions for Applications (ApplCore) Setup application EAR file to the MDS partition.
Include the product application model libraries in the ApplCore Setup application.
Deploy the product application and the ApplCore Setup application to the WebLogic Server domains.
Prime the MDS partition with seeded flexfield artifacts.

26.2.2.1 Creating an MDS Partition

An MDS repository is used to store the information that enables implementors to customize applications. The flexfield packaging process requires a partition in the MDS repository that is associated with the application. You can create a partition specifically for flexfields or you can use the partition for other purposes as well. However, all Oracle Fusion applications and setup applications must use the same MDS partition for all flexfield artifacts.

If the application's MDS repository does not have the desired partition, use Oracle WebLogic Scripting Tool (WLST) to create one.

For more information about creating and registering MDS repositories and working with WLST, see the "Managing the Metadata Repository" chapter in the Oracle Fusion Middleware Administrator's Guide.

Before you begin:

Log in to the administration console for the WebLogic Server instance and verify that a Java Database Connectivity (JDBC) data source exists for the MDS repository. This data source is typically named mds-ApplicationMDSDB. Note that the URL for administration is commonly set to http://localhost:7101/console.

For more information about managing JDBC data sources, see the "Creating and Managing JDBC Data Sources" section in the Oracle Fusion Middleware Administrator's Guide.

To Create an MDS Partition:

At the command line, enter the following line to start WLST.
```
sh jdev_install/oracle_common/common/bin/wlst.sh
```
On Windows, use wlst.cmd.
Enter the following WLST command to connect to the WebLogic Server instance, replacing the user name and password arguments with your user name and password.
```
connect('wls_username', 'wls_password', 'wls_uri')
```
The values must be wrapped in single-quotes. The wls_uri value is typically t3://localhost:7101.
Enter the following WLST command to create the partition.
```
createMetadataPartition('mds_jdbc_data_source', 'partition_name')
```
The mds_jdbc_data_source is the JDBC data source for the MDS repository. The partition_name can be any string. You might want to consult with your operations team or release team for suggested partition names.
Disconnect from WLST.
```
disconnect()
```

26.2.2.2 Mapping the EAR File to the MDS Partition

To configure the application to store the flexfield customization metadata in the desired MDS partition, use the flexfield packaging plugin to update the application's adf-config.xml file with the partition name.

Before you begin:

Ensure that the FLEX_DEPLOY_ADDIN_ENABLED environment variable is set to true in your working environment, as described in Section 26.2.1.1, "Enabling the Flexfield Packaging Plugin."
Generate the EAR file as described in Section 26.2.1.2, "Generating an EAR File for the Application."
Ensure that an MDS partition exists for the flexfield metadata. For more information, see Section 26.2.2.1, "Creating an MDS Partition."
Obtain the Java Naming and Directory Interface (JNDI) name for the MDS data source. You can find this value in the Services > JDBC > Data Sources page in the administration console for the WebLogic Server instance.

To map the EAR file to the MDS partition:

At the command line, enter the following line to start WLST.
```
sh jdev_install/oracle_common/common/bin/wlst.sh
```
On Windows, use wlst.cmd.
Enter the following WLST command to connect to the WebLogic Server instance, replacing the user name and password arguments with your user name and password.
```
connect('wls_username', 'wls_password', 'wls_uri')
```
The values must be wrapped in single-quotes. The wls_uri value is typically t3://localhost:7101.
From WLST, execute the following commands.
```
archive=getMDSArchiveConfig('product_EAR_file_pathname')
archive.setAppMetadataRepository(
  'mds_jdbc_data_source',
  'partition_name',
  'DB',
  'mds_datasource_JNDI', 
  None)
archive.save()
```
The mds_jdbc_data_source is the JDBC data source for the MDS repository. The partition_name is the name of the MDS partition that you are using to store the flexfield customization metadata for all your Oracle Fusion applications. You might need to ask your operations team or release team for the partition name. The mds_datasource_JNDI is the JNDI name for the MDS data source, such as jdbc/mds/mds-ApplicationMDSDBDS.

Optionally, unzip the EAR file and inspect the adf-config.xml file to verify that the flexfield packaging plugin updated the metadata-store-usage tags to add the partition name. Example 26-2 shows sample tag entries.

Example 26-2 adf-config.xml metadata-store-usage tags with Added Partition Name

<mds:metadata-store-usages>
<mds:metadata-store-usage default-cust-store="true" 
deploy-target="true" id="WebCenterFileMetadataStore">
<mds:metadata-store class-name="oracle.mds.persistence.stores.db.DBMetadataStore">
<mds:property value="mds-ApplicationMDSDB" name="repository-name"/>
<mds:property value="ffpartition" name="partition-name"/>
<mds:property value="jdbc/mds/mds-ApplicationMDSDBDS" name="jndi-datasource"/>
</mds:metadata-store>
</mds:metadata-store-usage>
</mds:metadata-store-usages>

26.2.2.3 Mapping the ApplCore Setup Application to the MDS Partition

In order to perform a full lifecycle test, you must configure the flexfields in the same manner as an implementor would configure them. You use the ApplCore Setup application to complete the flexfield configurations as described in Section 26.2.3, "How to Configure Flexfields." Before using the ApplCore Setup application, you must configure the application to store the flexfield customization metadata in the desired MDS partition, just as you would with the product application's EAR file.

Before you begin:

Ensure that the FLEX_DEPLOY_ADDIN_ENABLED environment variable is set to true in your working environment, as described in Section 26.2.1.1, "Enabling the Flexfield Packaging Plugin."
Ensure that an MDS partition exists for the flexfield metadata. For more information, see Section 26.2.2.1, "Creating an MDS Partition."
Locate the ApplCore Setup application's FndSetup.ear file. This file can typically be found in the jdev_install/jdeveloper/jdev/oaext/external directory.
Obtain the JNDI name for the MDS data source. You can find this value in the Services > JDBC > Data Sources page in the administration console for the WebLogic Server instance.

To map the ApplCore Setup EAR file to the MDS partition:

At the command line, enter the following line to start WLST, if it is not currently running.
```
sh jdev_install/oracle_common/common/bin/wlst.sh
```
On Windows, use wlst.cmd.
If you have not yet connected to the server, enter the following WLST command to connect to the WebLogic Server instance, replacing the user name and password arguments with your user name and password.
```
connect('wls_username', 'wls_password', 'wls_uri')
```
The values must be wrapped in single-quotes. The wls_uri value is typically t3://localhost:7101.
From WLST, execute the following commands.
```
archive=getMDSArchiveConfig('ApplCore_Setup_EAR_file_pathname')
archive.setAppMetadataRepository(
  'mds_jdbc_data_source',
  'partition_name',
  'DB',
  'mds_datasource_JNDI',
  None)
archive.save()
```
The mds_jdbc_data_source is the JDBC data source for the MDS repository. The partition_name is the name of the MDS partition that you are using to store the flexfield customization metadata for all your Oracle Fusion applications. You might need to ask your operations team or release team for the partition name. The mds_datasource_JNDI is the JNDI name for the MDS data source, such as jdbc/mds/mds-ApplicationMDSDBDS.

26.2.2.4 Including Product Application Model Libraries in the ApplCore Setup EAR File

Before you deploy the ApplCore Setup EAR file, ensure that it contains all the model libraries that are required for your product application.

To include the product application model libraries in the ApplCore Setup EAR file:

In a terminal window, change to the directory that contains the FndSetup.ear file. This file can typically be found in the jdev_install/jdeveloper/jdev/oaext/external directory.
Execute the following commands to expand the EAR file.
```
mkdir tmpDir
cd tmpDir/
unzip ../FndSetup.ear
```
If the APP-INF/lib folder does not exist, execute the following commands to create it.
```
mkdir APP-INF
mkdir APP-INF/lib
```
Copy all the library Java archive (JAR) files that your product requires to the APP-INF/lib folder.
Change to the tmpDir folder.
Execute the following commands to re-create the EAR file with the added JAR files.
```
rm ../FndSetup.ear
zip -r FndSetup.ear .
mv FndSetup.ear ../
rm -Rf tmpDir
```

26.2.2.5 Deploying the Product and Setup Applications to the Server Domains

After you have mapped the applications as described in Section 26.2.2.2, "Mapping the EAR File to the MDS Partition" and Section 26.2.2.3, "Mapping the ApplCore Setup Application to the MDS Partition" and you have included the project model libraries in the ApplCore Setup application as described in Section 26.2.2.4, "Including Product Application Model Libraries in the ApplCore Setup EAR File," you can deploy the applications to the appropriate domains for your topology.

For information about creating domains, see the "Creating a WebLogic Domain" chapter in Oracle Fusion Middleware Creating Domains Using the Configuration Wizard. For information about installing EAR files, see the "Install an Enterprise Application" section in the Oracle Fusion Middleware Oracle WebLogic Server Administration Console Online Help.

26.2.2.6 Priming the MDS Partition with Configured Flexfield Artifacts

The flexfield application is configured to obtain the flexfield customization metadata from the MDS partition. However, no one can log in to the application until the application has gone through an initial process to translate the flexfield metadata into artifacts that are stored in the partition. This task must be completed, even if there is no customization metadata yet. You use WLST to perform this task.

Before you begin:

Deploy the product and setup applications, as described in Section 26.2.2.5, "Deploying the Product and Setup Applications to the Server Domains."

To prime the MDS partition with flexfield metadata artifacts:

Run the deployFlexForApp WLST command as described in Section 26.3.2, "How to Prepare Your Environment to Use the deployFlexForApp Command."

26.2.3 How to Configure Flexfields

Customers will use the Manage Flexfields tasks in the Oracle Fusion Functional Setup Manager to configure the flexfields. For testing purposes, you can use the same tasks in the ApplCore Setup application. For information about using these tasks to configure the flexfields, see the "Using Flexfields for Custom Attributes" chapter in the Oracle Fusion Applications Extensibility Guide.

When you have configured a flexfield, click Deploy to deploy the configuration to the product application. Because flexfield artifacts are cached per end user session, you must log out and log back in to see the deployed configuration.

26.3 Using the WLST Flexfield Commands

You can use the Manage Key Flexfields, Manage Descriptive Flexfields, and Manage Extensible Flexfields tasks to deploy flexfields, as described in the "Using Flexfields for Custom Attributes" chapter in Oracle Fusion Applications Extensibility Guide. In addition, the following WLST commands are available for priming the MDS repository with seeded flexfield artifacts and for deploying flexfields:

deployFlexForApp: Use this command to prime the MDS repository with seeded flexfield artifacts. Deploys all flexfields that do not have a status of DEPLOYED. You can also use this comment to deploy all flexfields regardless of their status by setting the force parameter to 'true'.
deployFlex: Use this command to deploy a single flexfield. Deploys the flexfield regardless of status.
deleteFlexPatchingLabels: Use this command to inquire about or delete all flexfield patching labels.

For information about the WLST flexfield commands, see the "Deploying Flexfields Using the Command Line: Explained" section in the Oracle Fusion Applications Common Implementation Guide. For information about using the WLST command-line scripting interface, see Oracle Fusion Middleware Oracle WebLogic Scripting Tool.

Before you can use any WLST flexfield command from a development environment, you must first prepare the environment as described in Section 26.3.1, "How to Prepare Your Environment to Use the WLST Flexfield Commands." If you use the deployFlexForApp command in a development environment, you must complete additional steps described in Section 26.3.2, "How to Prepare Your Environment to Use the deployFlexForApp Command."

After you execute a WLST flexfield command, you can log into the application and view the pages that contain flexfields. If you have seeded any flexfield configurations by defining value sets, segments, contexts, or structures, for example, the flexfields should appear on the appropriate pages. If a flexfield has not been configured, the corresponding user interface sections will be blank.

26.3.1 How to Prepare Your Environment to Use the WLST Flexfield Commands

Before you can use the WLST flexfield commands, you must prepare your environment. The commands will not work until these steps are completed.

To prepare your environment for WLST flexfield commands:

The WLST flexfield commands can be executed only on the Administration Server for a domain that has a running instance of the ApplCore Setup application. For information on deploying the ApplCore Setup application, see Section 26.2.2.5, "Deploying the Product and Setup Applications to the Server Domains."
Ensure that the AppMasterDB data source is registered as a JDBC data source with the Administration Server and points to the same database as the ApplicationDB data source.

26.3.2 How to Prepare Your Environment to Use the deployFlexForApp Command

The deployFlexForApp command translates the product application's seeded flexfield metadata into artifacts in the MDS repository. This command must be run after you configure your application to read the flexfield artifacts from the MDS repository and before you log into the application for the first time, even if there is no seeded flexfield metadata. For more information, see Section 26.2.2.6, "Priming the MDS Partition with Configured Flexfield Artifacts."

To prepare your environment to use the deployFlexForApp command:

Configure the product application to store the flexfield customization metadata in the desired MDS partition as described in Section 26.2.2.2, "Mapping the EAR File to the MDS Partition."
Map the setup application as described in Section 26.2.2.3, "Mapping the ApplCore Setup Application to the MDS Partition."
Deploy the product application and the ApplCore Setup application as described in Section 26.2.2.5, "Deploying the Product and Setup Applications to the Server Domains."
Prepare your environment as described in Section 26.3.1, "How to Prepare Your Environment to Use the WLST Flexfield Commands."

26.4 Regenerating Flexfield Business Components Programmatically

After you complete the flexfield development activities to incorporate a flexfield into your application, you might need to update the flexfield implementation in your application at a later time by repeating the process of creating the flexfield business components.

To re-create the flexfield business components, you can use the Create Flexfield Business Components wizard, which invokes the flexfield business component modeler to generate (or regenerate) the business components. Alternatively, you can create a Java program to invoke the flexfield business component modeler and thus automate the creation of the business components without implementor interaction.

The flexfield business component modeler can be invoked through the Java application programming interface (API) only in a deployed web application. You must have the following artifacts:

The ADF Business Components objects required for generating the flexfield business components. Typically these are entity objects. You can deploy them in a JAR file.
The MDS repository for the generated flexfield business components. If you use a file-system based repository, the metadata path must be an existing writable path.

You either can create a new application to invoke the modeler, or, if you already have a web application for testing, you can include the Java code required for invoking the modeler in your application. The deployment process is the same as any other web application.

Your project must be set up correctly for the program to run successfully. The project configuration requirements are the same as that for the Create Flexfield Business Components wizard.

Example 26-3 demonstrates appropriate Java code for updating the business components for a descriptive flexfield.

Example 26-3 Java Code for Invoking the Flexfield Business Component Modeler

import oracle.apps.fnd.applcore.flex.runtime.util.BCModeler;
 
public class Example
{
  public static void main(String[] margs)
  {
    BCModeler.Arguments modelerArgs = new BCModeler.Arguments();
 
    modelerArgs.put(BCModeler.Parameter.CONNECTION_URL,
                    "jdbc:oracle:thin:user/pass@dev1.companyname.com:1999:dev1");
 
    // Specify where the objects should be.
    modelerArgs.put(BCModeler.Option.OUTPUT_PATH,
                    "/mytest/mds/");
 
    // The owner of the flexfield should have the following information.
    modelerArgs.put(BCModeler.Parameter.FLEXFIELD_TYPE, "DFF");
    modelerArgs.put(BCModeler.Parameter.APP_SHORT_NAME, "FND");
    modelerArgs.put(BCModeler.Parameter.FLEXFIELD_CODE, "FLEX_DFF1");
    modelerArgs.put(BCModeler.Parameter.TABLE_USAGE_CODE, "FLEX_DFF1");
    modelerArgs.put(BCModeler.Parameter.TABLE_NAME, "FND_DF_TEST_DFF1_T1");
    modelerArgs.put(BCModeler.Parameter.ENTITY_DEF_FULL_NAME,
                    "oracle.apps.fnd.applcore.flex.test.model.entity.Dff1EO");
 
    // See BCModeler.Option for more usage-specific options.  Consult the owner
    // of the flexfield to see if any usage-specific option is required.
 
    Exception e = BCModeler.run(modelerArgs.getCommandLineArgs(false),
                                System.out);
    if (e != null)
    {
      e.printStackTrace();
    }
  }
}

Examine BCModeler.Option for usage-specific settings.

26.5 Integrating Flexfield Task Flows into Oracle Fusion Functional Setup Manager

Every Oracle Fusion application registers task flows for setup activities with a product called Oracle Fusion Functional Setup Manager. For example, a human resources (HR) application can register setup activities such as "Create Employees" and "Manage Employee Tree Structure." Implementors and administrators use these registered task flows, which are accessed from the Oracle Fusion Applications Setup and Maintenance work area of Oracle Fusion Applications, to configure the applications by defining custom configuration templates or tasks based on their business needs.

Note:

The registration application task flow is not available for extensible flexfields and key flexfields. You must use the FND_FLEX_DF_SETUP_APIS PL/SQL to register extensible flexfields as described in Chapter 24, "Defining and Registering Extensible Flexfields." You must use the FND_FLEX_KF_SETUP_APIS PL/SQL API to register key flexfields as described in Section 25.2.1, "How to Develop Key Flexfields."

Table 26-1 lists the flexfield setup task flows. To make these task flows available to developers, implementors, or administrators, register the appropriate task. For more information, see the Oracle Fusion Applications Common Implementation Guide.

For information about using the tasks for managing the flexfields, see the "Using Flexfields for Custom Attributes" chapter in the Oracle Fusion Applications Extensibility Guide. For more information about the Register Descriptive Flexfields task, see Section 23.2.2, "How to Register and Define Descriptive Flexfields."

Table 26-1 Flexfields Task Flows and Parameters

Task Flow Name	Task Flow XML	Parameters Passed	Behavior
Register Descriptive Flexfields	/WEB-INF/oracle/apps/fnd/applcore/flex/dff/ui/publicFlow/RegisterDescriptiveFlexfieldsTF.xml#RegisterDescriptiveFlexfieldsTF	To invoke search mode: mode='search' To restrict search mode to descriptive flexfields belonging to a particular product module: mode='search' moduleType='moduletype' moduleKey='modulekey' To invoke edit mode for a specific descriptive flexfield: mode='edit' descriptiveFlexfieldCode=dffcode applicationId=appid To optionally specify a page heading for the task flow: pageTitle='titlestring'	Search and edit descriptive flexfield registration metadata.
Manage Descriptive Flexfields	/WEB-INF/oracle/apps/fnd/applcore/flex/dff/ui/publicFlow/ManageDescriptiveFlexfieldsTF.xml#ManageDescriptiveFlexfieldsTF	To invoke search mode: mode='search' To restrict search mode to descriptive flexfields belonging to a particular product module: mode='search' moduleType='moduletype' moduleKey='modulekey' To invoke edit mode for a specific descriptive flexfield: mode='edit' descriptiveFlexfieldCode=dffcode applicationId=appid To optionally specify a page heading for the task flow: pageTitle='titlestring'	Search and edit descriptive flexfield configuration.
Manage Extensible Flexfields	/WEB-INF/oracle/apps/fnd/applcore/flex/dff/ui/publicFlow/ManageExtensibleFlexfieldsTF.xml#ManageExtensibleFlexfieldsTF	To invoke search mode: mode='search' To restrict search mode to extensible flexfields belonging to a particular product module: mode='search' moduleType='moduletype' moduleKey='modulekey' To invoke edit mode for a specific extensible flexfield: mode='edit' extensibleFlexfieldCode=effcode applicationId=appid To optionally specify a page heading for the task flow: pageTitle='titlestring'	Search and edit extensible flexfield configuration.
Manage Key Flexfields	/WEB-INF/oracle/apps/fnd/applcore/flex/kff/ui/publicFlow/ManageKeyFlexfieldsTF.xml#ManageKeyFlexfieldsTF	To invoke search mode: mode='search' To restrict search mode to key flexfields belonging to a particular product module: mode='search' moduleType='moduletype' moduleKey='modulekey' To invoke edit mode for a specific key flexfield: mode='edit' keyFlexfieldCode=kffcode applicationId=appid To optionally specify a page heading for the task flow: pageTitle='titlestring'	Search and edit key flexfield configuration.
Manage Value Sets	/WEB-INF/oracle/apps/fnd/applcore/flex/vst/ui/publicFlow/ManageValueSetsTF.xml#ManageValueSetsTF	To invoke search mode for any value set: mode='search' To restrict search mode to value sets belonging to a particular product module: mode='search' moduleType=moduletype moduleKey=modulekey To invoke edit mode for a specific value set: mode='edit' valueSetCode=vscode To optionally specify a page heading for the task flow: pageTitle='titlestring'	Search and edit flexfield value sets.

For related information about functional security actions and roles based on task flows, see Chapter 50, "Implementing Function Security".