# Business Logic — JKKSeikySakiHeigoCC.editInMsg_ECK0151D010() [256 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKSeikySakiHeigoCC` |
| Layer | CC / Common Component (Controller Component — message mapping layer) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKSeikySakiHeigoCC.editInMsg_ECK0151D010()

This method constructs the inbound Service Component (SC) request message (CAANMsg) for the **Instruction Document Registration** (`指針書登録`) process identified by SC Code `ECK0151D010`. It is a message-mapping common component that follows the **builder pattern** — it creates a typed `CAANMsg` instance using the `ECK0151D010CBSMsg` schema, populates it with common metadata (template ID, function code, operator ID, operating date/time) and business-specific field values derived from `childMap` and `dataMap`, then attaches the result to the `param` request parameter object under `JCMConstants.TEMPLATE_LIST_KEY`.

The method serves as a **shared utility** called by screen entry methods (e.g., `execECK0151D010`) within the Instruction Document Management domain. It does not perform any database operations or service calls itself — its sole responsibility is transforming incoming screen parameters into a structured, schema-typed SC input message. The method handles 20 parameter fields (parameter_1 through parameter_20), with some fields exhibiting special data-source logic: parameter_6 draws from a separate `dataMap` work field (`ekk0321c020_kakins_tendymd_work`) rather than `childMap`, and several other parameters (8, 9, 10, 12, 13) are also sourced from `dataMap` work fields instead of `childMap`. Parameters 21 through 50 are always explicitly nullified to ensure the SC caller receives a clean message envelope. The method also retrieves user data from the KKSV0546 screen's CCList and fetches a work area mapping for potential cross-reference.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["editInMsg_ECK0151D010"])
    
    START --> S1["S1: Call editInMsg(param) - common field setup"]
    S1 --> S2["S2: Create CAANMsg template from ECK0151D010CBSMsg"]
    S2 --> S3["S3: Set TEMPLATEID = ECK0151D010"]
    S3 --> S4["S4: Set FUNC_CODE = 1"]
    S4 --> S5["S5: Set OPERATOR_ID from param.getControlMapData"]
    S5 --> S6["S6: Set OPERATE_DATE from param.getControlMapData"]
    S6 --> S7["S7: Set OPERATE_DATETIME from param.getControlMapData"]
    S7 --> S8["S8: Get workMap from param.getMappingWorkArea"]
    S8 --> S9["S9: Get user data from param.getData KKSV0546CCList"]
    S9 --> S10["S10: Overwrite FUNC_CODE from dataMap FUNC_CODE_KEY"]
    
    S10 --> COND_TRN["trn_cd empty?"]
    COND_TRN -->|Yes| NULL_TRN["setNull TRN_CD"]
    COND_TRN -->|No| SET_TRN["set TRN_CD from childMap"]
    NULL_TRN --> COND_TABLE["trgt_table_id empty?"]
    SET_TRN --> COND_TABLE
    
    COND_TABLE -->|Yes| NULL_TABLE["setNull TRGT_TABLE_ID"]
    COND_TABLE -->|No| SET_TABLE["set TRGT_TABLE_ID from childMap"]
    NULL_TABLE --> COND_SYSID["tran_trgt_sysid empty?"]
    SET_TABLE --> COND_SYSID
    
    COND_SYSID -->|Yes| NULL_SYSID["setNull TRAN_TRGT_SYSID"]
    COND_SYSID -->|No| SET_SYSID["set TRAN_TRGT_SYSID from childMap"]
    NULL_SYSID --> COND_RSLT["rslt_flg empty?"]
    SET_SYSID --> COND_RSLT
    
    COND_RSLT -->|Yes| NULL_RSLT["setNull RSLT_FLG"]
    COND_RSLT -->|No| SET_RSLT["set RSLT_FLG from childMap"]
    NULL_RSLT --> COND_YK["parameter_yk_cnt empty?"]
    SET_RSLT --> COND_YK
    
    COND_YK -->|Yes| NULL_YK["setNull PARAMETER_YK_CNT"]
    COND_YK -->|No| SET_YK["set PARAMETER_YK_CNT from childMap"]
    NULL_YK --> LOOP_PARAM["Loop parameter_1 to parameter_20"]
    SET_YK --> LOOP_PARAM
    
    LOOP_PARAM --> P6_CHECK["param_5 childMap empty?"]
    P6_CHECK -->|Yes| P6_PSEUDO["set PARAMETER_5 from parameter_6"]
    P6_CHECK -->|No| P6_SET["set PARAMETER_5 from parameter_5"]
    
    P6_SET --> P6_ALT_CHECK["dataMap ekk0321c020_kakins_tendymd_work null or empty?"]
    P6_PSEUDO --> P6_ALT_CHECK
    
    P6_ALT_CHECK -->|Yes| P6_USE_PARAM6["set PARAMETER_5 from parameter_6"]
    P6_ALT_CHECK -->|No| P6_USE_KAKINS["set PARAMETER_6 from dataMap kakins_tendymd_work"]
    
    P6_USE_PARAM6 --> PARAM_ALT["Parameters 8, 9, 10, 12, 13 from dataMap work fields"]
    P6_USE_KAKINS --> PARAM_ALT
    
    PARAM_ALT --> NULL_21_50["setNull PARAMETER_21 through PARAMETER_50"]
    NULL_21_50 --> BUILD_ARRAY["Build CAANMsg array with template"]
    BUILD_ARRAY --> PUT_TEMPLATE["paramMap put TEMPLATE_LIST_KEY"]
    PUT_TEMPLATE --> RETURN["Return paramMap"]
    RETURN --> END(["editInMsg_ECK0151D010 returns"])
