24 Use Extensible Flexfields

How Extensible Flexfields Are Modeled in Oracle Application Development Framework

Extensible flexfields are modeled as a collection of Oracle Application Development Framework (ADF) polymorphic view rows, as described in the Working with Polymorphic View Rows section in the Developing Fusion Web Applications with Oracle Application Development Framework.

The category hierarchy translates into a hierarchy of view objects that are configured to support polymorphic view rows. The view objects have view links to associated context view objects. A CategoryCode attribute acts as the discriminator that determines which category view row type is used. At application runtime, the category in the base category view object row determines what pages and contexts are displayed. Given a collection of polymorphic view rows, each row can be a different type depending upon the category. An application module that holds the category view object is generated for each category.

Each flexfield usage requires a base extension table. This table stores nontranslatable contexts and their segment values. The table name should have a suffix of _B to identify it as the base extension table. The name should have the _B suffix regardless of whether the extensible flexfield has a translation table.

Table 24-1 lists the columns that you must include in a base extension table. You can include additional columns, such as columns that are required by product teams or application standards. For space considerations, the table shows only the first and last attribute columns for each type.

Add as many attribute columns as necessary. The attribute columns can be of type VARCHAR2, NUMBER, and TIMESTAMP. Do not set scale or precision for the NUMBER columns. There are no size requirements for the VARCHAR2 columns. To avoid compatibility and interoperability problems, name the columns ATTRIBUTE_type-and-number, such as ATTRIBUTE_CHAR1 for a VARCHAR2 column, ATTRIBUTE_NUMBER1 for a NUMBER column, and ATTRIBUTE_TIMESTAMP1 for a TIMESTAMP column.

For columns of type NUMBER, you can optionally add a column named ATTRIBUTE_NUMBERn_UOM to store the unit of measure.

The primary key of the base extension table must include the EFF_LINE_ID column, the CONTEXT_CODE column, the CATEGORY_CODE column, and the columns that match the primary key columns of the product table.

If you plan to allow customers to store translations for some contexts on a locale-by-locale basis, then you must also create a translation extension table and a single table translation view from that table. The translation extension table and the translation extension view are not required. However, if you do not provide these tables, the customers cannot store translations for their extensible flexfields as described in the "Translating Flexfield and Value Set Configurations" section in the Extensibility Guide for Developers. For more information about multilanguage tables, see Understanding Multi-Language Support Features. For information about creating the view, see How to Create a Translation Extension View.

Note that unlike typical translation tables, the base extension table is completely separate from the translation extension table. All the segment values for a context go in either the base extension table or in the translation extension table. If a context is marked as translatable, all segment values are stored in the translation extension table. If a context is not marked as translatable all segment values are stored in the base extension table. This means that a translatable context cannot contain segments of non-translatable data types, such as numbers or dates.

Table 24-2 lists the required translation extension table columns. The required columns are similar to those in the base extension table, except that the attribute columns must be of type VARCHAR2 and you must include the LANGUAGE and SOURCE_LANG columns. For space considerations, the table shows only the first and last attribute columns. You can include additional columns, such as columns that are required by product teams or application standards.

The translation table name should have a suffix of _TL to identify it as a translation table.

The primary key of the translation extension table must include the EFF_LINE_ID column, the CONTEXT_CODE column, the CATEGORY_CODE column, the LANGUAGE column, and the columns that match the primary key columns of the product table.

Developers typically create the same number of VARCHAR2 type attribute columns in the translation extension table as exist in the base extension table, but you are not required to do so. Create as many VARCHAR2 type attribute columns as you think are necessary for a translatable context. To avoid compatibility and interoperability problems, name the columns ATTRIBUTE_CHARnumber, such as ATTRIBUTE_CHAR1, ATTRIBUTE_CHAR2, and so on. When setting the size of the VARCHAR2 columns in an extension translation table, consider that the columns might need to contain multibyte characters.

If you create a translation extension table, you must also create a view from the translation extension table. To create the view, use a view definition statement that follows the format shown in Example 24-1. The name of the translation extension view should have a suffix of _VL.

Example 24-2 shows a sample view definition.

You must register an extensible flexfield's base extension table as a secured object by registering a database resource for the table. If you create a translation extension table and view for an extensible flexfield, then you must register the view as a database resource as well. Use the Manage Database Security Policies task, which is accessed from the Setup and Maintenance work area of any Oracle Fusion Setup application, to create the database resources.

