> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreflux.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Oracle E-Business Suite (Integrated SOA Gateway)

> Client-mode REST API connectors for Oracle E-Business Suite 12.2 through Integrated SOA Gateway: inventory material transactions, WIP job requests and work orders, quality results import, concurrent programs, and any other deployed ISG REST service

Technical Preview

## Overview

[Oracle E-Business Suite](https://www.oracle.com/applications/ebusiness/) (EBS) runs inventory, manufacturing (Work in Process) and quality for many plants. Release 12.2 exposes its interfaces as REST services through **Integrated SOA Gateway (ISG)**. Connecting it to the broker lets the shop floor post material transactions as they happen, create or update discrete jobs from a line controller, read work orders, record inspection results against a collection plan, and check which interface rows failed and why.

ISG has no fixed public API. Your integration administrator picks an interface in the **Integration Repository**, gives it a **service alias**, chooses the HTTP methods and deploys it. Each deployed service gets a URL `https://<host>:<port>/webservices/rest/<alias>/<resource>/` and its own WADL. This template covers the interfaces plants use most and leaves the alias as a payload field.

The template has one client-mode connector, `OracleEbsIsg`, with 17 events under `erp/oracle-ebs/`. Each event publishes the reply on `<topic>/response`. Seven events write (POST or PUT).

| Event | Topic | Method | Use |
| - | - | - | - |
| `Login` | `erp/oracle-ebs/auth/login` | GET | Log in with HTTP Basic; returns `accessTokenName` and `accessToken` (fields: `basic`) |
| `InitializeSession` | `erp/oracle-ebs/auth/initialize` | POST | Optional: set responsibility, security group and organization for the session (XML body) (fields: `body`, `cookie`) |
| `Logout` | `erp/oracle-ebs/auth/logout` | GET | End the EBS session behind the cookie (fields: `cookie`) |
| `GetServiceWadl` | `erp/oracle-ebs/service/wadl/get` | GET | WADL of a deployed service: resources, methods and XSD links (fields: `alias`, `cookie`) |
| `GetRestInterface` | `erp/oracle-ebs/service/interface/get` | GET | REST Service Locator: details of a deployed interface by internal name (fields: `alias`, `cookie`, `irepclass`) |
| `InventoryTransactionsCreate` | `erp/oracle-ebs/inventory/transactions/create` | POST | **Write.** Insert material transactions into `MTL_TRANSACTIONS_INTERFACE` (fields: `alias`, `body`, `cookie`) |
| `InventoryTransactionsGet` | `erp/oracle-ebs/inventory/transactions/get` | GET | Read material transaction interface rows, for example failed rows with their errors (fields: `alias`, `cookie`, `query`) |
| `InventoryTransactionsUpdate` | `erp/oracle-ebs/inventory/transactions/update` | PUT | **Write.** Update interface rows that match a filter, for example to resubmit fixed rows (fields: `alias`, `body`, `cookie`) |
| `InventoryTransactionLotsCreate` | `erp/oracle-ebs/inventory/transaction-lots/create` | POST | **Write.** Insert lot rows into `MTL_TRANSACTION_LOTS_INTERFACE` (fields: `alias`, `body`, `cookie`) |
| `WipJobRequestsCreate` | `erp/oracle-ebs/wip/job-requests/create` | POST | **Write.** Request new or updated discrete jobs in `WIP_JOB_SCHEDULE_INTERFACE` (fields: `alias`, `body`, `cookie`) |
| `WipJobRequestsGet` | `erp/oracle-ebs/wip/job-requests/get` | GET | Read job request load status (`PROCESS_PHASE`, `PROCESS_STATUS`) (fields: `alias`, `cookie`, `query`) |
| `WipWorkOrdersGet` | `erp/oracle-ebs/wip/work-orders/get` | GET | Read work orders through the open interface view your administrator deployed (fields: `alias`, `cookie`, `query`, `view`) |
| `QualityResultsCreate` | `erp/oracle-ebs/quality/results/create` | POST | **Write.** Insert quality results for a collection plan into `QA_RESULTS_INTERFACE` (fields: `alias`, `body`, `cookie`) |
| `QualityResultsGet` | `erp/oracle-ebs/quality/results/get` | GET | Read quality import rows and their `PROCESS_STATUS` (fields: `alias`, `cookie`, `query`) |
| `ConcurrentProgramSubmit` | `erp/oracle-ebs/concurrent-program/submit` | POST | **Write.** Run an interface's concurrent program (`SUBMIT_CP_` + program internal name) (fields: `alias`, `body`, `cookie`, `method`) |
| `ServicePost` | `erp/oracle-ebs/service/post` | POST | **Write (may write).** POST to any deployed method, for example a PL/SQL public API (fields: `alias`, `body`, `cookie`, `method`) |
| `ServiceGet` | `erp/oracle-ebs/service/get` | GET | GET any deployed method that supports GET (fields: `alias`, `cookie`, `method`, `params`) |

## Prerequisites

* Oracle E-Business Suite 12.2 with the ISG REST service infrastructure configured (on 12.2 this includes the `$FND_TOP/patch/115/bin/ISGRestSetup.pl` setup script), reachable over HTTPS from the broker.
* The interfaces you need deployed as REST services from the Integration Repository (Integrated SOA Gateway responsibility, Integration Repository, REST Web Service tab):
  * Open interfaces (inbound tables support GET, POST, PUT and DELETE): the Material Transactions Interface (`MTL_TRANSACTIONS_INTERFACE`, lots in `MTL_TRANSACTION_LOTS_INTERFACE`), the WIP Job Schedule Interface (`WIP_JOB_SCHEDULE_INTERFACE`) and the Quality Results Interface (`QA_RESULTS_INTERFACE`). Each table appears as a resource; the interface's concurrent program appears as `SUBMIT_CP_<program internal name>` (POST only).
  * An open interface view (GET only) for reading work orders, if your administrator has one deployed.
  * Optionally the REST Service Locator Java Bean Service (`oracle.apps.fnd.rep.ws.service.EbsRestLocator`) to look up deployed services.
* Both **HTTP Basic** and **Token Based** authentication selected as REST security on those services, and a security grant on each method for the EBS user the broker logs in as.
* Profile option **FND: Authn Service Token Scope** set to **Header and Body** so the login response carries the token in the body (Oracle Doc ID 2938671.1).
* The alias of each deployed service. Open its WADL (`/webservices/rest/<alias>/?WADL`) to see the exact resource names and payload element names.

## Connection and security

Store the login as a broker secret and pass it with `GET SECRET`:

| Secret | Value |
| - | - |
| `EBS_BASIC_AUTH` | `Basic ` + base64 of `user:password` for the EBS user |

1. Publish `{"basic":"Basic ..."}` to `erp/oracle-ebs/auth/login`. ISG answers on `erp/oracle-ebs/auth/login/response` with `data.accessTokenName`, `data.accessToken` (the EBS session ID, also sent as `Set-Cookie`), `data.ebsVersion` and `data.userName`.
2. Pass `"cookie":"<accessTokenName>=<accessToken>"` on every other event. ISG checks the session instead of the password.
3. Optionally publish to `erp/oracle-ebs/auth/initialize` once per session to set the responsibility, security group and organization. Without it, send the context in each request (see Payload).
4. Publish to `erp/oracle-ebs/auth/logout` to end the session. The reply has `accessToken` `-1`.

If token-based security is not enabled on a service, replace the `Cookie` header on its event with `ADD "Authorization" "{value.json.basic}"` and send the Basic value instead.

## Payload

Every service event takes `cookie` and `alias`. Values go into the URL as they are, so URL-encode them first.

* **Application context.** Many EBS APIs need a responsibility and an organization. In POST and PUT bodies put a `RESTHeader` object (`Responsibility`, `RespApplication`, `SecurityGroup`, `NLSLanguage`, `Org_Id`). On GET use the query parameters `ctx_responsibility`, `ctx_respapplication`, `ctx_securitygroup`, `ctx_nlslanguage` and `ctx_orgid`. With token-based security, context sent once is reused by later calls on the same token.
* **`query`** (GET on open interface tables and views): `select=COL1,COL2`, `filter=COL==value;COL2=le=100` (`;` is AND; operators include `==`, `=le=`, `=gt=`), `sort`, and `offset` / `limit` for paging. Pass `""` for no query.
* **`body`** (POST / PUT): a JSON string. For an open interface table the root element is `<TABLE>_Input` with `RESTHeader` and `InputParameters`, and each row is a `<TABLE>_REC` object. PUT updates rows that match a `Filter` inside an `Update` object. For PL/SQL services the root is `<METHOD>_Input`. Take the element names from the service's WADL and XSD.
* **`method`**, **`view`**, **`irepclass`**, **`params`**: the resource segment of the URL where the event leaves it open, for example `SUBMIT_CP_<program>` on `ConcurrentProgramSubmit`, the deployed view name on `WipWorkOrdersGet`, `PLSQL:FND_PROFILE` on `GetRestInterface`.

Material transaction (a row the Inventory Transaction Manager picks up when `PROCESS_FLAG` is 1, `LOCK_FLAG` is 2 and `TRANSACTION_MODE` is 3):

```json theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"cookie":"<accessTokenName>=<accessToken>","alias":"<inventory alias>","body":"{\"MTL_TRANSACTIONS_INTERFACE_Input\":{\"RESTHeader\":{\"Responsibility\":\"<responsibility key>\",\"RespApplication\":\"INV\",\"SecurityGroup\":\"STANDARD\",\"NLSLanguage\":\"AMERICAN\",\"Org_Id\":\"<org id>\"},\"InputParameters\":{\"MTL_TRANSACTIONS_INTERFACE_REC\":{\"SOURCE_CODE\":\"COREFLUX\",\"SOURCE_LINE_ID\":\"1\",\"SOURCE_HEADER_ID\":\"1\",\"PROCESS_FLAG\":\"1\",\"LOCK_FLAG\":\"2\",\"TRANSACTION_MODE\":\"3\",\"ORGANIZATION_ID\":\"<org id>\",\"ITEM_SEGMENT1\":\"<item>\",\"TRANSACTION_QUANTITY\":\"-1\",\"TRANSACTION_UOM\":\"<uom>\",\"TRANSACTION_DATE\":\"2026-10-05\",\"SUBINVENTORY_CODE\":\"<subinventory>\",\"TRANSACTION_TYPE_ID\":\"<transaction type id>\"}}}}"}
```

Failed inventory rows:

```json theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
{"cookie":"<accessTokenName>=<accessToken>","alias":"<inventory alias>","query":"filter=PROCESS_FLAG==3&select=TRANSACTION_INTERFACE_ID,SOURCE_CODE,ERROR_CODE,ERROR_EXPLANATION&limit=50"}
```

Job requests use `WIP_JOB_SCHEDULE_INTERFACE` columns such as `GROUP_ID`, `LOAD_TYPE`, `ORGANIZATION_CODE`, `JOB_NAME`, `START_QUANTITY`, `STATUS_TYPE`, `FIRST_UNIT_START_DATE` and `LAST_UNIT_COMPLETION_DATE`; WIP Mass Load reports `PROCESS_PHASE` and `PROCESS_STATUS`. Quality rows use `QA_RESULTS_INTERFACE` columns such as `ORGANIZATION_CODE`, `PLAN_NAME`, `INSERT_TYPE` (1 insert, 2 update with `MATCHING_ELEMENTS`), `PROCESS_STATUS`, `SOURCE_CODE` and the plan's `CHARACTERx` columns.

## Pacing and errors

* Faults come back as `ISGServiceFault` with `Code`, `Message`, `Resolution` and `ServiceDetails`. Open interface writes return `OutputParameters.Summary` (`SuccessCount`, `ErrorCount`) and a `Status` and `Message` for each row.
* Interface rows are only staged. The Inventory Transaction Manager, WIP Mass Load and Collection Import move them to base tables later, so read the interface back (`PROCESS_FLAG`, `PROCESS_STATUS`, `ERROR_EXPLANATION`) before you treat a transaction as posted.
* Open interface GETs page with `offset` and `limit` (the documented sample response reports `Limit` 200). Keep `limit` small and poll on a coarse schedule.
* Long ISG calls can hit web tier timeouts. The template uses a 120-second request timeout.

## Example actions

These log in every 20 minutes, keep the session cookie on a topic, and read failed inventory interface rows every hour.

```lot theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
# Example actions for the Oracle E-Business Suite routes (docs page). Not part of the route template.
# Secret: EBS_BASIC_AUTH = "Basic <base64 of user:password>" for an EBS user with grants on the deployed REST methods.
#   The login response carries data.accessTokenName and data.accessToken; the cookie is "<accessTokenName>=<accessToken>".
#   Inline JSON object literals are not supported when publishing to a topic, so requests use COLLAPSED models sent
#   with PUBLISH MODEL. "invtxn" is an example alias: use the alias your administrator gave the inventory interface.

DEFINE MODEL EbsLoginRequest COLLAPSED
    ADD STRING "basic"

DEFINE MODEL EbsQueryRequest COLLAPSED
    ADD STRING "cookie"
    ADD STRING "alias"
    ADD STRING "query"

DEFINE ACTION EbsLoginEvery20Minutes
ON EVERY 20 MINUTES DO
    PUBLISH MODEL EbsLoginRequest TO "erp/oracle-ebs/auth/login" WITH
        basic = (GET SECRET "EBS_BASIC_AUTH")

DEFINE ACTION EbsKeepCookie
ON TOPIC "erp/oracle-ebs/auth/login/response" DO
    SET "name" WITH GET JSON "data.accessTokenName" IN PAYLOAD AS STRING
    SET "token" WITH GET JSON "data.accessToken" IN PAYLOAD AS STRING
    KEEP TOPIC "erp/oracle-ebs/state/cookie" WITH {name} + "=" + {token}

DEFINE ACTION EbsFailedInventoryTransactionsEveryHour
ON EVERY 1 HOUR DO
    SET "cookie" WITH GET TOPIC "erp/oracle-ebs/state/cookie" AS STRING
    PUBLISH MODEL EbsQueryRequest TO "erp/oracle-ebs/inventory/transactions/get" WITH
        cookie = {cookie}
        alias = "invtxn"
        query = "filter=PROCESS_FLAG==3&select=TRANSACTION_INTERFACE_ID,SOURCE_CODE,ERROR_CODE,ERROR_EXPLANATION&limit=50"
```

## Connector template

```lot theme={"theme":"css-variables","languages":{"custom":["/languages/lot.json"]}}
# Coreflux REST_API template — Oracle E-Business Suite 12.2 (Integrated SOA Gateway REST services) for plants:
#   post inventory material transactions (+ lots) through the Material Transactions Interface, create / update
#   discrete jobs through the WIP Job Schedule (Work Order) Interface, read work orders through a deployed Interface
#   View, import quality results through the Quality Results (Collection Import) Interface, read back interface rows
#   and their errors, submit the associated concurrent programs, and call any other deployed ISG REST service.
# Hugo catalog #7, Tier 3 (erp). Sources fetched 2026-10-05: Oracle E-Business Suite Integrated SOA Gateway Developer's
#   Guide 12.2 (E20927: REST messages, WADL, PL/SQL / Java Bean / Open Interface REST services), Implementation Guide
#   (E20925: REST security, deploying REST services), User's Guide (E20923: Integration Repository), Mobile Apps
#   Developer's Guide (E69284: login / initialize / logout services), Oracle eTRM 12.2 table definitions (via etrm.live).
#   Cached in openapi-cache/oracle-e-business-suite/. There is no public OpenAPI: every REST service is deployed per
#   interface from the Integration Repository by your integration administrator and described by its own WADL, so
#   events are hand-curated from the documented URL patterns.
# Docs: https://docs.coreflux.org/latest/lot-language/routes/rest-api-apps/oracle-e-business-suite
#
# One route, topic prefix erp/oracle-ebs/:
#   OracleEbsIsg  https://ebs.example.com  (your EBS web entry point, add :port; all paths start /webservices/rest/)
# URLs: /webservices/rest/<service alias>/<resource>/ . The alias is chosen when the interface is deployed (REST Web
#   Service tab, Integration Repository); the resource is the method name for PL/SQL / Java services, the table or
#   view name for open interfaces, and SUBMIT_CP_<concurrent program internal name> for the interface's program.
#   Pass the alias in every payload ("alias"). The WADL for a deployed service is /webservices/rest/<alias>/?WADL.
# Auth: HTTP Basic or token-based (both must be selected as REST security when the service is deployed).
#   GET /webservices/rest/login with "Authorization: Basic base64(user:password)" returns accessTokenName +
#   accessToken (EBS session id, also in Set-Cookie). Send "Cookie: <accessTokenName>=<accessToken>" on later
#   calls (payload field "cookie"); /webservices/rest/logout ends the session. Keep the Basic value in broker secret
#   EBS_BASIC_AUTH and pass it with GET SECRET. EBS 12.2 needs profile "FND: Authn Service Token Scope" = Header and
#   Body for the token in the login body (Oracle Doc ID 2938671.1). The user needs a grant on each deployed method.
# App context: pass Responsibility / RespApplication / SecurityGroup / NLSLanguage / Org_Id in "RESTHeader" in POST /
#   PUT bodies, as ctx_responsibility / ctx_respapplication / ctx_securitygroup / ctx_nlslanguage / ctx_orgid query
#   parameters on GET, or once per session with POST /webservices/rest/initialize.
# Open interface GET query: select=COL1,COL2&filter=COL==value;COL2=le=100&sort=...&offset=0&limit=200 (URL-encoded).
# Errors: JSON / XML ISGServiceFault {Code, Message, Resolution, ServiceDetails}; per-row Status / Message in
#   OutputParameters.Result.Output for open interface writes.
# Writes (# WRITE): rows inserted / updated in interface tables are only staged until the interface program
#   (Inventory Transaction Manager, WIP Mass Load, Collection Import Manager) moves them to base tables.
# Not packaged: DELETE on interface tables, SOAP services, business events, XML Gateway, Oracle Integration EBS adapter.
#
# Payload fields (JSON on the source topic): cookie on every event except Login; alias on every service event;
#   query (URL-encoded GET query, or "" for none); body (JSON string) on POST / PUT; method / view / irepclass /
#   params where the endpoint names them.
#     Login                        {"basic":"Basic <base64 user:password>"}
#     InventoryTransactionsCreate  {"cookie":"demo=...","alias":"invtxn","body":"{\"MTL_TRANSACTIONS_INTERFACE_Input\":{...}}"}
#     InventoryTransactionsGet     {"cookie":"demo=...","alias":"invtxn","query":"filter=PROCESS_FLAG==3&select=TRANSACTION_INTERFACE_ID,ERROR_CODE,ERROR_EXPLANATION&limit=50"}
#     WipWorkOrdersGet             {"cookie":"demo=...","alias":"wipjobs","view":"<deployed interface view>","query":"filter=ORGANIZATION_ID==207&limit=50"}
#     ConcurrentProgramSubmit      {"cookie":"demo=...","alias":"wipjobs","method":"SUBMIT_CP_<program>","body":"{...}"}

DEFINE ROUTE OracleEbsIsg WITH TYPE REST_API
    ADD REST_API_CONFIG
        WITH BASE_ADDRESS "https://ebs.example.com"
        WITH ENABLE_CLIENT "true"
        WITH USE_SSL "true"
        WITH REQUEST_TIMEOUT '120'
        WITH DEFAULT_CONTENT_TYPE "application/json"
        # Replace with your EBS web entry point (https://<host>:<port>). Long ISG calls may need a higher timeout.
    # AOL security Login service: HTTP Basic login. Returns data.accessTokenName + data.accessToken (EBS session id, also in Set-Cookie). Build cookie = accessTokenName=accessToken.
    ADD EVENT Login
        WITH SOURCE_TOPIC "erp/oracle-ebs/auth/login"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/auth/login/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/login"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Authorization" "{value.json.basic}"
    # AOL security Initialize service: Optional. Sets responsibility / security group / org context for the session. body (XML): <data><resp><key>..</key><applKey>..</applKey></resp><securityGroup><key>STANDARD</key></securityGroup><org><id>..</id></org></data>
    ADD EVENT InitializeSession
        WITH SOURCE_TOPIC "erp/oracle-ebs/auth/initialize"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/auth/initialize/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/initialize"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/xml"
        WITH BODY "{value.json.body}"
    # AOL security Logout service: Invalidates the EBS session behind the cookie (response accessToken -1).
    ADD EVENT Logout
        WITH SOURCE_TOPIC "erp/oracle-ebs/auth/logout"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/auth/logout/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/logout"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Deployed REST service: WADL of a deployed service (resources, methods, XSD links). Use it to check paths and payload element names.
    ADD EVENT GetServiceWadl
        WITH SOURCE_TOPIC "erp/oracle-ebs/service/wadl/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/service/wadl/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/?WADL"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # REST Service Locator (Java Bean Service oracle.apps.fnd.rep.ws.service.EbsRestLocator): Details of a deployed REST interface by internal name, for example PLSQL:FND_PROFILE. Needs the locator deployed (doc alias servicelocator).
    ADD EVENT GetRestInterface
        WITH SOURCE_TOPIC "erp/oracle-ebs/service/interface/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/service/interface/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/getRestInterface/{value.json.irepclass}/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Open interface: Material Transactions Interface (MTL_TRANSACTIONS_INTERFACE): WRITE: insert material transactions (issues, receipts, transfers, WIP completions). Rows with PROCESS_FLAG 1, LOCK_FLAG 2, TRANSACTION_MODE 3 are picked up by the Inventory Transaction Manager.
    ADD EVENT InventoryTransactionsCreate
        WITH SOURCE_TOPIC "erp/oracle-ebs/inventory/transactions/create"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/inventory/transactions/create/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/MTL_TRANSACTIONS_INTERFACE/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Open interface: Material Transactions Interface (MTL_TRANSACTIONS_INTERFACE): Read interface rows not yet processed or failed (PROCESS_FLAG 3 + ERROR_CODE / ERROR_EXPLANATION). query: select / filter / sort / offset / limit.
    ADD EVENT InventoryTransactionsGet
        WITH SOURCE_TOPIC "erp/oracle-ebs/inventory/transactions/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/inventory/transactions/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/MTL_TRANSACTIONS_INTERFACE/?{value.json.query}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Open interface: Material Transactions Interface (MTL_TRANSACTIONS_INTERFACE): WRITE: update interface rows by Filter, for example reset failed rows to PROCESS_FLAG 1 / LOCK_FLAG 2 after fixing data.
    ADD EVENT InventoryTransactionsUpdate
        WITH SOURCE_TOPIC "erp/oracle-ebs/inventory/transactions/update"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/inventory/transactions/update/response"
        WITH METHOD "PUT"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/MTL_TRANSACTIONS_INTERFACE/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Open interface: Material Transactions Interface lots (MTL_TRANSACTION_LOTS_INTERFACE): WRITE: lot rows for lot-controlled items, linked by TRANSACTION_INTERFACE_ID. Only if the table is a method of your deployed inventory interface.
    ADD EVENT InventoryTransactionLotsCreate
        WITH SOURCE_TOPIC "erp/oracle-ebs/inventory/transaction-lots/create"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/inventory/transaction-lots/create/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/MTL_TRANSACTION_LOTS_INTERFACE/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Open interface: WIP Job Schedule (Work Order) Interface (WIP_JOB_SCHEDULE_INTERFACE): WRITE: requests to create or update discrete jobs / repetitive schedules (LOAD_TYPE, GROUP_ID, JOB_NAME, START_QUANTITY, dates). WIP Mass Load processes them.
    ADD EVENT WipJobRequestsCreate
        WITH SOURCE_TOPIC "erp/oracle-ebs/wip/job-requests/create"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/wip/job-requests/create/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/WIP_JOB_SCHEDULE_INTERFACE/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Open interface: WIP Job Schedule (Work Order) Interface (WIP_JOB_SCHEDULE_INTERFACE): Read load status of job requests (PROCESS_PHASE, PROCESS_STATUS, WIP_ENTITY_ID) by GROUP_ID / JOB_NAME.
    ADD EVENT WipJobRequestsGet
        WITH SOURCE_TOPIC "erp/oracle-ebs/wip/job-requests/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/wip/job-requests/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/WIP_JOB_SCHEDULE_INTERFACE/?{value.json.query}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Open interface view (GET only): Read work orders through the Interface View your administrator deployed (view = the view name shown as the resource in its WADL). query: select / filter / sort / offset / limit.
    ADD EVENT WipWorkOrdersGet
        WITH SOURCE_TOPIC "erp/oracle-ebs/wip/work-orders/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/wip/work-orders/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/{value.json.view}/?{value.json.query}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Open interface: Quality Results Interface (QA_RESULTS_INTERFACE, collection import): WRITE: quality results for a collection plan (ORGANIZATION_CODE, PLAN_NAME, INSERT_TYPE 1 insert / 2 update + MATCHING_ELEMENTS, CHARACTERx values). Collection Import moves them to QA_RESULTS.
    ADD EVENT QualityResultsCreate
        WITH SOURCE_TOPIC "erp/oracle-ebs/quality/results/create"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/quality/results/create/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/QA_RESULTS_INTERFACE/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Open interface: Quality Results Interface (QA_RESULTS_INTERFACE, collection import): Read import status of quality rows (PROCESS_STATUS, GROUP_ID) by PLAN_NAME / SOURCE_CODE.
    ADD EVENT QualityResultsGet
        WITH SOURCE_TOPIC "erp/oracle-ebs/quality/results/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/quality/results/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/QA_RESULTS_INTERFACE/?{value.json.query}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
    # Open interface / concurrent program REST service: WRITE: run the interface's concurrent program (method SUBMIT_CP_<program internal name>, POST only), for example the import program of a deployed open interface.
    ADD EVENT ConcurrentProgramSubmit
        WITH SOURCE_TOPIC "erp/oracle-ebs/concurrent-program/submit"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/concurrent-program/submit/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/{value.json.method}/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Any deployed PL/SQL, Java Bean, Application Module or Business Service Object REST service: WRITE (may write): POST {<METHOD>_Input:{RESTHeader:{...},InputParameters:{...}}} to a deployed method, for example a PL/SQL public API.
    ADD EVENT ServicePost
        WITH SOURCE_TOPIC "erp/oracle-ebs/service/post"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/service/post/response"
        WITH METHOD "POST"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/{value.json.method}/"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
            ADD "Content-Type" "application/json"
        WITH BODY "{value.json.body}"
    # Any deployed REST service with a GET method: GET a deployed method. params: path variables + query, for example PLSQL:FND_PROFILE/ or ?ctx_orgid=204&offset=0&limit=5.
    ADD EVENT ServiceGet
        WITH SOURCE_TOPIC "erp/oracle-ebs/service/get"
        WITH DESTINATION_TOPIC "erp/oracle-ebs/service/get/response"
        WITH METHOD "GET"
        WITH ENDPOINT "/webservices/rest/{value.json.alias}/{value.json.method}/{value.json.params}"
        WITH HEADERS
            ADD "Accept" "application/json"
            ADD "User-Agent" "Coreflux-Broker REST_API route (https://www.coreflux.org)"
            ADD "Cookie" "{value.json.cookie}"
```

## Not packaged

* DELETE on interface tables, SOAP services, business events, XML Gateway messages and the Oracle Integration (OIC) E-Business Suite adapter.
* Fixed paths for PL/SQL public APIs: deploy the API you need and call it with `ServicePost` / `ServiceGet`.

## Testing

Static checks 110/110, a local mock ISG server 17/17 (login, cookie built from `accessTokenName` and `accessToken`, then every event with its method, path, cookie and body), mock controls 5/5 (wrong Basic, stale cookie, logout token `-1`, missing payload field, non-JSON body) and live checks of the six Oracle documentation pages the template is built from 6/6 passed. E-Business Suite is hosted by each customer and Oracle offers no public instance, so no call against a real ISG endpoint has run. See `TEST.md` in the package.

## Suggested branches

* `feat/rest-api-route-oracle-e-business-suite` (broker template)
* `feat/docs-rest-api-oracle-e-business-suite` (this page)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.