OIC - Removing Base64 Padding (=) for JWT Generation in Oracle Integration Cloud (OIC)

When generating a JWT in Oracle Integration Cloud (OIC), the header and payload must be Base64URL encoded before creating the signature. Standard Base64 encoding adds = characters as padding to make the encoded string a multiple of four characters. However, the JWT specification does not allow these padding characters.

To remove the padding, use the following expression in an Assign action:

replace(encodeReferenceToBase64(FileReference), '=', '')

How It Works

encodeReferenceToBase64(FileReference) encodes the input into a standard Base64 string.

replace(..., '=', '') removes all = padding characters from the encoded value.

The resulting string is then used as the JWT header or payload before generating the signature.

Why Is This Required?

JWT uses Base64URL encoding, which differs from standard Base64 by:

Removing the = padding characters.

Using URL-safe characters (- and _) instead of + and / (if applicable).

Removing the padding ensures that the generated JWT follows the standard specification and can be successfully validated by external applications and APIs.

Using this simple expression helps generate JWT-compliant header and payload values directly within OIC, without requiring any additional custom code.

OIC - Generate SHA-256 Checksum Using JavaScript in OIC

Oracle Integration Cloud (OIC) provides a built-in checksum function to generate a SHA-256 hash without using any external library. This is useful when creating request signatures or validating message integrity.

JavaScript Action (SHA256Generator.js)

function checksum_sha256(inputStr) {
    var sha256_result = oic.checksum.sha256(inputStr, "sha-256");
    return sha256_result;
}

Use Cases

Generate SHA-256 checksum for REST requests.

Create secure hash values for authentication.

Verify message integrity before sending data.

This reusable JavaScript action can be called from any OIC integration whenever a SHA-256 checksum is required.

Reference:

https://docs.oracle.com/en/cloud/paas/application-integration/integrations-user/import-library-file.html#GUID-D9638CD4-ADCE-4C8A-B5B3-1969086E642E

Notepad - Improve Productivity in Notepad++ by Managing Multiple Open Tabs

Introduction

When numerous files are open in Notepad++, not all tabs are visible in a single row. Enabling multi-line tabs allows Notepad++ to display open tabs across multiple lines, making file navigation quicker and more convenient.

Solution

To display all the tabs in multi lines:

1. Go to Settings → Preferences.
2. Select General.
3. Under the Tab Bar section, select multi line.

Benefits

Improved visibility of open files.

Faster navigation between documents.

Reduced chances of opening or editing the wrong file.

Better productivity when working with multiple project files.

This small configuration change can significantly improve your daily development experience, especially when working with large OIC projects containing many similar file names.

OIC - Oracle Integration Cloud (OIC): Automatically Create Folder Structures in OCI Object Storage | use of ends-with() function

 Introduction

When working with OCI Object Storage, we often need to create multiple folders and subfolders before uploading files. Although this can be done manually through the OCI Console, repeatedly logging in and creating folders becomes time-consuming, especially during project setup or migration activities.

In this blog, we'll build a reusable Oracle Integration Cloud (OIC) service that automatically creates the required folder hierarchy in an OCI Object Storage bucket.

Business Requirement

Create an OIC REST service that accepts:

• Object Storage Namespace
• Bucket Name
• An array of folder and subfolder paths

The integration will iterate through each folder path and create an empty placeholder object so that the folder structure is visible in Object Storage.

This eliminates the need to manually log in to OCI and create folders one by one.

Sample Request

{
  "namespace": "my_namespace",
  "bucketName": "integration-bucket",
  "folders": [
    "Inbound",
    "Outbound",
    "Archive",
    "Archive/Success",
    "Archive/Error",
    "Logs",
    "Reports/Daily",
    "Reports/Monthly"
  ]
}

Solution Design

The integration performs the following steps:

1. Expose a REST endpoint.
2. Read the Namespace, Bucket Name, and folder array.
3. Use a For-Each action to iterate through every folder path.
4. For each folder:
   • Append a trailing / if required.
   • Create a dummy empty object (0-byte file) using the OCI Object Storage Adapter.
5. Return a success response once all folders have been created.

Integration Flow

REST Trigger
      │
      ▼
Read Request Payload
      │
      ▼
For Each Folder
      │
      ▼
Create Empty Object in OCI Object Storage
      │
      ▼
Next Folder
      │
      ▼
Return Success Response

Why Create an Empty File?

OCI Object Storage does not actually store folders. Instead, folders are represented by object names containing /.

By creating an empty object (0-byte placeholder) for each folder path, the OCI Console displays the folder hierarchy, making it easier for users and integrations to organize files.

Benefits

