# Business Logic — JKKAdchgCheckerCC.telOpPackCheck() [98 LOC]

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

## 1. Role

### JKKAdchgCheckerCC.telOpPackCheck()

This method performs a **Telephone Select Option Pack validation check** (電話セレクトオプションパックチェック処理) in a telecommunications billing/ordering system. Its core business responsibility is to verify that a customer's service contract is correctly associated with the appropriate optional service packs — bundles of add-on features (such as FTTH internet, mail services, ENUM, etc.) that are attached to a telephone service contract line item.

The method implements a **query-and-dispatch routing pattern**. It iterates over a list of options selected on the screen (`judge_pcrs_cd_list`), and for each option it performs two database reads: first, it queries the pricing/cost code mapping via `EKK0351A010SC`, and second, it queries the sub-option service status via `EKK0401B001SC`. These pricing codes are aggregated into a canonical `paramJudgePcrsCdList`. It then delegates the actual option-pack eligibility logic to `JFUOptPackAplyChkCC.judgeOptPack()`, which applies business rules to determine whether a pack should be attached, whether the attached pack matches expectations, and whether any pack conflicts exist.

The method serves as a **shared validation utility** called during service contract modification/check operations. It is invoked from `chkTelOpPack()` (a screen-facing check method) within the `JKKAdchgCheckerCC` class, which orchestrates multiple validation checks (credit, address, service changes) as part of a broader service change workflow. The method returns `true` if all option pack validations pass, or `false` if a pack mismatch, missing pack, or unauthorized pack attachment is detected.

