# Business Logic — JKKKikiIchiranKkKaifukuCC.editInArrayMsg() [93 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKKikiIchiranKkKaifukuCC` |
| Layer | CC/Common Component (EJB module common utility) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKKikiIchiranKkKaifukuCC.editInArrayMsg()

This method is a **parameter assembly utility** that constructs a fully-populated request parameter map (`HashMap<String, Object>`) for invoking a Service Component (SC) via the `callSCArray` dispatcher. It serves as the central data-binding layer between incoming request metadata and the SC invocation payload.

The method performs three distinct assembly phases: (1) it extracts transaction-level contextual information — such as transaction ID, use case ID, operation ID, call type, client hostname, client IP address, screen ID, and operator ID — from the `IRequestParameterReadWrite` object and the control map, placing them into the `paramMap`; (2) it instantiates a `CAANMsg` template object using a message resource bundle keyed on the service interface name (`svcIf`), then populates it with operator and operation date/time control data; (3) it iterates over a `mappingData` two-dimensional array to bind individual field mappings (key-value pairs from `mappingData[i][0]` → `mappingData[i][1]`) onto the root `CAANMsg` template, setting values or nulls based on whether the mapped value is empty.

Additionally, for list-level message data, the method either retrieves an existing child message array from the template via `getCAANMsgList(inListMsgName)`, or creates a new one sized to `inList`. It then iterates over each element in `inList` (an `ArrayList<HashMap<String, Object>>`), creating or reusing a child `CAANMsg` template (keyed on a pattern like `%sCBSMsg1List`) and binding each child map's key-value pairs onto it. The assembled child array is then set back onto the root template under `inListMsgName`.

Finally, it wraps the root template in a `CAANMsg[]` array and stores it under `TEMPLATE_LIST_KEY` in the `paramMap`, which is then passed to `ServiceComponentRequestInvoker.run()` by the caller `callSCArray`.

**Design pattern:** This method implements a **parameter builder / data mapper pattern**, transforming request-scoped data and mapping configurations into a structured SC invocation payload. It acts as a **shared utility** within the common component layer, called exclusively by `callSCArray`, which serves as the SC invocation gateway for the KKKikiIchiran (equipment information listing) screen functionality.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START["editInArrayMsg param, mappingData, inListMsgName, inList"]
    CREATE1["Create paramMap = new HashMap"]
    PUT1["Put TRANZACTION_ID from param.getTelegramID"]
    PUT2["Put USECASE_ID from param.getUsecaseID"]
    PUT3["Put OPERATION_ID from param.getOperationID"]
    PUT4["Put CALL_TYPE from param.getCallType"]
    PUT5["Put CLIENT_HOST_NAME from param.getControlMapData REQ_HOSTNAME"]
    PUT6["Put CLIENT_IP_ADDRESS from param.getControlMapData REQ_HOSTIP"]
    PUT7["Put INVOKE_GAMEN_ID from param.getControlMapData REQ_VIEWID"]
    PUT8["Put OPERATOR_ID from param.getControlMapData OPERATOR_ID"]
    GET1["Get svcIf = mappingData[0][1]"]
    CREATE2["Create template = new CAANMsg eo.ejb.cbs.cbsmsg.%sCBSMsg"]
    TSET1["template.set OPERATOR_ID"]
    TSET2["template.set OPERATE_DATE"]
    TSET3["template.set OPERATE_DATETIME"]
    LOOP1["For i = 0 to mappingData.length"]
    COND1["mappingData[i][1] is empty"]
    SN1["template.setNull mappingData[i][0]"]
    SM1["template.set mappingData[i][0], mappingData[i][1]"]
    GET2["Get templateArray = template.getCAANMsgList inListMsgName"]
    COND2["templateArray == null"]
    CREATE3["Create templateArray = new CAANMsg[inList.size]"]
    LOOP2["For i = 0 to inList.size"]
    GET3["Get childMap = inList.get[i]"]
    GET4["Get childTemplate = templateArray[i]"]
    COND3["childTemplate == null"]
    CREATE4["Create childTemplate = new CAANMsg eo.ejb.cbs.cbsmsg.%sCBSMsg1List"]
    ITER1["Iterate childMap.keySet"]
    COND4["childMap.get key is empty"]
    SN2["childTemplate.setNull key"]
    SM2["childTemplate.set key, childMap.get key"]
    STORE1["templateArray[i] = childTemplate"]
    PSET["template.set inListMsgName, templateArray"]
    CREATE5["Create templates = new CAANMsg[1]"]
    SET1["templates[0] = template"]
    PUT9["Put TEMPLATE_LIST templates into paramMap"]
    RETURN1["Return paramMap"]
    ENDNODE["End"]

    START --> CREATE1
    CREATE1 --> PUT1
    PUT1 --> PUT2
    PUT2 --> PUT3
    PUT3 --> PUT4
    PUT4 --> PUT5
    PUT5 --> PUT6
    PUT6 --> PUT7
    PUT7 --> PUT8
    PUT8 --> GET1
    GET1 --> CREATE2
    CREATE2 --> TSET1
    TSET1 --> TSET2
    TSET2 --> TSET3
    TSET3 --> LOOP1
    LOOP1 --> COND1
    COND1 -->|true| SN1
    COND1 -->|false| SM1
    SN1 --> LOOP1
    SM1 --> LOOP1
    LOOP1 --> GET2
    GET2 --> COND2
    COND2 -->|true| CREATE3
    COND2 -->|false| LOOP2
    CREATE3 --> LOOP2
    LOOP2 --> GET3
    GET3 --> GET4
    GET4 --> COND3
    COND3 -->|true| CREATE4
    COND3 -->|false| ITER1
    CREATE4 --> ITER1
    ITER1 --> COND4
    COND4 -->|true| SN2
    COND4 -->|false| SM2
    SN2 --> ITER1
    SM2 --> ITER1
    ITER1 --> STORE1
    STORE1 --> LOOP2
    LOOP2 --> PSET
    PSET --> CREATE5
    CREATE5 --> SET1
    SET1 --> PUT9
    PUT9 --> RETURN1
    RETURN1 --> ENDNODE
