# Business Logic — JKKPauseChgRsvClCC.executePauseRls() [60 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JKKPauseChgRsvClCC` |
| Layer | CC / Common Component |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JKKPauseChgRsvClCC.executePauseRls()

This method performs the core business operation of **Service Contract Suspension Release** (サービス契約休止解除) — the process of lifting a previously placed service contract suspension and restoring the customer's telecommunications services to an active state. It acts as a **delegating orchestration method** that first queries the current suspension state through the `callEKK0081C080` service component (SC EKK0081C080, responsible for service contract suspension change processing), then, if not in check mode, executes a sequence of downstream operational steps to finalize the release. These steps include: (1) **Progress Registration** via `makeProgress` (SC EKK1091D010) to record the suspension release in the work-in-progress tracking table; (2) **Fault Cell Movement Information Registration** via `executeFmtcelIdoInf` to log the fault cell movement event with the divergence category "Pause Change/Reserve Cancellation" (休止変更・予約取消); and (3) **Skip Key Information Operation** via `executeSptvKeyInfPauseRls` to process skip key handling (e.g., cable modem skip key regeneration or renewal) associated with the suspension release, using processing code "5" (KAIHK = Kaiho/Hakai — Release/Remooval). When `isCheckMode` is `true` (deduction-check phase), the method skips all execution steps and returns early, serving the screen's pre-validation mode.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["executePauseRls(params)"])
    CALL1["callEKK0081C080<br/>Service Contract Suspension Change"]
    COND{"isCheckMode<br/>== true?"}
    PUT["resultHash.put<br/>RESULT_HASH_KEY_EKK0081C080<br/>(getWorkCAANMsg)"]
    CALL2["makeProgress<br/>Progress Registration<br/>(SC EKK1091D010)"]
    GET1["param.getData(fixedText)<br/>-> trgtMap"]
    GET2["trgtMap.get(PAUSE_RECEPT_MAP)<br/>-> inMap"]
    CALL3["executeFmtcelIdoInf<br/>Fault Cell Movement Info Reg."]
    GET3["inMap.get(SVC_PAUSE_RLS_YMD)<br/>-> pauseRlsYmd"]
    CALL4["executeSptvKeyInfPauseRls<br/>Skip Key Info Operation"]
    END_NODE(["Return / Next"])

    START --> CALL1 --> COND
    COND -->|false| PUT --> CALL2 --> GET1 --> GET2 --> CALL3 --> GET3 --> CALL4 --> END_NODE
    COND -->|true| END_NODE
