# Business Logic — JKKKojiChgPlaceNoCC.callSC() [86 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.callSC()

The `callSC` method is the **central Service Component (SC) invocation and result-handling facade** for the K-Opticom customer base system (eo customer main system). It is invoked across 15+ internal callers within `JKKKojiChgPlaceNoCC` to execute a wide variety of downstream service contracts — including line location changes (EKK0341A010), service detail updates (EKK0341B012), order cancellations (EKK0341C200/C220/C234), equipment number updates (EKK0361A010, EKK1081D010), and error information checks (EKKA0020002/EKKA0020003/EKKA0020004). 

The method implements a **delegation + post-processing pattern**: it receives a prepared parameter map, forwards it to an arbitrary SC via `ServiceComponentRequestInvoker.run()`, then performs a three-phase post-processing routine. First, it interprets the SC return code and template status, applying a fallback status (9000) when the SC returns a non-zero return code. Second, it performs conditional error information enrichment based on the template ID specified in `mappingData`, routing to one of three error-detail-editing methods (`editErrorInfoEKKA0020002`, `editErrorInfoEKKA0020003`, or `editErrorInfoEKKA0020004`). Third, it consolidates error information via `TemplateErrorUtil.getErrorInfo()`.

As a **shared utility method**, `callSC` serves as the single point of SC communication for all business processes in `JKKKojiChgPlaceNoCC`, encapsulating SC invocation, status normalization, error enrichment, and result validation — ensuring consistent error handling across every caller in this class.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["callSC(params)"])
    STEP_EDIT["editInMsg(param, mappingData, placeNo)"]
    STEP_CALL["scCall.run(paramMap, handle)"]
    STEP_TEMPLATES["Extract templates from result via JCMConstants.TEMPLATE_LIST_KEY"]
    STEP_MSG["msg = templates[0]"]
    STEP_STATUS["statKey = EKK0251B001CBSMsg.STATUS"]
    STEP_RETCD["returnCode = result.get(JCMConstants.RET_CD_INT_KEY) as Integer"]
    STEP_TMPSTAT["templateStatus = msg.getInt(statKey)"]
    STEP_RC_CHECK["returnCode != 0?"]
    STEP_SET_STATUS["templateStatus = 9000"]
    STEP_MSG_CHECK["JCMAPLConstMgr.getString(RETURN_MESSAGE_templateStatus) == null?"]
    STEP_SET_TMP0["templateStatus = 0"]
    STEP_BP_STATUS["bpStatus = param.getControlMapData(RETURN_CODE) as Integer, default -1"]
    STEP_CMP_STATUS["templateStatus > bpStatus?"]
    STEP_SET_RETURN["Set RETURN_CODE and RETURN_MESSAGE in controlMap"]
    STEP_TEMPLATE_COMPARE["mappingData[0][1] == TEMPLATE_ID_EKKA0020002?"]
    STEP_EKKA2["editErrorInfoEKKA0020002(dataMap, templates)"]
    STEP_TEMPLATE_COMPARE3["TEMPLATE_ID_EKKA0020003?"]
    STEP_EKKA3["editErrorInfoEKKA0020003(dataMap, templates)"]
    STEP_TEMPLATE_COMPARE4["TEMPLATE_ID_EKKA0020004?"]
    STEP_EKKA4["editErrorInfoEKKA0020004(dataMap, templates)"]
    STEP_ERR_LIST["Get ERROR_INFO from controlMap, init to new ArrayList if null"]
    STEP_SET_ERR["Set ERROR_INFO via TemplateErrorUtil.getErrorInfo(result, errList)"]
    STEP_RTN_CODE["rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString()"]
    STEP_STATUS_INT["status = msg.getInt(JCMConstants.STATUS_INT_KEY)"]
    STEP_VALIDATE["rtnCode == 0 AND status == 0?"]
    STEP_THROW["Throw SCCallException with return values"]
    STEP_RETURN["Return msg"]

    START --> STEP_EDIT
    STEP_EDIT --> STEP_CALL
    STEP_CALL --> STEP_TEMPLATES
    STEP_TEMPLATES --> STEP_MSG
    STEP_MSG --> STEP_STATUS
    STEP_STATUS --> STEP_RETCD
    STEP_RETCD --> STEP_TMPSTAT
    STEP_TMPSTAT --> STEP_RC_CHECK
    STEP_RC_CHECK -- "true" --> STEP_SET_STATUS
    STEP_RC_CHECK -- "false" --> STEP_MSG_CHECK
    STEP_SET_STATUS --> STEP_MSG_CHECK
    STEP_MSG_CHECK -- "true" --> STEP_SET_TMP0
    STEP_MSG_CHECK -- "false" --> STEP_BP_STATUS
    STEP_SET_TMP0 --> STEP_BP_STATUS
    STEP_BP_STATUS --> STEP_CMP_STATUS
    STEP_CMP_STATUS -- "true" --> STEP_SET_RETURN
    STEP_CMP_STATUS -- "false" --> STEP_TEMPLATE_COMPARE
    STEP_SET_RETURN --> STEP_TEMPLATE_COMPARE
    STEP_TEMPLATE_COMPARE -- "true" --> STEP_EKKA2
    STEP_TEMPLATE_COMPARE -- "false" --> STEP_TEMPLATE_COMPARE3
    STEP_EKKA2 --> STEP_ERR_LIST
    STEP_TEMPLATE_COMPARE3 -- "true" --> STEP_EKKA3
    STEP_TEMPLATE_COMPARE3 -- "false" --> STEP_TEMPLATE_COMPARE4
    STEP_EKKA3 --> STEP_ERR_LIST
    STEP_TEMPLATE_COMPARE4 -- "true" --> STEP_EKKA4
    STEP_TEMPLATE_COMPARE4 -- "false" --> STEP_ERR_LIST
    STEP_EKKA4 --> STEP_ERR_LIST
    STEP_ERR_LIST --> STEP_SET_ERR
    STEP_SET_ERR --> STEP_RTN_CODE
    STEP_RTN_CODE --> STEP_STATUS_INT
    STEP_STATUS_INT --> STEP_VALIDATE
    STEP_VALIDATE -- "false" --> STEP_THROW
    STEP_VALIDATE -- "true" --> STEP_RETURN
    STEP_THROW --> END(["Exception propagated"])
    STEP_RETURN --> END_RETURN(["Return msg"])
