# Business Logic — JKKKojiChgPlaceNoCC.editInMsg() [147 LOC]

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

## 1. Role

### JKKKojiChgPlaceNoCC.editInMsg()

This method is a **message-in (editInMsg) builder** that constructs the request message payload (`CAANMsg`) for CBS (Central Business System) calls related to **service contract cancellation detail line location address updates**. The class `JKKKojiChgPlaceNoCC` serves as a shared common component for updating the line address of a service contract cancellation and coordinating place number changes with the home device management system.

The method implements the **template dispatch pattern**: it selects a CBS message template based on a service interface code (`svcIf`), then populates it with common header data (transaction ID, usecase ID, operator, timestamps, client info) and body data extracted from a `mappingData` array. The template ID in `mappingData[0][1]` determines which of four message-shaping branches is used, corresponding to different CBS scenarios: equipment model registration (EKKA0020002), a generic multi-item list pattern (EKKA0020003), a device change pattern with place number and change reason (EKKA0020004), and a catch-all default branch.

Its role in the larger system is that of a **message assembly bridge**: it converts screen-level parameter data and mapping configuration into a structured `CAANMsg` envelope that downstream Service Components (SCs) and CBS programs consume. It is called by `callSC()` and `getInvokeCBS()` within the same class, serving as the preparation step before the actual CBS invocation via `ServiceComponentRequestInvoker`.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["editInMsg"])
    A1["Create paramMap"] --> A2["Extract telegram header from param"]
    A2 --> B["Extract user context from control map"]
    B --> C["Extract svcIf from mappingData"]
    C --> D["Build CAANMsg template with svcIf"]
    D --> E["Set operator date time on template"]
    E --> F["Set mappingData row 0 and 1 on template"]
    F --> G{Check template ID}
    G -->|EKKA0020002| H["Process EKKA0020002 branch"]
    G -->|EKKA0020003| I["Process EKKA0020003 branch"]
    G -->|EKKA0020004| J["Process EKKA0020004 branch"]
    G -->|default| K["Process default branch"]
    H --> L["Get EKKA0020002CBSMsg1List from template"]
    L --> M["Iterate mappingData rows 2 onward, set fields on msg 0"]
    M --> N["Store msg 0 into list, set list on template"]
    N --> ENDNODE(["Create CAANMsg array templates set on paramMap return paramMap"])
    I --> O["Get EKKA0020003CBSMsg1List from template"]
    O --> P["Iterate list from mappingData row 2 col 1, set key_tk_mdl_cd and key_kk_seizo_no"]
    P --> Q["Set list on template"]
    Q --> ENDNODE
    J --> R["Get EKKA0020004CBSMsg1List from template"]
    R --> S["Iterate list from mappingData row 2 col 1, set fields incl setplace_no and key_chg_rsn_cd"]
    S --> T["Set list on template"]
    T --> ENDNODE
    K --> U["Iterate mappingData rows 2 onward, set fields on template directly"]
    U --> ENDNODE