```

**CRITICAL — Constant Resolution:**
- `TEMPLATE_ID_ECK0151D010` = `"ECK0151D010"` — the instruction document registration template identifier, defined as a `private static final String` in the calling class.
- `FUNC_CODE` = `"1"` — hardcoded function code indicating the registration operation type for instruction document mapping.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The request parameter object carrying the full screen context — operator ID, operating date/time, and work area mapping. It serves as the carrier for the built message envelope (`paramMap`) returned via `TEMPLATE_LIST_KEY`. |
| 2 | `dataMap` | `Map<String, Object>` | A data dictionary holding screen-level state and work fields. Used as an alternative source for parameters 6, 8, 9, 10, 12, 13 when they reference `ekk0321c020_*_work` fields (e.g., scroll date `kakins_tendymd_work`, mark flag `mk_flg_work`, addition datetime `add_dtm_work`, update datetime `upd_dtm_work`). Also provides the function code via `JCMConstants.FUNC_CODE_KEY`. |
| 3 | `childMap` | `HashMap<String, Object>` | A child data map carrying instruction document registration mapping fields — transaction code (`trn_cd`), target table ID (`trgt_table_id`), target system ID (`tran_trgt_sysid`), result flag (`rslt_flg`), parameter count (`parameter_yk_cnt`), and parameters 1–20 (`parameter_1` through `parameter_20`). These represent the individual data points of the instruction document being registered. |

**Instance fields / external state read:**
- None directly — all external state is accessed through `param`, `dataMap`, and `childMap` parameters.

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| U | `editInMsg` | - | - | Calls `editInMsg(param)` to initialize the common request parameter map (base template setup). |
| R | `param.getControlMapData` | - | - | Reads operator ID, operating date, and operating time from control map. |
| R | `param.getMappingWorkArea` | - | - | Retrieves the work area mapping from the request parameter. |
| R | `param.getData` | - | - | Fetches user data for screen `KKSV0546CCList`. |
| - | `CAANMsg.set` | - | - | Populates fields on the CAANMsg template instance. |
| - | `CAANMsg.setNull` | - | - | Nullifies fields on the CAANMsg template instance. |

**Analysis Notes:**
- This method is a **pure message builder** — it does not directly access any database tables, entities, or service component endpoints that query data.
- The only internal method call is `editInMsg(param)` which performs common request parameter initialization.
- All data source is from the caller's parameter objects (`param`, `dataMap`, `childMap`), which were populated by the calling screen method (`execECK0151D010`).
- The built `CAANMsg` is attached to `paramMap` under `JCMConstants.TEMPLATE_LIST_KEY` and returned to the caller, who then passes it to `scCall.run()` for the actual SC invocation.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | `JKKSeikySakiHeigoCC.execECK0151D010` | `execECK0151D010` -> `editInMsg_ECK0151D010` -> `scCall.run(paramMap, handle)` | `scCall.run [C/R/U/D] (SC invocation for instruction document registration)` |

**Call Chain Detail:**
- `execECK0151D010` is the entry-point processing method that orchestrates the instruction document registration screen logic. It calls `editInMsg_ECK0151D010` to build the inbound message, passes the result to `scCall.run()` for Service Component execution, then calls `editOutMsg_ECK0151D010` to parse the response and `jdgErrRslt` to evaluate the result.
- `JKKSeikyKeiBunkatsuCC.editInMsg_ECK0151D010` (in `JKKSeikyKeiBunkatsuCC`) — same method signature but in a different class for service contract splitting logic. This is a separate copy of the method in another component.

**Terminal operations reached from this method:** All terminal operations are `setNull` calls on the CAANMsg template (parameters 21–50 are nullified). The actual business-level terminal operations (SC CRUD) are performed by the caller's `scCall.run()` invocation, which is outside the scope of this method.

## 6. Per-Branch Detail Blocks

**Block 1** — [SET] Common field setup (L2496)

Initializes the base request parameter map and creates the message template.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | CALL | `editInMsg(param)` | Calls parent/common editInMsg to set up base request parameter map |
| 2 | SET | `template = new CAANMsg(ECK0151D010CBSMsg.class.getName())` | Creates a CAANMsg typed to the ECK0151D010 CBS message schema |
| 3 | SET | `template.set(TemplateID, TEMPLATE_ID_ECK0151D010)` | [-> `TEMPLATE_ID_ECK0151D010 = "ECK0151D010"`] Sets the template ID for the instruction document registration |
| 4 | SET | `template.set(FUNC_CODE, "1")` | Sets function code to "1" for the registration operation |
| 5 | SET | `operatorId = param.getControlMapData(OPERATOR_ID)` | Retrieves operator ID from control map |
| 6 | SET | `template.set(OPERATOR_ID_KEY, operatorId)` | Sets operator ID on the message |
| 7 | SET | `operateDate = param.getControlMapData(OPE_DATE)` | Retrieves operating date from control map |
| 8 | SET | `template.set(OPERATE_DATE_KEY, operateDate)` | Sets operating date on the message |
| 9 | SET | `operateDateTime = param.getControlMapData(OPE_TIME)` | Retrieves operating date/time from control map |
| 10 | SET | `template.set(OPERATE_DATETIME_KEY, operateDateTime)` | Sets operating date/time on the message |
| 11 | SET | `templateArray = null` | Declares and initializes unused CAANMsg array |
| 12 | SET | `inMap = null` | Declares and initializes unused HashMap |
| 13 | SET | `inList = null` | Declares and initializes unused ArrayList |
| 14 | SET | `workMap = param.getMappingWorkArea()` | Retrieves work area mapping for potential cross-reference |
| 15 | SET | `inMap = (HashMap)param.getData("KKSV0546CCList")` | Retrieves user data from KKSV0546 screen's CCList |
| 16 | SET | `template.set(FUNC_CODE, dataMap.get(FUNC_CODE_KEY))` | Overwrites FUNC_CODE from dataMap (screen provides actual function code) |

**Block 2** — [IF/ELSE] Transaction code (trn_cd) mapping (L2544)

Copies the transaction code from childMap to the template. If empty, sets null.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | SET | `childMap.get("trn_cd")` | Gets transaction code from childMap |
| 2 | IF | `"".equals(childMap.get("trn_cd"))` | [CHECK: Is trn_cd an empty string?] |
| 3 | EXEC | `template.setNull(TRN_CD)` | Sets transaction code field to null (empty input) |
| 4 | EXEC | `template.set(TRN_CD, (String) childMap.get("trn_cd"))` | Sets transaction code field from childMap value |

**Block 3** — [IF/ELSE] Target table ID mapping (L2550)

Copies the target table ID from childMap to the template.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `"".equals(childMap.get("trgt_table_id"))` | [CHECK: Is target table ID an empty string?] |
| 2 | EXEC | `template.setNull(TRGT_TABLE_ID)` | Sets target table ID to null (empty input) |
| 3 | EXEC | `template.set(TRGT_TABLE_ID, (String) childMap.get("trgt_table_id"))` | Sets target table ID from childMap |

**Block 4** — [IF/ELSE] Processing target SYSID mapping (L2556)

Copies the processing target system ID from childMap to the template.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `"".equals(childMap.get("tran_trgt_sysid"))` | [CHECK: Is processing target SYSID an empty string?] |
| 2 | EXEC | `template.setNull(TRAN_TRGT_SYSID)` | Sets target SYSID to null (empty input) |
| 3 | EXEC | `template.set(TRAN_TRGT_SYSID, (String) childMap.get("tran_trgt_sysid"))` | Sets target SYSID from childMap |

**Block 5** — [IF/ELSE] Result flag mapping (L2562)

Copies the result flag from childMap to the template.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `"".equals(childMap.get("rslt_flg"))` | [CHECK: Is result flag an empty string?] |
| 2 | EXEC | `template.setNull(RSLT_FLG)` | Sets result flag to null (empty input) |
| 3 | EXEC | `template.set(RSLT_FLG, (String) childMap.get("rslt_flg"))` | Sets result flag from childMap |

**Block 6** — [IF/ELSE] Parameter valid count mapping (L2568)

Copies the parameter valid count from childMap to the template.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `"".equals(childMap.get("parameter_yk_cnt"))` | [CHECK: Is parameter valid count an empty string?] |
| 2 | EXEC | `template.setNull(PARAMETER_YK_CNT)` | Sets parameter valid count to null |
| 3 | EXEC | `template.set(PARAMETER_YK_CNT, (String) childMap.get("parameter_yk_cnt"))` | Sets parameter valid count from childMap |

**Block 7** — [IF/ELSE x 20] Parameter fields 1–20 mapping (L2574–L2728)

Each parameter (parameter_1 through parameter_20) follows the same pattern: if the childMap value is an empty string, set null on the template; otherwise, set the value. Parameters 6, 8, 9, 10, 12, and 13 have special logic that sources from `dataMap` instead of `childMap`.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF/ELSE | For each parameter_1 through parameter_20: `"".equals(childMap.get("parameter_N"))` | Check if parameter value is empty |
| 2 | EXEC | `template.setNull(PARAMETER_N)` | Set parameter to null when empty |
| 3 | EXEC | `template.set(PARAMETER_N, (String) childMap.get("parameter_N"))` | Set parameter from childMap |

**Block 7.1** — [IF/ELSE] Parameter_6 special case: uses dataMap for value (L2609)

Parameter_6 has special behavior — when childMap's parameter_5 is not empty, the check shifts to the dataMap for the `ekk0321c020_kakins_tendymd_work` field. If that field is null/empty, parameter_6 uses the childMap's parameter_6 value instead (assigned to PARAMETER_5 field slot).

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_kakins_tendymd_work") == null || "".equals(dataMap.get("ekk0321c020_kakins_tendymd_work"))` | [CHECK: Is the scroll display date work field null or empty in dataMap?] |
| 2 | EXEC | `template.set(PARAMETER_5, (String) childMap.get("parameter_6"))` | Fallback: use childMap's parameter_6 value in PARAMETER_5 slot |
| 3 | EXEC | `template.set(PARAMETER_6, dataMap.get("ekk0321c020_kakins_tendymd_work"))` | Primary: set PARAMETER_6 from dataMap's scroll display date work field |

