# Business Logic — JKKWrisvcAutoAplyGetSvcInfoCC.getSvcInfo() [120 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKWrisvcAutoAplyGetSvcInfoCC` |
| Layer | CC / Common Component (Controller/Common Component — part of the Fujitsu Futurity BPM framework's custom common component layer) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKWrisvcAutoAplyGetSvcInfoCC.getSvcInfo()

This method is the core input-gathering orchestration method for the **Discount Service Auto-Apply** feature within K-Opticom's customer base system. It retrieves and processes service contract information for three distinct discount service operation types — **cancel** (subscription cancellation / 解約), **add** (new registration / 登録), and **update** (plan change / プラン変更) — by reading modification lists from the request parameter, fetching service detail data through a Service Component (SC) call to the `EKK0081A010` CBS, and then dispatching each processed record to the auto-apply engine.

The method implements a **batch routing/dispatch pattern**: it iterates over three independent lists (cancel_inf_list, add_inf_list, upd_inf_list) extracted from the request payload, processes each item through a common SC query and return-editing pipeline, collects the resulting data maps, and then dispatches each collection to the `JKKWrisvcAutoAplyCC` auto-apply engine via `JKKCallWrisvcAutoAplyUtil.callWrisvcAutoAply()`. The three dispatch paths are labeled with different operation keys — `cancelWrisvcMap`, `addWrisvcMap`, and `updWrisvcMap` — which the downstream auto-apply engine uses to determine the correct business rule path.

Its role in the larger system is that of a **shared CC (Common Component) utility** called by screen controllers (e.g., `JKKAddNetNorikaeCC.addNetNorikae()`) to prepare and dispatch discount service auto-application data. It acts as the bridge between the screen-layer request parameters and the back-end auto-apply business logic, ensuring all service detail information is fetched, validated, and routed correctly before the discount application proceeds.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["getSvcInfo handle, param, fixedText"])

    START --> INIT["Initialize: scCall, paramMap, result, template"]
    INIT --> GET_INMAP["Extract inMap = param.getData(fixedText)"]

    GET_INMAP --> INMAP_NULL{inMap == null?}
    INMAP_NULL -- true --> RETURN_PARAM["Return param (early exit)"]
    INMAP_NULL -- false --> PROCESS_CCL["Get cancel_inf_list from inMap"]

    PROCESS_CCL --> CCL_EXISTS{cancel_inf_list != null?}
    CCL_EXISTS -- true --> INIT_CCL_LIST["Initialize cclSvcKeiList"]
    INIT_CCL_LIST --> CCL_LOOP["For each childMap in cclList"]

    CCL_LOOP --> CCL_BODY["dataMap = new HashMap()"]
    CCL_BODY --> CCL_TEMPLATE["editInEKK0081A010 param, fixedText, svc_kei_no"]
    CCL_TEMPLATE --> CCL_SC["scCall.run putParamMap, template, handle"]
    CCL_SC --> CCL_RET["editRetEKK0081A010 result, param, fixedText, 05, dataMap, null"]
    CCL_RET --> CCL_ERR{getReturnCode >= 1000?}
    CCL_ERR -- true --> CCL_THROW["Throw CCException service error"]
    CCL_ERR -- false --> CCL_ADD["cclSvcKeiList.add dataMap"]
    CCL_ADD --> CCL_LOOP

    CCL_EXISTS -- false --> PROCESS_ADD["Get add_inf_list from inMap"]
    PROCESS_ADD --> ADD_EXISTS{add_inf_list != null?}

    CCL_LOOP --> ADD_EXISTS
    ADD_EXISTS -- true --> GET_SVKEI["getSvkeiNo param, fixedText"]
    GET_SVKEI --> INIT_ADD_LIST["Initialize addSvcKeiList"]
    INIT_ADD_LIST --> ADD_LOOP["For each childMap in addList"]

    ADD_LOOP --> ADD_BODY["dataMap = new HashMap()"]
    ADD_BODY --> ADD_TEMPLATE["editInEKK0081A010 param, fixedText, svc_kei_no"]
    ADD_TEMPLATE --> ADD_SC["scCall.run putParamMap, template, handle"]
    ADD_SC --> ADD_RET["editRetEKK0081A010 result, param, fixedText, 01, dataMap, childMap"]
    ADD_RET --> ADD_ERR{getReturnCode >= 1000?}
    ADD_ERR -- true --> ADD_THROW["Throw CCException service error"]
    ADD_ERR -- false --> ADD_ADD["addSvcKeiList.add dataMap"]
    ADD_ADD --> ADD_LOOP

    ADD_EXISTS -- false --> PROCESS_UPD["Get upd_inf_list from inMap"]
    PROCESS_UPD --> UPD_EXISTS{upd_inf_list != null?}

    ADD_LOOP --> UPD_EXISTS
    UPD_EXISTS -- true --> INIT_UPD_LIST["Initialize updSvcKeiList"]
    INIT_UPD_LIST --> UPD_LOOP["For each childMap in updList"]

    UPD_LOOP --> UPD_BODY["dataMap = new HashMap()"]
    UPD_BODY --> UPD_TEMPLATE["editInEKK0081A010 param, fixedText, svc_kei_no"]
    UPD_TEMPLATE --> UPD_SC["scCall.run putParamMap, template, handle"]
    UPD_SC --> UPD_RET["editRetEKK0081A010 result, param, fixedText, 02, dataMap, childMap"]
    UPD_RET --> UPD_ERR{getReturnCode >= 1000?}
    UPD_ERR -- true --> UPD_THROW["Throw CCException service error"]
    UPD_ERR -- false --> UPD_ADD["updSvcKeiList.add dataMap"]
    UPD_ADD --> UPD_LOOP

    UPD_EXISTS -- false --> EXEC_CANCEL["Process cancelWrisvcMap: for each in cclSvcKeiList, setData + callWrisvcAutoAply"]
    EXEC_CANCEL --> EXEC_ADD["Process addWrisvcMap: for each in addSvcKeiList, setData + callWrisvcAutoAply"]
    EXEC_ADD --> EXEC_UPD["Process updWrisvcMap: for each in updSvcKeiList, setData + callWrisvcAutoAply"]
    EXEC_UPD --> FINAL_RETURN["Return param"]

    CCL_THROW --> FINAL_RETURN
    ADD_THROW --> FINAL_RETURN
    UPD_THROW --> FINAL_RETURN
    RETURN_PARAM --> END(["End"])
    FINAL_RETURN --> END