```

**Phase 1 — Request Context Extraction:** The method begins by creating a new `HashMap<String, Object>` called `paramMap`. It populates this map with six transaction-level metadata fields extracted from the `param` object: `TRANZACTION_ID_KEY` (from `getTelegramID()`), `USECASE_ID_KEY` (from `getUsecaseID()`), `OPERATION_ID_KEY` (from `getOperationID()`), `CALL_TYPE_KEY` (from `getCallType()`). It then adds four control-map fields: `CLIENT_HOST_NAME_KEY` (from `getControlMapData(SCControlMapKeys.REQ_HOSTNAME)`), `CLIENT_IP_ADDRESS_KEY` (from `getControlMapData(SCControlMapKeys.REQ_HOSTIP)`), `INVOKE_GAMEN_ID_KEY` (from `getControlMapData(SCControlMapKeys.REQ_VIEWID)`), and `OPERATOR_ID_KEY` (from `getControlMapData(SCControlMapKeys.OPERATOR_ID)`).

**Phase 2 — Root Template Initialization:** The method reads `mappingData[0][1]` to extract the service interface name (`svcIf`), which is used to construct a `CAANMsg` template resource bundle key in the format `eo.ejb.cbs.cbsmsg.%sCBSMsg` where `%s` is replaced by `svcIf`. It then sets three control fields on the template: `OPERATOR_ID_KEY`, `OPERATE_DATE_KEY`, and `OPERATE_DATETIME_KEY`, all sourced from the control map.

**Phase 3 — Mapping Data Binding Loop:** The method iterates over `mappingData` array from index 0 to `mappingData.length`. For each row, it checks if `mappingData[i][1]` is an empty string (`""`). If true, it calls `template.setNull()` with the key from `mappingData[i][0]`, effectively clearing that field in the template. If false, it calls `template.set()` to bind the key-value pair onto the template.

**Phase 4 — Child Message Array Resolution:** The method calls `template.getCAANMsgList(inListMsgName)` to retrieve an existing child message array. If the result is `null`, it creates a new `CAANMsg[]` array sized to `inList.size()`.

**Phase 5 — Child Message Population Loop:** The method iterates over `inList` from index 0 to `inList.size()`. For each index, it retrieves the `HashMap` child map from the list and checks whether `templateArray[i]` already has a child template. If null, it creates a new `CAANMsg` with a resource bundle key of `eo.ejb.cbs.cbsmsg.%sCBSMsg1List` (appending `1List` to distinguish child messages). It then iterates over all keys in the child map, setting each as either a null or a string value on the child template, similar to the mapping data loop. The child template is stored back at `templateArray[i]`.

**Phase 6 — Final Assembly:** The child template array is set onto the root template under the `inListMsgName` key. A `CAANMsg[]` array of size 1 is created, the root template is placed at index 0, and this array is stored in `paramMap` under `TEMPLATE_LIST_KEY`. The populated `paramMap` is returned.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The incoming request parameter object containing transaction-level metadata (transaction ID, use case ID, operation ID, call type) and control map data (hostname, IP address, screen ID, operator ID, operation date/time). This carries the full request context for the current screen operation. |
| 2 | `mappingData` | `Object[][]` | A two-dimensional mapping array where each row represents a field binding: `mappingData[i][0]` is the target field name (key) in the SC message, and `mappingData[i][1]` is the value to bind. The first row's second element (`mappingData[0][1]`) additionally serves as the service interface name (`svcIf`) used to resolve the message resource bundle. Empty string values result in null bindings (field clearing). |
| 3 | `inListMsgName` | `String` | The message list key name that identifies the child message array within the SC template. It is used both to retrieve an existing child message array from the root template via `getCAANMsgList()` and to set the assembled child array back onto the root template via `template.set()`. In business terms, this identifies which list-level message section (e.g., order detail lines, service item rows) the child messages belong to. |
| 4 | `inList` | `ArrayList<HashMap<String, Object>>` | A list of child data maps, where each map represents one row of list-level data for the SC message. Each child map's key-value pairs are bound onto a corresponding child `CAANMsg` template. The size of this list determines the number of child message instances and the size of the child message array. |

**External state / constants referenced:**

| Source | Constant / Key | Business Meaning |
|--------|---------------|-----------------|
| `JCMConstants.TRANZACTION_ID_KEY` | Transaction ID key | Identifier for the current SC transaction session |
| `JCMConstants.USECASE_ID_KEY` | Use Case ID key | Identifier for the use case executing this operation |
| `JCMConstants.OPERATION_ID_KEY` | Operation ID key | Identifier for the specific operation being executed |
| `JCMConstants.CALL_TYPE_KEY` | Call Type key | Distinguishes the type of service call (e.g., read, write, batch) |
| `JCMConstants.CLIENT_HOST_NAME_KEY` | Client Host Name key | The hostname of the requesting client |
| `JCMConstants.CLIENT_IP_ADDRESS_KEY` | Client IP Address key | The IP address of the requesting client |
| `JCMConstants.INVOKE_GAMEN_ID_KEY` | Invoke Gamen ID key | The screen/page ID that initiated the request (gamen = 画面, screen) |
| `JCMConstants.OPERATOR_ID_KEY` | Operator ID key | The ID of the user/operator performing the action |
| `JCMConstants.OPERATE_DATE_KEY` | Operate Date key | The operational date for the SC invocation |
| `JCMConstants.OPERATE_DATETIME_KEY` | Operate DateTime key | The operational datetime for the SC invocation |
| `JCMConstants.TEMPLATE_LIST_KEY` | Template List key | The key used to store the assembled SC message templates in the result map |
| `SCControlMapKeys.REQ_HOSTNAME` | Request Hostname key | Control map key for client hostname |
| `SCControlMapKeys.REQ_HOSTIP` | Request Host IP key | Control map key for client IP address |
| `SCControlMapKeys.REQ_VIEWID` | Request View ID key | Control map key for screen/view ID |
| `SCControlMapKeys.OPERATOR_ID` | Operator ID key | Control map key for operator ID |
| `SCControlMapKeys.OPE_DATE` | Operation Date key | Control map key for operation date |
| `SCControlMapKeys.OPE_TIME` | Operation Time key | Control map key for operation time |

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `param.getTelegramID` | - | - | Reads transaction ID from the request parameter object |
| - | `param.getUsecaseID` | - | - | Reads use case ID from the request parameter object |
| - | `param.getOperationID` | - | - | Reads operation ID from the request parameter object |
| - | `param.getCallType` | - | - | Reads call type classification from the request parameter object |
| - | `param.getControlMapData` | - | - | Reads control map data entries (hostname, IP, screen ID, operator, date/time) from the request |
| - | `new CAANMsg` (resource bundle load) | - | - | Loads a CAANMsg template from message resource bundle `eo.ejb.cbs.cbsmsg.%sCBSMsg` |
| - | `template.set` / `template.setNull` | - | - | Binds or clears field values on the root CAANMsg template |
| - | `template.getCAANMsgList` | - | - | Retrieves child message array from the root template by list key |
| - | `new CAANMsg` (child) | - | - | Creates child CAANMsg templates from resource bundle `eo.ejb.cbs.cbsmsg.%sCBSMsg1List` |
| - | `childTemplate.set` / `childTemplate.setNull` | - | - | Binds or clears field values on each child CAANMsg template |

**Note:** This method itself does not perform database CRUD operations. It is a **parameter preparation/builder method** that assembles SC invocation payloads. The actual database operations are performed by the called Service Component (SC) at the next layer, via `scCall.run(paramMap, handle)` in the caller `callSCArray`. The `CAANMsg` resource bundles (`eo.ejb.cbs.cbsmsg.%sCBSMsg`) are loaded from the framework's internationalized message file system to define the structure of the SC request payload.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:JKKKikiIchiranKkKaifukuCC (CBS: callSCArray) | `JKKKikiIchiranKkKaifukuCC.callSCArray` -> `JKKKikiIchiranKkKaifukuCC.editInArrayMsg` | SC invocation via ServiceComponentRequestInvoker.run() (R - reads from target SC) |

**Analysis:** The `editInArrayMsg` method is a **private utility** called exclusively by `callSCArray()` within the same class (`JKKKikiIchiranKkKaifukuCC`). The `callSCArray` method itself serves as the SC invocation gateway for the KKKikiIchiran (equipment information listing/inquiry) screen functionality, assembling the request parameter map, invoking the Service Component, and processing the result. There are no independent screen entry points (KKSV*) or batch entry points that call this method directly — it is always reached through the `callSCArray` dispatcher.

## 6. Per-Branch Detail Blocks

**Block 1** — [SET / MULTIPLE PUT] (L1177)

> Initializes the paramMap and populates it with transaction-level metadata from the param object.

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap = new HashMap<String, Object>()` // Create new parameter map |
| 2 | EXEC | `paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID())` // 【取得元：電文ヘッダ(ヘッダ)】Transaction ID [-> TRANZACTION_ID_KEY] |
| 3 | EXEC | `paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID())` // Use case ID [-> USECASE_ID_KEY] |
| 4 | EXEC | `paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID())` // Operation ID [-> OPERATION_ID_KEY] |
| 5 | EXEC | `paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType())` // Service call-type classification [-> CALL_TYPE_KEY] |
| 6 | EXEC | `paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME))` // 【取得元：ユーザエリア(コントローラマップ)】Request hostname [-> CLIENT_HOST_NAME_KEY] |
| 7 | EXEC | `paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP))` // Request source IP address [-> CLIENT_IP_ADDRESS_KEY] |
| 8 | EXEC | `paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID))` // Request source screen ID (gamen = 画面) [-> INVOKE_GAMEN_ID_KEY] |
| 9 | EXEC | `paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID))` // Operator ID [-> OPERATOR_ID_KEY] |

