# Business Logic — KKW01027SF03DBean.typeModelData() [344 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `eo.web.webview.KKA15001SF.KKW01027SF03DBean` |
| Layer | Webview Bean / View Data Binding (package `eo.web.webview.KKA15001SF`, implements `X33VDataTypeBeanInterface`, `X33VListedBeanInterface`) |
| Module | `KKA15001SF` (Package: `eo.web.webview.KKA15001SF`) |

## 1. Role

### KKW01027SF03DBean.typeModelData()

This method is a **data type resolution router** (also known as a model metadata dispatcher) for the KKA15001SF screen within the K-Opticom web application platform. It serves as the **single source of truth** for determining the Java runtime type (`Class<?>`) of every UI data field rendered on the service contract/order screen managed by this module.

The method handles **seven service type categories**: Registration Choice (登録選択), Registration Choice Value String (登録選択文字列), System ID (SYSID), Contract Type (契約種別), Campaign Code (キャンペーンコード), Campaign Code Name (キャンペーンコード名称), Type Code/Name (タイプコード/タイプコード名称), Service Code/Service Contract Number (サービスコード/サービス契約番号), Immediate Application Flag (即時適用フラグ), Application Month (適用月), Application Month Name (適用月名称), Desired Start Date (利用開始希望日), Display Conditions (表示条件), Application Month Name Radio Buttons (適用月名称ラジオボタン), EO Optical Multi-Function Router Exchange Flags (EO光多機能ルーター交換有无), and Owned Router (所有ルーター).

It implements the **routing/dispatch design pattern** — a cascade of `if-else if` branches matches the incoming `key` (item name) and `subkey` (property name: `value`, `enable`, `state`) to return the correct Java type. This enables the **Futurity X33 view framework** to dynamically bind field metadata during JSF rendering, ensuring that data validation, input constraints, and display behavior are correct for each field.

It has **no database or service-level calls** — it is a pure in-memory lookup method that returns type information based solely on the input parameters. Its role in the larger system is to support the **data-driven form generation** of the KKW01027SF03 screen, where field types are resolved at runtime without hard-coded model classes per field.