```

**Processing flow summary:**

1. **Parameter preparation:** Calls `editInMsg(param, mappingData, placeNo)` to build a parameter map (`paramMap`) from the input parameter object, mapping data, and place number.
2. **SC invocation:** Delegates to `scCall.run(paramMap, handle)` to execute the Service Component, receiving a result `Map` containing return code, template list, and other data.
3. **Result extraction:** Extracts the template array from the result via `JCMConstants.TEMPLATE_LIST_KEY`, takes the first template as the response message, and resolves the status key from `EKK0251B001CBSMsg.STATUS`.
4. **Return code fallback:** If the SC return code is non-zero, sets `templateStatus = 9000` (error override).
5. **Template status validation:** Checks whether a localized message exists for the template status. If not, resets `templateStatus = 0`.
6. **BP status comparison:** Compares `templateStatus` against the BP-level return code from `param.getControlMapData(SCControlMapKeys.RETURN_CODE)`. If template status is higher, updates the control map with the SC's status code and message.
7. **Conditional error enrichment:** Based on the template ID in `mappingData[0][1]`, routes to one of three error-detail editing methods:
   - `TEMPLATE_ID_EKKA0020002` = "EKKA0020002" -> `editErrorInfoEKKA0020002()`
   - `TEMPLATE_ID_EKKA0020003` -> `editErrorInfoEKKA0020003()`
   - `TEMPLATE_ID_EKKA0020004` -> `editErrorInfoEKKA0020004()`
8. **Error consolidation:** Retrieves the existing error list from the control map, then updates it via `TemplateErrorUtil.getErrorInfo()`.
9. **Result validation:** Validates that both the SC return code is "0" and the message status is 0. If not, throws `SCCallException` with the actual return values.
10. **Return:** Returns the `CAANMsg` template on success.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `handle` | `SessionHandle` | Database session handle for the current transaction context. Carries the database connection and transaction metadata needed for SC execution. |
| 2 | `scCall` | `ServiceComponentRequestInvoker` | The service component execution engine. This is a configurable invoker that delegates to the actual downstream SC (Service Component). Allows different SC implementations to be injected for testing or routing purposes. |
| 3 | `param` | `IRequestParameterReadWrite` | The parameter container that holds all request and response data flowing between the BP (Business Process) and the SC. Contains data maps, control maps (return codes, error info, status messages), and serves as both input and output carrier. |
| 4 | `dataMapKey` | `String` | The key used to retrieve business data from `param`. This key identifies which data map within the parameter object contains the business entity data (e.g., order information, customer data) that will be processed by the called SC. |
| 5 | `mappingData` | `Object[][]` | A two-dimensional array defining the template mapping for the SC call. `mappingData[0][1]` contains the template ID (e.g., "EKKA0020002") used to determine which error enrichment routine to execute post-SC. This array effectively classifies what type of SC operation is being performed. |
| 6 | `placeNo` | `String` | The place number (location code) that identifies the physical location or office associated with the service contract change. Used in parameter preparation (`editInMsg`) to contextualize the SC request. |

**External state / instance fields read:**
- None directly — `callSC` is a self-contained static-like method that only uses its parameters and local variables. It delegates instance-level operations to `editInMsg`, `editErrorInfoEKKA0020002/3/4` which are other methods within the same class.

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `editInMsg` | (internal) | param data | Prepares the parameter map for the SC call, extracting and formatting input data [-> editInMsg] |
| R | `scCall.run` | Varies by caller | Varies | Delegates to the actual Service Component — the target SC and its data source depend on the caller's configuration |
| - | `JCMConstants.TEMPLATE_LIST_KEY` resolution | - | - | Extracts the template list array from the SC result map |
| - | `EKK0251B001CBSMsg.STATUS` | - | - | Resolves the status field key from the EKK0251B001 CBS message definition |
| U | `editErrorInfoEKKA0020002` | EKKA0020002 | - | Enriches error info for EKKA0020002 template responses (line location change error details) |
| U | `editErrorInfoEKKA0020003` | EKKA0020003 | - | Enriches error info for EKKA0020003 template responses |
| U | `editErrorInfoEKKA0020004` | EKKA0020004 | - | Enriches error info for EKKA0020004 template responses |
| R | `TemplateErrorUtil.getErrorInfo` | - | - | Consolidates error information from the SC result into the standard error list format |
| U | `param.setControlMapData(SCControlMapKeys.RETURN_CODE, ...)` | - | - | Updates the return code in the control map for downstream consumption |
| U | `param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, ...)` | - | - | Updates the return message in the control map for downstream consumption |
| U | `param.setControlMapData(SCControlMapKeys.ERROR_INFO, ...)` | - | - | Updates the consolidated error list in the control map |

**How to classify:**
- `callSC` itself is an **R** (Read/Invoke) operation: it reads input parameters, invokes an external SC, and reads back the result. The actual CRUD operation on the database depends on which SC is being invoked (the caller configures `scCall` and `mappingData`).
- The conditional branches (`editErrorInfoEKKA0020002/3/4`) are **U** (Update) operations: they modify error state within the parameter object.

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | CBS: `JKKKojiChgPlaceNoCC.addPlnoRnktgkkWkExecSvcKei` | `addPlnoRnktgkkWkExecSvcKei` -> `callSC` | `scCall.run [R] Varies by caller` |
| 2 | CBS: `JKKKojiChgPlaceNoCC.execEKK0341C200` | `execEKK0341C200` -> `callSC` | `scCall.run [R] Order cancellation (EKK0341C200)` |
| 3 | CBS: `JKKKojiChgPlaceNoCC.execEKK0341C220` | `execEKK0341C220` -> `callSC` | `scCall.run [R] Order cancellation (EKK0341C220)` |
| 4 | CBS: `JKKKojiChgPlaceNoCC.execEKK0341C234` | `execEKK0341C234` -> `callSC` | `scCall.run [R] Order cancellation (EKK0341C234)` |
| 5 | CBS: `JKKKojiChgPlaceNoCC.execKktkSvcKeiPlaceUpdate` | `execKktkSvcKeiPlaceUpdate` -> `callSC` | `scCall.run [R] Service detail place update` |
| 6 | CBS: `JKKKojiChgPlaceNoCC.execSvckeiEmgUpd` | `execSvckeiEmgUpd` -> `callSC` | `scCall.run [R] Service detail emergency update` |
| 7 | Screen: `JKKKojiChgPlaceNoCC.execute` | `execute` -> `callSC` | `scCall.run [R] Main execution entry` |
| 8 | CBS: `JKKKojiChgPlaceNoCC.findZ1OrderAtKK1041` | `findZ1OrderAtKK1041` -> `callSC` | `scCall.run [R] Order lookup (KK1041)` |
| 9 | CBS: `JKKKojiChgPlaceNoCC.getKktkInfExecSvcKei` | `getKktkInfExecSvcKei` -> `callSC` | `scCall.run [R] Executed service detail info retrieval` |
| 10 | CBS: `JKKKojiChgPlaceNoCC.getKktkSvcKei` | `getKktkSvcKei` -> `callSC` | `scCall.run [R] Executed service detail retrieval` |
| 11 | CBS: `JKKKojiChgPlaceNoCC.getKojiak` | `getKojiak` -> `callSC` | `scCall.run [R] Service contract line retrieval` |
| 12 | CBS: `JKKKojiChgPlaceNoCC.getKojiakTgKikiList` | `getKojiakTgKikiList` -> `callSC` | `scCall.run [R] Service contract target company list retrieval` |
| 13 | CBS: `JKKKojiChgPlaceNoCC.getTaknkikiModel` | `getTaknkikiModel` -> `callSC` | `scCall.run [R] Transmission equipment model retrieval` |
| 14 | CBS: `JKKKojiChgPlaceNoCC.htelNoInfoChgeOdrCtrl` | `htelNoInfoChgeOdrCtrl` -> `callSC` | `scCall.run [R] Home tel number info change order control` |
| 15 | CBS: `JKKKojiChgPlaceNoCC.updTaknkiki` | `updTaknkiki` -> `callSC` | `scCall.run [R] Transmission equipment update` |

**Terminal operations from `callSC`:**
- `getErrorInfo` [R] — Error info extraction (via `TemplateErrorUtil`)
- `getErrorInfo` [R] — Error info retrieval from SC results
- `editErrorInfoEKKA0020004` [U] — EKKA0020004 error detail update
- `getData` [R] — Data retrieval from param control map
- `editErrorInfoEKKA0020003` [U] — EKKA0020003 error detail update
- `editErrorInfoEKKA0020002` [U] — EKKA0020002 error detail update
- `scCall.run` [R] — Service Component invocation (CRUD type depends on caller's SC)

## 6. Per-Branch Detail Blocks

### Block 1 — EXEC (Line 685)

Prepares the parameter map by delegating to `editInMsg`, which extracts data from the parameter object and formats it for SC consumption.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `editInMsg(param, mappingData, placeNo)` |

### Block 2 — EXEC (Line 687)

Invokes the Service Component with the prepared parameters.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `scCall.run(paramMap, handle)` |

### Block 3 — EXEC (Lines 689–692)

Extracts the template list from the SC result map and retrieves the status key for the message.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY)` // Extracts the CAANMsg template array |
| 2 | SET | `msg = templates[0]` // First template is the response message |
| 3 | SET | `statKey = EKK0251B001CBSMsg.STATUS` // Status field key from EKK0251B001 CBS message |
| 4 | SET | `returnCode = (Integer) result.get(JCMConstants.RET_CD_INT_KEY)` // Return code from SC |

