# Business Logic — JKKKikiDslAddCC.editErrorInfo_EKK1081D010CBS() [193 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKKikiDslAddCC` |
| Layer | CC / Common Component (Business logic shared across DSL processing) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKKikiDslAddCC.editErrorInfo_EKK1081D010CBS()

This method implements the **Order Issuance Condition Registration error information retrieval service interface**. It receives processing result error data from a service component (`EKK1081D010CBS`) via a `CAANMsg` template array and maps the error information back into the business parameter work area so that the calling screen can present meaningful error messages to the user.

The method first resolves the service component's return status, overriding it to `9000` (error) when the outer `returnCode` indicates failure, then validates the status against the return message constant registry to ensure a user-readable message exists. It then performs a status comparison: if the service component's status is numerically worse (higher) than the business processor's current status, it propagates the more severe status and its associated message to the control map, implementing a **max-severity override pattern**.

After status resolution, the method initializes the work area and the order issuance condition registration mapping map (`HAKKOSODCCWORKMAP`). It then iterates through **15 distinct error fields** extracted from the template message, copying each non-null error value into the work map — but only if the key has not already been set, implementing a **first-write-wins deduplication pattern** to prevent later errors from overwriting earlier, more specific error messages.

The 15 error fields cover: service contract number, service contract detail number, equipment-provided service contract number, option service contract number, sub-option service contract number, billing option service contract number, order type code, service order code, request type code, order issuance condition code, common processing number, indoor equipment model code, equipment serial number, email address, Spot Login system ID, transmission request completion timestamp, and service contract line detail number. This method acts as a **dedicated error-handoff bridge** between the CBS layer and the screen-level business processor (`editResultRP_EKK1081D010CBS`), ensuring that the error context flows cleanly upward without losing granularity.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["editErrorInfo_EKK1081D010CBS"])
    A["template = templates[0]"] --> B["templateStatus = template.getInt(STATUS)"]
    B --> C{returnCode != 0}
    C -->|true| D["templateStatus = 9000"]
    C -->|false| E["keep templateStatus"]
    D --> F{JCMAPLConstMgr.getString null for RETURN_MESSAGE_ + status}
    E --> F
    F -->|yes| G["templateStatus = 0"]
    F -->|no| H["keep templateStatus"]
    G --> I["bpStatus = parseControlMapData(RETURN_CODE)"]
    H --> I
    I --> J{templateStatus > bpStatus}
    J -->|true| K["Set formatted status + message to controlMapData"]
    J -->|false| L["skip status update"]
    K --> L
    L --> M{workMap is null}
    M -->|yes| N["workMap = new HashMap, setMappingWorkArea"]
    M -->|no| O["workMap exists"]
    N --> O
    O --> P{inMap is null}
    P -->|yes| Q["inMap = new HashMap, setData(HAKKOSODCCWORKMAP)"]
    P -->|no| R["inMap exists"]
    Q --> R
    R --> S["svc_kei_no_err field"]
    S --> T["svc_kei_ucwk_no_err field"]
    T --> U["kktk_svc_kei_no_err field"]
    U --> V["op_svc_kei_no_err field"]
    V --> W["sbop_svc_kei_no_err field"]
    W --> X["seiopsvc_kei_no_err field"]
    X --> Y["order_sbt_cd_err field"]
    Y --> Z["svc_order_cd_err field"]
    Z --> AA["yokyu_sbt_cd_err field"]
    AA --> AB["odr_hakko_joken_cd_err field"]
    AB --> AC["same_trn_no_err field"]
    AC --> AD["taknkiki_model_cd_err field"]
    AD --> AE["kiki_seizo_no_err field"]
    AE --> AF["mlad_err field"]
    AF --> AG["spot_login_sysid_err field"]
    AG --> AH["send_req_fin_dtm_err field"]
    AH --> AI["svc_kei_kaisen_ucwk_err field"]
    AI --> END(["return param"])