**Block 2** — [SET] (L1189)

> Extracts the service interface name from the first row of mappingData.

| # | Type | Code |
|---|------|------|
| 1 | SET | `svcIf = (String) mappingData[0][1]` // Service interface name — determines the SC message resource bundle key |

**Block 3** — [SET / EXEC] (L1191–L1198)

> Creates the root CAANMsg template and initializes it with control data.

| # | Type | Code |
|---|------|------|
| 1 | SET | `template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf))` // 【取得元：電文ヘッダ(ヘッダ)】Creates CAANMsg template from resource bundle |
| 2 | EXEC | `template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID))` // 【オペレータID】Set operator ID on template [-> OPERATOR_ID_KEY] |
| 3 | EXEC | `template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE))` // 【運用日付】Set operational date [-> OPERATE_DATE_KEY] |
| 4 | EXEC | `template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME))` // 【運用日時】Set operational datetime [-> OPERATE_DATETIME_KEY] |

**Block 4** — [FOR LOOP] (L1200–L1210)

> Iterates over the mappingData array, binding each key-value pair onto the root template. Empty string values trigger null-setting (field clearing).

| # | Type | Code |
|---|------|------|
| 1 | SET | `for i = 0; i < mappingData.length; i++` // Loop over all mapping rows |
| 2 | IF | `"".equals(mappingData[i][1])` // Check if mapped value is empty string |

  **Block 4.1** — [IF-TRUE: empty value] (L1202)

  > Sets the field to null in the template when the mapped value is empty.

  | # | Type | Code |
  |---|------|------|
  | 1 | EXEC | `template.setNull((String) mappingData[i][0])` // Clear the field — mappingData[i][0] is the target field name |

  **Block 4.2** — [IF-FALSE: non-empty value] (L1204)

  > Sets the field value in the template when the mapped value is non-empty.

  | # | Type | Code |
  |---|------|------|
  | 1 | EXEC | `template.set((String) mappingData[i][0], mappingData[i][1])` // Bind key-value pair onto template |