You can optionally create actions and conditions for the database resource. The preconfigured actions appear in the View Privileges and Edit Privileges dropdown lists for a context's usages in the Manage Extensible Flexfields task. Customers use these actions to restrict view and edit privileges.

To create a database resource:

You use the Create Flexfield Business Components wizard to create the flexfield business components for an extensible flexfield's usage.

The business components that are generated will replace any existing components that are based on the same flexfield usage.

Before you begin:

• Create the flexfield entity objects as described in How to Create and Configure Extensible Flexfield Entity Objects.

• Create the flexfield view objects and the declarative SQL-based view object as described How to Create and Configure Extensible Flexfield View Objects.

• Register the flexfield as described in How to Register Extensible Flexfields.

• Build your project to ensure that the entity objects are available in classes. The modeler relies on what is in your classes.

• Ensure that you have added the Applications Core library to your project as described in Setting Up Your JDeveloper Application Workspace and Projects .

• Ensure that at least one customization class is included in the adf-config.xml file. This inclusion serves to ensure correct application behavior. It does not matter which customization class you include.

  For information about customization layers, see the "Understanding Customization Layers" section in the Extensibility Guide for Developers.

To create extensible flexfield business components:

You can easily incorporate an extensible flexfield into the UI in one of the following layouts by dragging the view object for the flexfield-enabled object from the Data Controls panel and dropping it onto the page:

• Single page layout: The extensible flexfield is incorporated as a single task flow that presents a set of contexts associated with a specified logical page and usage as shown in Figure 24-1.

• Panel splitter layout: The extensible flexfield is incorporated as a list of the logical pages for a specified usage, combined with the contexts for the user-selected logical page, and integrated into a single task flow, as shown n Figure 24-2.

Before you begin:

1. Create and configure business components to support the extensible flexfield as described in Creating Extensible Flexfield Business Components.

2. Execute the following SQL query to obtain the name of the view object for the flexfield-enabled object:

   SELECT VIEW_OBJECT FROM FND_DF_ADFBC_USAGES WHERE TABLE_NAME IN
   (SELECT TABLE_NAME FROM FND_DF_TABLE_USAGES TBL WHERE
   DESCRIPTIVE_FLEXFIELD_CODE = flexfield-code AND
   TBL.APPLICATION_ID = application-id AND
   TABLE_TYPE = 'BASE' AND FLEXFIELD_USAGE_CODE = flexfield-usage-code)
   

To add an extensible flexfield as a single flow for multiple contexts:

1. Open the page to which you want to add the extensible flexfield.

2. From the Data Controls panel, drag the view object for the flexfield-enabled object onto the page or Structure window.

3. When prompted, choose Applications and then choose Oracle Extensible Flexfield.

4. In the User Interface region in the Create Extensible Flexfield dialog, select Panel Splitter or Single Page, as shown in Figure 24-11

   Figure 24-11 Create Extensible Flexfield Dialog

   

5. Accept the default group code or change its value.

6. If you selected the single page layout, enter the page code for the logical page to be displayed at runtime.

7. Specify the usage code.

8. In the Object Keys region, specify the values to use for the category code and the primary keys. The expression/value provided is evaluated at runtime to determine the object instance for which the extensible flexfield attribute values are to be shown

9. Click Apply.

10. (Optional) Complete the following steps to modify the ReadOnly and _eff_param1 through _eff_param5 properties:

    1. Right click in the page and choose Go to Page Definition.

    2. In Executables section in the page definition, select taskFlow - ExtensibleFlexfieldRruntimeUI1 and click the Edit icon.

    3. In the Input Parameters region in the Edit Task Flow Binding dialog, set ReadOnly to Y if the page should render all segments as read-only fields. Otherwise, set to N or leave the parameter value blank.

    4. If you need to pass in custom parameters for UI customization, as described in How to Customize the Runtime User Interface Modeler for Extensible Flexfields, use the _eff_param1 through _eff_param5 parameters to specify the custom parameter values. For example, if you need to customize the page to display or not display certain segments based upon the user's location, you can use one of these parameters to provide the location as an input parameter.

11. If you have not done so already, complete the following substeps:

    1. Open the Databindings.cpx file and add the following EFFRuntimeAM data control:

       <BC4JDataControl      id="EFFRuntimeAMDataControl"
                             Package="oracle.apps.fnd.applcore.flex.eff.
                               runtime.applicationModule"
                             FactoryClass="oracle.adf.model.bc4j.
                               DataControlFactoryImpl"
                             SupportsTransactions="true" SupportsFindMode="true"
                             SupportsRangesize="true" SupportsResetState="true"
                             SupportsSortCollection="true" Configuration=
                               "EFFRuntimeAM"
                             syncMode="Immediate"
                             xmlns="http://xmlns.oracle.com/adfm/datacontrol"/>
       

    2. Add the following code to the Application tag at the top of the Databindings.cpx file to enable the application to find the page definitions for the generated UI artifacts:

       PageMapClass="oracle.jbo.uicli.mom.DynamicPageMapImpl"
                    BasePageDefPackageName="pageDefs"
       