```

**Constant Resolution:**

| Constant | Actual Value | Business Meaning |
|----------|-------------|------------------|
| `JPCModelConstant.SINGLEDATA_ERR` | `1000` | Single data error threshold — return codes at or above this value indicate a per-item processing error that triggers an exception |
| `SC_ERROR_STRING` | `"サービスコンテンツエラー"` (Service Content Error) | Error message string used when constructing the CCException for error-state exceptions |

**Operation Code Mapping (editRetEKK0081A010 status parameter):**

| Code | Branch | Business Meaning |
|------|--------|------------------|
| `"05"` | cancel_inf_list | Cancel (解約) — subscription cancellation processing |
| `"01"` | add_inf_list | Add (登録) — new service registration processing |
| `"02"` | upd_inf_list | Update (プラン変更) — plan change processing |

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `handle` | `SessionHandle` | Database session handle used for Service Component invocations — carries the active database connection, transaction context, and user authentication information for SC calls. |
| 2 | `param` | `IRequestParameterReadWrite` | Request parameter object that holds the incoming screen data. It contains the cancel/add/update modification lists under the `fixedText` key, and is used as the data carrier throughout processing (set and retrieved via `getData`/`setData`). The same object is returned at the end with results populated. |
| 3 | `fixedText` | `String` | Service message identifier used as a key to extract the input map from `param`. It serves as the namespace/key for `param.getData(fixedText)` which returns the HashMap containing `cancel_inf_list`, `add_inf_list`, and `upd_inf_list`. Also passed through to SC query methods. |

**Instance fields / external state read:**
- None — this method is stateless with respect to instance fields. All external state is passed through parameters.

**Constants used (resolved):**
- `JPCModelConstant.SINGLEDATA_ERR = 1000` — Single data error threshold for return code validation
- `SC_ERROR_STRING = "サービスコンテンツエラー"` (Service Content Error) — Error message for exception construction

## 4. CRUD Operations / Called Services

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

The method invokes the `EKK0081A010` Service Component (CBS) to query service detail information, and then dispatches results to the `JKKWrisvcAutoAplyCC` auto-apply engine.

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `JBSbatDKNyukaFinAdd.getData` | EKK0081A010SC | Service contract detail data | Calls `getData` in `JBSbatDKNyukaFinAdd` (inferred from editInEKK0081A010 SC query) |
| U | `JKKWrisvcAutoAplyGetSvcInfoCC.editInEKK0081A010` | EKK0081A010SC | Service contract detail data | Prepares SC input template by setting `svc_kei_no` for service detail query |
| U | `JKKWrisvcAutoAplyGetSvcInfoCC.editRetEKK0081A010` | EKK0081A010SC | Service contract detail data | Processes SC return data, extracts and sets result fields into `dataMap` using the operation code ("01"/"02"/"05") |
| R | `JKKWrisvcAutoAplyGetSvcInfoCC.getReturnCode` | EKK0081A010SC | Service contract detail data | Reads the return code from `param` to check for single-item errors (>= 1000 threshold) |
| R | `JKKWrisvcAutoAplyGetSvcInfoCC.getSvkeiNo` | EKK0081A010SC | Service contract number data | Fetches the service contract number (契約番号) — called once before the add loop to retrieve the contract reference |
| U | `JKKWrisvcAutoAplyGetSvcInfoCC.putParamMap` | - | Parameter map | Merges the common input data (`paramMap`) with the SC template into a combined parameter map |
| U | `JKKWrisvcAutoAplyGetSvcInfoCC.setSCInputCommonData` | - | Common input data | Extracts common service component input fields from `param` into a HashMap |
| U | `JKKCallWrisvcAutoAplyUtil.callWrisvcAutoAply` | JKKWrisvcAutoAply | Discount service auto-apply records | Dispatches each processed service detail record to the auto-apply engine (`JKKWrisvcAutoAplyCC.execute`) for discount calculation and application |

**How the SC call works:**
The method uses `ServiceComponentRequestInvoker` (a BPM framework utility) to invoke the `EKK0081A010` Service Component. For each service detail item in the cancel/add/update lists, it:
1. Builds an input template via `editInEKK0081A010(param, fixedText, svc_kei_no)` — setting the service detail number.
2. Merges the template with common data via `putParamMap`.
3. Executes the SC call via `scCall.run(...)`.
4. Processes the result via `editRetEKK0081A010(...)`, passing the operation code ("01"/"02"/"05") and the childMap as a data graft target.
5. Validates the return code — throws an exception if it exceeds `SINGLEDATA_ERR` (1000).

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Controller:JKKAddNetNorikaeCC | `JKKAddNetNorikaeCC.addNetNorikae` -> `JKKWrisvcAutoAplyGetSvcInfoCC.getSvcInfo` | `callWrisvcAutoAply [U] discount auto-apply` |

**Call chain details:**
- `JKKAddNetNorikaeCC` (Add Net Norikae Controller — 「ネット乗り換え追加」: Add Broadband Migration) is the screen controller that invokes `getSvcInfo()` to retrieve and dispatch discount service auto-application information when adding a broadband migration request.

**Terminal operations from this method:**
- `callWrisvcAutoAply` [U] — Writes discount service auto-apply records via `JKKWrisvcAutoAplyCC.execute` (for cancel/add/update types)
- `editRetEKK0081A010` [U] — Updates result data maps with service detail information from SC return
- `setData` [U] — Sets processed data maps into param under keys `cancelWrisvcMap`, `addWrisvcMap`, `updWrisvcMap`

## 6. Per-Branch Detail Blocks

**Block 1** — INIT (L76–L80)
> Initialize local variables: create the ServiceComponentRequestInvoker, set up the common input parameter map, and declare result/template variables.

| # | Type | Code |
|---|------|------|
| 1 | SET | `scCall = new ServiceComponentRequestInvoker()` — Creates the SC call invoker |
| 2 | SET | `paramMap = setSCInputCommonData(param, new HashMap<String, Object>())` — Extracts common SC input fields from param [-> CC_WORK_AREA_NAME_WRI_GET_INFO="JKKWrisvcAutoAplyGetSvcInfoCCWork"] |
| 3 | SET | `result = null` — SC return result placeholder |
| 4 | SET | `template = null` — SC template placeholder |

**Block 2** — EXTRACT INPUT MAP (L81–L82)
> Retrieve the input HashMap from the request parameter using fixedText as the key.

| # | Type | Code |
|---|------|------|
| 1 | SET | `inMap = (HashMap)param.getData(fixedText)` — Extracts input map containing cancel/add/update lists |

**Block 3** — IF `inMap == null` — EARLY EXIT (L84–L87)
> If the input map is not set (no service detail data to process), return the parameter unchanged. This is a guard clause to skip processing when there is nothing to do.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `return param;` — Early return if inMap is null — マップに値が設定されていない場合は処理を行わない。(Do not process if no values are set in the map) |

**Block 4** — PROCESS CANCEL LIST (L89–L108)
> Process the cancel_inf_list: iterate over each service item marked for cancellation, fetch its service detail via the SC, edit the result with operation code "05" (cancel), validate the return code, and collect the processed data map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `cclSvcKeiList = null` — Cancel service detail list placeholder |
| 2 | SET | `cclList = (ArrayList<HashMap>)inMap.get("cancel_inf_list")` — Extract cancel modification list |

**Block 4.1** — IF `cclList != null` (L91)
> If there are cancellation items, initialize the collection and iterate.

| # | Type | Code |
|---|------|------|
| 1 | SET | `cclSvcKeiList = new ArrayList<HashMap>()` — Initialize cancel result list |

**Block 4.2** — FOR LOOP over `cclList` (L93–L108)
> For each childMap (cancellation item) in the cancel list:

| # | Type | Code |
|---|------|------|
| 1 | SET | `dataMap = new HashMap()` — Data map for this cancel item |
| 2 | SET | `template = editInEKK0081A010(param, fixedText, (String)childMap.get("svc_kei_no"))` — Build SC input template with service detail number |
| 3 | CALL | `result = scCall.run(putParamMap(paramMap, template), handle)` — Execute SC query |
| 4 | CALL | `editRetEKK0081A010(result, param, fixedText, "05", dataMap, null)` — Process SC return with cancel code [-> OPR_CD_CANCEL="05"] |

**Block 4.3** — IF `getReturnCode(param) >= SINGLEDATA_ERR` (L102)
> If the return code is >= 1000, the status has a per-item error. Throw a CCException. ステータスが単項目エラーであれば例外をスロー。(Throw an exception if the status has a single-item error)

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR` [-> `SINGLEDATA_ERR = 1000`] — Per-item error check |
| 2 | THROW | `throw new CCException(SC_ERROR_STRING, new Exception())` [-> `SC_ERROR_STRING = "サービスコンテンツエラー"`] (Service Content Error) |
| 3 | SET | `cclSvcKeiList.add(dataMap)` — Add processed data map to cancel result list |

