Microsoft Excel - Fundamentals

Launching excel:

windows task bar >> start >> Search Excel >> Open 

When you open Excel, you'll see a start screen displaying a blank workbook, various templates to choose from, as well as options for account settings and recently opened workbooks. Click Blank Workbook to begin.

Basic Control and Parts of Excel Window 

1. **Quick Access Toolbar**: Located at the top left, this shows frequently used commands and can be customized.

2. **File Tab**: Replaces the Office button, allowing file operations like opening, saving, and printing.

3. **Title Bar**: Displays the name of the current document at the top of the window.

4. **Control Buttons**: Located at the top-right corner, these buttons help you minimize, maximize, or close the window.

5. **Menu Bar**: Contains tabs like File, Insert, and Data for accessing different commands.

6. **Ribbon/Toolbar**: Shows commands organized by tabs (e.g., Home, Insert) and groups within them (e.g., fonts, alignment).

7. **Dialog Box Launcher**: A small arrow in the lower-right of a command group that provides more options.

8. **Name Box**: Shows the location of the active cell or range.

9. **Formula Bar**: Allows you to view and edit the content or formula of the active cell.

10. **Scrollbars**: Used to move around the document vertically and horizontally.

11. **Spreadsheet Area**: Where you enter data, including rows, columns, and cells.

12. **Sheet Tab**: Located at the bottom, it shows the current sheet and lets you switch between sheets.

13. **Columns Bar**: Displays column labels (A, B, C, etc.) and is located below the formula bar.

14. **Rows Bar**: Displays row numbers (1, 2, 3, etc.) on the left side of the sheet.

15. **Cells**: Individual boxes in the spreadsheet, identified by their column letter and row number (e.g., A1).

16. **Status Bar**: At the bottom, shows summary info and lets you customize what’s displayed.

17. **View Buttons**: Three buttons for different views: Normal, Page Layout, and Page Break.

18. **Zoom Control**: Located at the bottom-right, lets you zoom in and out of the spreadsheet

Hide Excel Ribbon

Double clink on any selected tab to hide/unhide

The middle blank area is called a workbook, which contains multiple worksheets. A worksheet is where you enter and organize your data.

• Total columns: XFD (16,384)
• Total rows: 1,048,576
• To quickly navigate:
  • Ctrl + → / ↓ → Move to the last column or row
  • Ctrl + Home → Return to cell A1

To save a Excel:

Quick Access Toolbar:

• Use the Save button or press Ctrl + S to save your work quickly.

File Tab Options:

• Save / Save As:
  • Choose Save As when creating a new file for the first time.
  • Use Save to update an existing workbook.
• Open:
  • Access previously saved Excel files or browse to open a new one.

Shorcuts commands: 

Following are the most frequently used shortcuts in Excel for Windows. 

---

🔹 Basic File Operations

• Ctrl + S : Save worksheet
• Ctrl + O : Open worksheet
• Ctrl + W : Close worksheet
• Alt + F → Save / Save As : Save new or existing file
• Ctrl + P : Print worksheet

---

🔹 Navigation & Tabs

• Alt + H : Go to Home tab
• Alt + N : Go to Insert tab
• Alt + P : Go to Page Layout tab
• Alt + M : Go to Formula tab
• Alt + A : Go to Data tab
• Alt + W : Go to View tab

---

🔹 Editing & Formatting

• Ctrl + C : Copy
• Ctrl + X : Cut
• Ctrl + V : Paste
• Ctrl + Z : Undo
• Delete : Clear cell contents
• Ctrl + B : Bold text
• Alt + H, H : Choose fill color
• Alt + H, A, C : Center align contents
• Alt + H, B : Add borders
• Alt + H, D, C : Delete column

---

🔹 Row & Column Management

• Ctrl + 9 : Hide selected rows
• Ctrl + 0 : Hide selected columns

---

🔹 Cell Navigation

• Shift + Tab : Move to previous cell
• Up Arrow : Move one cell up
• Down Arrow : Move one cell down
• Left Arrow : Move one cell left
• Right Arrow : Move one cell right
• Ctrl + Arrow key : Jump to edge of data region
• End + Arrow key : Move to next nonblank cell
• Ctrl + End : Go to last used cell
• Ctrl + Shift + End : Extend selection to last used cell
• Home + Scroll Lock : Move to upper-left corner
• Ctrl + Home : Go to beginning (cell A1)