If the service contract number (`svc_kei_no`) or service detail work number (`svc_kei_ucwk_no`) is absent, the method short-circuits and returns `true`, treating the absence of a contract as "nothing to validate."

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["telOpPackCheck entry"])
    SETUP["Setup: reqMap, condMap, resMap declarations"]
    GET_DATA["Extract paramMap from param.getData(fixedText)"]
    GET_FIELDS["Get svcKeiNo, svcKeiUcwkNo, wribSvcCd from paramMap"]
    CHECK_EMPTY{"svcKeiNo or svcKeiUcwkNo is empty?"}
    SKIP_CHECK["Skip check, return true"]
    INIT_CACHE["Init: mapper, scCall, paramJudgePcrsCdList"]
    GET_JUDGE_LIST["Get judgePcrsCdList from paramMap"]
    CHECK_JUDGE_NULL{"judgePcrsCdList is null?"}
    INIT_LOOP["i = 0"]
    CHECK_LOOP{"i < judgePcrsCdList.size()?"}
    GET_CHILD["Get childMap from judgePcrsCdList[i]"]
    GET_OP_SVC_KEI_NO["Get opSvcKeiNo from childMap"]
    CLEAR_COND1["condMap.clear()"]
    PUT_COND["condMap.put opSvcKeiNo + getOpeDate"]
    SET_EKK351["mapper.setEKK0351A010(param, fixedText, condMap)"]
    RUN_SC351["scCall.run(reqMap, keepSesHandle.get())"]
    GET_EKK351["mapper.getEKK0351A010(param, fixedText, resMap)"]
    RESULT_CHECK_351["mapper.scResultCheck(param)"]
    CREATE_OP_MAP["Create opMap with pcrs_cd + pplan_cd from EKK0351A010"]
    CHECK_DUPLICATE{"paramJudgePcrsCdList contains opMap?"}
    ADD_OP_MAP["paramJudgePcrsCdList.add(opMap)"]
    CLEAR_COND2["condMap.clear()"]
    PUT_COND2["condMap.put opSvcKeiNo"]
    SET_EKK401["mapper.setEKK0401B001(param, fixedText, condMap)"]
    RUN_SC401["scCall.run(reqMap, keepSesHandle.get())"]
    GET_EKK401["mapper.getEKK0401B001(param, fixedText, resMap)"]
    RESULT_CHECK_401["mapper.scResultCheck(param)"]
    CHECK_STAT{"SBOP_SVC_KEI_STAT >= 900?"}
    CREATE_SUB_MAP["Create subOpMap with pcrs_cd + pplan_cd from EKK0401B001"]
    CHECK_SUB_DUP{"paramJudgePcrsCdList contains subOpMap?"}
    ADD_SUB_MAP["paramJudgePcrsCdList.add(subOpMap)"]
    INC_LOOP["i++"]
    PREPARE_DATA_MAP["Create dataMap with base_date + judge_pcrs_cd_list"]
    INIT_OPT_PACK["Create new JFUOptPackAplyChkCC"]
    SET_DATA_OPT["param.setData(fixedTextJFUOptPackAplyChkCC, dataMap)"]
    CALL_JUDGE_OPT["optPackAplyChkCC.judgeOptPack(handle, param, fixedText)"]
    GET_RET_MAP["param.getData(fixedTextJFUOptPackAplyChkCC)"]
    GET_RET_WRIB["Get retWribSvcCd from retMap"]
    CHECK_BOTH_EMPTY{"Both wribSvcCd and retWribSvcCd are empty?"}
    NO_PACK_OK["No pack attached, return true"]
    CHECK_NEED_PACK{"Only retWribSvcCd is present?"}
    NEED_PACK["Pack should be attached, return false"]
    CHECK_MISMATCH{"wribSvcCd != retWribSvcCd?"}
    PACK_MISMATCH["Pack mismatch, return false"]
    PACK_OK["Return true"]
    END_NODE(["Return true"])

    START --> SETUP
    SETUP --> GET_DATA
    GET_DATA --> GET_FIELDS
    GET_FIELDS --> CHECK_EMPTY
    CHECK_EMPTY -->|Yes| SKIP_CHECK
    CHECK_EMPTY -->|No| INIT_CACHE
    SKIP_CHECK --> END_NODE
    INIT_CACHE --> GET_JUDGE_LIST
    GET_JUDGE_LIST --> CHECK_JUDGE_NULL
    CHECK_JUDGE_NULL -->|true| INC_LOOP
    CHECK_JUDGE_NULL -->|false| INIT_LOOP
    INIT_LOOP --> CHECK_LOOP
    CHECK_LOOP -->|true| GET_CHILD
    CHECK_LOOP -->|false| PREPARE_DATA_MAP
    GET_CHILD --> GET_OP_SVC_KEI_NO
    GET_OP_SVC_KEI_NO --> CLEAR_COND1
    CLEAR_COND1 --> PUT_COND
    PUT_COND --> SET_EKK351
    SET_EKK351 --> RUN_SC351
    RUN_SC351 --> GET_EKK351
    GET_EKK351 --> RESULT_CHECK_351
    RESULT_CHECK_351 --> CREATE_OP_MAP
    CREATE_OP_MAP --> CHECK_DUPLICATE
    CHECK_DUPLICATE -->|true| INC_LOOP
    CHECK_DUPLICATE -->|false| ADD_OP_MAP
    ADD_OP_MAP --> CLEAR_COND2
    CLEAR_COND2 --> PUT_COND2
    PUT_COND2 --> SET_EKK401
    SET_EKK401 --> RUN_SC401
    RUN_SC401 --> GET_EKK401
    GET_EKK401 --> RESULT_CHECK_401
    RESULT_CHECK_401 --> CHECK_STAT
    CHECK_STAT -->|true| CREATE_SUB_MAP
    CHECK_STAT -->|false| INC_LOOP
    CREATE_SUB_MAP --> CHECK_SUB_DUP
    CHECK_SUB_DUP -->|true| INC_LOOP
    CHECK_SUB_DUP -->|false| ADD_SUB_MAP
    ADD_SUB_MAP --> INC_LOOP
    INC_LOOP --> CHECK_LOOP
    PREPARE_DATA_MAP --> INIT_OPT_PACK
    INIT_OPT_PACK --> SET_DATA_OPT
    SET_DATA_OPT --> CALL_JUDGE_OPT
    CALL_JUDGE_OPT --> GET_RET_MAP
    GET_RET_MAP --> GET_RET_WRIB
    GET_RET_WRIB --> CHECK_BOTH_EMPTY
    CHECK_BOTH_EMPTY -->|true| NO_PACK_OK
    CHECK_BOTH_EMPTY -->|false| CHECK_NEED_PACK
    NO_PACK_OK --> END_NODE
    CHECK_NEED_PACK -->|true| NEED_PACK
    CHECK_NEED_PACK -->|false| CHECK_MISMATCH
    NEED_PACK --> END_NODE
    CHECK_MISMATCH -->|true| PACK_MISMATCH
    CHECK_MISMATCH -->|false| PACK_OK
    PACK_MISMATCH --> END_NODE
    PACK_OK --> END_NODE
