Monday, November 2, 2026

OIC - Common Service - Streamlining OIC Schedule Management Through REST API Automation

 Working...

Introduction

In Oracle Integration Cloud (OIC), managing scheduled integrations involves operations such as Stop, Start, Pause, Resume, Add Schedule, and Update Schedule. Performing these operations manually across multiple integrations can be time-consuming.

To simplify this process, we can develop an automated Scheduling Management Service using OIC Factory REST APIs. The solution follows a lookup-driven approach to identify the integrations, execute the required scheduling operations, and generate a consolidated execution report.

Solution Approach

1. Lookup Configuration

Maintain all required details in an OIC lookup, including:

  • Project name
  • Integration identifier
  • Schedule name
  • Operation type (Stop/Start/Pause/Resume/Add/Update)
  • Required schedule configuration for Add or Update operations.

2. Main Integration – Scheduling Service

  • Fetch all configuration records from the lookup.
  • Read the project, integration, schedule, and operation details.
  • Pass the required configuration details to the Child Integration.
  • Invoke the Child Integration to process the scheduling operations.

3. Child Integration – Schedule Operations

  • Receive configuration details from the Main Integration.
  • For each record, call the OIC Factory API to retrieve the existing schedule details.
  • Append the retrieved schedule information to a file for processing.
  • Iterate through each schedule entry.
  • Use a Switch action to identify the requested operation.
  • Based on the operation type, invoke the corresponding OIC Factory REST API.

Supported Operations:

  • Stop: Stop an active schedule.
  • Start: Start a stopped schedule.
  • Pause: Temporarily pause schedule execution.
  • Resume: Resume a paused schedule.
  • Add Schedule: Create a new schedule.
  • Update Schedule: Modify an existing schedule.
Stop Schedule:





Resume Schedule:



Pause Schedule:



Start Schedule:


4. Consolidated Execution Report

After processing all records:

  • Capture the API response for each operation.
  • Maintain success and failure status for every record.
  • Capture error details wherever an operation fails.
  • Generate a consolidated execution report.
  • Send the report through email to the configured recipients.

Benefits

  • Automates bulk scheduling operations across multiple OIC integrations.
  • Eliminates repetitive manual schedule management.
  • Lookup-driven configuration makes the solution reusable and easy to maintain.
  • Supports multiple scheduling operations through a single service.
  • Provides centralized execution tracking and failure details.
  • Improves operational efficiency and reduces manual errors.

Conclusion

By leveraging OIC Factory REST APIs and lookup-driven configurations, we can build a reusable Scheduling Management Service that automates multiple scheduling operations from a single integration. This approach simplifies OIC operational management and provides a consolidated view of all scheduling activities through email reporting.


Friday, October 30, 2026

OIC - Automated OIC Project Export and Backup Using Factory APIs

1. Introduction

To simplify OIC project backup, we developed a reusable integration solution using OIC Factory APIs to export projects as CAR files and save them to the OIC embedded SFTP server. The exported files can then be manually downloaded and uploaded to SharePoint or any other backup location.

2. Solution Overview

The solution consists of two integrations: Main and Child.

Lookup Configuration

An OIC lookup maintains the following project details:

  • Project Code
  • Project Type (Developed / XBA)
  • Version (for Accelerator projects)

3. Integration Flow

Main Integration:

  1. Fetch all project details from the configured lookup.
  2. Iterate through the lookup records.
  3. Pass project code, project type, and version one by one to the child integration.
  4. Invoke the child integration for each project.
Get Export lookup data:
GET /ic/api/integration/v1/projects/{projectId}/lookups/{name}


Trigger:


Run from Lookup for all projects:










Adhoc projects run:








Child Integration:

  1. Receive project details from the main integration.
  2. Prepare the export request based on the project type and version.
  3. Invoke the OIC Factory API to export the respective project.
  4. Retrieve the generated CAR file.
  5. Save the CAR file to the configured OIC SFTP directory.
  6. Return the export status to the main integration.
API used: https://<OIC-HOST>/ic/api/integration/v1/projects/{id}/archive?integrationInstance=<service-instance-name>

Request payload:
{
  "code": "TEST_PROJECT",
  "type": "DEVELOPED",
  "label": "01.00.0000"
}












4. Backup Process

Once all projects are exported successfully, the CAR files are available in the OIC SFTP directory. These files can be manually downloaded and uploaded to SharePoint, OCI Object Storage, or any other enterprise backup location.

Oracle Documentation:

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-projects-id-archive-post.html?utm_source=chatgpt.com

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-lookups-name-get.html?source=%3Aow%3Alp%3Acpo%3A%3A%3A%3ARC_CORP250721P00028%3ADMO400412486

5. Benefits

  • Automates project export using OIC Factory APIs.
  • Centralizes project configuration through lookups.
  • Supports multiple project types.
  • Reuses a common child integration for all projects.
  • Reduces manual effort in project backup.
  • Provides a centralized location for exported CAR files.

6. Conclusion

This solution provides a reusable and configurable approach to exporting multiple OIC projects and consolidating their CAR files in SFTP. It simplifies project backup activities and makes the exported archives available for storage in external backup locations.

Thursday, October 15, 2026

OIC Common Service to Submit CCS Batch Jobs and Monitor Job Status | Extract file from Oracle CCS to Object Storage

Objective

Create a reusable common service in Oracle Integration Cloud (OIC) to submit batch jobs to CCS, monitor their execution status, and retrieve the generated files from the Object Storage bucket.

Proposed Flow

Main Integration → Submit Job → Monitor Job Status → Process Output

1. Submit Batch Job

Invoke the CCS API to submit the batch job.

Capture the Job ID returned by CCS.







2. Check Job Status

Use the Job ID to periodically check the job status.

Continue polling until the job reaches a terminal status, such as Success or Failure.

Implement a timeout and retry mechanism.







3. Handle Successful Execution

Once the job succeeds, identify the output files generated by the batch job.

The files are stored in the configured OCI Object Storage bucket.

Retrieve the required file details or file contents for further processing.

4. Handle Failed Execution

Capture the failure status and available error details.


Log the error and notify the calling integration or trigger the required error-handling process.

Architecture Diagram

       Calling Integration

                |

                v

       OIC Common Service

                |

                v

       Submit Job to CCS

                |

                v

        Capture Job ID

                |

                v

       Check Job Status

                |

          +-----+-----+

          |           |

       Running      Terminal

          |           |

          |      +----+----+

          |      |         |

          |   Success    Failure

          |      |         |

          |      v         v

          |  OCI Object   Log Error

          |  Storage      / Notify

          |      |

          +------+

         Poll Again

         While Running

Key Design Considerations

  • Reusability: The common service should accept the required job parameters so multiple integrations can use it.
  • Polling: Configure an appropriate polling interval and maximum wait time.
  • Job tracking: Maintain the Job ID and execution status for monitoring and troubleshooting.
  • Object Storage: Ensure the generated files are available in the expected bucket and location.
  • Error handling: Handle submission failures, job failures, timeouts, and Object Storage access errors separately.

Expected Outcome

A centralized OIC common service that submits CCS batch jobs, monitors their execution, and handles the generated files in OCI Object Storage based on the final job status.

Featured Post

OIC - Common Service - Streamlining OIC Schedule Management Through REST API Automation

 Working... Introduction In Oracle Integration Cloud (OIC), managing scheduled integrations involves operations such as Stop, Start, Pause,...