The method's conditional branches map each field name to its `value` type (String or Boolean), its `enable` type (Boolean), or its `state` type (always String). For fields with a `state` subkey, the method consistently returns `String.class` regardless of the field's primary data type.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["typeModelData key, subkey"])
    START --> NPE["Check null: key or subkey null?"]
    NPE -->|Yes| NULL_RETURN(["return null"])
    NPE -->|No| SEP["int separaterPoint = key.indexOf /"]
    SEP --> BR1["Block 1: 登録選択 (add_choice)"]
    BR1 -->|key match| SUB1A{subkey == value?}
    SUB1A -->|Yes| R_BOOL1(["return Boolean.class"])
    SUB1A -->|No| SUB1B{subkey == enable?}
    SUB1B -->|Yes| R_BOOL2(["return Boolean.class"])
    SUB1B -->|No| SUB1C{subkey == state?}
    SUB1C -->|Yes| R_STR1(["return String.class"])

    BR1 -->|No| BR2["Block 2: 登録選択文字列 (add_choice_value)"]
    BR2 -->|key match| SUB2A{subkey == value?}
    SUB2A -->|Yes| R_STR2(["return String.class"])
    SUB2A -->|No| SUB2B{subkey == enable?}
    SUB2B -->|Yes| R_BOOL3(["return Boolean.class"])
    SUB2B -->|No| SUB2C{subkey == state?}
    SUB2C -->|Yes| R_STR3(["return String.class"])

    BR2 -->|No| BR3["Block 3: SYSID (sysid)"]
    BR3 -->|key match| SUB3A{subkey == value?}
    SUB3A -->|Yes| R_STR4(["return String.class"])
    SUB3A -->|No| SUB3B{subkey == state?}
    SUB3B -->|Yes| R_STR5(["return String.class"])

    BR3 -->|No| BR4["Block 4: 契約種別 (kei_kind)"]
    BR4 -->|key match| SUB4A{subkey == value?}
    SUB4A -->|Yes| R_STR6(["return String.class"])
    SUB4A -->|No| SUB4B{subkey == state?}
    SUB4B -->|Yes| R_STR7(["return String.class"])

    BR4 -->|No| BR5["Block 5: キャンペーンコード (campaign_cd)"]
    BR5 -->|key match| SUB5A{subkey == value?}
    SUB5A -->|Yes| R_STR8(["return String.class"])
    SUB5A -->|No| SUB5B{subkey == enable?}
    SUB5B -->|Yes| R_BOOL4(["return Boolean.class"])
    SUB5B -->|No| SUB5C{subkey == state?}
    SUB5C -->|Yes| R_STR9(["return String.class"])

    BR5 -->|No| BR6["Block 6: キャンペーンコード名称 (campaign_cd_nm)"]
    BR6 -->|key match| SUB6A{subkey == value?}
    SUB6A -->|Yes| R_STR10(["return String.class"])
    SUB6A -->|No| SUB6B{subkey == enable?}
    SUB6B -->|Yes| R_BOOL5(["return Boolean.class"])
    SUB6B -->|No| SUB6C{subkey == state?}
    SUB6C -->|Yes| R_STR11(["return String.class"])

    BR6 -->|No| BR7["Block 7: タイプコード (type_cd)"]
    BR7 -->|key match| SUB7A{subkey == value?}
    SUB7A -->|Yes| R_STR12(["return String.class"])
    SUB7A -->|No| SUB7B{subkey == state?}
    SUB7B -->|Yes| R_STR13(["return String.class"])

    BR7 -->|No| BR8["Block 8: タイプコード名称 (type_cd_nm)"]
    BR8 -->|key match| SUB8A{subkey == value?}
    SUB8A -->|Yes| R_STR14(["return String.class"])
    SUB8A -->|No| SUB8B{subkey == enable?}
    SUB8B -->|Yes| R_BOOL6(["return Boolean.class"])
    SUB8B -->|No| SUB8C{subkey == state?}
    SUB8C -->|Yes| R_STR15(["return String.class"])

    BR8 -->|No| BR9["Block 9: サービスコード (svc_cd)"]
    BR9 -->|key match| SUB9A{subkey == value?}
    SUB9A -->|Yes| R_STR16(["return String.class"])
    SUB9A -->|No| SUB9B{subkey == state?}
    SUB9B -->|Yes| R_STR17(["return String.class"])

    BR9 -->|No| BR10["Block 10: サービス契約番号 (svc_kei_no)"]
    BR10 -->|key match| SUB10A{subkey == value?}
    SUB10A -->|Yes| R_STR18(["return String.class"])
    SUB10A -->|No| SUB10B{subkey == enable?}
    SUB10B -->|Yes| R_BOOL7(["return Boolean.class"])
    SUB10B -->|No| SUB10C{subkey == state?}
    SUB10C -->|Yes| R_STR19(["return String.class"])

    BR10 -->|No| BR11["Block 11: 即時適用フラグ (aply_jun)"]
    BR11 -->|key match| SUB11A{subkey == value?}
    SUB11A -->|Yes| R_STR20(["return String.class"])
    SUB11A -->|No| SUB11B{subkey == state?}
    SUB11B -->|Yes| R_STR21(["return String.class"])

    BR11 -->|No| BR12["Block 12: 適用月 (tekiyo_ymd)"]
    BR12 -->|key match| SUB12A{subkey == value?}
    SUB12A -->|Yes| R_STR22(["return String.class"])
    SUB12A -->|No| SUB12B{subkey == enable?}
    SUB12B -->|Yes| R_BOOL8(["return Boolean.class"])
    SUB12B -->|No| SUB12C{subkey == state?}
    SUB12C -->|Yes| R_STR23(["return String.class"])

    BR12 -->|No| BR13["Block 13: 適用月名称 (tekiyo_ymd_nm)"]
    BR13 -->|key match| SUB13A{subkey == value?}
    SUB13A -->|Yes| R_STR24(["return String.class"])
    SUB13A -->|No| SUB13B{subkey == enable?}
    SUB13B -->|Yes| R_BOOL9(["return Boolean.class"])
    SUB13B -->|No| SUB13C{subkey == state?}
    SUB13C -->|Yes| R_STR25(["return String.class"])

    BR13 -->|No| BR14["Block 14: 利用開始希望日 (riyo_sta_ymd)"]
    BR14 -->|key match| SUB14A{subkey == value?}
    SUB14A -->|Yes| R_STR26(["return String.class"])
    SUB14A -->|No| SUB14B{subkey == enable?}
    SUB14B -->|Yes| R_BOOL10(["return Boolean.class"])
    SUB14B -->|No| SUB14C{subkey == state?}
    SUB14C -->|Yes| R_STR27(["return String.class"])

    BR14 -->|No| BR15["Block 15: 利用開始希望日_年 (riyo_sta_ymd_year)"]
    BR15 -->|key match| SUB15A{subkey == value?}
    SUB15A -->|Yes| R_STR28(["return String.class"])
    SUB15A -->|No| SUB15B{subkey == enable?}
    SUB15B -->|Yes| R_BOOL11(["return Boolean.class"])
    SUB15B -->|No| SUB15C{subkey == state?}
    SUB15C -->|Yes| R_STR29(["return String.class"])

    BR15 -->|No| BR16["Block 16: 利用開始希望日_月 (riyo_sta_ymd_mon)"]
    BR16 -->|key match| SUB16A{subkey == value?}
    SUB16A -->|Yes| R_STR30(["return String.class"])
    SUB16A -->|No| SUB16B{subkey == enable?}
    SUB16B -->|Yes| R_BOOL12(["return Boolean.class"])
    SUB16B -->|No| SUB16C{subkey == state?}
    SUB16C -->|Yes| R_STR31(["return String.class"])

    BR16 -->|No| BR17["Block 17: 利用開始希望日_日 (riyo_sta_ymd_day)"]
    BR17 -->|key match| SUB17A{subkey == value?}
    SUB17A -->|Yes| R_STR32(["return String.class"])
    SUB17A -->|No| SUB17B{subkey == enable?}
    SUB17B -->|Yes| R_BOOL13(["return Boolean.class"])
    SUB17B -->|No| SUB17C{subkey == state?}
    SUB17C -->|Yes| R_STR33(["return String.class"])

    BR17 -->|No| BR18["Block 18: 表示条件1 (disp_jkn_1)"]
    BR18 -->|key match| SUB18A{subkey == value?}
    SUB18A -->|Yes| R_BOOL14(["return Boolean.class"])
    SUB18A -->|No| SUB18B{subkey == state?}
    SUB18B -->|Yes| R_STR34(["return String.class"])

    BR18 -->|No| BR19["Block 19: 表示条件2 (disp_jkn_2)"]
    BR19 -->|key match| SUB19A{subkey == value?}
    SUB19A -->|Yes| R_BOOL15(["return Boolean.class"])
    SUB19A -->|No| SUB19B{subkey == state?}
    SUB19B -->|Yes| R_STR35(["return String.class"])

    BR19 -->|No| BR20["Block 20: 表示条件利用開始希望日 (disp_riyo_sta_ymd)"]
    BR20 -->|key match| SUB20A{subkey == value?}
    SUB20A -->|Yes| R_BOOL16(["return Boolean.class"])
    SUB20A -->|No| SUB20B{subkey == state?}
    SUB20B -->|Yes| R_STR36(["return String.class"])

    BR20 -->|No| BR21["Block 21: 適用月名称ラジオボタン1 (tekiyo_ymd_nm_1)"]
    BR21 -->|key match| SUB21A{subkey == value?}
    SUB21A -->|Yes| R_STR37(["return String.class"])
    SUB21A -->|No| SUB21B{subkey == enable?}
    SUB21B -->|Yes| R_BOOL17(["return Boolean.class"])
    SUB21B -->|No| SUB21C{subkey == state?}
    SUB21C -->|Yes| R_STR38(["return String.class"])

    BR21 -->|No| BR22["Block 22: 適用月名称ラジオボタン2 (tekiyo_ymd_nm_2)"]
    BR22 -->|key match| SUB22A{subkey == value?}
    SUB22A -->|Yes| R_STR39(["return String.class"])
    SUB22A -->|No| SUB22B{subkey == enable?}
    SUB22B -->|Yes| R_BOOL18(["return Boolean.class"])
    SUB22B -->|No| SUB22C{subkey == state?}
    SUB22C -->|Yes| R_STR40(["return String.class"])

    BR22 -->|No| BR23["Block 23: EO光多機能ルーター交換有无 (takinou_rtr_chg_umu)"]
    BR23 -->|key match| SUB23A{subkey == value?}
    SUB23A -->|Yes| R_STR41(["return String.class"])
    SUB23A -->|No| SUB23B{subkey == enable?}
    SUB23B -->|Yes| R_BOOL19(["return Boolean.class"])
    SUB23B -->|No| SUB23C{subkey == state?}
    SUB23C -->|Yes| R_STR42(["return String.class"])

    BR23 -->|No| BR24["Block 24: EO光多機能ルーター交換有无ラジオボタン1名称 (takinou_rtr_chg_nm_1)"]
    BR24 -->|key match| SUB24A{subkey == value?}
    SUB24A -->|Yes| R_STR43(["return String.class"])
    SUB24A -->|No| SUB24B{subkey == enable?}
    SUB24B -->|Yes| R_BOOL20(["return Boolean.class"])
    SUB24B -->|No| SUB24C{subkey == state?}
    SUB24C -->|Yes| R_STR44(["return String.class"])

    BR24 -->|No| BR25["Block 25: EO光多機能ルーター交換有无ラジオボタン2名称 (takinou_rtr_chg_nm_2)"]
    BR25 -->|key match| SUB25A{subkey == value?}
    SUB25A -->|Yes| R_STR45(["return String.class"])
    SUB25A -->|No| SUB25B{subkey == enable?}
    SUB25B -->|Yes| R_BOOL21(["return Boolean.class"])
    SUB25B -->|No| SUB25C{subkey == state?}
    SUB25C -->|Yes| R_STR46(["return String.class"])

    BR25 -->|No| BR26["Block 26: EO光多機能ルーター交換有无ラジオボタン表示条件 (disp_jkn_umu)"]
    BR26 -->|key match| SUB26A{subkey == value?}
    SUB26A -->|Yes| R_BOOL22(["return Boolean.class"])
    SUB26A -->|No| SUB26B{subkey == state?}
    SUB26B -->|Yes| R_STR47(["return String.class"])

    BR26 -->|No| BR27["Block 27: EO光多機能ルーター交換有无ラジオボタン操作条件 (sosa_jkn_umu)"]
    BR27 -->|key match| SUB27A{subkey == value?}
    SUB27A -->|Yes| R_BOOL23(["return Boolean.class"])
    SUB27A -->|No| SUB27B{subkey == state?}
    SUB27B -->|Yes| R_STR48(["return String.class"])

    BR27 -->|No| BR28["Block 28: 所有ルーター (use_rtr)"]
    BR28 -->|key match| SUB28A{subkey == value?}
    SUB28A -->|Yes| R_STR49(["return String.class"])
    SUB28A -->|No| SUB28B{subkey == state?}
    SUB28B -->|Yes| R_STR50(["return String.class"])

    BR28 -->|No| FALLBACK(["return null"])