---

🔹 Worksheet Navigation

• Page Down : Move one screen down
• Page Up : Move one screen up
• Alt + Page Down : Move one screen right
• Alt + Page Up : Move one screen left
• Ctrl + Page Down : Next sheet
• Ctrl + Page Up : Previous sheet
• Tab : Move right / next unlocked cell

---

🔹 Miscellaneous

• Shift + F10 or Context Key : Open context menu

---

Excel extension:

Before 2007, Excel used the .xls binary file format; from 2007 onward, it uses the XML-based .xlsx format.

The maximum number of worksheets in a Microsoft Excel workbook is not explicitly fixed — it is limited only by your computer’s available memory. 

Data types:

1. By deafult , text are left aligned
2. By default, numbers right aligned.
3. Date values are treated as numeric . For example if you mention Jan-2019 the backend value will be 1/1/2019(m/d/yyyy)

From the Home tab >>Number group and we can choose different date format or we can create custom one.

OIC - How to Encrypt and Decrypt Using AES Key and OCI Function in Oracle Integration Cloud (OIC)

 Working...

📌 Use Case

In real-world Oracle Integration Cloud (OIC) projects, sensitive data like passwords, API keys, or personal information must be transmitted securely. A common approach is to encrypt data before sending it to a target system and decrypt it upon retrieval.

By leveraging AES encryption/decryption inside an OCI Function and invoking it from OIC, we can:

1. Securely encrypt payloads before sending to external applications.
2. Decrypt incoming encrypted data from third-party systems.
3. Ensure compliance with data security requirements (AES/CBC/PKCS5Padding or AES/ECB/PKCS5Padding).

This approach allows OIC to delegate cryptographic operations to OCI Functions, ensuring flexibility and security without exposing raw secrets in integration flows.

✅ Solution Steps

1. Create an OCI Function for AES Encryption/Decryption

Develop a Java OCI Function (see full code below).

Function accepts input parameters:

• message → Text to encrypt or decrypt.
• secretKeyBase64 → AES key (Base64 encoded).
• ivBase64 → Initialization Vector (required for CBC mode).
• aesMode → Cipher mode (e.g., AES/CBC/PKCS5Padding or AES/ECB/PKCS5Padding).
• actionType → Either ENCRYPT or DECRYPT.

2. Deploy the Function in OCI

Use Fn Project CLI to deploy.

Make sure the function has appropriate IAM permissions to be invoked from OIC.

3. Invoke OCI Function from OIC

• In OIC, create a REST Adapter to call the OCI Function.
• Pass input parameters (message, aesMode, etc.) in the request body.
• Receive encrypted/decrypted message in the response payload.

4. Use in Integration Flows

Encrypt sensitive data (like API credentials) before storing or transmitting.

Decrypt incoming messages before business logic processing.

📝 Function Code

Here’s the Java OCI Function code you can deploy:

package com.clp.fn;

import javax.crypto.Cipher;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import java.util.Base64;

import java.util.logging.*;

import java.security.SecureRandom;

public class AESEncryptDecrypt {

    private static final Logger logger = Logger.getLogger(AESEncryptDecrypt.class.getName());

    public static class Input {

        public String message;

        public String secretKeyBase64;

        public String ivBase64;

        public String aesMode;     // AES/CBC/PKCS5Padding or AES/ECB/PKCS5Padding

        public String actionType;  // ENCRYPT or DECRYPT

    }

    public static class Result {

        public String message;

        public String salt;

        public String wechataeskey;

        public String executionInfo;

    }

    public Result handleRequest(Input input) {

        logger.log(Level.INFO, "OIC - message:", input.message);

        logger.log(Level.INFO, "OIC - secretKeyBase64:", input.secretKeyBase64);

        logger.log(Level.INFO, "OIC - ivBase64", input.ivBase64);

        logger.log(Level.INFO, "OIC - aesMode:", input.aesMode);

        logger.log(Level.INFO, "OIC - actionType:", input.actionType);

        Result result = null;

        if ("DECRYPT".equals(input.actionType)) {

            result = decryptMyMessage(input);

        } else if ("ENCRYPT".equals(input.actionType)) {

            result = encryptMyMessage(input);

        } else {

            result = new Result();

            result.executionInfo = "ERROR: No proper action found , " +

                    "possible value is ENCRYPT or DECRYPT , recieved value:" + input.actionType;

        }

        return result;

    }