```

The method processes in three phases:

**Phase 1 — Status Resolution (Lines 1152–1160):** The method retrieves the status code from the first template message, overrides it to `9000` if the outer `returnCode` signals failure, and then validates that a user-facing return message exists in the constant registry for the resolved status. If no message constant exists, it resets the status to `0` (success/no-error), preventing the system from attempting to display a message that cannot be rendered.

**Phase 2 — Severity Comparison (Lines 1162–1174):** The method reads the current business processor status from the control map. If the service component's status is numerically higher (worse) than the BP status, it formats the status as a zero-padded 4-digit string, retrieves the corresponding message from constants, and writes both the formatted status and the human-readable message back into the control map. This implements a max-severity override — only the most severe error status is surfaced.

**Phase 3 — Error Field Mapping (Lines 1186–1336):** The method ensures the work map and the HAKKOSODCCWORKMAP in-map exist (creating them if null). It then iterates through 15 error fields from the template, copying each non-null error value into the in-map only if the key has not already been written. This first-write-wins strategy preserves the most specific error when multiple fields are erroneous.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The business data access interface carrying the request context, including control map data (return code, return message), and the mapping work area. It serves as the carrier for error information being pushed back to the calling screen layer. |
| 2 | `templates` | `CAANMsg[]` | An array of `CAANMsg` objects representing the service component result messages. `templates[0]` holds the error information returned from the `EKK1081D010CBS` service component, containing structured error fields for order issuance condition registration. |
| 3 | `returnCode` | `int` | The outer return code from the calling CBS layer. If non-zero, it forces the template status to `9000` (error), overriding whatever status the service component reported. This allows the caller to enforce a global failure state. |

**External state read:**

| Field | Type | Business Description |
|-------|------|---------------------|
| `JCMAPLConstMgr` | Constant manager | Static accessor for return message text keyed by `"RETURN_MESSAGE_" + status code`. Used to validate and retrieve user-facing error messages. |
| `SCControlMapKeys.RETURN_CODE` | Constant key | Control map key used to store and retrieve the current business processor return code (BP status). |
| `SCControlMapKeys.RETURN_MESSAGE` | Constant key | Control map key used to store the human-readable return message corresponding to the status. |
| `JKKHakkoSODConstCC.HAKKOSODCCWORKMAP` | Constant key | Work map key identifying the order issuance (Hakko) Service Order Data (SOD) CC work map, where error details are accumulated during DSL add processing. |
| `EKK1081D010CBSMsg.STATUS` | Constant key | Message key for extracting the service component status code from the template. |
| `EKK1081D010CBSMsg.SVC_KEI_NO_ERR` | Constant key | Message key for the service contract number error field. |
| `EKK1081D010CBSMsg.SVC_KEI_UCWK_NO_ERR` | Constant key | Message key for the service contract detail number error field. |
| `EKK1081D010CBSMsg.KKTK_SVC_KEI_NO_ERR` | Constant key | Message key for the equipment-provided service contract number error field. |
| `EKK1081D010CBSMsg.OP_SVC_KEI_NO_ERR` | Constant key | Message key for the option service contract number error field. |
| `EKK1081D010CBSMsg.SBOP_SVC_KEI_NO_ERR` | Constant key | Message key for the sub-option service contract number error field. |
| `EKK1081D010CBSMsg.SEIOPSVC_KEI_NO_ERR` | Constant key | Message key for the billing option service contract number error field. |
| `EKK1081D010CBSMsg.ORDER_SBT_CD_ERR` | Constant key | Message key for the order type code error field. |
| `EKK1081D010CBSMsg.SVC_ORDER_CD_ERR` | Constant key | Message key for the service order code error field. |
| `EKK1081D010CBSMsg.YOKYU_SBT_CD_ERR` | Constant key | Message key for the request type code error field. |
| `EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD_ERR` | Constant key | Message key for the order issuance condition code error field. |
| `EKK1081D010CBSMsg.SAME_TRN_NO_ERR` | Constant key | Message key for the common processing number error field. |
| `EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD_ERR` | Constant key | Message key for the indoor equipment model code error field. |
| `EKK1081D010CBSMsg.KIKI_SEIZO_NO_ERR` | Constant key | Message key for the equipment serial number error field. |
| `EKK1081D010CBSMsg.MLAD_ERR` | Constant key | Message key for the email address error field. |
| `EKK1081D010CBSMsg.SPOT_LOGIN_SYSID_ERR` | Constant key | Message key for the Spot Login system ID error field. |
| `EKK1081D010CBSMsg.SEND_REQ_FIN_DTM_ERR` | Constant key | Message key for the transmission request completion timestamp error field. |
| `EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR` | Constant key | Message key for the service contract line detail number error field (note: getter reads from `SVC_KEI_KAISEN_UCWK_NO_ERR` constant but maps to key `svc_kei_kaisen_ucwk_err`). |

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `JCMAPLConstMgr.getString` | - | - | Reads return message text from the constant registry for the resolved template status code |
| R | `param.getControlMapData` | - | - | Reads the current BP return code (bpStatus) from the control map |
| U | `param.setControlMapData` | - | - | Writes the formatted status code and message back into the control map when template status is more severe |
| R | `param.getMappingWorkArea` | - | - | Reads the work area map used for mapping between DSL layers |
| U | `param.setMappingWorkArea` | - | - | Initializes and stores a new empty work area map when one does not exist |
| R | `param.getData` | - | - | Reads the existing in-map from the parameter for the `HAKKOSODCCWORKMAP` key |
| U | `param.setData` | - | - | Stores the in-map (error accumulation buffer) into the parameter under `HAKKOSODCCWORKMAP` |
| R | `template.getInt` | - | - | Reads the status integer from the template message object |
| R | `JCMAPLConstMgr.getString` | - | - | Looks up whether a return message constant exists for a given status, to validate the status |
| R | `template.isNull` | - | - | Checks if each of the 15 error fields in the template contains a null/empty value |
| R | `template.getString` | - | - | Reads the error value string from the template for each of the 15 error fields |
| U | `inMap.put` | - | - | Writes the error value into the in-map work buffer under a specific string key, if key not already present |

**Classification rationale:**
- This method performs **no direct database operations**. It is a pure **data mapping and status resolution** method that operates on in-memory objects (`CAANMsg`, `HashMap`, `IRequestParameterReadWrite`).
- All reads (`R`) retrieve data from objects in memory: the template message, the control map, and the constant registry.
- All writes (`U`) modify in-memory structures: the control map (status + message) and the in-map work buffer (error fields).
- No Create, Delete, or entity/table-level operations are performed.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | JKKKikiDslAddCC | `editResultRP_EKK1081D010CBS()` -> `editErrorInfo_EKK1081D010CBS()` | `template.getInt [R] STATUS`, `template.getString [R] error fields`, `JCMAPLConstMgr.getString [R] RETURN_MESSAGE_*`, `param.setControlMapData [U] RETURN_CODE/RETURN_MESSAGE`, `param.setData [U] HAKKOSODCCWORKMAP` |

**Details:**
- The only direct caller is `editResultRP_EKK1081D010CBS()` within the same class (`JKKKikiDslAddCC`). This method is invoked after the `EKK1081D010CBS` service component executes, to interpret and propagate its results.
- No screen entry points (`KKSV*`) or batch entry points are found within 8 hops of this method. It is a downstream utility method in the DSL add processing pipeline.
- The terminal operations are all in-memory reads and writes with no database persistence.

## 6. Per-Branch Detail Blocks

**Block 1** — SET `(initialization)` (L1152)

Extracts the template message and initial status code.

| # | Type | Code |
|---|------|------|
| 1 | SET | `template = templates[0]` // First CAANMsg from the template array |
| 2 | SET | `templateStatus = template.getInt(EKK1081D010CBSMsg.STATUS)` // Service component status code |

**Block 2** — IF `(returnCode != 0)` (L1154)

Overrides template status to error code 9000 when the outer return code signals failure.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = 9000` // Force error status when outer return code is non-zero [-> 9000] |