**Block 5** — PROCESS ADD LIST (L110–L133)
> Process the add_inf_list: iterate over each service item marked for new registration, fetch its service detail via the SC, edit the result with operation code "01" (add), validate the return code, and collect the processed data map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `addSvcKeiList = null` — Add service detail list placeholder |
| 2 | SET | `addList = (ArrayList<HashMap>)inMap.get("add_inf_list")` — Extract add modification list |

**Block 5.1** — IF `addList != null` (L115)
> If there are add items, first get the service contract number, then initialize and iterate.

| # | Type | Code |
|---|------|------|
| 1 | SET | `addSvcKeiList = new ArrayList<HashMap>()` — Initialize add result list |
| 2 | CALL | `getSvkeiNo(param, fixedText)` — サービス契約番号取得処理 (Service contract number acquisition processing) |

**Block 5.2** — FOR LOOP over `addList` (L118–L133)
> For each childMap (add item) in the add list:

| # | Type | Code |
|---|------|------|
| 1 | SET | `dataMap = new HashMap()` — Data map for this add item |
| 2 | SET | `template = editInEKK0081A010(param, fixedText, (String)childMap.get("svc_kei_no"))` — Build SC input template with service detail number |
| 3 | CALL | `result = scCall.run(putParamMap(paramMap, template), handle)` — Execute SC query |
| 4 | CALL | `editRetEKK0081A010(result, param, fixedText, "01", dataMap, childMap)` — Process SC return with add code [-> OPR_CD_ADD="01"], graft childMap as data source |