    // Generate random 16-byte IV for AES/CBC

    public static IvParameterSpec generateIV() {

        byte[] iv = new byte[16]; // 128-bit IV

        new SecureRandom().nextBytes(iv);

        IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

        return ivParameterSpec;

    }

    public Result encryptMyMessage(Input input) {

        Result result = new Result();

        try {

            byte[] decodedKey = null;

            if (input.secretKeyBase64 == null) {

                // Generate 16-digit random numeric string

                String keyString = generateRandomDigits(16);

                //System.out.println("Generated 16-digit AES key: " + keyString);

                // Convert to byte array (each digit becomes 1 byte, 16 bytes total = 128 bits)

                result.wechataeskey = keyString;

                decodedKey = keyString.getBytes("UTF-8");

            } else {

                // Decode the base64 encoded string

                decodedKey = Base64.getDecoder().decode(input.secretKeyBase64);

            }

byte[] messageBytes = input.message.getBytes("UTF-8");

        // Create a SecretKeySpec for the AES key

        SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, "AES");

        // Create a Cipher instance for AES

        Cipher cipher = Cipher.getInstance(input.aesMode);

        if (input.aesMode.contains("CBC")) {

            // AES/CBC/PKCS5Padding required IV

            IvParameterSpec ivParameterSpec = generateIV();

            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);

            result.salt = Base64.getEncoder().encodeToString(ivParameterSpec.getIV());

        } else {

            // AES/ECB/PKCS5Padding do not require IV

            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);

        }

        // Decrypt the message

        byte[] originalBytes = cipher.doFinal(messageBytes);

        String encodedString = Base64.getEncoder().encodeToString(originalBytes);

        result.message = encodedString;

        // String originalMessage = new String(originalBytes);

        result.executionInfo = "SUCCESS";

    } catch (Exception e) {

        result.executionInfo = e.getMessage();

        logger.log(Level.INFO, "Error Details:", e.getMessage());

    }

    return result;

}

public Result decryptMyMessage(Input input) {

    Result result = new Result();

    generateIV();

    try {

        // Decode the base64 encoded string

        byte[] decodedKey = Base64.getDecoder().decode(input.secretKeyBase64);

        byte[] encryptedBytes = Base64.getDecoder().decode(input.message);

        // Create a SecretKeySpec for the AES key

        SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, "AES");

        // Create a Cipher instance for AES

        Cipher cipher = Cipher.getInstance(input.aesMode);

        if (input.aesMode.contains("CBC")) {

            // AES/CBC/PKCS5Padding required IV

            byte[] decodedIV = Base64.getDecoder().decode(input.ivBase64);

            IvParameterSpec ivParameterSpec = new IvParameterSpec(decodedIV);

            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);

        } else {

            // AES/ECB/PKCS5Padding do not require IV

            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);

        }

        // Decrypt the message

        byte[] originalBytes = cipher.doFinal(encryptedBytes);

        String encodedString = Base64.getEncoder().encodeToString(originalBytes);

        result.message = encodedString;

        // String originalMessage = new String(originalBytes);

        result.executionInfo = "SUCCESS";

    } catch (Exception e) {

        result.executionInfo = e.getMessage();

        logger.log(Level.INFO, "Error Details:", e.getMessage());

    }

    return result;

}

// WeChat, generate a random string of digits for AES Key

public static String generateRandomDigits(int length) {

    SecureRandom random = new SecureRandom();

    StringBuilder sb = new StringBuilder(length);

    for (int i = 0; i < length; i++) {

        sb.append(random.nextInt(10)); //0-9

    }

    return sb.toString();

}

}

Code link:

https://drive.google.com/file/d/1pF3DGnyAr0M2F-HymQE-jJbC3kj-VBzi/view?usp=drivesdk

Key Benefits

• Ensures data confidentiality across systems.
• Supports multiple AES modes (CBC, ECB) with PKCS5Padding.
• Can be reused across multiple OIC integrations via a single OCI Function.
• No direct exposure of keys inside OIC flows

OIC - How to Use XSLT to Generate Namespaced Target Payload Blocks in OIC