```

**Constant Resolution:**

| Constant | Actual Value | Business Meaning |
|----------|-------------|-----------------|
| `TEMPLATE_ID_EKKA0020002` | `"EKKA0020002"` | Equipment model / certificate information template for service cancellation |
| `TEMPLATE_ID_EKKA0020003` | `"EKKA0020003"` | Multi-item list template (generic device registration) |
| `TEMPLATE_ID_EKKA0020004` | `"EKKA0020004"` | Device change template with place number linkage and change reason |

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The incoming request parameter object carrying all input data from the calling screen or CBS. It contains the telegram header (transaction ID, usecase ID, operation ID, call type) and a control map with operational context (client hostname, client IP, screen ID, operator ID, operate date/time). |
| 2 | `mappingData` | `Object[][]` | A 2D array encoding the message field mapping configuration. Row 0 (`[0][1]`) holds the template ID that determines which CBS message branch to use. Row 0 (`[0][0]`) and Row 1 (`[1][0]`, `[1][1]`) define the first two field mappings to set on the template (key-value pairs). Rows 2 and beyond contain additional fields; each row's `[0]` is a field name and `[1]` is its value (empty string means null). In branches 0020003 and 0020004, `mappingData[2][1]` holds an `ArrayList` of `HashMap` objects representing device records. |
| 3 | `placeNo` | `String` | The place number (場所番号) — the new location address identifier being updated as part of the service contract cancellation. This value is set on the `setplace_no` field in the EKKA0020004 device change branch, linking the device record to the new location. |

**External state / instance fields read:** None directly — all state is derived from parameters.

## 4. CRUD Operations / Called Services

### Pre-computed evidence from code analysis graph:

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `JKKKojiChgPlaceNoCC.setNull` | JKKKojiChgPlaceNoCC | - | Calls `setNull` on CAANMsg objects to clear fields with empty values |
| R | `JKKejbCallTypeChecker.getCallType` | JKKejbCallTypeChecker | - | Reads call type from request parameter (informational, not a DB read) |
| R | `SCW00701SFLogic.getName` | SCW00701SFLogic | - | Retrieves name from service component (informational) |

### Full method call analysis within `editInMsg`:

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `param.getTelegramID()` | - | - | Reads the telegram ID from the incoming request parameter (transaction identifier) |
| R | `param.getUsecaseID()` | - | - | Reads the usecase ID from the request parameter (business context identifier) |
| R | `param.getOperationID()` | - | - | Reads the operation ID from the request parameter (operation session identifier) |
| R | `param.getCallType()` | - | - | Reads the service call type from the request parameter |
| R | `param.getControlMapData(key)` | - | - | Reads control map values: client hostname, client IP, screen ID, operator ID, operate date, operate time |
| - | `new CAANMsg(...)` | - | - | Creates a CAANMsg message template with a service interface-specific message bundle (e.g., `eo.ejb.cbs.cbsmsg.EKKA0020002CBSMsg`) |
| - | `template.set(key, value)` | - | - | Sets individual fields on the CAANMsg template (operator ID, operate date, operate datetime, field mappings) |
| - | `template.getCAANMsgList(listKey)` | - | - | Retrieves the existing list of CAANMsg child messages from the template for the target branch |
| - | `new CAANMsg(class.getName())` | - | - | Creates a new CAANMsg child message instance (per branch-specific list class: EKKA0020002CBSMsg1List, EKKA0020003CBSMsg1List, EKKA0020004CBSMsg1List) |
| - | `msg.set(key, value)` | - | - | Sets individual fields on child message instances — field names vary by branch (e.g., `key_tk_mdl_cd`, `key_kk_seizo_no`, `setplace_no`, `key_chg_rsn_cd`, `key_btry_upd_dttm`, `svc_kei_no`) |
| - | `msg.setNull(key)` | - | - | Clears a field on the child message when the corresponding value in mappingData is empty string |
| - | `template.set(listKey, msg[])` | - | - | Assigns the populated child message array back to the parent template |
| - | `paramMap.put(key, value)` | - | - | Populates the result paramMap with header fields and the final template array |

**Note:** This method is a **message builder** — it does not directly invoke CBS or perform database CRUD operations itself. The actual CBS invocation (with its C/R/U/D operations) occurs in the caller methods (`callSC()`, `getInvokeCBS()`) which pass the constructed `paramMap` and `templates` to `ServiceComponentRequestInvoker`. The CBS template IDs used here (`EKKA0020002`, `EKKA0020003`, `EKKA0020004`) correspond to CBS programs handling equipment model/certificate registration, generic device list operations, and device change with place number linkage respectively.

## 5. Dependency Trace

No screen/batch entry points found within 8 hops. Direct callers found: 3 methods.
Terminal operations from this method: `setNull` [-], `getName` [R], `getName` [R], `setNull` [-], `getName` [R], `getCallType` [R]

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | CBS: `JKKKojiChgPlaceNoCC.callSC()` | `callSC()` -> `editInMsg(param, mappingData, placeNo)` | CAANMsg template assembly -> `ServiceComponentRequestInvoker.invoke()` (SC execution) |
| 2 | CBS: `JKKKojiChgPlaceNoCC.callSC()` | `callSC()` -> `editInMsg(param, mappingData, placeNo)` | Same as above — multiple invocations per callSC |
| 3 | CBS: `JKKKojiChgPlaceNoCC.getInvokeCBS()` | `getInvokeCBS()` -> `editInMsg(param, mappingData, placeNo)` | CAANMsg template assembly -> downstream CBS invocation |

**Note:** All direct callers are internal CBS methods within `JKKKojiChgPlaceNoCC`. The method does not have direct screen entry points; screens (such as `KKSV0200` — Service Contract Cancellation Detail) would reach this method through a chain of CBS/SC calls. The terminal operations are all read-oriented parameter extractions (`getTelegramID`, `getUsecaseID`, `getCallType`, `getControlMapData`) and message setters (`set`, `setNull`) — no direct database writes occur within this method.

## 6. Per-Branch Detail Blocks

**Block 1** — [SET] (L935)

> Creates the result map for the message envelope.

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap = new HashMap<String, Object>()` // Initialize result map |