**Block 5** — [SET / COND] (L1212–L1218)

> Retrieves or initializes the child message array from the root template.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateArray = template.getCAANMsgList(inListMsgName)` // Retrieve child message array by list key |
| 2 | IF | `templateArray == null` // Child array not yet initialized |

  **Block 5.1** — [IF-TRUE: create new array] (L1215)

  > Creates a new child message array sized to the inList size.

  | # | Type | Code |
  |---|------|------|
  | 1 | SET | `templateArray = new CAANMsg[inList.size()]` // Allocate child message array |

  **Block 5.2** — [IF-FALSE: reuse existing] (L1216)

  > The existing templateArray is reused as-is.

  | # | Type | Code |
  |---|------|------|
  | 1 | (no-op) | templateArray already populated from prior call |

**Block 6** — [FOR LOOP] (L1219–L1238)

> Iterates over the inList, binding each child map's data onto a child CAANMsg template.

| # | Type | Code |
|---|------|------|
| 1 | SET | `for i = 0; i < inList.size(); i++` // Loop over each list row |
| 2 | SET | `childMap = (HashMap) inList.get(i)` // Get child data map for this row |
| 3 | SET | `childTemplate = templateArray[i]` // Get or null — may already exist |
| 4 | IF | `childTemplate == null` // No child template pre-assigned |

  **Block 6.1** — [IF-TRUE: create child template] (L1225)

  > Creates a new child CAANMsg template keyed on the 1List resource bundle.

  | # | Type | Code |
  |---|------|------|
  | 1 | SET | `childTemplate = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg1List", svcIf))` // Child message template — the "1List" suffix distinguishes child message bundle from root bundle |

  **Block 6.2** — [IF-FALSE: reuse existing] (L1226)

  > The existing child template from templateArray[i] is reused.

  | # | Type | Code |
  |---|------|------|
  | 1 | (no-op) | childTemplate already exists |