**Block 7.2** — [IF/ELSE] Parameter_8 special case: uses dataMap (L2621)

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_mk_flg_work") == null || "".equals(dataMap.get("ekk0321c020_mk_flg_work"))` | [CHECK: Is the mark flag work field null or empty?] |
| 2 | EXEC | `template.setNull(PARAMETER_8)` | Set PARAMETER_8 to null when work field is empty |
| 3 | EXEC | `template.set(PARAMETER_8, dataMap.get("ekk0321c020_mk_flg_work"))` | Set PARAMETER_8 from dataMap's mark flag work field |

**Block 7.3** — [IF/ELSE] Parameter_9 special case: uses dataMap (L2627)

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_add_dtm_work") == null || "".equals(dataMap.get("ekk0321c020_add_dtm_work"))` | [CHECK: Is the addition datetime work field null or empty?] |
| 2 | EXEC | `template.setNull(PARAMETER_9)` | Set PARAMETER_9 to null when work field is empty |
| 3 | EXEC | `template.set(PARAMETER_9, dataMap.get("ekk0321c020_add_dtm_work"))` | Set PARAMETER_9 from dataMap's addition datetime work field |

**Block 7.4** — [IF/ELSE] Parameter_10 special case: uses dataMap (L2633)

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_add_opeacnt_work") == null || "".equals(dataMap.get("ekk0321c020_add_opeacnt_work"))` | [CHECK: Is the addition operator account work field null or empty?] |
| 2 | EXEC | `template.setNull(PARAMETER_10)` | Set PARAMETER_10 to null when work field is empty |
| 3 | EXEC | `template.set(PARAMETER_10, dataMap.get("ekk0321c020_add_opeacnt_work"))` | Set PARAMETER_10 from dataMap's addition operator account work field |