Use Case

When working with Oracle Integration Cloud (OIC) SOAP-based integrations, we often need to map fault objects (like error details or reasons) into a target response payload that follows a specific namespace and schema.

In this example, the target system expects a payload with the following structure:

<ns2:AddMeterToInventoryResponse xmlns:ns2="turtletech.com/TS2/">
   <ns2:AddMeterToInventoryResult>
      <ns2:ErrorObj>
         <ns2:errorString>Meter Not Added</ns2:errorString>
      </ns2:ErrorObj>
   </ns2:AddMeterToInventoryResult>
</ns2:AddMeterToInventoryResponse>

The challenge is to generate this block dynamically from fault objects (like $GlobalFaultObject/nspr1:fault) while preserving the correct namespace (ns2) and nested structure.

---

Solution with XSLT Mapper

To achieve this in OIC mapper, we can leverage <xsl:apply-templates> and define templates that build the required XML block.

---

1. Declare the Namespace

In your stylesheet, ensure that the target namespace (ns2) is declared:

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:ns2="turtletech.com/TS2/"
                xmlns:nspr1="http://schemas.oracle.com/faults"
                exclude-result-prefixes="nspr1"
                version="1.0">

---

2. Entry Template

Start with a root template that applies templates for faults:

<xsl:template match="/">
   <nstrgmpr:InboundSOAPResponseDocument>
      <nstrgmpr:Body>
         <xsl:apply-templates select="$GlobalFaultObject/nspr1:fault"/>
      </nstrgmpr:Body>
   </nstrgmpr:InboundSOAPResponseDocument>
</xsl:template>

---

3. Fault Handling Template

Define how the fault is transformed into the required target structure:

<xsl:template match="nspr1:fault">
   <ns2:AddMeterToInventoryResponse>
      <ns2:AddMeterToInventoryResult>
         <xsl:choose>
            <xsl:when test="$GlobalFaultObject/nspr1:fault/nspr1:details = ''">
               <ns2:ErrorObj>
                  <ns2:errorString>
                     <xsl:value-of select="$GlobalFaultObject/nspr1:fault/nspr1:reason"/>
                  </ns2:errorString>
               </ns2:ErrorObj>
            </xsl:when>
            <xsl:otherwise>
               <ns2:ErrorObj>
                  <ns2:errorString>
                     <xsl:value-of select="$GlobalFaultObject/nspr1:fault/nspr1:details"/>
                  </ns2:errorString>
               </ns2:ErrorObj>
            </xsl:otherwise>
         </xsl:choose>
      </ns2:AddMeterToInventoryResult>
   </ns2:AddMeterToInventoryResponse>
</xsl:template>

---

4. Execution

With this template setup:

• OIC picks up the fault object.
• The <xsl:apply-templates> dispatches it to the fault template.
• The correct namespace-prefixed block (ns2) is generated.

This ensures your output matches the required schema exactly and avoids namespace mismatches.

---

Key Takeaways

• Always declare the target namespace (ns2) in the XSLT stylesheet.
• Use <xsl:apply-templates> and <xsl:template match> to modularize transformation logic.
• Use <xsl:choose> to conditionally pick reason or details from fault objects.
• This approach guarantees a reusable and scalable mapping for multiple fault scenarios.

---

👉 This method is highly reusable for any SOAP service response transformation in OIC where a specific namespace-aligned block must be built dynamically.

---

OIC - How to Generate RSA Private Key for Oracle OIC Vault, Functions, and Connections Using ssh-keygen (Windows CMD)

📌 Use Case

When working with Oracle Integration Cloud (OIC), secure authentication often requires RSA private keys in PEM format. These keys are commonly used for:

• Uploading secrets into OCI Vault.
• Configuring OIC Functions with key-based authentication.
• Creating SFTP, REST, or API Connections in OIC that use private keys instead of passwords.

If you are on Windows, you can use the built-in OpenSSH ssh-keygen tool (available in Windows 10/11 CMD or PowerShell) to generate or reformat RSA private keys.

---

⚙️ Solution Steps (Windows CMD)

Step 1: Ensure OpenSSH is Installed

• Open Command Prompt.
• Run:

  ssh -V
  

  If you see a version (e.g., OpenSSH_for_Windows_8.x), you’re good to go.
  If not, install OpenSSH from Windows Optional Features.