**Block 7** — [ITERATOR LOOP] (L1228–L1236)

> Iterates over all keys in the child map, binding each key-value pair onto the child template.

| # | Type | Code |
|---|------|------|
| 1 | SET | `it = childMap.keySet().iterator()` // Create iterator over child map keys |
| 2 | WHILE | `it.hasNext()` // Has more keys to process |

  **Block 7.1** — [WHILE body] (L1230–L1235)

  > For each key, determines whether to set null or the actual value.

  | # | Type | Code |
  |---|------|------|
  | 1 | SET | `key = (String) it.next()` // Get next key from child map |
  | 2 | IF | `"".equals(childMap.get(key))` // Check if the value for this key is empty |

    **Block 7.1.1** — [IF-TRUE: empty value] (L1232)

    | # | Type | Code |
    |---|------|------|
    | 1 | EXEC | `childTemplate.setNull(key)` // Clear the child field |

    **Block 7.1.2** — [IF-FALSE: non-empty value] (L1234)

    | # | Type | Code |
    |---|------|------|
    | 1 | EXEC | `childTemplate.set(key, (String) childMap.get(key))` // Bind key-value to child template |

**Block 8** — [SET] (L1238)

> Stores the processed child template back into the array.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateArray[i] = childTemplate` // Store child template at current index |

**Block 9** — [SET] (L1240)

> Sets the assembled child message array back onto the root template.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `template.set(inListMsgName, templateArray)` // Set child array onto root template under list key |

**Block 10** — [SET] (L1242–L1244)

> Wraps the root template in a CAANMsg array and stores it in the paramMap.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templates = new CAANMsg[1]` // Create single-element template array |
| 2 | SET | `templates[0] = template` // Place root template at index 0 |
| 3 | EXEC | `paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates)` // Store template array in param map [-> TEMPLATE_LIST_KEY] |

**Block 11** — [RETURN] (L1246)

