# Business Logic — JFUAddSvcKeiNetCC.editErrInfoEKK0171D010() [172 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JFUAddSvcKeiNetCC` |
| Layer | CC / Common Component — Custom business logic shared component (package `com.fujitsu.futurity.bp.custom.common`) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JFUAddSvcKeiNetCC.editErrInfoEKK0171D010()

This method is the error-mapping handler for the **Service Contract Detail (e-light Net) Registration** screen (screen I/F `EKK0171D010`). After a backend CBS (Call Back Service) invocation populates a `CAANMsg` template with error information, this method transfers the error details from the template into the request parameter's data map so the presentation layer can display field-level validation errors to the user.

The method implements a **priority-based error suppression pattern**: if the CBS returns a non-zero status code (indicating an error), the method overrides the template status to `9000` and compares it against any previously recorded status stored in the request's control map. Only if the new template status is higher (more severe) than the existing one does it propagate the new error details into the parameter. This prevents a less-severe error from overwriting a more-severe one when multiple CBS invocations occur in sequence (e.g., main contract + detail contract error handling).

It also performs **message key validation** — the template status is cross-checked against registered message resources (via `JCMAPLConstMgr.getString("RETURN_MESSAGE_" + status)`). If the status code does not correspond to a defined message key, the status is reset to `0` (success), effectively suppressing the error. This defensive check prevents display of undefined or malformed status codes.

The method then copies **17 distinct error fields** (service contract number, order detail number, provider plan contract number, payment method continuation flag, web option addition failure flag, various date fields, penalty code, migration division code, and provision area code) from the template to the inMap — but only if the field is non-null in the template and not already present in the local map (defensive duplicate suppression).

As a **private utility method**, it is called from `editErrorInfo()` (the main public error-mapping orchestrator) and `editOutEKK0171D010Msg()` (an alternate entry point for out-of-band message handling). It does not directly call any database or service component layers; all I/O is confined to in-memory parameter objects and message resource lookups.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["editErrInfoEKK0171D010"])
    START --> GET_STATUS["Get template status from template"]
    GET_STATUS --> RETURN_CHECK{"returnCode != 0?"}
    RETURN_CHECK -->|Yes| SET_ERR["Set templateStatus = 9000"]
    RETURN_CHECK -->|No| STATUS_KEEP["templateStatus remains as-is"]
    SET_ERR --> VALIDATE_STATUS["Validate: JCMAPLConstMgr.getString(RETURN_MESSAGE_ + status)?"]
    STATUS_KEEP --> VALIDATE_STATUS
    VALIDATE_STATUS --> NULL_CHECK{"Result == null?"}
    NULL_CHECK -->|Yes| RESET_STATUS["Set templateStatus = 0"]
    NULL_CHECK -->|No| VALID_OK["Status is valid"]
    RESET_STATUS --> VALID_OK
    VALID_OK --> GET_BP_STATUS["Get bpStatus from control map key RETURN_CODE"]
    GET_BP_STATUS --> BP_NULL{"bpStatus is null?"}
    BP_NULL -->|Yes| BP_NEG1["Set bpStatus = -1"]
    BP_NULL -->|No| PARSE_STATUS["Parse bpStatus = Integer.parseInt(returnCode)"]
    PARSE_STATUS --> COMPARE_STATUS{"templateStatus > bpStatus?"}
    BP_NEG1 --> COMPARE_STATUS
    COMPARE_STATUS -->|No| RETURN_PARAM["Return param"]
    COMPARE_STATUS -->|Yes| INIT_MAP["Get inMap from param.getData('EKK0171D010')"]
    INIT_MAP --> LOOP_FIELDS["Process 17 error fields"]
    LOOP_FIELDS --> FIELD_CHECK{"Field is not null in template?"}
    FIELD_CHECK -->|No| FIELD_DONE["Field skip: null in template"]
    FIELD_CHECK -->|Yes| CONTAIN_CHECK{"inMap contains key?"}
    CONTAIN_CHECK -->|Yes| FIELD_DONE
    CONTAIN_CHECK -->|No| PUT_VALUE["inMap.put(key, template.getString(field))"]
    PUT_VALUE --> FIELD_DONE
    FIELD_DONE --> MORE_FIELDS{"More fields to process?"}
    MORE_FIELDS -->|Yes| LOOP_FIELDS
    MORE_FIELDS -->|No| RETURN_PARAM
    RETURN_PARAM --> END(["Return param"])