```

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `key` | `String` | **Item name** — the Japanese display name of a UI field on the KKW01027SF03 screen. Determines which of the 28 field-type branches is matched. Examples: `登録選択` (Registration Choice), `キャンペーンコード` (Campaign Code), `契約種別` (Contract Type), `EO光多機能ルーター交換有无` (EO Optical Multi-Function Router Exchange Flag), `適用月名称ラジオボタン1` (Application Month Name Radio Button 1). |
| 2 | `subkey` | `String` | **Sub-key** — the property within the item whose type is being requested. Always one of three values: `value` (the data value type), `enable` (whether the field is editable/enabled), or `state` (the field's display state). Case-insensitive comparison (`equalsIgnoreCase`). |

**Instance fields / external state read:** None. This method has no side effects, does not read any instance fields, and does not access any external services, databases, or configuration. It is a pure function of its two input parameters.

## 4. CRUD Operations / Called Services

This method performs **no CRUD operations** and **calls no external services**. It is a pure in-memory type lookup. The method contains zero method invocations beyond Java built-ins (`String.indexOf`, `String.equals`, `String.equalsIgnoreCase`, `String.valueOf`).

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| — | — | — | — | No external calls. Pure in-memory type resolution. |

## 5. Dependency Trace

This method is called **indirectly** through the parent bean `KKW01027SFBean.typeModelData()` and through list-type sub-beans (e.g., `KKW01027SF01DBean.typeModelData()`) when processing nested data-table fields. The table below shows the call chains from screen entry points.

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Screen:KKW01027SF | `KKW01027SFBean.typeModelData(gamenId, key, subkey)` → `KKW01027SFBean.typeModelData(key, subkey)` → `KKW01027SF03DBean.typeModelData(key, subkey)` | N/A (no DB/SC calls) |
| 2 | Screen:KKW01027SF | `KKW01027SFBean.typeModelData(key, subkey)` → `((X33VDataTypeBeanInterface)cust_kei_hktgi_list_list.get(index)).typeModelData(keyElement, subkey)` → delegates to `KKW01027SF03DBean.typeModelData` | N/A |
| 3 | Screen:KKW01027SF | `KKW01027SFBean.typeModelData(key, subkey)` → `((X33VDataTypeBeanInterface)wrib_type_cd_list_list.get(index)).typeModelData(keyElement, subkey)` → delegates to `KKW01027SF03DBean.typeModelData` | N/A |
| 4 | Screen:KKW01027SF | `KKW01027SFBean.typeModelData(key, subkey)` → `((X33VDataTypeBeanInterface)wrib_aply_optnty_cd_list_list.get(index)).typeModelData(keyElement, subkey)` → delegates to `KKW01027SF03DBean.typeModelData` | N/A |
| 5 | Screen:KKW01027SF | `KKW01027SFBean.typeModelData(key, subkey)` → `((X33VDataTypeBeanInterface)campaign_icrn_list.get(index)).typeModelData(keyElement, subkey)` → delegates to `KKW01027SF03DBean.typeModelData` | N/A |

**Note:** The parent `KKW01027SFBean` also has its own `typeModelData(String key, String subkey)` method (lines 3219–3611 in source/koptWebA), which handles additional field types and delegates to sub-beans. When the key matches `KKW01027SF03DBean`-owned fields, the parent bean does NOT forward the call — instead, `KKW01027SF03DBean.typeModelData()` is called directly as a static utility (e.g., `KKW01027SF03DBean.typeModelData(key, subkey)` from the parent bean's implementation).

## 6. Per-Branch Detail Blocks

### Block 1 — IF (key.equals("登録添加") / "Registration Choice") (L1767)

> Handles the registration choice field (itemID: add_choice). This is a Boolean-typed field that also provides enable state and display state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | SET | `int separaterPoint = key.indexOf("/")` // Extracts separator position for path navigation [L1763] |
| 2 | IF | `key.equals("登録選択")` → matches "Registration Choice" field [L1767] |
| 3 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1768] |
| 4 | RETURN | `return Boolean.class` |
| 5 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1770] |
| 6 | RETURN | `return Boolean.class` |
| 7 | IF | `subkey.equalsIgnoreCase("state")` → display state (subkeyが"state"の場合、ステータスを返す / When subkey is "state", returns status) [L1772] |
| 8 | RETURN | `return String.class` |

### Block 2 — ELSE IF (key.equals("登録選択文字列") / "Registration Choice Value String") (L1782)

> Handles the registration choice value string field (itemID: add_choice_value). A String-typed field with enable and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("登録選択文字列")` → matches "Registration Choice Value String" field [L1782] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1783] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1785] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1787] |
| 7 | RETURN | `return String.class` |