```

**Processing flow description:**

1. **Step 1:** Call `callEKK0081C080(handle, param, fixedText, updDtm, mskmDtlNo)` to retrieve the current service contract suspension state. This builds an input message via `editInMsgEKK0081C080`, runs it through the `scCall` framework to invoke SC EKK0081C080, applies result mapping via `editResultRPEKK0081C080`, performs error checking via `errChk`, and returns the result map.

2. **Step 2 (conditional):** If `isCheckMode` is `false` (actual execution, not deduction check), proceed with the following sequence:

   2.1 Store the work CAAN message into `resultHash` under key `"EKK0081C080"` (`RESULT_HASH_KEY_EKK0081C080`) for downstream methods to access the suspension state data.

   2.2 Call `makeProgress(handle, param, fixedText, mskmDtlNo, resultHash)` to register the suspension release progress in the work-in-progress management system (linked to SC EKK1091D010).

   2.3 Retrieve the target data map from the request parameter using the `fixedText` key, then extract the pause reception map from it (`PAUSE_RECEPT_MAP` = `"pause_recept_map"`).

   2.4 Call `executeFmtcelIdoInf(handle, param, inMap, fixedText, rsltEKK1091D010)` to register fault cell movement information — logging that a service contract was suspended and then released, with the fault cell divergence category set to the pause/change/reserve-cancellation code.

   2.5 Extract the suspension release date (`SVC_PAUSE_RLS_YMD` = `"svc_pause_rls_ymd"`) from the pause reception map and call `executeSptvKeyInfPauseRls(handle, param, inMap, pauseRlsYmd)` to process skip key information operations (regeneration/renewal of cable modem skip keys tied to this suspension release).

3. **Step 3:** If `isCheckMode` is `true`, skip all execution steps and return immediately — this enables the calling screen to perform a pre-check (deduction) without side effects.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `handle` | `SessionHandle` | Database session handle carrying connection and transaction context. Used by all downstream service calls to execute database operations within the same transaction scope. |
| 2 | `param` | `IRequestParameterReadWrite` | Request parameter object holding model groups and control maps. Carries the incoming request data from the calling screen or batch process, including the service suspension change parameters and intermediate work maps. |
| 3 | `fixedText` | `String` | User-assigned arbitrary string used as a key to group and correlate request/result data within the parameter map. Acts as a namespace separator for multi-line or multi-item request handling. |
| 4 | `resultHash` | `HashMap<String, Object>` | Result map for passing data between processing steps within the same transaction. The suspended release results from `callEKK0081C080` are stored here under key `"EKK0081C080"` for `makeProgress` and `executeFmtcelIdoInf` to consume. |
| 5 | `updDtm` | `String` | Update timestamp — the date/time when the service contract suspension change is applied. Passed through to `callEKK0081C080` to record the effective update time in the database. |
| 6 | `mskmDtlNo` | `String` | Service detail number (サービスDETAIL番号) — internal tracking identifier for the specific service contract line item. Used to uniquely identify which service detail record is being suspended/released. |
| 7 | `svcCd` | `String` | Service code (サービスコード) — identifies the type of service being operated on (e.g., FTTH, ENUM, Mail). Passed as a parameter but not directly referenced in the current method body (used by caller context). |

**Instance fields read by this method:**

| Field | Type | Business Description |
|-------|------|---------------------|
| `isCheckMode` | `boolean` | Flag indicating whether the method is running in deduction-check mode (`true`) or actual execution mode (`false`). Set by the calling method based on the function code. |
| `mapper` | `JKKPauseChgRsvClMapperCC` (inferred) | Mapper object for transforming request parameters to/from service component input/output messages. |
| `scCall` | `SCRunner` (inferred) | Service Component runner for executing SC processes via the framework. |

## 4. CRUD Operations / Called Services

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

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R/U | `callEKK0081C080` | EKK0081C080 | KK_T_SVKEI (inferred) | Reads current service contract suspension state and records the suspension change request via mapper layer |
| R/U | `makeProgress` | EKK1091D010 | KK_T_HNTEI (inferred — 進捗登録 = progress registration) | Registers the suspension release in the work-in-progress management table |
| C | `executeFmtcelIdoInf` | (via `JKKBpCommon.addFmtcelIdoInf`) | KK_T_FMTCEL_IDO_INF (inferred) | Creates a fault cell movement information log entry for the pause/change/release event |
| C | `executeSptvKeyInfPauseRls` | (via `JKKSptvKeyInfOperateCC.execute`, `shori_cd` = `"5"` — 解放) | Skip key info table (inferred) | Registers skip key operation for suspension release, triggering skip key regeneration/renewal |
| R | `getWorkCAANMsg` | — | — | Extracts the CAAN message object from a result map (local utility, no DB access) |

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | `JKKPauseChgRsvClCC.pauseChgTranOn` | `pauseChgTranOn` -> `executePauseRls(handle, param, fixedText, resultHash, updDtm, mskmDtlNo, svcCd)` | `callEKK0081C080 [R/U] KK_T_SVKEI`, `makeProgress [R/U] KK_T_HNTEI`, `executeFmtcelIdoInf [C] KK_T_FMTCEL_IDO_INF`, `executeSptvKeyInfPauseRls [C] SkipKeyInfo` |
| 2 | `JKKPauseChgRsvClCC.pauseChgTranBat` | `pauseChgTranBat` -> `executePauseRls(handle, param, fixedText, resultHash, updDtm, mskmDtlNo)` | `callEKK0081C080 [R/U] KK_T_SVKEI`, `makeProgress [R/U] KK_T_HNTEI`, `executeFmtcelIdoInf [C] KK_T_FMTCEL_IDO_INF`, `executeSptvKeyInfPauseRls [C] SkipKeyInfo` |

**Notes on caller context:**
- `pauseChgTranOn` is the **online transaction** entry point, called when an operator initiates a service contract suspension change from a screen. It passes 7 parameters including `svcCd` (service code).
- `pauseChgTranBat` is the **batch transaction** entry point, called for scheduled or bulk suspension processing. It passes 6 parameters (no `svcCd`), indicating batch processes do not require a specific service code.
- The `isCheckMode` field determines whether actual execution or deduction-check mode runs. When called from online screens, the mode is determined by the function code (`JPCModelConstant.FUNC_CD_2` = check mode).

## 6. Per-Branch Detail Blocks

**Block 1** — [CALL] `(service contract suspension change)` (L1488)

> Call the service component to retrieve the current suspension state and record the suspension change request.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `callEKK0081C080(handle, param, fixedText, updDtm, mskmDtlNo)` // Service Contract Suspension Change (サービス契約休止変更) |
| 2 | SET | `rsltEKK0081C080 = <return value>` // Map of suspension state data |

**Inside `callEKK0081C080`:**

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `mapper.editInMsgEKK0081C080(param, fixedText, tmpUpdDtm, tmpMskmDtlNo)` // Build input message for SC EKK0081C080 |
| 2 | CALL | `scCall.run(mapEKK0081C080, handle)` // Execute SC EKK0081C080 |
| 3 | EXEC | `mapper.editResultRPEKK0081C080(rsltEKK0081C080, param, fixedText)` // Map result to param |
| 4 | CALL | `errChk(rsltEKK0081C080)` // Error check on SC result |

**Block 2** — [IF] `(isCheckMode == true)` (L1490)

> Conditional branch: when in check (deduction) mode, skip all execution steps. This enables pre-validation without side effects.

**Block 2.1** — [ELSE] `(isCheckMode == false)` (L1490)

> Actual execution path: perform service suspension release operations.

**Block 2.1.1** — [SET] `(store work CAAN message)` (L1516)

> Store the result from `callEKK0081C080` into `resultHash` for downstream consumption.

| # | Type | Code |
|---|------|------|
| 1 | SET | `resultHash.put(RESULT_HASH_KEY_EKK0081C080, getWorkCAANMsg(rsltEKK0081C080))` // Store under "EKK0081C080" [-> RESULT_HASH_KEY_EKK0081C080="EKK0081C080"] |

**Block 2.1.2** — [CALL] `(progress registration)` (L1517)

> Register the suspension release as a progress entry in the work-in-progress management system.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `makeProgress(handle, param, fixedText, mskmDtlNo, resultHash)` // Progress Registration (進捗登録) (SC EKK1091D010) |
| 2 | SET | `rsltEKK1091D010 = <return value>` // Progress registration result |

**Block 2.1.3** — [EXEC] `(extract pause reception map)` (L1521-1523)

> Extract the target data map and the pause reception sub-map from the request parameters for fault cell movement info registration.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `HashMap<String, Object> trgtMap = (HashMap<String, Object>)param.getData(fixedText)` // Get target data map (ターゲットデータ) |
| 2 | EXEC | `HashMap<String, Object> inMap = (HashMap<String, Object>)trgtMap.get(PAUSE_RECEPT_MAP)` // Get pause reception map [-> PAUSE_RECEPT_MAP="pause_recept_map" (JKKPauseChgRsvClConstCC.java:112)] |

**Block 2.1.4** — [CALL] `(fault cell movement info registration)` (L1524)

> Register fault cell movement information to log the service suspension and release event. Sets the fault cell divergence category to "00025 (Pause Change/Reserve Cancellation)" (異動区分: 休止変更・予約取消).

| # | Type | Code |
|---|------|------|
| 1 | CALL | `executeFmtcelIdoInf(handle, param, inMap, fixedText, rsltEKK1091D010)` // Fault Cell Movement Info Registration (フェムセル異動情報登録) |

**Block 2.1.5** — [CALL] `(skip key info operation)` (L1528)

> Process skip key information operations for the suspension release. Extracts the suspension release date from the pause reception map and passes it to the skip key operation handler.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `(String)inMap.get(SVC_PAUSE_RLS_YMD)` // Extract suspension release date [-> SVC_PAUSE_RLS_YMD="svc_pause_rls_ymd" (JKKPauseChgRsvClConstCC.java:118)] |
| 2 | CALL | `executeSptvKeyInfPauseRls(handle, param, inMap, pauseRlsYmd)` // Skip Key Info Operation CC Call (スケープキー情報操作CC呼び出し), processing code = `"5"` (解放 = Release) |

**Block 3** — [END] `(return)` (L1532)

> Method completes. All changes are committed or rolled back by the caller's transaction management.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return;` // void method — implicit return |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `executePauseRls` | Method | Service Contract Suspension Release — the core method that lifts a service suspension and restores services |
| `休止解除` (Kyuushi Kaijo) | Japanese term | Suspension Release — the business act of removing a previously placed service suspension |
| `サービス契約休止変更` (Service Contract Suspension Change) | Japanese term | SC EKK0081C080 — the service component that reads and updates the service contract suspension state |
| `進捗登録` (Shincho Touroku) | Japanese term | Progress Registration — recording a process step (e.g., suspension release) in the work-in-progress tracking table |
| `フェムセル異動情報` (Femtocell Idou Jouhou) | Japanese term | Femtocell/Fault Cell Movement Information — logs when services move between states (suspended, active, cancelled) |
| `スケープキー` (Sukepu Kii) | Japanese term | Skip Key — a security credential used in cable modem / broadband authentication that may need regeneration on suspension release |
| `解放` (Kaihou) | Japanese term | Release — the processing code `"5"` indicating a release (as opposed to creation, change, or cancellation) |
| `休止変更・予約取消` (Kyuushi Henkou · Yoyaku Torikeshi) | Japanese term | Pause Change / Reserve Cancellation — fault cell divergence category `"00025"` identifying this as a suspension-then-release scenario |
| `isCheckMode` | Field | Deduction-check flag — when `true`, the method performs read-only validation without side effects |
| `PAUSE_RECEPT_MAP` | Constant | Map key `"pause_recept_map"` — holds intermediate pause processing data (reception date, service code, divergence type) |
| `SVC_PAUSE_RLS_YMD` | Constant | Map key `"svc_pause_rls_ymd"` — the calculated or input suspension release date (year-month-day) |
| `RESULT_HASH_KEY_EKK0081C080` | Constant | Hash key `"EKK0081C080"` — used to store/retrieve the work CAAN message from the suspension change call in resultHash |
| `SKCD` | Acronym | Sub-Contract Code — internal classification code for service sub-contracts (used in related constant domain, e.g., `ylan_kino_mode_skcd`) |
| FTTH | Business term | Fiber To The Home — fiber-optic broadband internet service |
| ENUM | Business term | Session Initiation Protocol (SIP) telephony service — VoIP over the broadband connection |
| CAANMsg | Technical | Communication Abstract Application Network — Fujitsu's message object format used for SC input/output data exchange |
| SC | Acronym | Service Component — a service-layer module that encapsulates business logic and database operations |
| CBS | Acronym | CBS (Common Business Service) — the underlying business service layer that SC components invoke |

---

*Document generated for method `JKKPauseChgRsvClCC.executePauseRls()` — 60 lines of code — Enterprise DD Standard*