```

**Processing summary:**

| Step | Description |
|------|-------------|
| 1 | Extract the CBS error status code from the template's `STATUS` field (`EKK0091D010CBSMsg.STATUS`). If `returnCode` is non-zero, force template status to `9000` (critical error). |
| 2 | Validate the status code against the message resource registry. If no matching message exists for `RETURN_MESSAGE_<status>`, reset status to `0` (suppress invalid status). |
| 3 | Read the previously recorded business process status (`bpStatus`) from the control map's `RETURN_CODE` key. If absent, default to `-1` (lowest severity). |
| 4 | Compare `templateStatus` vs `bpStatus`. Only if the new status is strictly greater (more severe) does the method proceed to copy error fields. This is the **priority-based error suppression** gate. |
| 5 | If the gate passes, retrieve the `EKK0171D010` data map from the parameter. Then iterate through 17 error fields, each following the same pattern: if the field is non-null in the template AND the local map does not already contain that key, copy the value. This prevents duplicate overwrites and respects fields already populated by prior processing. |
| 6 | Return the parameter (with modified inMap) to the caller. |

**Constant Resolution:**

| Constant | Resolved Value | Business Meaning |
|----------|---------------|------------------|
| `RETURN_MESSAGE_STRING` | `"RETURN_MESSAGE_"` | Prefix for message resource lookups by 4-digit status code |
| `RETURN_MESSAGE_FORMAT` | `"%1$04d"` | Format specifier: zero-padded 4-digit status (e.g., "1000", "9000") |
| `TMCK_ERR_STATUS` | `1000` | Template mapping error status threshold (defined in class, used in other methods) |

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The request parameter object carrying both control map metadata (return code, error info) and a data map keyed by `EKK0171D010` that holds service contract detail registration field values and their associated error messages. This object is passed through the entire processing chain and returned with updated error fields. |
| 2 | `template` | `CAANMsg` | A CBS message template populated by the backend service component. Contains both the `STATUS` field (error severity code) and individual error fields (each suffixed with `_ERR`) carrying field-level validation error values from the database or business logic layer. |
| 3 | `returnCode` | `int` | The return code from the CBS invocation. Non-zero indicates the CBS execution encountered an error — in this case, the method overrides the template's status to `9000` (critical error status). Zero indicates successful CBS execution. |
| 4 | `fixedText` | `String` | A fixed identifier text used as a prefix/key when retrieving error field names from the template. In the caller, this is always `"EKK0171D010"` — identifying the specific screen's error data area. |

**Fields/State read during processing:**

| Source | Field/Key | Purpose |
|--------|-----------|---------|
| `JCMAPLConstMgr` | Message resource lookups via `getString("RETURN_MESSAGE_" + status)` | Validates that the status code has a corresponding user-facing message |
| `param` control map | `SCControlMapKeys.RETURN_CODE` | Previously recorded error severity for priority comparison |
| `param` data map | Key `"EKK0171D010"` → `HashMap` | The target map where error field values are copied |

## 4. CRUD Operations / Called Services

This method performs **no database operations** and **no service component (SC) calls**. All processing is in-memory: reading from the `CAANMsg` template, reading/writing the `IRequestParameterReadWrite` object's control map and data map, and performing a message resource lookup.

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `JCMAPLConstMgr.getString` | - | - | Reads message resource bundle by key to validate whether the template status code corresponds to a defined error message |
| R | `param.getControlMapData` | - | - | Reads the previously recorded return code from the control map |
| W | `param.setControlMapData` | - | - | Updates the control map with a new return code and error message (only when template status exceeds current) |
| R/W | `param.getData("EKK0171D010")` | - | - | Retrieves the data map for error field storage; writes via `inMap.put()` for each error field |
| R | `template.isNull(...)` | - | - | Checks whether each error field is populated in the CBS template |
| R | `template.getString(...)` | - | - | Reads the error field value from the CBS template |

**Note:** While this method does not directly invoke any CBS, SC, or DAO layer, it is part of the CBS error-handling pipeline. The CBS responses (in the `template` parameter) originate from prior invocations such as `EKK0171D010SC` or `EKK0091D010SC`, which do perform database operations on the service contract detail entities.

## 5. Dependency Trace

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

No screen/batch entry points found within 8 hops. Direct callers found: 2 methods.

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:KKSV0004 (example — eo light net registration) | `KKSV0004.doProcess` -> `JFUAddSvcKeiNetCC.editErrorInfo` -> `JFUAddSvcKeiNetCC.editErrInfoEKK0171D010` | `template.getString` [R], `template.isNull` [R], `JCMAPLConstMgr.getString` [R] |
| 2 | Screen:KKSV0004 (alternate path) | `KKSV0004.doProcess` -> `JFUAddSvcKeiNetCC.editOutEKK0171D010Msg` -> `JFUAddSvcKeiNetCC.editErrInfoEKK0171D010` | `template.getString` [R], `template.isNull` [R], `JCMAPLConstMgr.getString` [R] |

**Direct callers:**

| Caller | Kind | Context |
|--------|------|---------|
| `JFUAddSvcKeiNetCC.editErrorInfo()` | CC Method | Public orchestrator that iterates over CBS response templates for the main contract (`EKK0091D010`) and detail contract (`EKK0171D010`), delegating error mapping to this private method for each |
| `JFUAddSvcKeiNetCC.editOutEKK0171D010Msg()` | CC Method | Alternate error-mapping entry point used for out-of-band message scenarios; processes templates in a loop and delegates to this method per template |

**Terminal operations from this method:**

All operations are in-memory reads/writes — no database, SC, or external system calls:
- `template.getString(...)` [R] × 17 (error field values)
- `template.isNull(...)` [R] × 17 (null checks for each error field)
- `JCMAPLConstMgr.getString(...)` [R] × 1 (message resource validation)
- `param.getControlMapData(...)` [R] × 1 (bpStatus read)
- `param.setControlMapData(...)` [W] × 2 (returnCode and returnMessage)
- `inMap.put(...)` [W] × 0-17 (error field writes, conditional)

## 6. Per-Branch Detail Blocks

### Block 1 — IF `(returnCode != 0)` (L2798)

Determine if the CBS invocation returned a non-zero return code. If so, override the template's status to `9000` (critical error).

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = template.getInt(EKK0091D010CBSMsg.STATUS)` |
| 2 | IF | `returnCode != 0` (non-zero CBS return code indicates error) |