### Block 3 — ELSE IF (key.equals("SYSID") / "System ID") (L1797)

> Handles the system ID field (itemID: sysid). A String-typed field with value and state sub-properties. No `enable` property for this field.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("SYSID")` → matches "System ID" field [L1797] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1798] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1800] |
| 5 | RETURN | `return String.class` |

### Block 4 — ELSE IF (key.equals("契約種別") / "Contract Type") (L1809)

> Handles the contract type field (itemID: kei_kind). A String-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("契約種別")` → matches "Contract Type" field [L1809] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1810] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1812] |
| 5 | RETURN | `return String.class` |

### Block 5 — ELSE IF (key.equals("キャンペーンコード") / "Campaign Code") (L1821)

> Handles the campaign code field (itemID: campaign_cd). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("キャンペーンコード")` → matches "Campaign Code" field [L1821] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1822] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1824] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1826] |
| 7 | RETURN | `return String.class` |

### Block 6 — ELSE IF (key.equals("キャンペーンコード名称") / "Campaign Code Name") (L1836)

> Handles the campaign code name field (itemID: campaign_cd_nm). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("キャンペーンコード名称")` → matches "Campaign Code Name" field [L1836] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1837] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1839] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1841] |
| 7 | RETURN | `return String.class` |

### Block 7 — ELSE IF (key.equals("タイプコード") / "Type Code") (L1850)