**Block 3** — IF `{null == JCMAPLConstMgr.getString(...)}` (L1158)

Validates that a return message constant exists for the resolved status. If no message constant is found, resets status to 0 (success), preventing display of an unresolvable status.

| # | Type | Code |
|---|------|------|
| 1 | SET | `msgKey = "RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)` // Zero-padded 4-digit status |
| 2 | CALL | `JCMAPLConstMgr.getString(msgKey)` // Look up message constant |
| 3 | SET | `templateStatus = 0` // Reset to success — no user message available [-> 0] |

**Block 4** — SET / IF / ELSE `(bpStatus resolution)` (L1163–L1171)

Reads the current business processor status from the control map. If the control map key is absent, defaults `bpStatus` to -1 (so any positive status code will override it).

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = 0` // Default value |
| 2 | EXEC | `obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE)` // Current BP return code |
| 3 | IF | `null == obj` (L1165) |
| 3.1 | SET | `bpStatus = -1` // No existing BP status — any error will override [-> -1] |
| 3.2 | ELSE | (L1168) |
| 3.2.1 | SET | `bpStatus = Integer.parseInt((String) obj)` // Parse existing BP status |

**Block 5** — IF `(templateStatus > bpStatus)` (L1173)

Compares the resolved template status against the current BP status. Only if the template status is numerically higher (worse) does it propagate the template's status and message — implementing the max-severity override pattern.

| # | Type | Code |
|---|------|------|
| 1 | SET | `formatStatus = String.format("%1$04d", templateStatus)` // Zero-padded 4-digit status |
| 2 | CALL | `message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus)` // Retrieve user-facing message |
| 3 | SET | `param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus)` // Update BP return code |
| 4 | SET | `param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message)` // Update BP return message |

**Block 6** — IF `(null == workMap)` (L1188)

Ensures the mapping work area exists. If the work map is null (first invocation), creates a new HashMap and registers it.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `workMap = param.getMappingWorkArea()` // Retrieve current work area |
| 2 | IF | `null == workMap` (L1189) |
| 2.1 | SET | `workMap = new HashMap()` // Create new work area |
| 2.2 | SET | `param.setMappingWorkArea(workMap)` // Store it |

**Block 7** — IF `(null == inMap)` (L1194)

Ensures the order issuance condition registration mapping work map exists. This map (`HAKKOSODCCWORKMAP`) is the accumulation buffer for all error fields from the CBS layer.

| # | Type | Code |
|---|------|------|
| 1 | SET | `inMap = (HashMap) param.getData(JKKHakkoSODConstCC.HAKKOSODCCWORKMAP)` // Retrieve existing in-map |
| 2 | IF | `null == inMap` (L1195) |
| 2.1 | SET | `inMap = new HashMap()` // Create new accumulation buffer |
| 2.2 | SET | `param.setData(JKKHakkoSODConstCC.HAKKOSODCCWORKMAP, inMap)` // Store it |

**Block 8** — IF chain: 15 error field mappings (L1201–L1336)

Each of the 15 error fields follows the identical pattern: check if the template field is non-null, check if the in-map key has not already been written (first-write-wins), then copy the error value. These are presented as a flat sequence since they are sequential independent checks (no branching between fields).

> **Block 8.1** — `svc_kei_no_err` (L1201) — Service Contract Number Error
> Maps the service contract number error if present and not already set.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SVC_KEI_NO_ERR)` (L1202) |
| 1.1 | IF | `!inMap.containsKey("svc_kei_no_err")` (L1203) |
| 1.1.1 | SET | `inMap.put("svc_kei_no_err", template.getString(EKK1081D010CBSMsg.SVC_KEI_NO_ERR))` |