**Block 1.1** — IF branch: `returnCode != 0` (L2800)

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = 9000` // Override to critical error status |

### Block 2 — IF `(JCMAPLConstMgr.getString(...) == null)` (L2803)

Validate that the current `templateStatus` corresponds to a registered message resource key. If no message resource exists for the status code, reset to `0` (success/no error). This prevents display of undefined status codes.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus))` |
| 2 | IF | `result == null` (no message resource for this status) |

**Block 2.1** — IF branch: no matching message resource (L2805)

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = 0` // Reset to success — suppress undefined status |

### Block 3 — BP STATUS READ (L2808–2818)

Read the previously recorded error severity from the control map. This is the value against which the new template status will be compared for priority-based suppression.

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = 0` // Default initial value |
| 2 | EXEC | `obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE)` |
| 3 | IF | `obj == null` (no prior return code recorded) |

**Block 3.1** — IF branch: no prior return code (L2812)

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = -1` // Default to lowest severity |

**Block 3.2** — ELSE branch: prior return code exists (L2815–2818)

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE))` |

### Block 4 — IF `(templateStatus > bpStatus)` (L2820)

**Priority gate**: Only propagate errors if the new template status is strictly more severe than what is already recorded. This prevents less-severe errors from overwriting previously recorded more-severe errors when multiple CBS invocations occur in sequence.

| # | Type | Code |
|---|------|------|
| 1 | SET | `formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus)` |
| 2 | SET | `message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus)` |
| 3 | SET | `param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus)` |
| 4 | SET | `param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message)` |

### Block 5 — DATA MAP RETRIEVAL (L2823)

Retrieve the data map where error field values will be stored. The map is keyed by the screen identifier `"EKK0171D010"`.