### Block 4 — IF-ELSE (Lines 694–696)

Checks if the SC return code is non-zero. If so, overrides the template status to 9000 (error indicator).

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = msg.getInt(statKey)` // Current template status from response message |
| 2 | IF | `returnCode != 0` // SC returned an error/non-zero return code |

### Block 4.1 — ELSE (Line 695)

Sets template status to 9000 when the SC reports an error return code.

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

### Block 5 — IF-ELSE (Lines 698–700)

Validates that a localized return message exists for the current template status. If not, resets status to 0.

| # | Type | Code |
|---|------|------|
| 1 | IF | `JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null` // No localized message found for this status |

### Block 5.1 — ELSE (Line 699)

Resets template status to 0 when no corresponding localized message is found.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = 0` // Reset to 0 — fallback default status |

### Block 6 — IF-ELSE-ELSE (Lines 702–711)

Determines the BP-level return code (`bpStatus`) from the control map. If the control map data is null, defaults to -1.

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = 0` // Default BP status |
| 2 | EXEC | `obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE)` // Retrieve BP return code |
| 3 | IF | `obj == null` // No BP return code set yet |

### Block 6.1 — ELSE (Line 705)

Sets BP status to -1 when no return code data exists in the control map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = -1` // No BP-level return code, indicate below any valid status |