> Returns the fully assembled param map to the caller.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return paramMap` // Returns the assembled SC invocation parameter map |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `svcIf` | Field | Service Interface name — the interface identifier used to resolve the SC message resource bundle (e.g., `EKK0361A010CBS` → resource bundle `eo.ejb.cbs.cbsmsg.EKK0361A010CBSCBSMsg`) |
| `inListMsgName` | Field | In-List Message Name — the key identifying which child message list section within the SC template the child messages belong to |
| `mappingData` | Parameter | Mapping data — a 2D array of field name/value pairs used to populate the SC message template; `mappingData[i][0]` is the field name, `mappingData[i][1]` is the field value |
| `paramMap` | Field | Parameter map — the assembled request payload containing transaction metadata, control data, and SC message templates for invocation |
| `CAANMsg` | Class | CAANMessage — the framework's message container class used to build and manage SC request/response payloads; supports key-value field binding via `set()` / `setNull()` and hierarchical child message arrays |
| `callSCArray` | Method | Call Service Component Array — the SC invocation gateway method that uses `editInArrayMsg` to prepare parameters, invokes the SC via `ServiceComponentRequestInvoker.run()`, and handles results/errors |
| SC | Acronym | Service Component — an enterprise service that encapsulates business logic and database operations; invoked via the `ServiceComponentRequestInvoker` framework |
| SC Code | Acronym | Service Component Code — the identifier for a specific SC (e.g., `EKK0361A010SC`); the actual SC code is determined by the `svcIf` value in `mappingData[0][1]` |
| `TRANZACTION_ID_KEY` | Constant | Transaction ID key in JCMConstants — used to identify the SC transaction session (note: "TRANZACTION" is the spelling used in the codebase) |
| `USECASE_ID_KEY` | Constant | Use Case ID key — identifies the business use case executing the operation |
| `CALL_TYPE_KEY` | Constant | Call Type key — classifies the type of SC call (e.g., read, write, batch) |
| `TEMPLATE_LIST_KEY` | Constant | Template List key — the key under which the CAANMsg array is stored in the result param map |
| `REQ_HOSTNAME` | Constant | Request Hostname key in SCControlMapKeys — control map key for client hostname |
| `REQ_HOSTIP` | Constant | Request Host IP key in SCControlMapKeys — control map key for client IP address |
| `REQ_VIEWID` | Constant | Request View ID key in SCControlMapKeys — control map key for the screen/page ID |
| `OPE_DATE` | Constant | Operation Date key — control map key for the operational date |
| `OPE_TIME` | Constant | Operation Time key — control map key for the operational time |
| `eo.ejb.cbs.cbsmsg.%sCBSMsg` | Pattern | Root message resource bundle pattern — CAANMsg templates are loaded from this i18n resource bundle path, where `%s` is the service interface name |
| `eo.ejb.cbs.cbsmsg.%sCBSMsg1List` | Pattern | Child message resource bundle pattern — the `1List` suffix distinguishes child/line-item message templates from root templates |
| 電文ヘッダ | Japanese term | Telegram Header — the message header section containing transaction metadata (transaction ID, use case ID, etc.) |
| ユーザエリア | Japanese term | User Area — the control map section containing request context data (hostname, IP, screen ID, operator, date/time) |
| オペレータID | Japanese term | Operator ID — the ID of the user/operator performing the action |
| 運用日付 | Japanese term | Operation Date — the business date for the SC invocation |
| 運用日時 | Japanese term | Operation DateTime — the business datetime for the SC invocation |
| 依頼先ホスト名 | Japanese term | Request Destination Hostname — the hostname of the requesting client system |
| 依頼元IPアドレス | Japanese term | Request Source IP Address — the IP address of the requesting client |
| 依頼元画面ID | Japanese term | Request Source Screen ID — the screen/page that initiated the request |
| 戻値不正 | Japanese term | Return Value Error — the error message thrown when the SC returns an abnormal status (via `SCCallException`) |
| IRequestParameterReadWrite | Interface | The framework interface for reading/writing request parameters, providing access to transaction metadata and control map data |
| SCCallException | Exception | Framework exception thrown when a Service Component returns a non-zero return code or non-zero status, wrapping the return code and status for error handling |
| ServiceComponentRequestInvoker | Interface | The framework interface for invoking Service Components, with `run()` accepting a parameter map and session handle, returning a result map |
| SessionHandle | Class | Framework session handle passed to SC invocations, carrying connection and security context |
| KKKikiIchiran | Japanese term | Equipment Information Listing — the screen/feature for inquiring and displaying equipment information (equipment = 機器, ichiran = 一覧/listing) |