| # | Type | Code |
|---|------|------|
| 1 | SET | `inMap = (HashMap)(param.getData("EKK0171D010"))` |

### Block 6 — FIELD 1: SVC_KEI_NO_ERR (Service Contract Number Error) (L2826–2831)

> サービス契約番号 — Service Contract Number

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.SVC_KEI_NO_ERR)` |

**Block 6.1** — Nested IF: field not in local map (L2828)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("svc_kei_no_err")` |
| 2 | EXEC | `inMap.put("svc_kei_no_err", template.getString(EKK0171D010CBSMsg.SVC_KEI_NO_ERR))` |

### Block 7 — FIELD 2: MSKM_DTL_NO_ERR (Order Detail Number Error) (L2834–2839)

> 申込明細番号 — Order Detail Number

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.MSKM_DTL_NO_ERR)` |

**Block 7.1** — Nested IF: field not in local map (L2836)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("mskm_dtl_no_err")` |
| 2 | EXEC | `inMap.put("mskm_dtl_no_err", template.getString(EKK0171D010CBSMsg.MSKM_DTL_NO_ERR))` |

### Block 8 — FIELD 3: TK_HOSHIKI_KEI_NO_ERR (Provider Plan Contract Number Error) (L2842–2847)

> 提供方式契約番号 — Provider Plan Contract Number

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.TK_HOSHIKI_KEI_NO_ERR)` |

**Block 8.1** — Nested IF: field not in local map (L2844)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("tk_hoshiki_kei_no_err")` |
| 2 | EXEC | `inMap.put("tk_hoshiki_kei_no_err", template.getString(EKK0171D010CBSMsg.TK_HOSHIKI_KEI_NO_ERR))` |

### Block 9 — FIELD 4: PAYWAY_KEIZOKU_FLG_ERR (Payment Method Continuation Flag Error) (L2850–2855)

> 支払方法継続フラグ — Payment Method Continuation Flag

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.PAYWAY_KEIZOKU_FLG_ERR)` |

**Block 9.1** — Nested IF: field not in local map (L2852)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("payway_keizoku_flg_err")` |
| 2 | EXEC | `inMap.put("payway_keizoku_flg_err", template.getString(EKK0171D010CBSMsg.PAYWAY_KEIZOKU_FLG_ERR))` |

### Block 10 — FIELD 5: WEB_OP_ADD_FAIL_FLG_ERR (Web Option Addition Failure Flag Error) (L2858–2863)

> WEBオプション追加不可フラグ — Web Option Addition Impossible Flag

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR)` |

**Block 10.1** — Nested IF: field not in local map (L2860)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("web_op_add_fail_flg_err")` |
| 2 | EXEC | `inMap.put("web_op_add_fail_flg_err", template.getString(EKK0171D010CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR))` |

### Block 11 — FIELD 6: SVC_USE_STA_KIBO_YMD_ERR (Service Usage Start Desired Date Error) (L2866–2871)

> サービス利用開始希望年月日 — Service Usage Start Desired Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR)` |

**Block 11.1** — Nested IF: field not in local map (L2868)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("svc_use_sta_kibo_ymd_err")` |
| 2 | EXEC | `inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0171D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))` |

### Block 12 — FIELD 7: RSV_TSTA_KIBO_YMD_ERR (Reservation Application Start Desired Date Error) (L2874–2879)

> 予約適用開始希望年月日 — Reservation Application Start Desired Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR)` |

**Block 12.1** — Nested IF: field not in local map (L2876)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("rsv_tsta_kibo_ymd_err")` |
| 2 | EXEC | `inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0171D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))` |

### Block 13 — FIELD 8: FTRIAL_KANYU_YMD_ERR (Free Trial Entry Date Error) (L2882–2887)

> 試用加入年月日 — Free Trial Entry Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.FTRIAL_KANYU_YMD_ERR)` |

**Block 13.1** — Nested IF: field not in local map (L2884)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("ftrial_kanyu_ymd_err")` |
| 2 | EXEC | `inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0171D010CBSMsg.FTRIAL_KANYU_YMD_ERR))` |

### Block 14 — FIELD 9: FTRIAL_PRD_ENDYMD_ERR (Free Trial Period End Date Error) (L2890–2895)