**Block 7.5** — [IF/ELSE] Parameter_12 special case: uses dataMap (L2659)

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_upd_dtm_work") == null || "".equals(dataMap.get("ekk0321c020_upd_dtm_work"))` | [CHECK: Is the update datetime work field null or empty?] |
| 2 | EXEC | `template.setNull(PARAMETER_12)` | Set PARAMETER_12 to null when work field is empty |
| 3 | EXEC | `template.set(PARAMETER_12, dataMap.get("ekk0321c020_upd_dtm_work"))` | Set PARAMETER_12 from dataMap's update datetime work field |

**Block 7.6** — [IF/ELSE] Parameter_13 special case: uses dataMap (L2665)

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | IF | `dataMap == null || dataMap.get("ekk0321c020_upd_opeacnt_work") == null || "".equals(dataMap.get("ekk0321c020_upd_opeacnt_work"))` | [CHECK: Is the update operator account work field null or empty?] |
| 2 | EXEC | `template.setNull(PARAMETER_13)` | Set PARAMETER_13 to null when work field is empty |
| 3 | EXEC | `template.set(PARAMETER_13, dataMap.get("ekk0321c020_upd_opeacnt_work"))` | Set PARAMETER_13 from dataMap's update operator account work field |

**Block 8** — [EXEC x 30] Nullify parameters 21–50 (L2734–L2763)