To build the UI page:

Build an application page with a single task flow as a dynamic region on the right, and containing the context that was passed. This variation does not present an extensible flexfield usage or page-list task flow in the user interface.

Before you begin:

Create and configure business components to support the extensible flexfield as described in Creating Extensible Flexfield Business Components.

To expose the extensible flexfield context:

1. Create a task flow for Pages List, for example, PageListTF.xml.

2. Add a managed bean called EffCategoryPagesBean to this task flow. It should have a class of pageFlowScope.EffCategoryPagesBean and a scope of pageFlow.

3. Create a fragment, for example PageListFrag.jsff, and drag and drop the EffCatPageListContainer task flow from the ViewController FlexModeler-View library on the fragment.

4. Add the following parameters:

   • _eff_application_id: Provide #{pageFlowScope._eff_application_id}.

   • _eff_descriptive_flexfield_code: Provide #{pageFlowScope._eff_descriptive_flexfield_code}.

   • _eff_category_code: Provide #{pageFlowScope._eff_category_code}.

   • _eff_usage_code: Provide #{pageFlowScope._eff_usage_code}.

   • _eff_page_code: Provide #{pageFlowScope._eff_page_code}.

   • _eff_containerBean: Provide #{pageFlowScope.EffCategoryPagesBean}.

   • _eff_check_privilege: (optional) Set to Y if the view privilege is to be honored for the context regions. [[Check with Gaurav whether this should be included]]

5. Place the task flow on any page on which you want the page list to appear.

6. Create a task flow, for example, ContextsTF.xml.

7. Add an empty fragment to this task flow, for example, ContextsFrag.jsff.

8. Access the page on which you would like your contexts to appear. This could possibly be the same page as in Step 5, but is likely the second facet of a splitter.

9. Drag and drop ContextsTF.xml as a dynamic region onto this page at the correct location.

10. When prompted for a backing bean, enter a new bean name, class, and package, for example, ContextsRenderingBean.java, and allow it to remain as a backing bean.

11. Open the Java file and add the following code, replacing the value for taskFlowId with the appropriate string:

    public class ContextsRenderingBean {
      private String taskFlowId = 
    "/WEB-INF/oracle/apps/fnd/applcore/flex/eff/runtime/ui/test/flow/ContextsTF.xml#ContextsTF";
      private String newTaskFlowId =null;
      private boolean refreshRegion = false;
    
      public ContextsRenderingBean () {
      }
    
      public TaskFlowId getDynamicTaskFlowId() {
        return TaskFlowId.parse(taskFlowId);
      }
      public boolean getRefreshRegion() {
        refreshRegion = false;
        newTaskFlowId = (String) ADFContext.getCurrent().getSessionScope().
          get("_eff_context_tf_id");
    
        if (newTaskFlowId != null && taskFlowId.compareTo(newTaskFlowId) != 0 ) {
           taskFlowId = newTaskFlowId;
           refreshRegion = true;
        }
        return refreshRegion;
      }
    }
    

12. Open the page definition for the launch page and scroll to the location of the dynamic region binding.

13. Add the following refresh condition setting to the taskFlow tag:

    RefreshCondition="#{backingBeanScope.ContextsRenderingBean.refreshRegion}"
    

    This setting provides the callback and the conditions for the refresh of the contexts region.

    When you run the page and click the page link, the callback to refreshRegion will look up the ID for the contexts task flow and enable a refresh condition of the dynamic region.

14. If you have not done so already, complete the following substeps:

    1. Open the Databindings.cpx file and add the following EFFRuntimeAM data control:

       <BC4JDataControl      id="EFFRuntimeAMDataControl"
                             Package="oracle.apps.fnd.applcore.flex.eff.
                               runtime.applicationModule"
                             FactoryClass="oracle.adf.model.bc4j.
                               DataControlFactoryImpl"
                             SupportsTransactions="true" SupportsFindMode="true"
                             SupportsRangesize="true" SupportsResetState="true"
                             SupportsSortCollection="true" Configuration=
                               "EFFRuntimeAM"
                             syncMode="Immediate"
                             xmlns="http://xmlns.oracle.com/adfm/datacontrol"/>
       

    2. Add the following code to the Application tag at the top of the Databindings.cpx file to enable the application to find the page definitions for the generated UI artifacts:

       PageMapClass="oracle.jbo.uicli.mom.DynamicPageMapImpl"
                    BasePageDefPackageName="pageDefs"
       