### Block 6.2 — ELSE (Lines 708–709)

Parses the return code as an integer when control map data exists.

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

### Block 7 — IF-ELSE (Lines 713–722)

Compares template status against BP status. If the SC's template status is more severe (higher), update the control map with the SC's status and message.

| # | Type | Code |
|---|------|------|
| 1 | IF | `templateStatus > bpStatus` // SC status is more severe than BP status |

### Block 7.1 — ELSE (implicit)

If SC status is not higher, skip the control map update and proceed directly to template ID comparison.

### Block 7.2 — IF body (Lines 715–718)

Sets the SC's return status and message into the control map for downstream use.

| # | Type | Code |
|---|------|------|
| 1 | SET | `formatStatus = String.format("%1$04d", templateStatus)` // Format status as 4-digit zero-padded string |
| 2 | SET | `message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus)` // Lookup localized message |
| 3 | EXEC | `param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus)` // Store return code |
| 4 | EXEC | `param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message)` // Store return message |

### Block 8 — IF-ELSE IF-ELSE IF (Lines 724–736)

Routes to the appropriate error-info editing method based on the template ID in `mappingData[0][1]`. This is the key conditional branch that determines what kind of post-processing error handling is applied.

| # | Type | Code |
|---|------|------|
| 1 | IF | `TEMPLATE_ID_EKKA0020002.equals(mappingData[0][1])` [EKKA0020002 = "EKKA0020002" (Line location change error info)] |
| 2 | ELSE IF | `TEMPLATE_ID_EKKA0020003.equals(mappingData[0][1])` [EKKA0020003] |
| 3 | ELSE IF | `TEMPLATE_ID_EKKA0020004.equals(mappingData[0][1])` [EKKA0020004] |