**Block 5.3** — IF `getReturnCode(param) >= SINGLEDATA_ERR` (L127)
> If the return code is >= 1000, the status has a per-item error. Throw a CCException.

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR` [-> `SINGLEDATA_ERR = 1000`] — Per-item error check |
| 2 | THROW | `throw new CCException(SC_ERROR_STRING, new Exception())` [-> `SC_ERROR_STRING = "サービスコンテンツエラー"`] (Service Content Error) |
| 3 | SET | `addSvcKeiList.add(dataMap)` — Add processed data map to add result list |

**Block 6** — PROCESS UPDATE LIST (L135–L157)
> Process the upd_inf_list: iterate over each service item marked for plan change, fetch its service detail via the SC, edit the result with operation code "02" (update), validate the return code, and collect the processed data map.

| # | Type | Code |
|---|------|------|
| 1 | SET | `updSvcKeiList = null` — Update service detail list placeholder |
| 2 | SET | `updList = (ArrayList<HashMap>)inMap.get("upd_inf_list")` — Extract update modification list |

**Block 6.1** — IF `updList != null` (L140)
> If there are update items, initialize and iterate.

| # | Type | Code |
|---|------|------|
| 1 | SET | `updSvcKeiList = new ArrayList<HashMap>()` — Initialize update result list |

**Block 6.2** — FOR LOOP over `updList` (L142–L157)
> For each childMap (update item) in the update list:

| # | Type | Code |
|---|------|------|
| 1 | SET | `dataMap = new HashMap()` — Data map for this update item |
| 2 | SET | `template = editInEKK0081A010(param, fixedText, (String)childMap.get("svc_kei_no"))` — Build SC input template with service detail number |
| 3 | CALL | `result = scCall.run(putParamMap(paramMap, template), handle)` — Execute SC query |
| 4 | CALL | `editRetEKK0081A010(result, param, fixedText, "02", dataMap, childMap)` — Process SC return with update code [-> OPR_CD_UPD="02"], graft childMap as data source |

**Block 6.3** — IF `getReturnCode(param) >= SINGLEDATA_ERR` (L149)
> If the return code is >= 1000, the status has a per-item error. Throw a CCException.

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR` [-> `SINGLEDATA_ERR = 1000`] — Per-item error check |
| 2 | THROW | `throw new CCException(SC_ERROR_STRING, new Exception())` [-> `SC_ERROR_STRING = "サービスコンテンツエラー"`] (Service Content Error) |
| 3 | SET | `updSvcKeiList.add(dataMap)` — Add processed data map to update result list |