> **Block 8.2** — `svc_kei_ucwk_no_err` (L1210) — Service Contract Detail Number Error
> Maps the service contract detail number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO_ERR)` (L1211) |
| 1.1 | IF | `!inMap.containsKey("svc_kei_ucwk_no_err")` (L1212) |
| 1.1.1 | SET | `inMap.put("svc_kei_ucwk_no_err", template.getString(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO_ERR))` |

> **Block 8.3** — `kktk_svc_kei_no_err` (L1218) — Equipment-Provided Service Contract Number Error
> Maps the equipment-provided (Konteki) service contract number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.KKTK_SVC_KEI_NO_ERR)` (L1219) |
| 1.1 | IF | `!inMap.containsKey("kktk_svc_kei_no_err")` (L1220) |
| 1.1.1 | SET | `inMap.put("kktk_svc_kei_no_err", template.getString(EKK1081D010CBSMsg.KKTK_SVC_KEI_NO_ERR))` |

> **Block 8.4** — `op_svc_kei_no_err` (L1226) — Option Service Contract Number Error
> Maps the option service contract number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.OP_SVC_KEI_NO_ERR)` (L1227) |
| 1.1 | IF | `!inMap.containsKey("op_svc_kei_no_err")` (L1228) |
| 1.1.1 | SET | `inMap.put("op_svc_kei_no_err", template.getString(EKK1081D010CBSMsg.OP_SVC_KEI_NO_ERR))` |

> **Block 8.5** — `sbop_svc_kei_no_err` (L1234) — Sub-Option Service Contract Number Error
> Maps the sub-option service contract number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SBOP_SVC_KEI_NO_ERR)` (L1235) |
| 1.1 | IF | `!inMap.containsKey("sbop_svc_kei_no_err")` (L1236) |
| 1.1.1 | SET | `inMap.put("sbop_svc_kei_no_err", template.getString(EKK1081D010CBSMsg.SBOP_SVC_KEI_NO_ERR))` |

