# Business Logic — FUW02701SFLogic.createOptioinData() [107 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `eo.web.webview.FUW02701SF.FUW02701SFLogic` |
| Layer | Service (Web view business logic, within `eo.web.webview` layer) |
| Module | `FUW02701SF` (Package: `eo.web.webview.FUW02701SF`) |

## 1. Role

### FUW02701SFLogic.createOptioinData()

This method generates a **pricing table for optional Web capacity add-on requests** in the K-Opticom fiber internet service subscription system. When a customer visits the Web capacity addition screen (FUW02701), they can select how much additional bandwidth to add beyond their current contract. This method builds the entire dynamic pricing table that displays available capacity tiers with their corresponding fees, determining which tiers are free (within the free allowance) and which incur a per-amount charge.

The method implements a **loop-until-complete builder pattern**: it iteratively constructs capacity tiers starting from zero additional capacity up to the configured maximum increment step, computing the cost for each tier based on the customer's current contract capacity, free capacity allowance, and the unit price per increment. It uses a **routing decision** to set a chargeable flag (`payFlg`) based on whether the free allowance covers the full range of add-on options or whether key pricing parameters are missing. The pricing data is then assembled into structured maps for downstream processing by `JFUWebCommon.setPrcInfoArea()` in the mapping layer.

This method is a **shared utility within the capacity addition workflow** — it is called by `FUW02701SFLogic.init()` as part of the initial screen display logic. It is invoked during both the initial display of the capacity addition request screen and subsequent postback scenarios where the customer adjusts their selection.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["createOptioinData(bean, outputMap)"])
    
    START --> R1["Read: baseValue = current Web contract capacity"]
    START --> R2["Read: freeValue = free capacity allowance"]
    START --> R3["Read: addValue = capacity increment step"]
    START --> R4["Read: endValue = capacity increment upper limit"]
    START --> R5["Read: tanka = unit price per increment"]
    START --> R6["Read: tani = unit name (e.g., MB)"]
    
    R1 --> INIT["Initialize: dataList, idx=0, gamenListArray, addCapaListDataType"]
    
    INIT --> PAY_FLG["Set payFlg = false"]
    
    PAY_FLG --> COND_PAY{endValue == 0 OR freeValue == 0 OR freeValue >= endValue OR tanka == 0}
    
    COND_PAY --> |true| PAY_FALSE["payFlg = false (no charge)"]
    COND_PAY --> |false| PAY_TRUE["payFlg = true (chargeable)"]
    
    PAY_FALSE --> WHILE_START["while(true) loop"]
    PAY_TRUE --> WHILE_START
    
    WHILE_START --> CALC["Calculate: addCapa = addValue * idx, goukeiCapa = baseValue + addCapa"]
    
    CALC --> COND_FREE{goukeiCapa <= freeValue OR NOT payFlg}
    
    COND_FREE --> |true| FREE_BRANCH["addMoney = 0, freeData = true"]
    COND_FREE --> |false| CHARGE_BRANCH["Check: baseValue >= freeValue"]
    
    FREE_BRANCH --> SET_PRC["Set ADD_PRC_01, ADD_CAPA_01, GOKEI_CAPA_01 in addCapaListDataType"]
    
    CHARGE_BRANCH --> COND_BASE{baseValue >= freeValue}
    
    COND_BASE --> |true| BASE_CALC["addMoney = tanka * (goukeiCapa - baseValue) / addValue"]
    COND_BASE --> |false| FREE_CALC["addMoney = tanka * (goukeiCapa - freeValue) / addValue"]
    
    BASE_CALC --> SET_PRC2["Set ADD_PRC_01, ADD_CAPA_01, GOKEI_CAPA_01 in addCapaListDataType"]
    FREE_CALC --> SET_PRC2
    
    SET_PRC --> CHILD_MAP["Create childMap, koteiAmountText"]
    SET_PRC2 --> CHILD_MAP
    
    CHILD_MAP --> COND_IDX{idx == 0 AND payFlg}
    
    COND_IDX --> |true| ZERO_PRICE["koteiAmountText = PRICE_ZERO, unit = tani"]
    COND_IDX --> |false| COND_FREE_DATA{freeData OR addCapa == 0}
    
    ZERO_PRICE --> ADD_CHILD["childMap.put(PPLAN_KOTEI_AMNT, childMap)"]
    
    COND_FREE_DATA --> |true| FREE_LABEL["koteiAmountText = FREE_LABEL, unit = EMPTY"]
    COND_FREE_DATA --> |false| NORMAL_UNIT["unit = tani"]
    
    FREE_LABEL --> ADD_CHILD
    NORMAL_UNIT --> ADD_CHILD
    
    ADD_CHILD --> ADD_LIST["dataList.add(childMap)"]
    
    ADD_LIST --> COND_BREAK{endValue <= goukeiCapa}
    
    COND_BREAK --> |true| BREAK["break loop"]
    COND_BREAK --> |false| INCR["idx++"]
    
    INCR --> CALC
    
    BREAK --> FINAL["Create dataMap, put dataList under EKK0601B001_LIST"]
    
    FINAL --> OUTPUT["outputMap.put(SC_TITLE_FUSV007604, dataMap)"]
    
    OUTPUT --> END(["Return void"])