You can expose extensible flexfield attributes as columns in a table that displays attributes for a specific category. The attributes from all the contexts that are associated with the selected category are displayed. The attributes are grouped in a column span and are labeled context:segment.

Before you begin:

• If you have not done so already, add the stub search view object that was created when you ran the Create Flexfields Business Components wizard to an application module. The stub search view object is in the view folder in the package that you registered for the extensible flexfield usage in the FND_DF_ADFBC_USAGES table.

  Note:

  The Create Flexfields Business Components wizard creates the stub search view object based on the flexfield's declarative SQL-based view object that was registered for the flexfield usage. If no declarative SQL-based view object was registered, then a stub search view object will not exist. You must create and register the SQL-based view object as described in Creating a Declarative SQL-Based View Object to Enable Searching and then run the Create Flexfield Business Components wizard as described in How to Create Business Components For an Extensible Flexfield's Usage.

To expose category attributes in a table:

You incorporate an extensible flexfield into a query search form by dropping a view criteria component from the Data Controls panel onto the page.

Before you begin:

• If you have not done so already, add the stub search view object that was created when you ran the Create Flexfields Business Components wizard to an application module. The stub search view object is in the view folder in the package that you registered for the extensible flexfield usage in the FND_DF_ADFBC_USAGES table.

  Note:

  The Create Flexfields Business Components wizard creates the stub search view object based on the flexfield's declarative SQL-based view object that was registered for the flexfield usage. If no declarative SQL-based view object was registered, then a stub search view object will not exist. You must create and register the SQL-based view object as described in Creating a Declarative SQL-Based View Object to Enable Searching and then run the Create Flexfield Business Components wizard as described in How to Create Business Components For an Extensible Flexfield's Usage.

• If the desired view criteria for the stub search view object does not exist, create it. The view criteria must contain the flexfield's CategoryCode attribute. The operator for the CategoryCode attribute must be set to Equals.

To incorporate an extensible flexfield into a search form:

To cause the business component modeler to generate the stub view object for business intelligence, you must business-intelligence enable the flexfield. Use the setup APIs to set the flexfield's BI_ENABLED flag business-intelligence as described in Using the Setup APIs to Register and Define Extensible Flexfields.

You can optionally use the setup APIs to provide flattened fact names for the flexfield's entity details. You provide a flattened fact name by setting the BI_FLATTENED_FACT_NAME value.

When you create business components for a business intelligence-enabled extensible flexfield, the business component modeler recognizes the business intelligence-enabled setting. A view object that is flattened for Oracle Business Intelligence is generated alongside the standard extensible flexfield polymorphic view object.

Before you begin:

1. Ensure that a business intelligence application module and a business intelligence view object exist for the product table for which you are implementing the extensible flexfield. For information, see Designing and Securing View Objects for .

2. Create a declarative SQL-Based view object as described in Creating a Declarative SQL-Based View Object to Enable Searching.

3. Ensure that the declarative SQL-Based view object was registered for the flexfield, either by using the Register Flexfield Metadata wizard to provide the fully qualified name of the search view object or by executing the following SQL statement to register it. Replace search-view-object with the fully qualified name for the search view object. Replace product-table with the name of the product table that the flexfield extends.

   UPDATE FND_DF_ADFBC_USAGES 
   SET EFF_SEARCH_VIEW_OBJECT = 'search-view-object'
   WHERE TABLE_NAME='product-table'
   AND ENTITY_OBJECT='product-table-entity-object';
   

4. Enable the flexfield and the desired segments for Oracle Business Intelligence as described in How to Enable an Extensible Flexfield for .

To produce a business intelligence-enabled flattened extensible flexfield model:

1. Create extensible flexfield business components as described in How to Create Business Components For an Extensible Flexfield's Usage.

   For a flexfield that is business intelligence-enabled, the Create Flexfield Business Components wizard generates a stub view object, which is named object-name-prefixEFFBIFlattenedVO, and other business components under a directory called analytics in the package root directory. These are generated in addition to the standard extensible flexfield view object.