> **Block 8.6** — `seiopsvc_kei_no_err` (L1242) — Billing Option Service Contract Number Error
> Maps the billing option service contract number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SEIOPSVC_KEI_NO_ERR)` (L1243) |
| 1.1 | IF | `!inMap.containsKey("seiopsvc_kei_no_err")` (L1244) |
| 1.1.1 | SET | `inMap.put("seiopsvc_kei_no_err", template.getString(EKK1081D010CBSMsg.SEIOPSVC_KEI_NO_ERR))` |

> **Block 8.7** — `order_sbt_cd_err` (L1250) — Order Type Code Error
> Maps the order type (sub-type) code error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.ORDER_SBT_CD_ERR)` (L1251) |
| 1.1 | IF | `!inMap.containsKey("order_sbt_cd_err")` (L1252) |
| 1.1.1 | SET | `inMap.put("order_sbt_cd_err", template.getString(EKK1081D010CBSMsg.ORDER_SBT_CD_ERR))` |

> **Block 8.8** — `svc_order_cd_err` (L1258) — Service Order Code Error
> Maps the service order code error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SVC_ORDER_CD_ERR)` (L1259) |
| 1.1 | IF | `!inMap.containsKey("svc_order_cd_err")` (L1260) |
| 1.1.1 | SET | `inMap.put("svc_order_cd_err", template.getString(EKK1081D010CBSMsg.SVC_ORDER_CD_ERR))` |

> **Block 8.9** — `yokyu_sbt_cd_err` (L1266) — Request Type Code Error
> Maps the request type code error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.YOKYU_SBT_CD_ERR)` (L1267) |
| 1.1 | IF | `!inMap.containsKey("yokyu_sbt_cd_err")` (L1268) |
| 1.1.1 | SET | `inMap.put("yokyu_sbt_cd_err", template.getString(EKK1081D010CBSMsg.YOKYU_SBT_CD_ERR))` |

> **Block 8.10** — `odr_hakko_joken_cd_err` (L1274) — Order Issuance Condition Code Error
> Maps the order issuance condition code error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD_ERR)` (L1275) |
| 1.1 | IF | `!inMap.containsKey("odr_hakko_joken_cd_err")` (L1276) |
| 1.1.1 | SET | `inMap.put("odr_hakko_joken_cd_err", template.getString(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD_ERR))` |

> **Block 8.11** — `same_trn_no_err` (L1282) — Common Processing Number Error
> Maps the common processing number error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SAME_TRN_NO_ERR)` (L1283) |
| 1.1 | IF | `!inMap.containsKey("same_trn_no_err")` (L1284) |
| 1.1.1 | SET | `inMap.put("same_trn_no_err", template.getString(EKK1081D010CBSMsg.SAME_TRN_NO_ERR))` |