• No manual login to the OCI Console.
• Quickly create complete folder hierarchies.
• Reusable across multiple projects and environments.
• Accepts any number of folders through a single request.
• Ideal for deployment automation and project onboarding.
• Reduces manual effort and configuration errors.

Sample Response

{
  "status": "SUCCESS",
  "message": "Folder structure created successfully."
}

Use Cases

• Initial Object Storage bucket setup.
• Environment provisioning.
• Automated deployment pipelines.
• Project onboarding.
• Creating standard folder templates across multiple buckets.

Conclusion

This reusable OIC service simplifies the creation of folder structures in OCI Object Storage by accepting a bucket name, namespace, and list of folder paths. Instead of manually navigating the OCI Console, users can create an entire folder hierarchy with a single API request, saving time and ensuring consistency across environments.

This lightweight utility is particularly useful for automation, CI/CD deployments, and projects that frequently provision new Object Storage buckets.

OIC - ERP - Resolving ORA-01403: No Data Found During ERP Import Costs ESS Job

Overview

While executing the Import Costs ESS job in Oracle ERP, the process failed with the following error:

Error:

ORA-01403: no data found

This error can be misleading because it doesn't always indicate missing transactional data. In our case, the issue was caused by incorrect parameter values being passed to the ESS job from Oracle Integration Cloud (OIC).

Error Scenario

The Import Costs ESS job completed with Error status, and the completion text displayed:

ORA-01403: no data found

As shown below:

Root Cause

The integration was retrieving ESS job parameters from a lookup table. During troubleshooting, we found that one or more parameter values stored in the lookup were incorrect.

Since the ESS job received invalid parameters, it couldn't find the expected data and returned the ORA-01403: no data found error.

Resolution

The issue was resolved by following these steps:

1. Reviewed the parameters passed to the Import Costs ESS job.
2. Compared them with the expected ERP values.
3. Identified incorrect values in the OIC lookup.
4. Updated the lookup with the correct parameter values.
5. Re-ran the integration.
6. After updating the lookup, the ESS job completed successfully without any errors.

Key Learning

When an ESS job fails with ORA-01403: no data found, don't assume the source data is missing. Also verify:

• The parameters passed to the ESS job.
• Lookup values used by the integration.
• Parameter mapping in OIC.
• Whether the parameter values match the ERP configuration.

Troubleshooting Checklist

• ✅ Verify all ESS job parameters.
• ✅ Check OIC lookup values.
• ✅ Validate parameter mapping before submitting the ESS job.
• ✅ Compare successful and failed job parameters.
• ✅ Re-run the ESS job after correcting the parameters.

Conclusion

In this case, the root cause was incorrect parameter values stored in the OIC lookup, not missing ERP data. Updating the lookup with the correct values resolved the ORA-01403: no data found error, and the Import Costs ESS job executed successfully.

Tip: Whenever an ERP ESS job throws ORA-01403, reviewing the submitted parameters should be one of the first troubleshooting steps, especially if those parameters are dynamically fetched from an OIC lookup or configuration table.

OIC Accelerator Upgrade: Reviewing Merge Reports and Resolving Unmerged Extensions

Working...

When upgrading an Oracle Integration Cloud (OIC) Accelerator, Oracle automatically merges the latest accelerator changes with your customized extensions. While most changes are merged successfully, some extensions may require manual intervention due to conflicts or customizations.

The Merge Report provides a consolidated view of all merged and unmerged extensions, allowing developers to quickly identify and resolve any outstanding issues before completing the upgrade.

This blog explains how to access the Merge Report from the Integration Palette and review each unmerged extension.

Why Review the Merge Report?

After an accelerator upgrade, reviewing the Merge Report helps you:

• Verify which extensions were merged successfully.
• Identify extensions that require manual review.
• Understand the reason behind merge conflicts.
• Ensure all customizations are retained after the upgrade.
• Validate the integration before deployment.

Steps to Review the Merge Report

Step 1: Open the Upgraded Integration

Open the upgraded integration in the OIC Designer.

Step 2: Open the Integration Palette

From the left-side panel, open the Integration Palette.

Navigate to the Extensions section.

Step 3: View the Merge Report

Select Merge Report from the Integration Palette.

The report displays:

Successfully merged extensions

Partially merged extensions

Unmerged extensions requiring manual resolution

This provides an overview of the upgrade status for all extensions.

Step 4: Review Each Unmerged Extension

Expand each unmerged extension listed in the report.

For every extension, review:

• The affected integration component
• The merge status
• The reason for the conflict
• Any customizations that were not merged automatically

This helps determine the manual changes required.

Step 5: Resolve the Unmerged Changes

Open the corresponding extension and compare it with the original implementation.