**Block 2** — [SET x4] (L938–946)

> Extracts telegram header fields from the request parameter. Comment: 【取得元：電文ヘッダ(ヘッダ)】(Source: Message Header (Header)).

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID())` // 電文ID (Transaction ID) [-> JCMConstants.TRANZACTION_ID_KEY] |
| 2 | SET | `paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID())` // ユーケースID (Usecase ID) [-> JCMConstants.USECASE_ID_KEY] |
| 3 | SET | `paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID())` // オペレーションID (Operation ID) [-> JCMConstants.OPERATION_ID_KEY] |
| 4 | SET | `paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType())` // サービス呼び出し区分 (Service call type/disambiguation) [-> JCMConstants.CALL_TYPE_KEY] |

**Block 3** — [SET x4] (L949–957)

> Extracts user context from the control map. Comment: 【取得元：ユーザエリア(コントロールマップ)】(Source: User Area (Control Map)).

| # | Type | Code |
|---|------|------|
| 1 | SET | `paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME))` // 依頼先ホスト名 (Request destination hostname) [-> JCMConstants.CLIENT_HOST_NAME_KEY] |
| 2 | SET | `paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP))` // 依頼元IPアドレス (Request source IP address) [-> JCMConstants.CLIENT_IP_ADDRESS_KEY] |
| 3 | SET | `paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID))` // 依頼元画面ID (Request source screen ID) [-> JCMConstants.INVOKE_GAMEN_ID_KEY] |
| 4 | SET | `paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID))` // オペレータID (Operator ID) [-> JCMConstants.OPERATOR_ID_KEY] |

**Block 4** — [SET] (L959)

> Extracts the service interface code from the first column of the mapping data.

| # | Type | Code |
|---|------|------|
| 1 | SET | `svcIf = (String) mappingData[0][1]` // Service interface identifier — determines which CBS message template to use |

**Block 5** — [SET] (L961)

> Creates a CAANMsg template using a message bundle name derived from the service interface. The bundle path follows the convention: `eo.ejb.cbs.cbsmsg.{svcIf}CBSMsg`.

| # | Type | Code |
|---|------|------|
| 1 | SET | `template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf))` // Loads the CBS message definition bundle for this service interface |

**Block 6** — [SET x3] (L964–970)

> Populates the template with operator and operation timestamp data.

| # | Type | Code |
|---|------|------|
| 1 | SET | `template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID))` // オペレータID (Operator ID) |
| 2 | SET | `template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE))` // 運用日付 (Operation date) [-> JCMConstants.OPERATE_DATE_KEY] |
| 3 | SET | `template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME))` // 運用日時 (Operation datetime) [-> JCMConstants.OPERATE_DATETIME_KEY] |
| 4 | SET | `template.set((String) mappingData[0][0], mappingData[0][1])` // Set first field mapping (key = mappingData[0][0], value = mappingData[0][1]) |
| 5 | SET | `template.set((String) mappingData[1][0], mappingData[1][1])` // Set second field mapping (key = mappingData[1][0], value = mappingData[1][1]) |

**Block 7** — [IF-ELSEIF-ELSEIF-ELSE] `(TEMPLATE_ID_EKKA0020002.equals(mappingData[0][1]))` [TEMPLATE_ID_EKKA0020002="EKKA0020002"] (L972)

> **EKKA0020002 branch**: Equipment model and certificate information processing. Creates a single child message (msg[0]) and populates it by iterating over mappingData rows 2 onward. Each mappingData row's value is checked — empty string results in `setNull()`, otherwise `set()` is called.

| # | Type | Code |
|---|------|------|
| 1 | SET | `subMsg = template.getCAANMsgList(EKKA0020002CBSMsg.EKKA0020002CBSMSG1LIST)` // Get existing EKKA0020002 child message list |
| 2 | IF | `subMsg == null` |
| 2.1 | SET | `subMsg = new CAANMsg[1]` // Allocate single-element array |
| 3 | SET | `msg = subMsg[0]` // Reference first element (may be null at this point) |
| 4 | IF | `msg == null` |
| 4.1 | SET | `msg = new CAANMsg(EKKA0020002CBSMsg1List.class.getName())` // Create new child message with EKKA0020002CBSMsg1List schema |
| 5 | FOR | `i = 2; i < mappingData.length; i++` // Iterate over remaining mappingData rows |
| 5.1 | IF | `"".equals(mappingData[i][1])` // Check if value is empty string |
| 5.1.1 | EXEC | `msg.setNull((String) mappingData[i][0])` // Clear field on msg (empty value means null) |
| 5.2 | ELSE | |
| 5.2.1 | EXEC | `msg.set((String) mappingData[i][0], mappingData[i][1])` // Set field on msg with mappingData value |
| 6 | SET | `subMsg[0] = msg` // Store the populated message back into the array |
| 7 | SET | `template.set(EKKA0020002CBSMsg.EKKA0020002CBSMSG1LIST, subMsg)` // Attach the list to the template |

**Block 8** — [IF-ELSEIF-ELSEIF-ELSE] `(TEMPLATE_ID_EKKA0020003.equals(mappingData[0][1]))` [TEMPLATE_ID_EKKA0020003="EKKA0020003"] (L1001)

> **EKKA0020003 branch**: Generic multi-item device list processing. The list data comes from `mappingData[2][1]` (an `ArrayList` of `HashMap` objects). Each list item is a device record with model code and manufacturing serial number.

| # | Type | Code |
|---|------|------|
| 1 | SET | `subMsg = template.getCAANMsgList(EKKA0020003CBSMsg.EKKA0020003CBSMSG1LIST)` // Get existing EKKA0020003 child message list |
| 2 | SET | `list = (ArrayList) mappingData[2][1]` // Extract device record list from mappingData |
| 3 | IF | `subMsg == null` |
| 3.1 | SET | `subMsg = new CAANMsg[list.size()]` // Allocate array sized to match the incoming list |
| 4 | FOR | `i = 0; i < subMsg.length; i++` // Iterate over each message slot in the list |
| 4.1 | SET | `msg = subMsg[i]` // Get existing message (may be null) |
| 4.2 | SET | `map = (HashMap) list.get(i)` // Get corresponding device record from the incoming list |
| 4.3 | IF | `msg == null` |
| 4.3.1 | SET | `msg = new CAANMsg(EKKA0020003CBSMsg1List.class.getName())` // Create new child message with EKKA0020003CBSMsg1List schema |
| 4.4 | EXEC | `msg.set("key_tk_mdl_cd", map.get("taknkiki_model_cd"))` // Set transportation equipment model code from device record [-> key_tk_mdl_cd] |
| 4.5 | EXEC | `msg.set("key_kk_seizo_no", map.get("kiki_seizo_no"))` // Set equipment manufacturing serial number from device record [-> key_kk_seizo_no] |
| 4.6 | SET | `subMsg[i] = msg` // Store the populated message back into the array |
| 5 | SET | `template.set(EKKA0020003CBSMsg.EKKA0020003CBSMSG1LIST, subMsg)` // Attach the list to the template |

**Block 9** — [IF-ELSEIF-ELSEIF-ELSE] `(TEMPLATE_ID_EKKA0020004.equals(mappingData[0][1]))` [TEMPLATE_ID_EKKA0020004="EKKA0020004"] (L1029)

> **EKKA0020004 branch**: Device change processing with place number linkage. This is the primary branch for the location address change scenario. It populates each device record with model code, serial number, change reason code (hardcoded to "1"), base update datetime, service contract number, and the new place number.

| # | Type | Code |
|---|------|------|
| 1 | SET | `subMsg = template.getCAANMsgList(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST)` // Get existing EKKA0020004 child message list |
| 2 | SET | `list = (ArrayList) mappingData[2][1]` // Extract device record list from mappingData |
| 3 | IF | `subMsg == null` |
| 3.1 | SET | `subMsg = new CAANMsg[list.size()]` // Allocate array sized to match the incoming list |
| 4 | FOR | `i = 0; i < subMsg.length; i++` // Iterate over each message slot in the list |
| 4.1 | SET | `msg = subMsg[i]` // Get existing message (may be null) |
| 4.2 | SET | `map = (HashMap) list.get(i)` // Get corresponding device record from the incoming list |
| 4.3 | IF | `msg == null` |
| 4.3.1 | SET | `msg = new CAANMsg(EKKA0020004CBSMsg1List.class.getName())` // Create new child message with EKKA0020004CBSMsg1List schema |
| 4.4 | EXEC | `msg.set("key_tk_mdl_cd", map.get("taknkiki_model_cd"))` // Set transportation equipment model code from device record [-> key_tk_mdl_cd] |
| 4.5 | EXEC | `msg.set("key_kk_seizo_no", map.get("kiki_seizo_no"))` // Set equipment manufacturing serial number from device record [-> key_kk_seizo_no] |
| 4.6 | EXEC | `msg.set("key_chg_rsn_cd", "1")` // Set change reason code to "1" (hardcoded — indicates standard change) [-> key_chg_rsn_cd] |
| 4.7 | EXEC | `msg.set("key_btry_upd_dttm", map.get("kihont_upd_dttm"))` // Set base (standard) update datetime from device record [-> key_btry_upd_dttm] |
| 4.8 | EXEC | `msg.set("svc_kei_no", map.get("svc_kei_no"))` // Set service contract number from device record [-> svc_kei_no] |
| 4.9 | EXEC | `msg.set("setplace_no", placeNo)` // Set the new place number (location address being updated) [-> setplace_no] |
| 4.10 | SET | `subMsg[i] = msg` // Store the populated message back into the array |
| 5 | SET | `template.set(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST, subMsg)` // Attach the list to the template |

**Block 10** — [ELSE] (default branch) (L1062)

> **Default branch**: Generic field-by-field population. Iterates over mappingData rows 2 onward and sets each field directly on the template (not a child message). Empty string values are set as null. This handles any service interface code not matching the three known template IDs.

| # | Type | Code |
|---|------|------|
| 1 | FOR | `i = 2; i < mappingData.length; i++` // Iterate over remaining mappingData rows |
| 1.1 | IF | `"".equals(mappingData[i][1])` // Check if value is empty string |
| 1.1.1 | EXEC | `template.setNull((String) mappingData[i][0])` // Clear field on template (empty value means null) |
| 1.2 | ELSE | |
| 1.2.1 | EXEC | `template.set((String) mappingData[i][0], mappingData[i][1])` // Set field on template with mappingData value |

**Block 11** — [SET x2, RETURN] (L1071–1074)

> Wraps the assembled template in a CAANMsg array and stores it in the paramMap under the template list key, then returns the paramMap as the message envelope ready for CBS invocation.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templates = new CAANMsg[1]` // Create single-element CAANMsg array |
| 2 | SET | `templates[0] = template` // Place the populated template as the sole element |
| 3 | SET | `paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates)` // 電文テンプレートリスト (Message template list) [-> JCMConstants.TEMPLATE_LIST_KEY] |
| 4 | RETURN | `return paramMap` // Return the complete message envelope to the caller |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `svcIf` | Field | Service interface identifier — determines which CBS message template bundle to load (e.g., "EKKA0020002") |
| `svc_kei_no` | Field | Service contract number — internal identifier for a service contract line item |
| `setplace_no` | Field | Place number (場所番号) — the target location address identifier for the service line being updated |
| `taknkiki_model_cd` | Field | Transportation equipment model code (搭載機器モデルコード) — model code of the home device/equipment |
| `kiki_seizo_no` | Field | Equipment manufacturing serial number (機器製造番号) — unique serial number of the device |
| `key_tk_mdl_cd` | Field | Key: transportation equipment model code — field name in the CBS message for the device model |
| `key_kk_seizo_no` | Field | Key: K-Opticom equipment manufacturing number — field name in the CBS message for the device serial |
| `key_chg_rsn_cd` | Field | Key: change reason code — field name in the CBS message indicating the reason for the change (hardcoded to "1") |
| `key_btry_upd_dttm` | Field | Key: base update datetime — field name in the CBS message for the standard/base system update timestamp |
| `kihont_upd_dttm` | Field | Base update datetime (基本更新日時) — the reference update timestamp for the device record |
| `paramMap` | Field | Result message envelope — HashMap containing header fields and the CAANMsg template array |
| `template` | Field | CAANMsg message template — the CBS request message being constructed |
| `subMsg` | Field | Child message array — array of CAANMsg objects for list-type data within the template |
| CAANMsg | Technical | Fujitsu message object — a hierarchical message container used to build CBS request/response payloads with nested lists |
| PARAMAPLConstMgr | Technical | Template placeholder constant manager — utility for managing message template placeholders |
| JCMConstants | Technical | JCM (Joint Communication Module) constants — defines standard message envelope field keys (TRANZACTION_ID_KEY, USECASE_ID_KEY, etc.) |
| SCControlMapKeys | Technical | Service Component control map keys — defines keys for operational context data (REQ_HOSTNAME, REQ_HOSTIP, REQ_VIEWID, OPERATOR_ID, OPE_DATE, OPE_TIME) |
| TEMPLATE_ID_EKKA0020002 | Constant | Template ID "EKKA0020002" — equipment model and certificate information message template |
| TEMPLATE_ID_EKKA0020003 | Constant | Template ID "EKKA0020003" — generic multi-item device list message template |
| TEMPLATE_ID_EKKA0020004 | Constant | Template ID "EKKA0020004" — device change with place number linkage message template |
| CBS | Acronym | Central Business System — the core backend system processing service contract operations |
| SC | Acronym | Service Component — a middleware component that routes requests to CBS programs |
| EAANMsg / CAANMsg | Technical | CAANMsg is the message model class representing a CBS message envelope with hierarchical fields and child message lists |
| 電文ヘッダ | Field (Japanese) | Message header — the top-level metadata fields (transaction ID, usecase ID, operation ID, call type) of the CBS message |
| ユーザエリア | Field (Japanese) | User area — the operational context data (hostname, IP, screen ID, operator, timestamps) extracted from the control map |
| カンバン (mappingData) | Field (Japanese context) | Mapping data array — configuration-driven field mapping used to populate message body fields |
| 運用日付 / 運用日時 | Field (Japanese) | Operation date / Operation datetime — the system date and time for the operation session |