---

Step 2: Run the ssh-keygen Command in CMD

Use the following command to create or reformat a private key in PEM format:

ssh-keygen -p -f my_oic_key.pem -N "" -t rsa -m pem

🔎 Example:

ssh-keygen -p -f svc_oic_ccsvault_tst@clp.com.hk-2025-09-16T13_18_48.364Z.pem -N "" -t rsa -m pem

Parameters explained:

• -p → Update or re-save the key file.
• -f my_oic_key.pem → Path and name of your private key file.
• -N "" → Empty passphrase (no password required).
• -t rsa → Generate RSA type key.
• -m pem → Export the key in PEM format (needed for OIC Vault, Functions, Connections).

---

Step 3: Verify the Key File

• Only one private key file (.pem) will be created/updated.
• It will be saved in PEM format.
• No public key file (.pub) is generated in this mode.

---

Step 4: Use in OIC

• Upload the .pem file into OCI Vault as a secret.
• Configure OIC Functions to read this private key.
• Use it in SFTP / REST / API Connections in OIC for key-based authentication.

---

✅ Final Result: You now have an RSA private key in PEM format, created directly from Windows CMD, ready for use in Oracle Integration Cloud Vault, Functions, and Connections.

OIC - Monitoring Oracle CCS Batch Job Failures in Real-Time with OIC and Datadog

Use Case

In Oracle Integration Cloud (OIC), batch jobs are frequently triggered in Oracle Customer Cloud Service (CCS) to handle customer data processing. However, if these batch jobs fail, it becomes critical for business users or technical support teams to be notified quickly to take corrective action. Traditional monitoring through CCS dashboards may cause delays, as failures might go unnoticed until users manually check.

To improve observability and responsiveness, we can integrate OIC with Datadog. This integration ensures that whenever a batch job fails in CCS, OIC captures the failure details and logs them into Datadog. From there, alerts can be configured to notify support teams instantly via email, Slack, or other preferred channels.

---

Solution Steps

1. OIC scheduler will run every 5 mins interval or as per business requirement.

2. Trigger Health check Batch Job in Oracle CCS from OIC

• Use the CCS Utility REST API or SOAP service to invoke a batch job from OIC.
• Pass required parameters like job name, job ID, and input arguments.

Note: in our case, not passing any param to health check up job.

Send Failure Details to Datadog

• Use OIC’s REST Adapter to call Datadog’s Log Intake API.
• Send the failure payload in JSON format
• Example payload to Datadog:

  {
    "F1-HealthCheck": {
      "healthOverallResponse": 200,
      "healthCheckResults": [
        {
          "healthCompFlg": "BLOS",
          "healthCompDetail": "Batch Control: BILLING - Create Bills for Open Bill Cycles",
          "healthCompStatusFlg": "DISA",
          "healthCompStatusDescr": "Disabled",
          "healthCompStatusReason": "Level of Service information is not available for this batch job.",
          "healthCompResponse": 200,
          "mo": "BATCH CNTL",
          "navOpt": "f1btctrlTabMenu",
          "pkVal1": "BILLING",
          "pkFld1": "BATCH_CD"
        }
      ]
    }
  }

Configure Alerts in Datadog

• In Datadog, create a monitor on the CCS job failure logs.
• Define alert conditions (e.g., “if error count > 0 in last 5 minutes”).
• Set up notification channels such as Slack, PagerDuty, or email for business/tech support teams.

Action by Support Team

• Support team receives alerts in real-time.
• They analyze failure details in Datadog dashboards and take immediate corrective actions in CCS.

---

✅ Outcome:

• Proactive monitoring of CCS batch jobs.
• Reduced downtime by instantly notifying stakeholders.
• Enhanced collaboration between business and IT teams via Datadog’s unified monitoring platform.

OIC - Solving Cold Start Latency in OCI Functions (AES Encryption/Decryption via OIC)

Use Case

In an integration scenario, we have an OCI Function that performs AES encryption and decryption.
This function is invoked from Oracle Integration Cloud (OIC) as part of secure data exchange.

However, we observed a performance bottleneck:

• When the function is invoked after being idle for a long time, the first request takes significantly longer to respond.
• Subsequent requests perform normally.
• This is the classic cold start issue with serverless functions.