**Block 7** — DISPATCH CANCEL TO AUTO-APPLY (L161–L168)
> Dispatch each cancel result to the auto-apply engine. 割引サービス自動適用CCを区分：キャンセルで実行 (Execute discount service auto-apply CC by category: cancel).

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `cclSvcKeiList != null` — Check if cancel results exist |
| 2 | FOR | `for each childMap in cclSvcKeiList` — Iterate cancel result items |
| 3 | EXEC | `param.setData("cancelWrisvcMap", childMap)` — Set cancel data map under key "cancelWrisvcMap" |
| 4 | CALL | `(new JKKCallWrisvcAutoAplyUtil()).callWrisvcAutoAply(handle, param, "cancelWrisvcMap")` — Dispatch to auto-apply engine for cancellation |

**Block 8** — DISPATCH ADD TO AUTO-APPLY (L170–L177)
> Dispatch each add result to the auto-apply engine. 割引サービス自動適用CCを区分：登録で実行 (Execute discount service auto-apply CC by category: registration).

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `addSvcKeiList != null` — Check if add results exist |
| 2 | FOR | `for each childMap in addSvcKeiList` — Iterate add result items |
| 3 | EXEC | `param.setData("addWrisvcMap", childMap)` — Set add data map under key "addWrisvcMap" |
| 4 | CALL | `(new JKKCallWrisvcAutoAplyUtil()).callWrisvcAutoAply(handle, param, "addWrisvcMap")` — Dispatch to auto-apply engine for new registration |