### Block 8.1 — IF body (Lines 725–726)

When the template ID matches EKKA0020002, calls the error info editing method for EKKA0020002 responses.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `editErrorInfoEKKA0020002((HashMap<String, Object>) param.getData(dataMapKey), templates)` |

### Block 8.2 — ELSE IF body (Lines 728–729)

When the template ID matches EKKA0020003, calls the error info editing method for EKKA0020003 responses.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `editErrorInfoEKKA0020003((HashMap<String, Object>) param.getData(dataMapKey), templates)` |

### Block 8.3 — ELSE IF body (Lines 731–732)

When the template ID matches EKKA0020004, calls the error info editing method for EKKA0020004 responses.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `editErrorInfoEKKA0020004((HashMap<String, Object>) param.getData(dataMapKey), templates)` |

### Block 9 — EXEC (Lines 735–739)

Retrieves or initializes the error list from the control map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `errList = (ArrayList<Object>) param.getControlMapData(SCControlMapKeys.ERROR_INFO)` // Get existing error list |
| 2 | IF | `errList == null` // No error list exists yet |

### Block 9.1 — IF body (Line 737)

Initializes a new empty error list if none exists.

| # | Type | Code |
|---|------|------|
| 1 | SET | `errList = new ArrayList<Object>()` // Create new empty error list |

### Block 10 — EXEC (Lines 741–742)