All remaining parameters (21 through 50) are explicitly set to null to ensure the SC caller receives a clean message envelope without stale data.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1–30 | EXEC | `template.setNull(PARAMETER_21)` through `template.setNull(PARAMETER_50)` | Nullify unused parameters 21 through 50 |

**Block 9** — [SET] Build and attach template array (L2766)

Constructs the CAANMsg array and attaches it to the parameter map for the caller.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | SET | `templates = new CAANMsg[1]` | Creates a single-element CAANMsg array |
| 2 | SET | `templates[0] = template` | Populates the array with the built message |
| 3 | SET | `paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates)` | Attaches the template array to the parameter map under the template list key |
| 4 | RETURN | `return paramMap` | Returns the populated request parameter map to the caller |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `tmplIdEck0151d010` | Constant | Template ID for the instruction document registration message schema — value `"ECK0151D010"` |
| `trn_cd` | Field | Transaction code — identifies the type of transaction being registered in the instruction document |
| `trgt_table_id` | Field | Target table ID — identifies the database table that is the target of the instruction document operation |
| `tran_trgt_sysid` | Field | Transaction target system ID — identifies the target system for the transaction in a multi-system environment |
| `rslt_flg` | Field | Result flag — indicates the result status of a prior operation (success/failure indicator) |
| `parameter_yk_cnt` | Field | Parameter valid count — the number of valid (non-empty) parameter fields being passed |
| `parameter_1` through `parameter_20` | Fields | Parameter 1 through Parameter 20 — individual data fields carrying business data for the instruction document registration |
| `parameter_21` through `parameter_50` | Fields | Reserved parameter fields — explicitly nullified to provide a clean message envelope for the SC |
| `ekk0321c020_kakins_tendymd_work` | Field | Scroll display date work field — a work area field from EKK0321C020 process holding a display/scroll date value |
| `ekk0321c020_mk_flg_work` | Field | Mark flag work field — a work area field from EKK0321C020 process holding a validity/mark flag |
| `ekk0321c020_add_dtm_work` | Field | Addition datetime work field — a work area field from EKK0321C020 process holding the record creation date/time |
| `ekk0321c020_add_opeacnt_work` | Field | Addition operator account work field — a work area field holding the operator account that created the record |
| `ekk0321c020_upd_dtm_work` | Field | Update datetime work field — a work area field from EKK0321C020 process holding the last update date/time |
| `ekk0321c020_upd_opeacnt_work` | Field | Update operator account work field — a work area field holding the operator account that last updated the record |
| CAANMsg | Technical | Fujitsu's message envelope class used for Service Component communication — strongly typed via CBS message schema classes |
| ECK0151D010CBSMsg | Technical | The CBS message schema class defining the field structure for the instruction document registration service interface |
| FUNC_CODE | Field | Function code — identifies the type of function being invoked; value "1" indicates the registration operation |
| TEMPLATE_ID_ECK0151D010 | Constant | Template identifier constant with value `"ECK0151D010"` used to tag the message envelope |
| KKSV0546CCList | Field | User data key referencing screen KKSV0546's CC (component controller) list data |
| KKSV0546 | Screen | Screen identifier for the instruction document registration input screen |
| `editInMsg` | Method | Common method that initializes base request parameter fields (operator ID, date/time) in the request parameter map |
| `execECK0151D010` | Method | Entry-point orchestration method that calls `editInMsg_ECK0151D010` for message building, then `scCall.run()` for the SC invocation |
| SC | Abbreviation | Service Component — a service layer component in the k-Opticom architecture that processes business operations |
| CBS | Abbreviation | Component-Based System — the service-oriented architecture layer used for inter-component communication |
| PARAMETER_YK_CNT | Field | Parameter valid count (yk = 有効 = valid/count) — indicates how many parameters are actually provided |
| OPERATOR_ID | Field | The ID of the user/operator performing the instruction document registration |
| OPE_DATE | Field | Operating date — the date of the operation, retrieved from the control map |
| OPE_TIME | Field | Operating date/time — the timestamp of the operation, retrieved from the control map |
| KK_T_SJISHO (inferred) | Table | Instruction Document table — the target database table for instruction document registration (based on field naming convention `sjisho_no` = instruction document number, `sjisho_naiyo_seq` = instruction document content sequence) |
| TEMPLATE_LIST_KEY | Constant | The key used to store the CAANMsg array in the request parameter map for SC invocation |