How do I FILL a Form with data from in an URL

 Introduction
Filling a form with data passed through a URL is a powerful technique in Oracle APEX that enables seamless user experiences by pre-populating form fields based on parameters sent in the URL. This approach is useful for scenarios like editing existing records, passing reference values between pages, or integrating with external systems. By capturing URL parameters and mapping them to page items, developers can streamline workflows and reduce manual data entry.

Filling a form with data from a URL in Oracle APEX involves passing values as URL parameters and then referencing those parameters in your application to pre-populate form fields. This technique is useful when you want to open a form page with certain fields already filled based on external input, such as links, emails, or navigation from other pages.

Here’s a detailed explanation of how to achieve this:

Step 1: Define the Page Items

Ensure your form page has page items that correspond to the data you want to pass and fill. For example, a form with items:

• P1_NAME (Text Field)
• P1_EMAIL (Text Field)

Step 2: Pass Parameters via URL

Construct a URL that includes the page number and the items with values as query string parameters.

Format:

f?p=App_ID:Page_ID:Session::NO:RP,PT,PX:item_name:item_value

Example:

f?p=100:1:&SESSION.::NO::P1_NAME,P1_EMAIL:John%20Doe,john.doe@example.com

Here,

• 100 is the application ID
• 1 is the page number
• &SESSION. is the current session token (use your actual session or APP_SESSION)
• P1_NAME and P1_EMAIL are the page items
• John Doe and john.doe@example.com are the values (URL-encoded)

When the user accesses this URL, Oracle APEX automatically sets the page items P1_NAME and P1_EMAIL with the specified values before rendering the page.

Step 3: Use the Items in the Form

The form items P1_NAME and P1_EMAIL will display the values passed via the URL automatically when the page loads, allowing the user to see or edit them as needed.Step 4: Additional Handling (Optional)

• If you need to process or validate these values on page load, you can add computations or processes in APEX.
• To handle URL parameters dynamically, you can also read them via :APP_USER, :APP_SESSION, or APEX_UTIL.GET_SESSION_STATE if needed.
• For complex scenarios, you may implement a Before Header process to manipulate or use the parameters.

Step 5: Testing

• Create a link or button that directs users to the URL with the parameters.
• Open the URL in a browser.
• Verify that the form fields are pre-populated with the correct values.

Filling form items from URL parameters in Oracle APEX is a straightforward and effective way to pass data into your application pages. It simplifies user input, supports deep linking, and enhances integration possibilities. By leveraging APEX’s built-in URL syntax for setting page items, developers can create responsive forms that adapt dynamically to external inputs or navigation flows.

Filling a Form with Data from a URL in Oracle APEX

Oracle APEX allows passing values through the URL to populate form fields dynamically. This is useful for pre-filling forms based on user selections or external links.

How URL Parameters Work in APEX

APEX uses the following URL structure to pass values:

f?p=App_ID:Page_ID:Session:Request:Debug:ClearCache:itemNames:itemValues

• App_ID - The Application ID
• Page_ID - The Page Number where the form exists
• Session - The session value (use &SESSION. to auto-populate)
• Request - Can be used for button processing or custom actions
• Debug - Debug mode (set to NO or YES)
• ClearCache - Clears session values (RP for resetting page items)
• itemNames - The page item(s) to set values for
• itemValues - The corresponding values for those items

Method 1: Pre-Filling a Form Using URL Parameters

If you have a form on Page 2 with fields P2_NAME and P2_EMAIL, you can pre-fill them using a URL like this:

f?p=100:2:&SESSION.::NO:RP:P2_NAME,P2_EMAIL:John,Doe@example.com

When users visit this URL, the P2_NAME field will be set to John, and the P2_EMAIL field will be set to Doe@example.com.

Steps to Implement

1. Create a Form Page in APEX with items like P2_NAME and P2_EMAIL.
2. Ensure these fields have Source set to Only When Current Value is Null to allow URL values.
3. Share the generated URL for pre-filling the form.

Method 2: Using JavaScript to Read URL Parameters