Review components such as:

Mappings (XSLT)

Variables

Assign actions

Switch conditions

Invoke activities

Fault handlers

Connections and adapter configurations

Apply the required changes manually while preserving both the accelerator updates and your customizations.

Step 6: Validate and Test

Once all unmerged extensions have been reviewed and resolved:

• Validate the integration.
• Resolve any validation or mapping errors.
• Perform functional testing.
• Activate the integration after successful validation.

Best Practices

• Always review the Merge Report immediately after an accelerator upgrade.
• Resolve all unmerged extensions before deployment.
• Compare customizations carefully to avoid losing business logic.
• Validate the integration after every manual update.
• Test all impacted integration flows before promoting to higher environments.

Conclusion

The Merge Report is an essential tool during OIC Accelerator upgrades. It provides a centralized view of merged and unmerged extensions, enabling developers to quickly identify areas requiring manual attention. By reviewing each unmerged extension and validating the integration thoroughly, you can ensure a smooth upgrade while preserving existing customizations and minimizing deployment risks.

OIC - Oracle Integration Cloud (OIC) – Upload File to UCM, Submit ESS Job, and Monitor Job Status

A common Oracle ERP Cloud integration pattern is to upload a file to UCM, submit an ESS job, and then poll the ESS job status until it completes successfully. This pattern is widely used for payment processing, FBDI imports, bank acknowledgements, and other batch integrations.

Business Requirement

Suppose an external system generates a file (CSV/XML/TXT) that needs to be processed by Oracle ERP Cloud.

The integration should:

1. Upload the file into Oracle ERP Cloud UCM.
2. Submit the required ESS job.
3. Wait for the job to finish.
4. Check the ESS job status.
5. Continue processing only when the job completes successfully.

Integration Flow

External System

      │

      ▼

Receive File

      │

      ▼

Upload File to UCM

      │

      ▼

Receive Content ID

      │

      ▼

Submit ESS Job

      │

      ▼

Receive Request ID

      │

      ▼

Loop Until Completion

      │

      ▼

Get ESS Job Status

      │

      ▼

Success / Error Handling

Step 1 – Upload File to UCM

Configure the Oracle ERP Cloud Adapter and select:

Operation: File Upload to WebCenter (UCM)

Example values:

Account: FAFusionImportExport

UCM Folder: fin$/payments$/import$

After upload, Oracle returns a Content ID, which is required by many ESS jobs.

Step 2 – Submit ESS Job

Invoke another ERP Cloud Adapter.

Choose: Submit ESS Job

Provide:

Job Package Name: /oracle/apps/ess/financials/payments/fundsDisbursement/payments/

Job Definition Name: FDAckProcessing

Parameters: <referenceNumber>

Example ESS Job Path:

/oracle/apps/ess/financials/payments/fundsDisbursement/payments/FDAckProcessing

The adapter returns an ESS Request ID.

Example:

Request ID : 300000458912345

Step 3 – Wait Before Polling

Instead of checking immediately, add a Wait activity.

Example:

Wait 20–30 seconds

This avoids unnecessary API calls while Oracle begins processing the job.

Step 4 – Check ESS Job Status

Use a While scope.

Pseudo logic: While Status != SUCCEEDED

   Wait 20 Seconds

   Get ESS Job Status : Pass the Request ID returned during job submission.

End While

If the status becomes:

SUCCEEDED → Continue integration.

ERROR → Raise fault.

WARNING → Handle based on business requirement.

Typical statuses include:

Status Meaning

WAIT Waiting to start

READY Ready for execution

RUNNING Currently executing

SUCCEEDED Completed successfully

ERROR Failed

WARNING Completed with warnings

When to use Upload File to UCM:

You are uploading a payment file or bank file.

You need to run a specific ESS job yourself after the upload.

The file is not a standard Oracle FBDI import.

You need full control over the sequence (Upload → ESS Job → Poll Status).

Example:

Upload payment acknowledgment file.

Upload HSBC bank file.

Upload custom XML/CSV.

Upload a file and then run FDAckProcessing ESS job.

When to use Bulk Import:

You are importing Oracle ERP business data using FBDI.

Oracle ERP supports that object through the Bulk Import operation.

You want Oracle to manage the import process for that business object.

Examples:

Supplier Import

Customer Import

GL Journal Import

AP Invoice Import

Asset Import

Item Import

Conclusion

Uploading a file to UCM, submitting an ESS job, and continuously monitoring the job status is one of the most common Oracle Integration Cloud design patterns. By combining the ERP Cloud Adapter, Wait, and While activities, you can build a robust integration that ensures downstream processing starts only after the ERP job has successfully completed.