> Handles the type code field (itemID: type_cd). A String-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("タイプコード")` → matches "Type Code" field [L1850] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1851] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1853] |
| 5 | RETURN | `return String.class` |

### Block 8 — ELSE IF (key.equals("タイプコード名称") / "Type Code Name") (L1862)

> Handles the type code name field (itemID: type_cd_nm). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("タイプコード名称")` → matches "Type Code Name" field [L1862] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1863] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1865] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1867] |
| 7 | RETURN | `return String.class` |

### Block 9 — ELSE IF (key.equals("サービスコード") / "Service Code") (L1876)

> Handles the service code field (itemID: svc_cd). A String-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("サービスコード")` → matches "Service Code" field [L1876] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1877] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1879] |
| 5 | RETURN | `return String.class` |

### Block 10 — ELSE IF (key.equals("サービス契約番号") / "Service Contract Number") (L1888)

> Handles the service contract number field (itemID: svc_kei_no). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("サービス契約番号")` → matches "Service Contract Number" field [L1888] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1889] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1891] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1893] |
| 7 | RETURN | `return String.class` |

### Block 11 — ELSE IF (key.equals("即時適用フラグ") / "Immediate Application Flag") (L1902)

> Handles the immediate application flag field (itemID: aply_jun). A String-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("即時適用フラグ")` → matches "Immediate Application Flag" field [L1902] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1903] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1905] |
| 5 | RETURN | `return String.class` |

### Block 12 — ELSE IF (key.equals("適用月") / "Application Month") (L1914)

> Handles the application month field (itemID: tekiyo_ymd). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("適用月")` → matches "Application Month" field [L1914] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1915] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1917] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1919] |
| 7 | RETURN | `return String.class` |