> 試用期間終了年月日 — Free Trial Period End Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR)` |

**Block 14.1** — Nested IF: field not in local map (L2892)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("ftrial_prd_endymd_err")` |
| 2 | EXEC | `inMap.put("ftrial_prd_endymd_err", template.getString(EKK0171D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))` |

### Block 15 — FIELD 10: HONKANYU_YMD_ERR (Full Registration Entry Date Error) (L2898–2903)

> 本加入年月日 — Full Service Entry Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.HONKANYU_YMD_ERR)` |

**Block 15.1** — Nested IF: field not in local map (L2900)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("honkanyu_ymd_err")` |
| 2 | EXEC | `inMap.put("honkanyu_ymd_err", template.getString(EKK0171D010CBSMsg.HONKANYU_YMD_ERR))` |

### Block 16 — FIELD 11: HONKANYU_IKO_KIGEN_YMD_ERR (Full Registration Migration Deadline Date Error) (L2906–2911)

> 本加入移行期限年月日 — Full Service Migration Deadline Date (Year-Month-Day)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR)` |

**Block 16.1** — Nested IF: field not in local map (L2908)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("honkanyu_iko_kigen_ymd_err")` |
| 2 | EXEC | `inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0171D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))` |

### Block 17 — FIELD 12: PNLTY_HASSEI_CD_ERR (Penalty Occurrence Code Error) (L2914–2919)

> 違約金発生コード — Penalty Occurrence Code

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.PNLTY_HASSEI_CD_ERR)` |

**Block 17.1** — Nested IF: field not in local map (L2916)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("pnlty_hassei_cd_err")` |
| 2 | EXEC | `inMap.put("pnlty_hassei_cd_err", template.getString(EKK0171D010CBSMsg.PNLTY_HASSEI_CD_ERR))` |

### Block 18 — FIELD 13: IDO_DIV_ERR (Migration Division Error) (L2922–2927)

> 異動区分 — Migration Division (code indicating type of service migration/transfer)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.IDO_DIV_ERR)` |

**Block 18.1** — Nested IF: field not in local map (L2924)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("ido_div_err")` |
| 2 | EXEC | `inMap.put("ido_div_err", template.getString(EKK0171D010CBSMsg.IDO_DIV_ERR))` |

### Block 19 — FIELD 14: TK_TAIIKI_CD_ERR (Provision Area Code Error) (L2930–2935)

> 提供帯域コード — Provision Bandwidth Area Code

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.TK_TAIIKI_CD_ERR)` |

**Block 19.1** — Nested IF: field not in local map (L2932)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("tk_taiiki_cd_err")` |
| 2 | EXEC | `inMap.put("tk_taiiki_cd_err", template.getString(EKK0171D010CBSMsg.TK_TAIIKI_CD_ERR))` |

### Block 20 — FIELD 15: UPD_DTM_BF_ERR (Update Date-Time Before Error — Service Interface Integration) (L2938–2943)