```

**Key business rules encoded in the flow:**

- The chargeable flag (`payFlg`) is set to `false` if any of these conditions hold: the capacity increment upper limit is zero, the free allowance is zero, the free allowance already meets or exceeds the maximum addable capacity, or the unit price is zero. Otherwise, the flag is `true`.
- Each capacity tier's additional fee (`addMoney`) is computed as: `tanka * (totalCapacity - applicableBase) / addValue`, where the applicable base is the larger of `baseValue` or `freeValue`.
- The first tier (idx=0) with a chargeable plan displays "0" as its fixed amount with the unit name, representing the base contract cost of zero additional fees.
- Free tiers display the Japanese "無料" (FREE) label with no unit shown.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `bean` | `X31SDataBeanAccess` | The data bean holding all screen input/output values for the capacity addition request. Contains the current Web contract capacity (`NOW_WEB_KEI_CAPA`), free capacity allowance (`MRYO_CAPA`), capacity increment step (`ADD_CAPA_ZOUBUN_VALUE`), increment upper limit (`ADD_CAPA_ZOUBUN_UPPL_VALUE`), fixed plan amount (`PPLAN_KOTEI_AMNT`), and unit name (`PPLAN_KOTEI_TANI_CD_NM`). The method reads all pricing parameters from this bean and writes back the chargeable flag (`PAY_FLG`). |
| 2 | `outputMap` | `HashMap<String, Object>` | The output map that carries pricing table data to the mapping layer. After processing, the key `SC_TITLE_FUSV007604` ("FUSV007604SC") is populated with a map containing the capacity tier list under key `EKK0601B001_LIST` ("EKK0601B001CBSMsg1List"). This data is consumed by `JFUWebCommon.setPrcInfoArea()` to render the pricing information area on the screen. |

**Instance fields / external state read:**

| Field | Type | Business Description |
|-------|------|---------------------|
| `EKK0601B001_LIST` | `String` = "EKK0601B001CBSMsg1List" | Map key for the price plan fixed unit list, used as the key to store the generated dataList within dataMap |
| `PPLAN_KOTEI_AMNT` | `String` = "pplan_kotei_amnt" | Map key for the fixed amount in each childMap entry of the pricing table |
| `PPLAN_KOTEI_TANI_CD_NM` | `String` = "pplan_kotei_tani_cd_nm" | Map key for the unit code name (e.g., "MB") in each childMap entry |
| `TANI_MB` | `String` = "MB" | Unit string appended to capacity values for display (e.g., "100MB") |
| `PRICE_ZERO` | `String` = "0" | Display value for zero-amount pricing rows (first tier on chargeable plans) |
| `SC_TITLE_FUSV007604` | `String` = "FUSV007604SC" | Service component key used to store the final pricing data in outputMap |

## 4. CRUD Operations / Called Services

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

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `JBSbatACInsentivePrcInfoSaksei.formatNumber` | JBSbatACInsentivePrcInfoSaksei | - | Calls `formatNumber` in `JBSbatACInsentivePrcInfoSaksei` (referenced from code graph, not directly called here) |
| - | `JPCFomatString.formatNumber` | JPCFomatString | - | Calls `formatNumber` in `JPCFomatString` (referenced from code graph, not directly called here) |
| - | `JPCUtilCommon.formatNumber` | JPCUtilCommon | - | Calls `formatNumber` in `JPCUtilCommon` (referenced from code graph, not directly called here) |
| C | `OneStopDataBeanAccessArray.addDataBean` | OneStopDataBeanAccessArray | - | Creates a new data bean entry in the add-capacity list array for storing tier display values |
| - | `OneStopDataBeanAccessArray.clearArray` | OneStopDataBeanAccessArray | - | Clears the add-capacity list array to ensure fresh state for each screen render |
| R | `OneStopDataBeanAccess.getDataBeanArray` | OneStopDataBeanAccess | - | Retrieves the add-capacity list data bean array from the main bean |
| - | `OneStopDataBeanAccess.sendMessageString` | OneStopDataBeanAccess | - | Reads string values (unit name) from the data bean for capacity add-on pricing |
| - | `OneStopDataBeanAccess.sendMessageBoolean` | OneStopDataBeanAccess | - | Writes the chargeable flag (payFlg) back to the data bean for screen consumption |
| - | `OneStopDataBeanAccess.sendMessageLong` | OneStopDataBeanAccess | - | Reads long values (capacity amounts, unit price) from the data bean |
| - | `FUW02704SFLogic.formatNumber` | FUW02704SFLogic | - | Calls `formatNumber` in `FUW02704SFLogic` (referenced from code graph, not directly called here) |
| - | `FUW07501SFLogic.formatNumber` | FUW07501SFLogic | - | Calls `formatNumber` in `FUW07501SFLogic` (referenced from code graph, not directly called here) |
| - | `JFUWebCommon.formatNumber` | JFUWebCommon | - | Formats an integer as a number string with thousands separators for capacity display |
| - | `X31SDataBeanAccess.sendMessageString` | X31SDataBeanAccess | - | Sets string values (additional charge, capacity text, total capacity) on individual capacity tier data beans |

**Note:** This method is purely a **data builder** — it reads configuration/pricing parameters from the bean, computes pricing tiers in memory, and writes results back to bean and outputMap. No direct database or CBS (CBS = Central Business System) calls are made within this method. The SC Code references in the pre-computed graph relate to formatting utilities rather than service components with DB operations.

## 5. Dependency Trace

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

No screen/batch entry points found within 8 hops. Direct callers found: 1 methods.
Terminal operations from this method: `sendMessageString` [-], `sendMessageString` [-], `sendMessageString` [-], `sendMessageString` [-], `formatNumber` [-], `formatNumber` [-], `formatNumber` [-], `formatNumber` [-], `formatNumber` [-], `sendMessageString` [-], `sendMessageString` [-], `addDataBean` [C], `clearArray` [-], `getDataBeanArray` [R], `sendMessageString` [-], `sendMessageString` [-], `sendMessageString` [-], `sendMessageString` [-]

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | (Not a direct screen entry point) | `FUW02701SFLogic.init()` -> `createOptioinData` | `sendMessageString` [-], `formatNumber` [-], `addDataBean` [C], `clearArray` [-], `getDataBeanArray` [R] |

**Call chain detail:** The method is called from `FUW02701SFLogic.init()` which serves as the main initialization routine for the Web capacity addition request screen (FUW02701). The `init()` method itself is called by the screen's entry-point class when the customer first accesses or refreshes the capacity add-on selection screen. No independent screen/batch entry class (e.g., KKSVxxxx) was found within 8 hops — this method is a subordinate logic method within the `FUW02701SFLogic` class, not a cross-module entry point.

**Data flow:** This method is a **pure computation and assembly method**. It produces no database side effects and no CBS invocations. Its output is a data structure (list of pricing tier maps) placed into the `outputMap`, which is then consumed by the mapping layer (`FUSV0076_FUSV0076OPDBMapper` or `FUSV0077_FUSV0077OPDBMapper`) for screen rendering.

## 6. Per-Branch Detail Blocks

**Block 1** — [INITIALIZATION] (L592)

> Reads all pricing parameters from the data bean and initializes data structures for building the pricing table.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `baseValue = Long.valueOf(bean.sendMessageString(FUW02701SFConst.NOW_WEB_KEI_CAPA, X31CWebConst.DATABEAN_GET_VALUE)).intValue()` | Read current Web contract capacity |
| 2 | SET | `freeValue = bean.sendMessageLong(FUW02701SFConst.MRYO_CAPA, X31CWebConst.DATABEAN_GET_VALUE).intValue()` | Read free capacity allowance |
| 3 | SET | `addValue = bean.sendMessageLong(FUW02701SFConst.ADD_CAPA_ZOUBUN_VALUE, X31CWebConst.DATABEAN_GET_VALUE).intValue()` | Read capacity increment step |
| 4 | SET | `endValue = bean.sendMessageLong(FUW02701SFConst.ADD_CAPA_ZOUBUN_UPPL_VALUE, X31CWebConst.DATABEAN_GET_VALUE).intValue()` | Read capacity increment upper limit |
| 5 | SET | `tanka = bean.sendMessageLong(FUW02701SFConst.PPLAN_KOTEI_AMNT, X31CWebConst.DATABEAN_GET_VALUE).intValue()` | Read fixed amount per increment [-> FUW02701SFConst.PPLAN_KOTEI_AMNT="料金プラン固定金額"] |
| 6 | SET | `tani = bean.sendMessageString(FUW02701SFConst.PPLAN_KOTEI_TANI_CD_NM, X31CWebConst.DATABEAN_GET_VALUE)` | Read unit name [-> FUW02701SFConst.PPLAN_KOTEI_TANI_CD_NM="料金プラン固定単位コード名"] |
| 7 | SET | `dataList = new ArrayList<Map<String, Object>>()` | Initialize pricing table data list |
| 8 | SET | `idx = 0` | Initialize iteration counter |
| 9 | SET | `gamenListArray = bean.getDataBeanArray(FUW02701SFConst.ADD_CAPA_LIST)` | Get add-capacity list data bean array [-> FUW02701SFConst.ADD_CAPA_LIST="追加容量リスト"] |
| 10 | EXEC | `gamenListArray.clearArray()` | Clear array for fresh state |
| 11 | SET | `addCapaListDataType = gamenListArray.addDataBean()` | Create a new data bean for tier display values |

**Block 2** — [IF/ELSE] `if (0 == endValue || 0 == freeValue || freeValue >= endValue || 0 == tanka)` (L609)

> Determines whether any tier of the pricing table is chargeable. The chargeable flag is `false` if the maximum add-on capacity is zero, the free allowance is zero, the free allowance already covers the full add-on range, or the unit price is zero.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `payFlg = false` | No charge — any pricing parameter is zero or free allowance exceeds max |
| 2 | ELSE-IF-N/A | (No ELSE-IF branches) | Direct if/else |
| 3 | ELSE | `payFlg = true` | Chargeable — all parameters allow tiered pricing |
| 4 | EXEC | `bean.sendMessageBoolean(FUW02701SFConst.PAY_FLG, X31CWebConst.DATABEAN_SET_VALUE, payFlg)` | Write payFlg to bean [-> FUW02701SFConst.PAY_FLG="有料フラグ"] |

**Block 3** — [WHILE TRUE] Loop (L616)

> Iteratively builds each pricing tier row until the maximum capacity is reached. Each iteration computes the additional capacity, total capacity, and additional fee for the current tier.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `addCapa = addValue * idx` | Incremental capacity at this tier (0, addValue, 2*addValue, ...) |
| 2 | SET | `goukeiCapa = baseValue + addCapa` | Total capacity = current + incremental |
| 3 | SET | `addMoney = 0` | Initialize additional fee |
| 4 | SET | `freeData = false` | Initialize free data flag |

**Block 3.1** — [IF/ELSE] `if ((goukeiCapa <= freeValue) || !(payFlg))` (L620)

> Determines whether the current tier falls within the free allowance or the plan is non-chargeable.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `addMoney = 0` | No charge — within free allowance |
| 2 | SET | `freeData = true` | Mark this tier as free |
| 3 | ELSE-IF-N/A | (No ELSE-IF) | Direct if/else |
| 4 | ELSE | (enters Block 3.2) | Tier requires charge calculation |

**Block 3.2** — [IF/ELSE] `if (baseValue >= freeValue)` (L624)

> Computes the additional fee when the tier exceeds the free allowance. The fee is based on the amount over whichever is larger: the current contract capacity or the free allowance.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `addMoney = tanka * (goukeiCapa - baseValue) / addValue` | Fee based on excess over base capacity |
| 2 | ELSE | `addMoney = tanka * (goukeiCapa - freeValue) / addValue` | Fee based on excess over free allowance |
| 3 | EXEC | `addCapaListDataType.sendMessageString(FUW02701SFConst.ADD_PRC_01, X31CWebConst.DATABEAN_ADD_VALUE, String.valueOf(addMoney))` | Set additional charge for this tier [-> FUW02701SFConst.ADD_PRC_01="追加料金"] |
| 4 | SET | `addCapaText = JFUWebCommon.formatNumber(String.valueOf(addCapa)) + TANI_MB` | Format capacity with unit [-> TANI_MB="MB"] |
| 5 | EXEC | `addCapaListDataType.sendMessageString(FUW02701SFConst.ADD_CAPA_01, X31CWebConst.DATABEAN_ADD_VALUE, addCapaText)` | Set additional capacity display text [-> FUW02701SFConst.ADD_CAPA_01="追加容量"] |
| 6 | EXEC | `addCapaListDataType.sendMessageString(FUW02701SFConst.GOKEI_CAPA_01, X31CWebConst.DATABEAN_ADD_VALUE, String.valueOf(goukeiCapa))` | Set total capacity after addition [-> FUW02701SFConst.GOKEI_CAPA_01="追加後合計容量"] |

**Block 3.3** — [IF/ELSE-IF/ELSE] `if ((0 == idx) && (payFlg))` (L636)

> Determines the fixed amount display and unit name for the childMap entry in the pricing table.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | IF | `if ((0 == idx) && (payFlg))` | First tier on a chargeable plan |
| 2 | SET | `koteiAmountText = PRICE_ZERO` | Display "0" for first tier [-> PRICE_ZERO="0"] |
| 3 | SET | `childMap.put(PPLAN_KOTEI_TANI_CD_NM, tani)` | Set unit name |
| 4 | ELSE-IF | `else if ((freeData || 0 == addCapa))` | Free tier (within free allowance or no additional capacity) |
| 5 | SET | `koteiAmountText = JFUStrConst.FREE_LABEL` | Display "無料" (FREE) [-> JFUStrConst.FREE_LABEL="無料"] |
| 6 | SET | `childMap.put(PPLAN_KOTEI_TANI_CD_NM, JFUStrConst.EMPTY)` | No unit for free tiers [-> JFUStrConst.EMPTY=""] |
| 7 | ELSE | Default (non-free, non-first tier) | Chargeable tier beyond free allowance |
| 8 | SET | `childMap.put(PPLAN_KOTEI_TANI_CD_NM, tani)` | Set unit name |
| 9 | SET | `childMap.put(PPLAN_KOTEI_AMNT, koteiAmountText)` | Set fixed amount [-> PPLAN_KOTEI_AMNT="pplan_kotei_amnt"] |

**Block 3.4** — [LOOP EXIT] `if (endValue <= goukeiCapa)` (L652)

> Checks whether the current tier's total capacity has reached or exceeded the maximum addable capacity.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | IF | `if (endValue <= goukeiCapa)` | Exit condition |
| 2 | RETURN | `break` | Terminate loop when max capacity reached |
| 3 | ELSE-IF-N/A | `idx++` | Increment iteration counter and continue |

**Block 4** — [FINALIZATION] (L657)

> Assembles the pricing table data list into the output map for the mapping layer to consume.

| # | Type | Code | Comment |
|---|------|------|---------|
| 1 | SET | `dataMap = new HashMap<String, Object>()` | Create container for pricing data |
| 2 | SET | `dataMap.put(FUW02701SFLogic.EKK0601B001_LIST, dataList)` | Put dataList under EKK0601B001CBSMsg1List key [-> EKK0601B001_LIST="EKK0601B001CBSMsg1List"] |
| 3 | SET | `outputMap.put(SC_TITLE_FUSV007604, dataMap)` | Store in outputMap under FUSV007604SC key [-> SC_TITLE_FUSV007604="FUSV007604SC"] |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `baseValue` | Field | Current Web contract capacity — the customer's existing allocated bandwidth in Mbps, read from the data bean |
| `freeValue` | Field | Free capacity allowance — the portion of add-on capacity that is provided at no additional charge to the customer |
| `addValue` | Field | Capacity increment step — the fixed amount of bandwidth (in Mbps) that each pricing tier represents (e.g., each step adds 100 Mbps) |
| `endValue` | Field | Capacity increment upper limit — the maximum amount of additional capacity the customer is allowed to add on |
| `tanka` | Field | Unit price per increment — the fixed monetary amount charged per capacity increment step (e.g., 500 JPY per 100 Mbps) |
| `tani` | Field | Unit name — the display unit for capacity values (e.g., "MB"), sourced from the pricing plan configuration |
| `payFlg` | Field | Chargeable flag — indicates whether any tiers in the pricing table carry a fee; `false` means all tiers are free or the plan has no chargeable options |
| `addCapa` | Field | Incremental capacity — the amount of additional bandwidth at the current tier (addValue × iteration index) |
| `goukeiCapa` | Field | Total capacity after addition — the sum of the customer's current capacity and the incremental capacity at this tier |
| `addMoney` | Field | Additional fee — the monetary charge for this tier, computed as `tanka × (goukeiCapa - applicableBase) / addValue` |
| `freeData` | Field | Free data flag — indicates whether this tier's capacity is covered by the free allowance |
| `koteiAmountText` | Field | Fixed amount display text — the formatted text shown for the tier's fixed amount (e.g., "0", "無料", or the computed amount) |
| `dataList` | Field | Pricing table data list — list of maps, each representing one pricing tier row with charge, capacity, and total capacity |
| `dataMap` | Field | Pricing data container — holds the dataList under the key EKK0601B001_LIST for output to the mapping layer |
| `gamenListArray` | Field | Capacity list data bean array — the data bean array used to store tier display values for the screen |
| `addCapaListDataType` | Field | Add-capacity list data type bean — a single data bean within gamenListArray for storing the current tier's display values |
| NOW_WEB_KEI_CAPA | Constant | Current Web contract capacity — data bean key for the customer's existing bandwidth allocation |
| MRYO_CAPA | Constant | Free capacity — data bean key for the free capacity allowance amount |
| ADD_CAPA_ZOUBUN_VALUE | Constant | Capacity increment step value — data bean key for the fixed increment per pricing tier |
| ADD_CAPA_ZOUBUN_UPPL_VALUE | Constant | Capacity increment upper limit value — data bean key for the maximum addable capacity |
| PPLAN_KOTEI_AMNT | Constant | Price plan fixed amount — data bean key for the unit price per increment |
| PPLAN_KOTEI_TANI_CD_NM | Constant | Price plan fixed unit code name — data bean key for the capacity unit display name |
| PAY_FLG | Constant | Chargeable flag — data bean key for the payFlg boolean written back to the bean |
| ADD_PRC_01 | Constant | Additional charge — data bean key for the additional fee at each tier |
| ADD_CAPA_01 | Constant | Additional capacity — data bean key for the incremental capacity display text at each tier |
| GOKEI_CAPA_01 | Constant | Total capacity after addition — data bean key for the total capacity display at each tier |
| EKK0601B001_LIST | Constant | Price plan fixed unit list key — map key ("EKK0601B001CBSMsg1List") for the pricing tier data list in the output map |
| SC_TITLE_FUSV007604 | Constant | Service component key for price plan list — map key ("FUSV007604SC") used to store pricing data in outputMap for consumption by the mapping layer |
| TANI_MB | Constant | Unit string "MB" — appended to capacity values for screen display |
| PRICE_ZERO | Constant | "0" — display value for zero-amount pricing rows (first tier on chargeable plans) |
| JFUStrConst.FREE_LABEL | Constant | "無料" — Japanese string for "FREE", displayed for tiers within the free allowance |
| JFUStrConst.EMPTY | Constant | "" — empty string, used as the unit value for free tiers |
| Web Capacity Addition | Business term | A customer-facing web service allowing K-Opticom fiber subscribers to request additional bandwidth beyond their current contract capacity, with pricing displayed as a tiered table |
| SetPrcInfoArea | Method | `JFUWebCommon.setPrcInfoArea()` — downstream method that consumes the pricing data map and renders the pricing information area on the web screen |
| FUSV007604SC | Business term | Service component code for price plan fixed unit pricing display — the SC that the mapping layer uses to process the pricing data |
| X31SDataBeanAccess | Framework class | K-Opticom's data bean access interface for reading/writing screen input/output values in the X31 framework |
| X31SDataBeanAccessArray | Framework class | Array wrapper for data bean access, used to manage lists of data bean entries (e.g., pricing tiers) |