Consolidates error information from the SC result using the utility class and stores it back into the control map.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList))` // Consolidate and store error info |

### Block 11 — EXEC (Lines 746–748)

Retrieves the return code and status values for final result validation. This implements the Japanese comment "// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする" (Check the acquired return code and status content to determine if there is an abnormality).

| # | Type | Code |
|---|------|------|
| 1 | SET | `rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString()` // Return code as string |
| 2 | SET | `status = msg.getInt(JCMConstants.STATUS_INT_KEY)` // Message status as Integer |

### Block 12 — IF (Lines 751–754)

Final validation: checks if either the return code or the status indicates an error. If so, throws `SCCallException` with the actual return values, preserving the error context for the caller. This implements the Japanese comment "// 異常の場合、SCCallExceptionを生成してスローする" (In case of abnormality, generate and throw SCCallException).

| # | Type | Code |
|---|------|------|
| 1 | IF | `!("0".equals(rtnCode) && 0 == status.intValue())` // Return code is not "0" OR status is not 0 |

### Block 12.1 — IF body (Lines 752–753)

Creates and throws an exception with detailed error information. The exception message is "戻値不正" (Invalid return value in Japanese).

| # | Type | Code |
|---|------|------|
| 1 | SET | `scCallEx = new SCCallException("戻値不正", rtnCode, status)` // "Invalid return value" |
| 2 | RETURN | `throw scCallEx` // Propagate the exception to the caller |

### Block 13 — RETURN (Line 755)

On successful SC execution with valid return code and status, returns the response message.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return msg` // Return the CAANMsg template |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `callSC` | Method | Service Component invocation method — the central dispatch point for calling downstream SCs from the BP layer |
| SC | Acronym | Service Component — a reusable business logic module that handles specific telecom operations (order, cancellation, update, etc.) |
| BP | Acronym | Business Process — the upper-layer application logic that orchestrates SCs to fulfill business use cases |
| SCCallException | Class | Custom exception thrown when an SC returns an invalid or error return code — wraps the actual return code and status for error reporting |
| `TEMPLATE_LIST_KEY` | Constant | Key to extract the CAANMsg template array from an SC result Map |
| `RET_CD_INT_KEY` | Constant | Key to extract the integer return code from an SC result Map |
| `STATUS_INT_KEY` | Constant | Key to extract the message status field from a CAANMsg |
| `EKK0251B001CBSMsg.STATUS` | Constant | The status field name in the EKK0251B001 CBS message definition — used to extract status from the response |
| `RETURN_CODE` | Constant | Control map key for the return status code (e.g., "0000", "9000") |
| `RETURN_MESSAGE` | Constant | Control map key for the localized return message string |
| `ERROR_INFO` | Constant | Control map key for the error information list |
| `TEMPLATE_ID_EKKA0020002` | Constant | Template ID "EKKA0020002" — identifies line location change error detail processing |
| `TEMPLATE_ID_EKKA0020003` | Constant | Template ID "EKKA0020003" — identifies error detail processing variant 3 |
| `TEMPLATE_ID_EKKA0020004` | Constant | Template ID "EKKA0020004" — identifies error detail processing variant 4 |
| `JKCMAPLConstMgr.getString()` | Method | Localization constant manager — retrieves localized messages by key (e.g., "RETURN_MESSAGE_0000") |
| `SCControlMapKeys` | Class | Constants class for control map keys used in SC return status and error communication |
| `JCMConstants` | Class | Core constant definitions for result map keys (TEMPLATE_LIST_KEY, RET_CD_INT_KEY, STATUS_INT_KEY) |
| `TemplateErrorUtil.getErrorInfo()` | Method | Utility that consolidates error information from an SC result into a standard error list format |
| `editInMsg` | Method | Internal method that prepares the input parameter map for SC invocation — extracts data, formats it |
| `editErrorInfoEKKA0020002/3/4` | Method | Internal methods that enrich error information in the response message based on the SC template type |
| 戻値不正 | Japanese | "Invalid return value" — error message thrown when SC returns non-zero return code or non-zero status |
| `placeNo` | Field | Place number — the location code (e.g., office, site) for the service contract line item |
| `dataMapKey` | Field | Data map key — the identifier for retrieving business data from the parameter object |
| `paramMap` | Local var | Parameter map — a HashMap containing all data to be sent to the SC |
| `templateStatus` | Local var | Template status — the status code extracted from the SC response message |
| `bpStatus` | Local var | BP-level status — the status code previously set by the business process (used for comparison) |
| `templateStatus = 9000` | Constant | Error override status — when SC returns a non-zero return code, the status is forced to 9000 to indicate an error condition |
| `JA` | Acronym | K-Opticom — a Japanese telecom carrier (the system domain) |
| e光電話 | Japanese | "e-Hikari Phone" — fiber-optic telecommunication service offered by K-Opticom |
| 回線場所変更 | Japanese | "Line location change" — a service contract operation to update the physical location of a telecom line |
| 宅内機器 | Japanese | "Indoor equipment" — customer premises equipment (CPE) managed in the system |
| 場所番号連動 | Japanese | "Location number linkage" — synchronization of location codes between the service contract system and equipment management system |
| EKK0341 | CBS | Order change/registration service component — handles order modifications including line location changes |
| EKK0361 | CBS | Equipment number registration service component |
| EKK1081 | CBS | Service detail update service component |
| EKKA0020002 | CBS | Error information check service component for line location change operations |
| CAANMsg | Class | Canonical message class — the standard message format used throughout the Fujitsu Futurity platform for service contract data exchange |
| SessionHandle | Class | Database session and transaction context handle passed to SC invocations |
| ServiceComponentRequestInvoker | Class | The service component execution engine — a configurable invoker that delegates to actual SC implementations |
| IRequestParameterReadWrite | Interface | Parameter container interface — holds request data, control maps, and response data for SC-BP communication |