> 更新年月日时分秒(更新前)エラー — Update Date-Time (YYYYMMDDHHMMSS) Before Update Error

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK0171D010CBSMsg.UPD_DTM_BF_ERR)` |

**Block 20.1** — Nested IF: field not in local map (L2940)

| # | Type | Code |
|---|------|------|
| 1 | IF | `!inMap.containsKey("upd_dtm_bf_err")` |
| 2 | EXEC | `inMap.put("upd_dtm_bf_err", template.getString(EKK0171D010CBSMsg.UPD_DTM_BF_ERR))` |

> ----- 2012/05/07 サービスインターフェース取込対応 h.iwamoto START ----
> (----- 2012/05/07 Service Interface Integration Countermeasure h.iwamoto START ----)

> ----- 2012/05/07 サービスインターフェース取込対応 h.iwamoto END ----
> (----- 2012/05/07 Service Interface Integration Countermeasure h.iwamoto END ----)

### Block 21 — RETURN (L2946)

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return param` |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `svc_kei_no_err` | Field | Service Contract Number Error — the contract number associated with an error, used for display in error messages |
| `mskm_dtl_no_err` | Field | Order Detail Number Error — the detail line number of the order that triggered an error |
| `tk_hoshiki_kei_no_err` | Field | Provider Plan Contract Number Error — the plan contract number from the service provider that is associated with an error |
| `payway_keizoku_flg_err` | Field | Payment Method Continuation Flag Error — indicates whether the existing payment method continues to be valid |
| `web_op_add_fail_flg_err` | Field | Web Option Addition Failure Flag Error — indicates that a web option could not be added due to validation failure |
| `svc_use_sta_kibo_ymd_err` | Field | Service Usage Start Desired Date Error — the customer's requested service start date (YYYYMMDD format) |
| `rsv_tsta_kibo_ymd_err` | Field | Reservation Application Start Desired Date Error — the customer's desired date for reservation application start (YYYYMMDD format) |
| `ftrial_kanyu_ymd_err` | Field | Free Trial Entry Date Error — the date the free trial period begins (YYYYMMDD format) |
| `ftrial_prd_endymd_err` | Field | Free Trial Period End Date Error — the date the free trial period ends (YYYYMMDD format) |
| `honkanyu_ymd_err` | Field | Full Service Entry Date Error — the date the service transitions from trial to full-paid status (YYYYMMDD format) |
| `honkanyu_iko_kigen_ymd_err` | Field | Full Service Migration Deadline Date Error — the deadline by which full service migration must be completed (YYYYMMDD format) |
| `pnlty_hassei_cd_err` | Field | Penalty Occurrence Code Error — a code indicating a breach of contract penalty has been incurred |
| `ido_div_err` | Field | Migration Division Error — a code classifying the type of service migration or account transfer |
| `tk_taiiki_cd_err` | Field | Provision Bandwidth Area Code Error — a code identifying the service provision area or bandwidth zone |
| `upd_dtm_bf_err` | Field | Update Date-Time Before Update Error — the date-time (YYYYMMDDHHMMSS) prior to the most recent update |
| `EKK0171D010` | Screen ID | Service Contract Detail (e-light Net) Registration — the screen that registers service contract line items for fiber-optic internet services |
| `EKK0091D010` | Screen ID | Service Contract (e-light Net) Registration — the screen that registers the main service contract header |
| `CAANMsg` | Technical | K-Opticom's message wrapper class for CBS (Call Back Service) request/response objects, providing type-safe field access |
| `IRequestParameterReadWrite` | Technical | Interface for the request parameter object that carries both control map metadata and data map fields through the processing pipeline |
| `SCControlMapKeys` | Technical | Constants class for control map keys used to store return codes, error info, and other control metadata |
| `RETURN_MESSAGE_*` | Constant | Message resource prefix used for lookups by 4-digit status code (e.g., `RETURN_MESSAGE_1000`) |
| `JCMAPLConstMgr` | Technical | Application-level constant/message resource manager that provides runtime-accessible string resources |
| `e-light Net` | Business | K-Opticom's fiber-optic internet service brand — "eoひかりネット" (eo Hikari Net) in Japanese |
| FTTH | Business | Fiber To The Home — the physical broadband delivery technology underlying the e-light Net service |
| CBS | Technical | Call Back Service — the enterprise service layer component invoked by the business process that performs database operations |
| CC | Technical | Common Component — a shared reusable component class containing business logic across multiple screens |
| bpStatus | Field | Business Process Status — the previously recorded error severity level from the control map, used for priority comparison |
| templateStatus | Local Variable | The CBS response status code extracted from the template, potentially overridden to 9000 if returnCode is non-zero |
| inMap | Local Variable | The HashMap holding field-level error data for the EKK0171D010 screen, keyed by field name |
| 申込明細番号 | Field (Japanese) | Order Detail Number — identifies a specific line item within a service order |
| 提供方式契約番号 | Field (Japanese) | Provider Plan Contract Number — the contract number assigned by the service provider for a specific service plan |
| 違約金発生コード | Field (Japanese) | Penalty Occurrence Code — a billing code that indicates a contract breach penalty has been assessed |
| 異動区分 | Field (Japanese) | Migration Division — a classification code for types of service account transfers or migrations |
| 提供帯域コード | Field (Japanese) | Provision Bandwidth Area Code — identifies the service provision zone and available bandwidth tier |