### Block 13 — ELSE IF (key.equals("適用月名称") / "Application Month Name") (L1928)

> Handles the application month name field (itemID: tekiyo_ymd_nm). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("適用月名称")` → matches "Application Month Name" field [L1928] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1929] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1931] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1933] |
| 7 | RETURN | `return String.class` |

### Block 14 — ELSE IF (key.equals("利用開始希望日") / "Desired Start Date") (L1942)

> Handles the desired start date field (itemID: riyo_sta_ymd). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("利用開始希望日")` → matches "Desired Start Date" field [L1942] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1943] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1945] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1947] |
| 7 | RETURN | `return String.class` |

### Block 15 — ELSE IF (key.equals("利用開始希望日_年") / "Desired Start Date_Year") (L1956)

> Handles the desired start date year field (itemID: riyo_sta_ymd_year). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("利用開始希望日_年")` → matches "Desired Start Date_Year" field [L1956] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1957] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1959] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1961] |
| 7 | RETURN | `return String.class` |

### Block 16 — ELSE IF (key.equals("利用開始希望日_月") / "Desired Start Date_Month") (L1970)

> Handles the desired start date month field (itemID: riyo_sta_ymd_mon). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("利用開始希望日_月")` → matches "Desired Start Date_Month" field [L1970] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1971] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1973] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1975] |
| 7 | RETURN | `return String.class` |

### Block 17 — ELSE IF (key.equals("利用開始希望日_日") / "Desired Start Date_Day") (L1984)

> Handles the desired start date day field (itemID: riyo_sta_ymd_day). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("利用開始希望日_日")` → matches "Desired Start Date_Day" field [L1984] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1985] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L1987] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L1989] |
| 7 | RETURN | `return String.class` |

### Block 18 — ELSE IF (key.equals("表示条件1") / "Display Condition 1") (L1998)

> Handles the display condition 1 field (itemID: disp_jkn_1). A Boolean-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("表示条件1")` → matches "Display Condition 1" field [L1998] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L1999] |
| 3 | RETURN | `return Boolean.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2001] |
| 5 | RETURN | `return String.class` |

### Block 19 — ELSE IF (key.equals("表示条件2") / "Display Condition 2") (L2010)

> Handles the display condition 2 field (itemID: disp_jkn_2). A Boolean-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("表示条件2")` → matches "Display Condition 2" field [L2010] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2011] |
| 3 | RETURN | `return Boolean.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2013] |
| 5 | RETURN | `return String.class` |

### Block 20 — ELSE IF (key.equals("表示条件利用開始希望日") / "Display Condition Desired Start Date") (L2022)

> Handles the display condition desired start date field (itemID: disp_riyo_sta_ymd). A Boolean-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("表示条件利用開始希望日")` → matches "Display Condition Desired Start Date" field [L2022] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2023] |
| 3 | RETURN | `return Boolean.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2025] |
| 5 | RETURN | `return String.class` |

### Block 21 — ELSE IF (key.equals("適用月名称ラジオボタン1") / "Application Month Name Radio Button 1") (L2034)

> Handles the application month name radio button 1 field (itemID: tekiyo_ymd_nm_1). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("適用月名称ラジオボタン1")` → matches "Application Month Name Radio Button 1" field [L2034] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2035] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L2037] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2039] |
| 7 | RETURN | `return String.class` |

### Block 22 — ELSE IF (key.equals("適用月名称ラジオボタン2") / "Application Month Name Radio Button 2") (L2048)