```

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `handle` | `SessionHandle` | The database session handle providing transactional context. It is used indirectly via the `keepSesHandle` ThreadLocal to pass the active session to the `ServiceComponentRequestInvoker` when executing SC (Service Component) calls. |
| 2 | `param` | `IRequestParameterReadWrite` | The request parameter object carrying the model group and control map for the current screen operation. It holds the input data map (retrieved via `param.getData(fixedText)`), the list of judgment option codes (`judge_pcrs_cd_list`), the base date (`base_date`), and the original write service code (`wrib_svc_cd`). After option pack validation, the modified result is stored back into `param` under the key `fixedTextJFUOptPackAplyChkCC`. |
| 3 | `fixedText` | `String` | A user-defined arbitrary string used as a map key/identifier to store and retrieve data within the `param` object. It acts as the namespace key for the input data map. |

**Instance fields / external state read:**

| Field | Type | Business Description |
|-------|------|---------------------|
| `keepSesHandle` | `ThreadLocal<SessionHandle>` | A thread-local storage field that holds the active session handle across SC calls within the same thread. Used to pass the session to `ServiceComponentRequestInvoker.run()`. Defined at JKKAdchgCheckerCC.java:84. |

## 4. CRUD Operations / Called Services

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

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `JBSbatDKNyukaFinAdd.getData` | JBSbatDKNyukaFinAdd | - | Calls `getData` to retrieve billing/financing delivery data |
| R | `JCCBPCommon.getOpeDate` | JCCBPCommon | - | Gets the current operational date for query conditions |
| R | `JFUOptPackAplyChkCC.judgeOptPack` | JFUOptPackAplyChkCC | - | Executes option pack eligibility judgment rules |
| R | `JKKAdchgMapperCC.getEKK0351A010` | JKKAdchgMapperCC | EKK0351A010SC | Retrieves pricing cost code and pricing plan code for a given option service contract number |
| R | `JKKAdchgMapperCC.getEKK0401B001` | JKKAdchgMapperCC | EKK0401B001SC | Retrieves sub-option service status, pricing cost code, and pricing plan code |
| R | `JKKAdchgMapperCC.setEKK0351A010` | JKKAdchgMapperCC | EKK0351A010SC | Sets query conditions (option service contract number, operation date) for the pricing cost code lookup |
| R | `JKKAdchgMapperCC.setEKK0401B001` | JKKAdchgMapperCC | EKK0401B001SC | Sets query conditions (option service contract number) for the sub-option service status lookup |
| - | `JKKAdchgMapperCC.scResultCheck` | JKKAdchgMapperCC | - | Checks SC execution result for errors and raises exceptions if failed |
| - | `JCCcomFileSearchUtil.clear` | JCCcomFileSearch | - | Clears the condition map before setting new query parameters |
| - | `ServiceComponentRequestInvoker.run` | - | - | Executes remote SC (Service Component) calls with the prepared request map and session handle |
| - | `JFUOptPackAplyChkCC.judgeOptPack` | JFUOptPackAplyChkCC | - | Delegates to the option pack application checker to validate pack attachment logic |
| R | `IRequestParameterReadWrite.getData` | - | - | Reads the input data map from the request parameter by key |
| - | `IRequestParameterReadWrite.setData` | - | - | Stores the result data map back into the request parameter |

## 5. Dependency Trace

### Caller chain

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:JKKAdchgCheckerCC.chkTelOpPack | `chkTelOpPack` -> `telOpPackCheck` | `setEKK0351A010 [R] pricing cost code`<br>`setEKK0401B001 [R] sub-option service status`<br>`judgeOptPack [-] option pack eligibility` |

**Details:**
- `chkTelOpPack()` (lines 1599–1634) is the public-facing entry point that orchestrates the telephone option pack check workflow. It wraps the call to `telOpPackCheck()` in a try-finally block that manages the `keepSesHandle` ThreadLocal session.
- On line 1618, if `telOpPackCheck()` returns `false`, the method sets the check result to `CHECK_ERR = "0"` (JKKAdchgCheckerCC.java:75), signaling that the option pack validation failed.
- On success, the check result is set to `CHECK_OK = "1"` (JKKAdchgCheckerCC.java:73).

### Terminal operations from this method

| Operation | Direction | SC Code / Target | Business Meaning |
|-----------|-----------|------------------|-----------------|
| `setEKK0351A010` | R | EKK0351A010SC | Query pricing cost code and pricing plan code for each option |
| `getEKK0351A010` | R | EKK0351A010SC | Read pricing cost code and pricing plan code from SC result |
| `scResultCheck` | - | - | Validate SC execution succeeded |
| `setEKK0401B001` | R | EKK0401B001SC | Query sub-option service status list |
| `getEKK0401B001` | R | EKK0401B001SC | Read sub-option service status, pricing code, and plan code |
| `scResultCheck` | - | - | Validate SC execution succeeded |
| `judgeOptPack` | - | JFUOptPackAplyChkCC | Delegate option pack eligibility judgment |
| `getEKK0401B001` | R | EKK0401B001SC | Returns list of sub-options with `SBOP_SVC_KEI_STAT >= 900` |
| `getOpeDate` | R | JCCBPCommon | Get the current operational date for query condition |

## 6. Per-Branch Detail Blocks

**Block 1** — [SET] Setup and data extraction (L1646–L1653)

> Extract the input data map and pull out key service identifiers needed for validation.

| # | Type | Code |
|---|------|------|
| 1 | SET | `reqMap` (declaration) |
| 2 | SET | `condMap = new HashMap<String, String>()` |
| 3 | SET | `resMap` (declaration) |
| 4 | SET | `paramMap = param.getData(fixedText)` [-> `fixedText` as key] |
| 5 | SET | `svcKeiNo = paramMap.get("svc_kei_no")` [Service contract number] |
| 6 | SET | `svcKeiUcwkNo = paramMap.get("svc_kei_ucwk_no")` [Service detail work number] |
| 7 | SET | `wribSvcCd = paramMap.get("wri_svc_cd")` [Write service code — the expected option pack] |

**Block 2** — [IF] Early return if no service contract exists (L1655–L1657)

> If the service contract number or service detail work number is missing, the method considers the check as passed (nothing to validate). This is a short-circuit for contracts that do not exist or are not yet created.

| # | Type | Code |
|---|------|------|
| 1 | IF | `StringUtils.isEmpty(svcKeiNo) \|\| StringUtils.isEmpty(svcKeiUcwkNo)` |
| 2 | RETURN | `return true` // Skip check, no service contract |

**Block 3** — [SET] Initialize caches and working lists (L1659–L1663)

> Create the mapper instance, service component request invoker, and the list that will collect unique pricing codes from all option service contracts.

| # | Type | Code |
|---|------|------|
| 1 | SET | `mapper = JKKAdchgMapperCC.getInstance()` |
| 2 | SET | `scCall = new ServiceComponentRequestInvoker()` |
| 3 | SET | `paramJudgePcrsCdList = new ArrayList<HashMap>()` // Judgment pricing code cost code list |
| 4 | SET | `judgePcrsCdList = (ArrayList<HashMap>)paramMap.get("judge_pcrs_cd_list")` // Screen-selected options list |

**Block 4** — [FOR] Iterate over screen-selected option service contracts (L1664–L1704)

> For each option code selected on the screen, query the pricing cost code and sub-option service status from the database, then aggregate unique pricing code pairs into `paramJudgePcrsCdList`.

| # | Type | Code |
|---|------|------|
| 1 | FOR | `i = 0; i < judgePcrsCdList.size(); i++` |
| 2 | SET | `childMap = judgePcrsCdList.get(i)` |
| 3 | SET | `opSvcKeiNo = childMap.get("op_svc_kei_no")` [Option service contract number] |
| 4 | EXEC | `condMap.clear()` [-> `JCCcomFileSearchUtil.clear`] |
| 5 | EXEC | `condMap.put(JKKAdchgMapperCC.COND_KEY_OP_SVC_KEI_NO, opSvcKeiNo)` [-> `COND_KEY_OP_SVC_KEI_NO = "cond_key_op_svc_kei_no" (JKKAdchgMapperCC.java:1587)] |
| 6 | EXEC | `condMap.put(JKKAdchgMapperCC.COND_KEY_OPEDATE, JCCBPCommon.getOpeDate(null))` [-> `COND_KEY_OPEDATE = "cond_key_opedate" (JKKAdchgMapperCC.java:1619)] |

**Block 4.1** — [CALL] Query pricing cost code via EKK0351A010SC (L1668–L1679)

> Query the pricing cost code and pricing plan code associated with this option service contract number and the current operational date.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `reqMap = mapper.setEKK0351A010(param, fixedText, condMap)` |
| 2 | CALL | `resMap = scCall.run(reqMap, keepSesHandle.get())` |
| 3 | CALL | `retMapEKK0351A010 = mapper.getEKK0351A010(param, fixedText, resMap)` |
| 4 | CALL | `mapper.scResultCheck(param)` |
| 5 | SET | `opMap = new HashMap()` |
| 6 | EXEC | `opMap.put("pcrs_cd", retMapEKK0351A010.get(EKK0351A010CBSMsg1List.PCRS_CD))` [Pricing cost code] |
| 7 | EXEC | `opMap.put("pplan_cd", retMapEKK0351A010.get(EKK0351A010CBSMsg1List.PPLAN_CD))` [Pricing plan code] |

**Block 4.1.1** — [IF] Deduplicate pricing codes (L1680–L1682)

> Only add the pricing code pair to the result list if it has not been seen before. This prevents duplicate entries for the same pricing code combination.

| # | Type | Code |
|---|------|------|
| 1 | IF | `!paramJudgePcrsCdList.contains(opMap)` |
| 2 | EXEC | `paramJudgePcrsCdList.add(opMap)` |

**Block 4.2** — [CALL] Query sub-option service status via EKK0401B001SC (L1686–L1693)

> Query the sub-option service status list for the same option service contract number. This returns sub-options with their status codes and pricing information.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `condMap.clear()` |
| 2 | EXEC | `condMap.put(JKKAdchgMapperCC.COND_KEY_OP_SVC_KEI_NO, opSvcKeiNo)` |
| 3 | CALL | `reqMap = mapper.setEKK0401B001(param, fixedText, condMap)` |
| 4 | CALL | `resMap = scCall.run(reqMap, keepSesHandle.get())` |
| 5 | CALL | `kk0401B001_list = mapper.getEKK0401B001(param, fixedText, resMap)` |
| 6 | CALL | `mapper.scResultCheck(param)` |

**Block 4.2.1** — [FOR] Iterate over sub-option service statuses (L1695–L1704)

> For each sub-option returned, check if its service status is active or pending (>= 900), and if so, collect its pricing code pair into the judgment list.

| # | Type | Code |
|---|------|------|
| 1 | FOR | `kk0401B001_map in kk0401B001_list` |
| 2 | IF | `"900".compareTo((String)kk0401B001_map.get(EKK0401B001CBSMsg1List.SBOP_SVC_KEI_STAT)) < 0` [Sub-option service contract status] |
| 3 | RETURN | `continue` // Skip sub-options with status < 900 (not active/pending) |

**Block 4.2.1.1** — [SET] Collect active sub-option pricing codes (L1698–L1704)

> For active sub-options (status >= 900), extract the pricing code pair and add it to the judgment list if not a duplicate.

| # | Type | Code |
|---|------|------|
| 1 | SET | `subOpMap = new HashMap()` |
| 2 | EXEC | `subOpMap.put("pcrs_cd", kk0401B001_map.get(EKK0401B001CBSMsg1List.PCRS_CD))` |
| 3 | EXEC | `subOpMap.put("pplan_cd", kk0401B001_map.get(EKK0401B001CBSMsg1List.PPLAN_CD))` |
| 4 | IF | `!paramJudgePcrsCdList.contains(subOpMap)` |
| 5 | EXEC | `paramJudgePcrsCdList.add(subOpMap)` |

**Block 5** — [SET] Prepare data map for option pack judgment (L1707–L1711)

> Build the data map that will be passed to the option pack judgment component. It includes the base date and the aggregated pricing code list.

| # | Type | Code |
|---|------|------|
| 1 | SET | `dataMap = new HashMap()` |
| 2 | EXEC | `dataMap.put("base_date", paramMap.get("base_date"))` [Base year/month/day] |
| 3 | EXEC | `dataMap.put("judge_pcrs_cd_list", paramJudgePcrsCdList)` |

**Block 6** — [CALL] Delegate to option pack application checker (L1713–L1716)

> Instantiate the option pack application check component and execute the option pack eligibility judgment. This is the core business rule engine that determines whether a pack should be attached and whether any conflicts exist.

| # | Type | Code |
|---|------|------|
| 1 | SET | `optPackAplyChkCC = new JFUOptPackAplyChkCC()` |
| 2 | EXEC | `param.setData("fixedTextJFUOptPackAplyChkCC", dataMap)` [-> Key: `"fixedTextJFUOptPackAplyChkCC"`] |
| 3 | CALL | `param = optPackAplyChkCC.judgeOptPack(handle, param, "fixedTextJFUOptPackAplyChkCC")` |

**Block 7** — [SET/IF] Evaluate option pack judgment results (L1718–L1733)

> Retrieve the result from the option pack checker and evaluate three conditions: (1) both original and returned write service codes are empty (no pack needed — OK), (2) only the returned code is present (pack should be attached but wasn't — FAIL), (3) both are present but different (pack mismatch — FAIL).

| # | Type | Code |
|---|------|------|
| 1 | SET | `retMap = (HashMap)param.getData("fixedTextJFUOptPackAplyChkCC")` |
| 2 | SET | `retWribSvcCd = (String)retMap.get("wrib_svc_cd")` [Returned write service code] |
| 3 | IF | `StringUtils.isEmpty(wribSvcCd) && StringUtils.isEmpty(retWribSvcCd)` [Both empty — no pack attached, OK] |
| 4 | RETURN | `return true` // No pack attached, that is correct |
| 5 | ELSE IF | `StringUtils.isEmpty(wribSvcCd) && !StringUtils.isEmpty(retWribSvcCd)` [Original empty but returned present — pack should be attached] |
| 6 | RETURN | `return false` // Pack should be attached |
| 7 | ELSE IF | `!StringUtils.isEmpty(wribSvcCd) && !wribSvcCd.equals(retWribSvcCd)` [Both present but different — pack mismatch] |
| 8 | RETURN | `return false` // Pack mismatch |
| 9 | RETURN | `return true` // All checks passed (either both empty, or both present and equal) |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|-----------------|
| `svc_kei_no` | Field | Service contract number — the unique identifier for a service contract line item in the telecommunications billing system. |
| `svc_kei_ucwk_no` | Field | Service detail work number — an internal tracking ID for service contract modification/processing work items. |
| `wri_svc_cd` | Field | Write service code — the expected option service code that should be attached to the contract. Used to compare against the returned result to detect mismatches. |
| `op_svc_kei_no` | Field | Option service contract number — the contract number for a specific option service within a main service contract. |
| `judge_pcrs_cd_list` | Field | Judgment pricing code list — the list of option codes selected on the screen for validation. Each entry contains an option service contract number. |
| `pcrs_cd` | Field | Pricing cost code — the code identifying the pricing/cost structure for a service or option. |
| `pplan_cd` | Field | Pricing plan code — the code identifying the specific pricing plan associated with a service. |
| `SBOP_SVC_KEI_STAT` | Field | Sub-option service contract status — the status code of a sub-option. Values >= "900" indicate active or pending status; values below are skipped. |
| `base_date` | Field | Base year/month/day — the reference date used in option pack eligibility calculations. |
| `cond_key_op_svc_kei_no` | Constant | Condition key for option service contract number — used in `condMap` to pass the option service contract number to SC queries. |
| `cond_key_opedate` | Constant | Condition key for operational date — used in `condMap` to pass the current operational date to SC queries. |
| `EKK0351A010SC` | SC Code | Pricing cost code inquiry service component — retrieves the pricing cost code and pricing plan code for an option service contract. |
| `EKK0401B001SC` | SC Code | Sub-option service status inquiry service component — retrieves sub-option service status information including pricing codes. |
| `JFUOptPackAplyChkCC` | Class | Option pack application check component — the business rule engine that determines option pack eligibility, attachment requirements, and conflicts. |
| `keepSesHandle` | Field | Session handle ThreadLocal — thread-local storage for the active database session, used across SC calls within the same request thread. |
| `CHECK_OK` | Constant | `"1"` — Check result value indicating the validation check passed. Defined at JKKAdchgCheckerCC.java:73. |
| `CHECK_ERR` | Constant | `"0"` — Check result value indicating the validation check failed. Defined at JKKAdchgCheckerCC.java:75. |
| FTTH | Business term | Fiber To The Home — fiber-optic broadband internet service, commonly offered as a telephone option pack. |
| Option Pack | Business term | A bundled add-on service attached to a telephone service contract (e.g., FTTH, mail service, ENUM). The system validates that the correct packs are attached. |
| SC | Technical | Service Component — a remote service layer component that handles database operations and business logic. Called via `ServiceComponentRequestInvoker`. |
| Judge | Business term | In this context, "judge" means "validate" or "evaluate" — the `judge_pcrs_cd_list` contains options that need validation, and `judgeOptPack` evaluates pack eligibility. |