> **Block 8.12** — `taknkiki_model_cd_err` (L1290) — Indoor Equipment Model Code Error
> Maps the indoor equipment (Takunaki) model code error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD_ERR)` (L1291) |
| 1.1 | IF | `!inMap.containsKey("taknkiki_model_cd_err")` (L1292) |
| 1.1.1 | SET | `inMap.put("taknkiki_model_cd_err", template.getString(EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD_ERR))` |

> **Block 8.13** — `kiki_seizo_no_err` (L1298) — Equipment Serial Number Error
> Maps the equipment serial number (Seizo Number) error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.KIKI_SEIZO_NO_ERR)` (L1299) |
| 1.1 | IF | `!inMap.containsKey("kiki_seizo_no_err")` (L1300) |
| 1.1.1 | SET | `inMap.put("kiki_seizo_no_err", template.getString(EKK1081D010CBSMsg.KIKI_SEIZO_NO_ERR))` |

> **Block 8.14** — `mlad_err` (L1306) — Email Address Error
> Maps the email address error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.MLAD_ERR)` (L1307) |
| 1.1 | IF | `!inMap.containsKey("mlad_err")` (L1308) |
| 1.1.1 | SET | `inMap.put("mlad_err", template.getString(EKK1081D010CBSMsg.MLAD_ERR))` |

> **Block 8.15** — `spot_login_sysid_err` (L1314) — Spot Login System ID Error
> Maps the Spot Login system ID error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SPOT_LOGIN_SYSID_ERR)` (L1315) |
| 1.1 | IF | `!inMap.containsKey("spot_login_sysid_err")` (L1316) |
| 1.1.1 | SET | `inMap.put("spot_login_sysid_err", template.getString(EKK1081D010CBSMsg.SPOT_LOGIN_SYSID_ERR))` |

> **Block 8.16** — `send_req_fin_dtm_err` (L1322) — Transmission Request Completion Timestamp Error
> Maps the transmission request completion date/time error.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SEND_REQ_FIN_DTM_ERR)` (L1323) |
| 1.1 | IF | `!inMap.containsKey("send_req_fin_dtm_err")` (L1324) |
| 1.1.1 | SET | `inMap.put("send_req_fin_dtm_err", template.getString(EKK1081D010CBSMsg.SEND_REQ_FIN_DTM_ERR))` |

> **Block 8.17** — `svc_kei_kaisen_ucwk_err` (L1330) — Service Contract Line Detail Number Error
> Maps the service contract line detail number error. Note: the in-map key is `svc_kei_kaisen_ucwk_err` (with `_err` suffix) while the template getter constant is `SVC_KEI_KAISEN_UCWK_NO_ERR`.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!template.isNull(EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO)` (L1331) |
| 1.1 | IF | `!inMap.containsKey("svc_kei_kaisen_ucwk_err")` (L1332) |
| 1.1.1 | SET | `inMap.put("svc_kei_kaisen_ucwk_err", template.getString(EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR))` |