> Handles the application month name radio button 2 field (itemID: tekiyo_ymd_nm_2). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("適用月名称ラジオボタン2")` → matches "Application Month Name Radio Button 2" field [L2048] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2049] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L2051] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2053] |
| 7 | RETURN | `return String.class` |

### Block 23 — ELSE IF (key.equals("EO光多機能ルーター交換有无") / "EO Optical Multi-Function Router Exchange Flag") (L2062)

> Handles the EO Optical Multi-Function Router Exchange flag field (itemID: takinou_rtr_chg_umu). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("EO光多機能ルーター交換有无")` → matches "EO Optical Multi-Function Router Exchange Flag" field [L2062] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2063] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L2065] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2067] |
| 7 | RETURN | `return String.class` |

### Block 24 — ELSE IF (key.equals("EO光多機能ルーター交換有无ラジオボタン1名称") / "Router Exchange Flag Radio Button 1 Name") (L2076)

> Handles the router exchange flag radio button 1 name field (itemID: takinou_rtr_chg_nm_1). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("EO光多機能ルーター交換有无ラジオボタン1名称")` → matches "Router Exchange Flag Radio Button 1 Name" field [L2076] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2077] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L2079] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2081] |
| 7 | RETURN | `return String.class` |

### Block 25 — ELSE IF (key.equals("EO光多機能ルーター交換有无ラジオボタン2名称") / "Router Exchange Flag Radio Button 2 Name") (L2090)

> Handles the router exchange flag radio button 2 name field (itemID: takinou_rtr_chg_nm_2). A String-typed field with value, enable, and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("EO光多機能ルーター交換有无ラジオボタン2名称")` → matches "Router Exchange Flag Radio Button 2 Name" field [L2090] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2091] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("enable")` → field enabled state [L2093] |
| 5 | RETURN | `return Boolean.class` |
| 6 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2095] |
| 7 | RETURN | `return String.class` |

### Block 26 — ELSE IF (key.equals("EO光多機能ルーター交換有无ラジオボタン表示条件") / "Router Exchange Flag Radio Button Display Condition") (L2104)

> Handles the router exchange flag radio button display condition field (itemID: disp_jkn_umu). A Boolean-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("EO光多機能ルーター交換有无ラジオボタン表示条件")` → matches "Router Exchange Flag Radio Button Display Condition" field [L2104] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2105] |
| 3 | RETURN | `return Boolean.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2107] |
| 5 | RETURN | `return String.class` |

### Block 27 — ELSE IF (key.equals("EO光多機能ルーター交換有无ラジオボタン操作条件") / "Router Exchange Flag Radio Button Operation Condition") (L2116)

> Handles the router exchange flag radio button operation condition field (itemID: sosa_jkn_umu). A Boolean-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("EO光多機能ルーター交換有无ラジオボタン操作条件")` → matches "Router Exchange Flag Radio Button Operation Condition" field [L2116] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2117] |
| 3 | RETURN | `return Boolean.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2119] |
| 5 | RETURN | `return String.class` |

### Block 28 — ELSE IF (key.equals("所有ルーター") / "Owned Router") (L2128)

> Handles the owned router field (itemID: use_rtr). A String-typed field with value and state sub-properties.

| # | Type | Code |
|---|------|------|
| 1 | IF | `key.equals("所有ルーター")` → matches "Owned Router" field [L2128] |
| 2 | IF | `subkey.equalsIgnoreCase("value")` → data value [L2129] |
| 3 | RETURN | `return String.class` |
| 4 | IF | `subkey.equalsIgnoreCase("state")` → display state [L2131] |
| 5 | RETURN | `return String.class` |

### Block 29 — ELSE (fallback / no matching condition) (L2139)

> If no condition matches, returns null. Comments: 条件に一致するプロパティが存在しない場合は、nullを返す / If no matching property exists, return null.

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return null` |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `add_choice` | Field (Item ID) | Registration Choice — whether a registration option is selected (Boolean) |
| `add_choice_value` | Field (Item ID) | Registration Choice Value String — the textual value of a selected registration option (String) |
| `sysid` | Field (Item ID) | System ID — a system-generated identifier for record tracking (String) |
| `kei_kind` | Field (Item ID) | Contract Type — the classification of a service contract (e.g., new, modification, cancellation) (String) |
| `campaign_cd` | Field (Item ID) | Campaign Code — a promotional campaign identifier associated with the service order (String) |
| `campaign_cd_nm` | Field (Item ID) | Campaign Code Name — human-readable name of the campaign code (String) |
| `type_cd` | Field (Item ID) | Type Code — a classification code for service types (String) |
| `type_cd_nm` | Field (Item ID) | Type Code Name — human-readable name of the type code (String) |
| `svc_cd` | Field (Item ID) | Service Code — the identifier for a specific telecommunication service (String) |
| `svc_kei_no` | Field (Item ID) | Service Contract Number — the unique contract number for a service line (String) |
| `aply_jun` | Field (Item ID) | Immediate Application Flag — whether changes take effect immediately (String) |
| `tekiyo_ymd` | Field (Item ID) | Application Month — the month when the service change takes effect (String) |
| `tekiyo_ymd_nm` | Field (Item ID) | Application Month Name — human-readable name of the application month (String) |
| `riyo_sta_ymd` | Field (Item ID) | Desired Start Date — the customer's requested service activation date (String) |
| `riyo_sta_ymd_year` | Field (Item ID) | Desired Start Date Year — year component of the desired start date (String) |
| `riyo_sta_ymd_mon` | Field (Item ID) | Desired Start Date Month — month component of the desired start date (String) |
| `riyo_sta_ymd_day` | Field (Item ID) | Desired Start Date Day — day component of the desired start date (String) |
| `disp_jkn_1` | Field (Item ID) | Display Condition 1 — a Boolean flag controlling the display of the first filtering condition (Boolean) |
| `disp_jkn_2` | Field (Item ID) | Display Condition 2 — a Boolean flag controlling the display of the second filtering condition (Boolean) |
| `disp_riyo_sta_ymd` | Field (Item ID) | Display Condition Desired Start Date — Boolean flag for displaying the start date condition (Boolean) |
| `tekiyo_ymd_nm_1` | Field (Item ID) | Application Month Name Radio Button 1 — label for the first radio button in the application month group (String) |
| `tekiyo_ymd_nm_2` | Field (Item ID) | Application Month Name Radio Button 2 — label for the second radio button in the application month group (String) |
| `takinou_rtr_chg_umu` | Field (Item ID) | EO Optical Multi-Function Router Exchange Flag — whether to exchange the existing router for an EO optical multi-function router (String) |
| `takinou_rtr_chg_nm_1` | Field (Item ID) | Router Exchange Radio Button 1 Name — label for the first radio button of the router exchange option (String) |
| `takinou_rtr_chg_nm_2` | Field (Item ID) | Router Exchange Radio Button 2 Name — label for the second radio button of the router exchange option (String) |
| `disp_jkn_umu` | Field (Item ID) | Router Exchange Flag Radio Button Display Condition — Boolean flag for showing the router exchange radio button options (Boolean) |
| `sosa_jkn_umu` | Field (Item ID) | Router Exchange Radio Button Operation Condition — Boolean flag controlling operability of the router exchange radio buttons (Boolean) |
| `use_rtr` | Field (Item ID) | Owned Router — the currently owned/used router identifier (String) |
| X33 | Acronym | Futurity X33 Web Application Framework — Fujitsu's enterprise Java web framework for JSF-based screens |
| X33VDataTypeBeanInterface | Interface | X33 View Data Type Bean Interface — contract for beans that provide type metadata for form fields |
| X33VListedBeanInterface | Interface | X33 View Listed Bean Interface — contract for beans that support list/row data binding |
| JSF | Acronym | JavaServer Faces — Sun/Oracle's component-based web UI framework |
| EO光 | Business term | EO Hikari — K-Opticom's fiber-optic broadband internet service (EO = Enhanced Optical) |
| 多機能ルーター | Business term | Multi-function Router — a combined router/modem unit supporting multiple telecom services |
| 交換有無 | Business term | Exchange Presence/Absence — a yes/no field indicating whether equipment should be swapped |
| 契約種別 | Business term | Contract Type — the type of service contract (new connection, modification, cancellation) |
| キャンペーン | Business term | Campaign — a promotional offer associated with a service subscription |
| 表示条件 | Business term | Display Condition — a flag or rule that determines whether a UI element is visible |
| 操作条件 | Business term | Operation Condition — a flag or rule that determines whether a UI element is interactable |
| subkey: value | Property | The data value of a field — the actual content stored/displayed |
| subkey: enable | Property | Whether the field is enabled for editing — Boolean flag controlling input interactivity |
| subkey: state | Property | The display state of the field — a String indicating current visibility/behavior state |