For business-critical integrations where response time is crucial (e.g., encrypting/decrypting sensitive payloads on-the-fly), this latency is unacceptable.

Solution: Provisioned Concurrency in OCI Functions

To eliminate cold starts and improve response consistency, we configure Provisioned Concurrency for the function.
Provisioned concurrency ensures that a set number of function instances are kept warm and ready, drastically reducing the cold start delay.

---

Step-by-Step Solution

1. Identify the Function

   • Go to OCI Console → Developer Services → Functions → Applications
   • Select the function used for AES encrypt/decrypt.

2. Check Current Behavior

   • Invoke the function from OIC after idle time.
   • Observe latency in the first response.

3. Enable Provisioned Concurrency

   • Navigate to the function details page.
   • Select Concurrency → Provisioned Concurrency.
   • Set the number of provisioned instances (e.g., 1 or 2, depending on expected workload).

4. Save and Deploy

   • Apply the configuration.
   • OCI will now keep those function instances warm.

5. Validate from OIC

   • Re-test the function invocation from OIC.
   • First call latency should now be drastically reduced.

6. Optimize Costs

   • Start with minimal provisioned concurrency (e.g., 1)
   • Monitor usage and increase only if high parallelism is required.

---

Key Benefits

✅ No cold start delays – consistent response time for AES operations
✅ Improved user experience – faster integration performance
✅ Scalable – adjust provisioned concurrency as per demand
✅ Secure – AES encryption/decryption handled in isolated OCI Function environment

---

👉 This setup ensures reliable, low-latency cryptographic operations for sensitive data processing in OIC integrations.

---

Reference:

https://docs.oracle.com/en-us/iaas/Content/Functions/Tasks/functionsusingprovisionedconcurrency.htm

OIC - OIC Utility to Reprocess Failed Real-Time Integration JSON Payloads

📌 Use Case

In real-time OIC integrations, JSON payloads are exchanged with external systems via REST APIs. When such integrations fail (due to downstream errors, connectivity issues, or invalid data), the input payload is saved into an OIC SFTP error folder for recovery.

Manually retrieving, reviewing, and resubmitting these payloads is time-consuming and error-prone.

To simplify recovery, we build an OIC Utility Service that:

• Takes Interface ID and Payload File Name as inputs
• Fetches error folder path and target REST endpoint (relative path) from a Lookup
• Reads the failed payload file from the error folder
• Encodes and decodes the payload as Base64
• Calls the dynamic downstream REST service
• Resubmits the payload as binary JSON for seamless reprocessing

This ensures that failed real-time integrations can be reprocessed quickly and reliably, without manual intervention.

---

🛠️ Solution Steps

1. Create a Lookup for Metadata

Define a Lookup in OIC with mappings for each interface:

• Interface ID → Error Folder Path → Relative REST Endpoint Path
  Example:

HCM_IFC    | /u01/error/hcm/json    | /hcm/v1/worker
Payroll_IFC| /u01/error/payroll/json| /payroll/v2/run

---

2. Design the Utility App-Driven Orchestration

Trigger the utility with a REST endpoint that accepts:

• Interface ID
• Payload File Name

---

3. Fetch Error Path and REST Endpoint from Lookup

• Use Lookup functions to dynamically retrieve:
  • Error folder path
  • Relative endpoint URI

---

4. List Files in Error Folder

• Use File Server (SFTP) action to list and fetch the payload file based on the provided name.
• Capture the fileReference from the file action (pointer to the file inside OIC).

---

5. Read and Encode Payload

• Use Read File (File Server Action) → Get the file content using fileReference.
• Encode the payload into Base64, then decode back to binary JSON inside OIC.

---

6. Call Dynamic REST Service

• Use HTTP Adapter with dynamic configuration:
  • Base URL → from OIC Connection
  • Relative Path → from Lookup
• Pass the decoded JSON payload as the request body.

---

7. Handle Logging & Tracking

• Log success/failure at each step (File found, Payload resubmitted, REST service status).
• Update monitoring dashboard or custom tables for auditing.

---

✅ Benefits

• Automated reprocessing of failed JSON payloads
• Dynamic & reusable across multiple interfaces via Lookup
• Reduces manual errors in resubmission
• Improves system reliability & recovery time for real-time integrations