If you need to process URL parameters dynamically, use JavaScript.

Step 1: Add JavaScript to Your Form Page

Go to Page Designer > Execute When Page Loads, then insert:

function getParameterByName(name) {

    let url = new URL(window.location.href);

    return url.searchParams.get(name);

}

let nameValue = getParameterByName("P2_NAME");

let emailValue = getParameterByName("P2_EMAIL");

if (nameValue) {

    $s("P2_NAME", nameValue);

}

if (emailValue) {

    $s("P2_EMAIL", emailValue);

}

Step 2: Test the URL

Use this URL format to test:

f?p=100:2:&SESSION.::NO:RP:P2_NAME,P2_EMAIL:John,Doe@example.com

This will extract values from the URL and fill the form fields using JavaScript.

Method 3: Using PL/SQL to Process URL Parameters

Sometimes, you may want to process URL parameters before displaying them on the form. You can do this using a Before Header PL/SQL Process.

Steps to Implement

1. In Page Designer, go to Processing > Before Header.
2. Create a new PL/SQL Process with this code:

BEGIN

    :P2_NAME := NVL(:P2_NAME, 'Default Name');

    :P2_EMAIL := NVL(:P2_EMAIL, 'default@example.com');

END;

3. Save and Run the page.

If values are not passed in the URL, the fields will use the default values.

Best Practices

• Use URL Encoding: If passing values that contain special characters (&, ?, /), encode them using JavaScript’s encodeURIComponent().
• Security Considerations: Do not pass sensitive information (like passwords) in URLs. Use session state protection for security.
• Clear Cache if Needed: If a user reloads the page, cached values may persist. Use RP in the URL to reset fields.

Filling a form with data from a URL in Oracle APEX is a simple yet powerful way to enhance user experience. You can use direct URL parameters, JavaScript, or PL/SQL depending on your requirements.

EXAMPLE:

Forms do not operate like a classic report. In order to make a form fill with data you need to create a “Pre-rendering” process that will fire off the loading of data.

In this example we are using the EMPLOYEES table provided with APEX. For our test there is an initiating page that has a link that  has two values:

• The textbox that we are passing the data into. In this case “P10_EMPNO”.
• The value that we are passing into that textbox. In this case “EMPNO”.

The code that we are using to generate the link looks something like the following code:

select "EMPNO",

    null LINK_CLASS,

    apex_page.get_url(p_items => 'P10_EMPNO', p_values => "EMPNO") LINK,

    null ICON_CLASS,

    null LINK_ATTR,

    null ICON_COLOR_CLASS,

    case when coalesce(:P9_EMPNO,'0') = "EMPNO"

      then 'is-active' 

      else ' '

    end LIST_CLASS,

    (substr("ENAME", 1, 50)||( case when length("ENAME") > 50 then '...' else '' end )) LIST_TITLE,

    (substr("JOB", 1, 50)||( case when length("JOB") > 50 then '...' else '' end )) LIST_TEXT,

    null LIST_BADGE

from "EMP" x

where (:P9_SEARCH is null

        or upper(x."ENAME") like '%'||upper(:P9_SEARCH)||'%'

        or upper(x."JOB") like '%'||upper(:P9_SEARCH)||'%'

    )

order by "ENAME"

Step 1 – Add a form to an empty page

• On the body of the page right click and then select Create Region.

• Make the region a form and name it Form Region

• Select the data table name

Step 2 – Create a process

• At the Pre-Rendering section right click Create Process

• Select Type : “Form-Initialization” and select the appropriate form region name

• Make sure that the Execution is as follows

Step 3 – Set the page Security to “Unrestricted”

Step 4 – Set the receiving control Security to “Unrestricted”

That’s it. It should work.

 

Conclusion
Using URL parameters to fill forms in Oracle APEX enhances application usability and flexibility. It allows data to flow smoothly between pages or external sources, making the user experience more intuitive and efficient. Mastering this technique enables developers to build dynamic, responsive applications that adapt to user context and improve productivity.