**Block 9** — RETURN `(end of method)` (L1336)

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return param` // Return the parameter with updated status, message, and error field mappings |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `editErrorInfo_EKK1081D010CBS` | Method | Error information retrieval for order issuance condition registration — maps CBS error results back to the DSL processing context |
| `HAKKOSODCCWORKMAP` | Field/Key | Order issuance (Hakko) Service Order Data (SOD) CC work map — the in-memory buffer holding error details for DSL add operations |
| `EKK1081D010CBS` | SC Code | Service Component code for order issuance condition registration error handling — part of the KKK DSL processing pipeline |
| `svc_kei_no` | Field | Service contract number — the primary identifier for a service contract line item |
| `svc_kei_no_err` | Field | Service contract number error — contains error text when the service contract number is invalid |
| `svc_kei_ucwk_no` | Field | Service contract detail number — a sub-identifier within a service contract for detailed line items |
| `svc_kei_ucwk_no_err` | Field | Service contract detail number error — contains error text when the detail number is invalid |
| `svc_kei_kaisen_ucwk_no` | Field | Service contract line detail number — further detail within a service contract line (kaisen = line/item) |
| `svc_kei_kaisen_ucwk_err` | Field | Service contract line detail number error — error text for the line detail number |
| `kktk_svc_kei_no` | Field | Equipment-provided (Konteki) service contract number — service contract number assigned to equipment-provided services |
| `kktk_svc_kei_no_err` | Field | Equipment-provided service contract number error |
| `op_svc_kei_no` | Field | Option service contract number — service contract number for optional/add-on services |
| `op_svc_kei_no_err` | Field | Option service contract number error |
| `sbop_svc_kei_no` | Field | Sub-option service contract number — service contract number for sub-option services |
| `sbop_svc_kei_no_err` | Field | Sub-option service contract number error |
| `seiopsvc_kei_no` | Field | Billing option service contract number — service contract number for billing-related option services |
| `seiopsvc_kei_no_err` | Field | Billing option service contract number error |
| `order_sbt_cd` | Field | Order type/sub-type code — classifies the type of order (e.g., new registration, change, cancellation) |
| `order_sbt_cd_err` | Field | Order type code error |
| `svc_order_cd` | Field | Service order code — code identifying the type of service order |
| `svc_order_cd_err` | Field | Service order code error |
| `yokyu_sbt_cd` | Field | Request type code — classifies the type of customer request (yokyu = request/claim) |
| `yokyu_sbt_cd_err` | Field | Request type code error |
| `odr_hakko_joken_cd` | Field | Order issuance condition code — code specifying the conditions under which an order is issued |
| `odr_hakko_joken_cd_err` | Field | Order issuance condition code error |
| `same_trn_no` | Field | Common processing number — a shared transaction identifier used to correlate related processing steps |
| `same_trn_no_err` | Field | Common processing number error |
| `taknkiki_model_cd` | Field | Indoor equipment model code — model identifier for indoor equipment (takunaki = indoor unit) |
| `taknkiki_model_cd_err` | Field | Indoor equipment model code error |
| `kiki_seizo_no` | Field | Equipment serial number — unique serial identifier for a piece of equipment (seizo = manufacturing/serial) |
| `kiki_seizo_no_err` | Field | Equipment serial number error |
| `mlad` | Field | Mail address — customer email address (MLAD = Mail Address) |
| `mlad_err` | Field | Email address error — indicates a validation or format problem with the email address |
| `spot_login_sysid` | Field | Spot Login system ID — identifier for the Spot Login system used for on-site provisioning |
| `spot_login_sysid_err` | Field | Spot Login system ID error |
| `send_req_fin_dtm` | Field | Transmission request completion date/time — timestamp when a transmission request was completed |
| `send_req_fin_dtm_err` | Field | Transmission request completion timestamp error |
| `STATUS` | Constant | Template message key for extracting the service component status code |
| `RETURN_MESSAGE_*` | Constant | Constant registry prefix for user-facing error messages — indexed by zero-padded 4-digit status code |
| `CAANMsg` | Class | Fujitsu's message/container class used for structured data transfer between CBS layers |
| `IRequestParameterReadWrite` | Interface | Business data access interface — provides get/set operations for control map data, work areas, and domain data |
| `JCMAPLConstMgr` | Class | Constant manager — static accessor for internationalized message text and configuration constants |
| `SCControlMapKeys` | Class | Constant holder for control map key names (e.g., RETURN_CODE, RETURN_MESSAGE) |
| `inMap` | Variable | In-memory HashMap acting as an error accumulation buffer — stores first-write-wins error details from the CBS layer |
| `workMap` | Variable | Work area map — intermediate mapping area between DSL layers |
| `bpStatus` | Variable | Business Processor status — the current return code held in the control map, compared against template status |
| `templateStatus` | Variable | Service component status — the raw status from the CBS, possibly overridden to 9000 on failure or reset to 0 if no message exists |
| `returnCode` | Parameter | Outer return code from the CBS layer — non-zero forces error status 9000 on the template |
| DSL | Acronym | Domain Specific Language — in this context, the Fujitsu business processing framework for telecom order fulfillment |
| CBS | Acronym | Component-Based Service — service component executing business logic |
| SC | Acronym | Service Component — a specific service component identified by a code like `EKK1081D010CBS` |
| SOD | Acronym | Service Order Data — the order data entity in the telecom order fulfillment domain |
| FTTH | Business term | Fiber To The Home — fiber-optic internet broadband service (one of the service types in the order system) |
| 9000 | Constant | Hard-coded error status code — used to signal a failure state when the outer returnCode is non-zero |
| 0 | Constant | Success/reset status code — used when no return message constant exists for a given status |
| -1 | Constant | Default bpStatus — used when the control map has no existing return code, ensuring any positive status overrides it |