2. Complete the following steps to link the stub view object to the business intelligence view object for the product table.

   1. From the File menu, choose New.

   2. In the New Gallery, go to Business Tier > ADF Business Components and select Flexfield View Link.

   3. Click OK to access the Create Flexfield View Link wizard.

   4. On the Name page, from the Package dropdown list, specify a package for the view link.

      Caution:

      You cannot move the view link to a different package after you create it. Instead, you must delete the view link and re-create it with the new package name.

   5. In the Name field, enter a name for the view link.

   6. Click Next.

   7. In the Select Source View Object tree, expand the available objects from your current project and select the master view object, which is the business intelligence view object for the product table.

   8. In the Select Destination Flexfield tree, expand the application and select the destination flexfield usage, which is the stub view object.

   9. In the View Link Accessor Name field, enter an appropriate name for the view link accessor.

   10. Click Next.

   11. On the Source Attributes page, click Finish.

       For extensible flexfields, the Source Attributes page is informational only. The wizard uses the primary key attributes of the source view object to define the view link.

       Note:

       You can skip the Properties page because view link-specific properties are not supported.

   12. On the Summary page, click Finish.

3. (Optional) To control how the extensible flexfield attributes appear in the Oracle Business Intelligence presentation layer, edit the application module that contains the stub view, and then, in the Custom Properties section in the General navigation tab, add one or more of the following properties:

   • To display only the attributes in the stub view object that have a specific context usage or category code, add one of the following custom properties and values to the application module:

     • FND_ACFF_SHOW_ATTRIBUTES_WITH_PROPERTY_stub-vo-instance-name ="FND_ACFF_EFF_CONTEXT_USAGE=propertyvalue"

     • FND_ACFF_SHOW_ATTRIBUTES_WITH_PROPERTY_stub-vo-instance-name ="FND_ACFF_EFF_CATEGORY_CODE=propertyvalue"

     For example, the following custom property specifies that when displaying the attributes from the ItemEFFBIFlattenedVO view object, only the attributes that have the FND_ACFF_EFF_CONTEXT_USAGE property with a value of EGO_ITEM_DL will be displayed in the presentation layer:

     FND_ACFF_SHOW_ATTRIBUTES_WITH_PROPERTY_ItemEFFBIFlattenedVO =
     "FND_ACFF_EFF_CONTEXT_USAGE=EGO_ITEM_DL"
     

     Note:

     If the property is not set, then all attributes appear in the presentation layer.

   • To specify how to arrange the attributes in the presentation layer, add one of the following properties:

     • To arrange the attributes by context within category, add the following custom property:

       FND_ACFF_EFF_BI_PRESENTATION_OPTION_stub-vo-instance-name =
       "FLAT_CATEGORY_CONTEXT_FOLDER_LIST"
       

       The attributes will be displayed in context folders within each applicable category folder.

     • To arrange the attributes by category within context, add the following custom property:

       FND_ACFF_EFF_BI_PRESENTATION_OPTION_stub-vo-instance-name =
       "FLAT_CATEGORY_FOLDER_LIST_NESTED_CONTEXT"
       

       The attributes will be displayed in category folders within each applicable context folder. This is the default option.

     Note:

     If the FND_ACFF_EFF_BI_PRESENTATION_OPTION_stub-vo-instance-name option is not defined, then the attributes are arranged by category within context.

To extend the runtime business component modeler for extensible flexfields, override the EFFBCModelerFactory.getCustomEFFBCModeler method, shown in Example 24-6, in the custom runtime business component modeler factory for extensible flexfields.

An example of the PIMBCModelerFactory.java override for this method is shown in Example 24-7.

To make web service access available for an extensible flexfield, associate the flexfield usage's stub search view object with the service-backed view object for the product table that the extensible flexfield extends. Then add a SERVICE_PROCESS_CHILDREN property to the view link and create service data object (SDO) classes for the service-backed view object.

The stub search view object serves as a placeholder for resolving build time dependencies. When the flexfield is deployed, the flexfield modelers generate a view object with the same name in the MDS repository, and generates the view object's XML schema definition (XSD). Because of the name space configuration, the generated view object and XSD are picked up instead of the view object that is shipped with the application. The XSD that is generated for the stub search view object includes references to the XSD definitions for the child categories and contexts that the implementor defines at runtime. At runtime, the application uses view object polymorphism to obtain the category and context view objects that extend from the stub search view object.

Before you begin:

• Ensure that a stub search view object exists for the flexfield usage. The stub search view object is in the view folder in the package that you registered for the extensible flexfield usage in the FND_DF_ADFBC_USAGES table. The name of the stub search view object begins with j_ and ends with the name of the usage's view object. You can use the following SQL statement to determine the package name and view object name for the flexfield usage.

  SELECT PACKAGE_NAME, VIEW_OBJECT 
  FROM FND_DF_ADFBC_USAGES 
  WHERE TABLE_NAME IN
  (SELECT TABLE_NAME FROM FND_DF_TABLE_USAGES TBL WHERE
  DESCRIPTIVE_FLEXFIELD_CODE = flexfield-code AND
  TBL.APPLICATION_ID = application-id AND
  TABLE_TYPE = 'BASE' AND 
  FLEXFIELD_USAGE_CODE = flexfield-usage-code)
  

  Note:

  The Create Flexfields Business Components wizard creates the stub search view object based on the flexfield's declarative SQL-based view object that was registered for the flexfield usage. If no declarative SQL-based view object was registered, then a stub search view object will not exist. You must create and register the SQL-based view object as described in Creating a Declarative SQL-Based View Object to Enable Searching and then run the Create Flexfield Business Components wizard as described in How to Create Business Components For an Extensible Flexfield's Usage.

• A service-backed view object must exist for the product table that the flexfield extends, as described in the Creating View Objects Backed by SDO Services section in the Developing Fusion Web Applications with Oracle Application Development Framework.

To expose an extensible flexfield as a web service:

1. Create a view link as described in the How to Create a Master-Detail Hierarchy for Entity-Based View Objects section in the Developing Fusion Web Applications with Oracle Application Development Framework.

   1. On the View Objects page, in the Select Source Attribute tree expand the service-based view object in the desired package. In the Select Destination Attribute tree expand the stub search view object.

      For entity-based view objects, notice that in addition to the view object attributes, relevant associations also appear in the list.

   2. Select the primary key and CategoryCode attributes in both Source and Destination trees. Then click Add to add the association to the table that is below the trees.

   3. Click Finish.

2. In the Application Navigator, double-click the view link that you just created.

3. In the overview editor, expand the Custom Properties section and add a SERVICE_PROCESS_CHILDREN property set to true, if one does not already exist.

4. Open the service-based view object.

5. In the overview editor click the Java navigation tab.

6. In the Java Classes section, click the Edit icon to generate and configure Java implementation classes.

7. In the Select Java Options dialog, select Generate Service Data Object Class and click OK.

Use the methods in oracle.apps.fnd.applcore.flex.runtime.util.common.ExtensibleFlexfieldUtil to get the names of the following Java business objects (JBOs) that are generated for an extensible flexfield:

• Context entity object: Use getContextEoName, which is shown in Example 24-11.

• Context view object: Use getContextVoName, which is shown in Example 24-12.

• Context entity association between base and extension entity objects: Use getCategoryContextAssocName, which is shown in Example 24-13.

• Context entity/view object attribute for a given segment code: Use getContextAttributeName, which is shown in Example 24-14.

• Categories: Use the various methods shown in Example 24-15.

• Search view object attributes: Use getSearchVoAttributeNames, which is shown in Example 24-16.

If a consumer of the flexfield wants to support interface loading of extensible flexfield data, create interface tables that correspond to the product (primary) table and the base extension table. If the flexfield has a translation extension table, also create a corresponding interface table for the translation extension table, and create a view for that interface table using a definition statement similar to that shown in Example 24-1. Create entity objects and view objects for these tables and view. Then add entries to the FND_DF_TABLE_USAGES and FND_DF_ADFBC_USAGES tables as shown in Table 24-4 and Table 24-5.

When the flexfield is deployed, a parallel set of ADF Business Components artifacts are created. You can use these artifacts to insert data into the interface tables.

If you require parallel sets of extensible flexfield artifacts generated for different uses (for example, public view objects and private view objects), replicate the entries in the FND_DF_ADFBC_USAGES table for that flexfield and use a different group name. When the business components are generated for the flexfield, a separate set of components is generated for each group name.

The following figure shows example entries for a flexfield usage. The FND_DF_TABLE_USAGES table contains rows for the product table (USGA_BASE), the usage base extension table (USGA_EFF_B), and the usage translation extension table (USGA_EFF_TL). The FND_DF_ADFBC_USAGES table contains two entries for each entry in the FND_DF_TABLE_USAGES table — one for the Private group and one for the Public group. Each row names the entity object and the view object. The rows for the translation extension table also name the entity object from the translation extension table. Note that not all columns are shown.

Figure 24-12 Example Entity Detail Entries