**Block 9** — DISPATCH UPDATE TO AUTO-APPLY (L179–L186)
> Dispatch each update result to the auto-apply engine. 割引サービス自動適用CCを区分：プラン変更で実行 (Execute discount service auto-apply CC by category: plan change).

| # | Type | Code |
|---|------|------|
| 1 | IF (cond) | `updSvcKeiList != null` — Check if update results exist |
| 2 | FOR | `for each childMap in updSvcKeiList` — Iterate update result items |
| 3 | EXEC | `param.setData("updWrisvcMap", childMap)` — Set update data map under key "updWrisvcMap" |
| 4 | CALL | `(new JKKCallWrisvcAutoAplyUtil()).callWrisvcAutoAply(handle, param, "updWrisvcMap")` — Dispatch to auto-apply engine for plan change |

**Block 10** — RETURN (L188)
> Return the enriched request parameter to the caller.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return param;` — Return the parameter with all auto-apply data set |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `svc_kei_no` | Field | Service detail number — internal identifier for a specific service contract line item within a customer's service portfolio |
| `cancel_inf_list` | Field | Cancel information list — ArrayList of HashMaps representing service items marked for subscription cancellation (解約) |
| `add_inf_list` | Field | Add information list — ArrayList of HashMaps representing service items marked for new registration (登録) |
| `upd_inf_list` | Field | Update information list — ArrayList of HashMaps representing service items marked for plan change (プラン変更) |
| `svkei_no` | Field | Service detail number (shortened form of svc_kei_no) — the service contract detail number used as the primary key for SC queries |
| CC | Acronym | Common Component — a reusable business logic component in the Fujitsu Futurity BPM framework that provides shared functionality across screens |
| SC | Acronym | Service Component — a back-end business logic module in the BPM framework that performs data access and business rule execution, typically mapped to a CBS (Common Business Service) |
| CBS | Acronym | Common Business Service — the back-end execution layer that wraps database operations and business rules; SCs call CBS modules |
| SINGLEDATA_ERR | Constant | Single data error — the error threshold (value: 1000) for per-item return codes. Codes >= this value indicate a processing error |
| EKK0081A010 | SC Code | Service detail query SC/CBS — the service component responsible for retrieving service contract detail information |
| `fixedText` | Parameter | Service message identifier — used as a namespace key to extract the input map from the request parameter; also passed to SC methods as context |
| `inMap` | Local variable | Input map — the HashMap extracted from param that contains cancel_inf_list, add_inf_list, and upd_inf_list |
| `dataMap` | Local variable | Data map — a temporary HashMap used to accumulate the processed result of a single service detail SC query |
| `cclSvcKeiList` | Local variable | Cancel service detail list — collected results from processing the cancel_inf_list |
| `addSvcKeiList` | Local variable | Add service detail list — collected results from processing the add_inf_list |
| `updSvcKeiList` | Local variable | Update service detail list — collected results from processing the upd_inf_list |
| ServiceComponentRequestInvoker | Class | BPM framework utility class — wraps Service Component invocations, enabling SC calls with parameter maps and session handles |
| CCException | Class | Common Component Exception — custom exception class used to signal errors at the CC layer with a descriptive message |
| auto-apply | Business term | Discount service auto-application — the process of automatically calculating and applying discount rules to service contracts based on customer eligibility |
| JKKWrisvcAutoAplyCC | Class | Discount Service Auto-Apply CC — the downstream CC that receives processed service detail data and executes the discount application logic |
| netNorikae | Business term | Broadband migration (ネット乗り換え) — a service where a customer migrates their broadband internet service to K-Opticom from another provider |
| ワークエリア名 | Japanese term | Work area name — the HashMap key prefix used to scope SC input common data |