# Business Logic - JFUAddSvcKeiNetCC.editErrInfoEKK0341D010() [657 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `com.fujitsu.futurity.bp.custom.common.JFUAddSvcKeiNetCC` |
| Layer | CC/Common Component (shared utility within the `custom.common` package) |
| Module | `common` (Package: `com.fujitsu.futurity.bp.custom.common`) |

## 1. Role

### JFUAddSvcKeiNetCC.editErrInfoEKK0341D010()

This method aggregates and transfers error item data from a CBS (Component-Based Service) response message template into the request parameter map for screen display. It serves as the **equipment-provided service error handler** (Japanese: 機器提供契約サービスエラー - Equipment-provided contract service error) for service contract registration operations, translating raw CBS-level error responses into user-facing error field structures. The method implements a **mapping and delegation pattern**: it first resolves the overall template status, compares it against an existing BP-level control map status, and only propagates the more severe status. Then it iterates through approximately 60 distinct error item fields covering service codes, pricing codes, address information, equipment details, and billing data, copying each non-null template value into a target HashMap only if the key does not already exist (preserving caller-supplied values as a fallback). The method is a shared utility called by multiple screen controllers (registration, modification, and cancellation flows) to consistently populate error data across different service types (network, mobile, TV, etc.).

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START["editErrInfoEKK0341D010(param, template, returnCode, fixedText)"]

    START --> STATUS_READ["Read template.status as templateStatus"]

    STATUS_READ --> RC_CHECK{if returnCode != 0}
    RC_CHECK --> |true| RC_SET["templateStatus = 9000"]
    RC_CHECK --> |false| MSG_CHECK1["JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + RETURN_MESSAGE_FORMAT.format(templateStatus))"]
    RC_SET --> MSG_CHECK1

    MSG_CHECK1 --> MSG_NULL{result == null?}
    MSG_NULL --> |true| STATUS_ZERO["templateStatus = 0"]
    MSG_NULL --> |false| BP_READ["Read param controlMapData(SCControlMapKeys.RETURN_CODE) as obj"]
    STATUS_ZERO --> BP_READ

    BP_READ --> BP_NULL{obj == null?}
    BP_NULL --> |true| BP_NEG1["bpStatus = -1"]
    BP_NULL --> |false| BP_PARSE["bpStatus = Integer.parseInt(obj)"]
    BP_NEG1 --> COMPARE{if templateStatus > bpStatus}
    BP_PARSE --> COMPARE

    COMPARE --> |true| PROPAGATE["param.setControlMapData(RETURN_CODE, formatStatus)"]
    PROPAGATE --> PROP_MSG["param.setControlMapData(RETURN_MESSAGE, message)"]
    PROP_MSG --> GET_DATA["Get HashMap from param.getData(fixedText)"]
    COMPARE --> |false| GET_DATA

    GET_DATA --> LOOP_START["For each error field in template"]

    LOOP_START --> F1{template.isNull(KKTK_SVC_CD_ERR)?}
    F1 --> |false| SKIP1["Skip field"]
    F1 --> |true| C1{inMap.containsKey(kktk_svc_cd_err)?}
    C1 --> |false| PUT1["inMap.put(kktk_svc_cd_err, template.getString(KKTK_SVC_CD_ERR))"]
    C1 --> |true| SKIP1

    PUT1 --> F2{template.isNull(PCRS_CD_ERR)?}
    F2 --> |false| SKIP2["Skip field"]
    F2 --> |true| C2{inMap.containsKey(pcrs_cd_err)?}
    C2 --> |false| PUT2["inMap.put(pcrs_cd_err, template.getString(PCRS_CD_ERR))"]
    C2 --> |true| SKIP2

    PUT2 --> F3{template.isNull(PPLAN_CD_ERR)?}
    F3 --> |false| SKIP3["Skip field"]
    F3 --> |true| C3{inMap.containsKey(pplan_cd_err)?}
    C3 --> |false| PUT3["inMap.put(pplan_cd_err, template.getString(PPLAN_CD_ERR))"]
    C3 --> |true| SKIP3

    SKIP3 --> F4{template.isNull(KKTK_SBT_CD_ERR)?}
    SKIP2 --> F4
    F4 --> |false| SKIP4["Skip field"]
    F4 --> |true| C4{inMap.containsKey(kktk_sbt_cd_err)?}
    C4 --> |false| PUT4["inMap.put(kktk_sbt_cd_err, template.getString(KKTK_SBT_CD_ERR))"]
    C4 --> |true| SKIP4

    PUT4 --> F5{template.isNull(HDD_CAPA_CD_ERR)?}
    F5 --> |false| SKIP5["Skip field"]
    F5 --> |true| C5{inMap.containsKey(hdd_capa_cd_err)?}
    C5 --> |false| PUT5["inMap.put(hdd_capa_cd_err, template.getString(HDD_CAPA_CD_ERR))"]
    C5 --> |true| SKIP5

    SKIP5 --> F6{template.isNull(SVC_USE_STA_KIBO_YMD_ERR)?}
    F6 --> |false| SKIP6["Skip field"]
    F6 --> |true| C6{inMap.containsKey(svc_use_sta_kibo_ymd_err)?}
    C6 --> |false| PUT6["inMap.put(svc_use_sta_kibo_ymd_err, template.getString(SVC_USE_STA_KIBO_YMD_ERR))"]
    C6 --> |true| SKIP6

    SKIP6 --> F7{template.isNull(RSV_TSTA_KIBO_YMD_ERR)?}
    F7 --> |false| SKIP7["Skip field"]
    F7 --> |true| C7{inMap.containsKey(rsv_tsta_kibo_y md_err)?}
    C7 --> |false| PUT7["inMap.put(rsv_tsta_kibo_ymd_err, template.getString(RSV_TSTA_KIBO_YMD_ERR))"]
    C7 --> |true| SKIP7

    SKIP7 --> F8{template.isNull(KIBO_MAKER_CD_ERR)?}
    F8 --> |false| SKIP8["Skip field"]
    F8 --> |true| C8{inMap.containsKey(kibo_maker_cd_err)?}
    C8 --> |false| PUT8["inMap.put(kibo_maker_cd_err, template.getString(KIBO_MAKER_CD_ERR))"]
    C8 --> |true| SKIP8

    SKIP8 --> F9{template.isNull(HAMBAI_SBT_CD_ERR)?}
    F9 --> |false| SKIP9["Skip field"]
    F9 --> |true| C9{inMap.containsKey(hambai_sbt_cd_err)?}
    C9 --> |false| PUT9["inMap.put(hambai_sbt_cd_err, template.getString(HAMBAI_SBT_CD_ERR))"]
    C9 --> |true| SKIP9

    SKIP9 --> F10{template.isNull(TSUSHIN_KIKI_SET_CD_ERR)?}
    F10 --> |false| SKIP10["Skip field"]
    F10 --> |true| C10{inMap.containsKey(tsushin_kiki_set_cd_err)?}
    C10 --> |false| PUT10["inMap.put(tsushin_kiki_set_cd_err, template.getString(TSUSHIN_KIKI_SET_CD_ERR))"]
    C10 --> |true| SKIP10

    SKIP10 --> F11{template.isNull(TAKNKIKI_SBT_CD_ERR)?}
    F11 --> |false| SKIP11["Skip field"]
    F11 --> |true| C11{inMap.containsKey(taknkiki_sbt_cd_err)?}
    C11 --> |false| PUT11["inMap.put(taknkiki_sbt_cd_err, template.getString(TAKNKIKI_SBT_CD_ERR))"]
    C11 --> |true| SKIP11

    SKIP11 --> F12{template.isNull(TAKNKIKI_MODEL_CD_ERR)?}
    F12 --> |false| SKIP12["Skip field"]
    F12 --> |true| C12{inMap.containsKey(taknkiki_model_cd_err)?}
    C12 --> |false| PUT12["inMap.put(taknkiki_model_cd_err, template.getString(TAKNKIKI_MODEL_CD_ERR))"]
    C12 --> |true| SKIP12

    SKIP12 --> F13{template.isNull(TAKNKIKI_SETHIN_MODEL_CD_ERR)?}
    F13 --> |false| SKIP13["Skip field"]
    F13 --> |true| C13{inMap.containsKey(taknkiki_sethin_model_cd_err)?}
    C13 --> |false| PUT13["inMap.put(taknkiki_sethin_model_cd_err, template.getString(TAKNKIKI_SETHIN_MODEL_CD_ERR))"]
    C13 --> |true| SKIP13

    SKIP13 --> F14{template.isNull(HUZOKUHIN_SBT_CD_ERR)?}
    F14 --> |false| SKIP14["Skip field"]
    F14 --> |true| C14{inMap.containsKey(huzokuhin_sbt_cd_err)?}
    C14 --> |false| PUT14["inMap.put(huzokuhin_sbt_cd_err, template.getString(HUZOKUHIN_SBT_CD_ERR))"]
    C14 --> |true| SKIP14

    SKIP14 --> F15{template.isNull(KIKI_STC_SAKI_PLACE_NO_ERR)?}
    F15 --> |false| SKIP15["Skip field"]
    F15 --> |true| C15{inMap.containsKey(kiki_stc_saki_place_no_err)?}
    C15 --> |false| PUT15["inMap.put(kiki_stc_saki_place_no_err, template.getString(KIKI_STC_SAKI_PLACE_NO_ERR))"]
    C15 --> |true| SKIP15

    SKIP15 --> F16{template.isNull(SVC_KEI_NO_ERR)?}
    F16 --> |false| SKIP16["Skip field"]
    F16 --> |true| C16{inMap.containsKey(svc_kei_no_err)?}
    C16 --> |false| PUT16["inMap.put(svc_kei_no_err, template.getString(SVC_KEI_NO_ERR))"]
    C16 --> |true| SKIP16

    SKIP16 --> F17{template.isNull(SVC_KEI_UCWK_NO_ERR)?}
    F17 --> |false| SKIP17["Skip field"]
    F17 --> |true| C17{inMap.containsKey(svc_kei_ucwk_no_err)?}
    C17 --> |false| PUT17["inMap.put(svc_kei_ucwk_no_err, template.getString(SVC_KEI_UCWK_NO_ERR))"]
    C17 --> |true| SKIP17

    SKIP17 --> F18{template.isNull(SVC_KEI_KAISEN_UCWK_NO_ERR)?}
    F18 --> |false| SKIP18["Skip field"]
    F18 --> |true| C18{inMap.containsKey(svc_kei_kaisen_ucwk_no_err)?}
    C18 --> |false| PUT18["inMap.put(svc_kei_kaisen_ucwk_no_err, template.getString(SVC_KEI_KAISEN_UCWK_NO_ERR))"]
    C18 --> |true| SKIP18

    SKIP18 --> F19{template.isNull(OP_SVC_KEI_NO_ERR)?}
    F19 --> |false| SKIP19["Skip field"]
    F19 --> |true| C19{inMap.containsKey(op_svc_kei_no_err)?}
    C19 --> |false| PUT19["inMap.put(op_svc_kei_no_err, template.getString(OP_SVC_KEI_NO_ERR))"]
    C19 --> |true| SKIP19

    SKIP19 --> F20{template.isNull(SYSID_ERR)?}
    F20 --> |false| SKIP20["Skip field"]
    F20 --> |true| C20{inMap.containsKey(sysid_err)?}
    C20 --> |false| PUT20["inMap.put(sysid_err, template.getString(SYSID_ERR))"]
    C20 --> |true| SKIP20

    SKIP20 --> F21{template.isNull(MSKM_DTL_NO_ERR)?}
    F21 --> |false| SKIP21["Skip field"]
    F21 --> |true| C21{inMap.containsKey(mskm_dtl_no_err)?}
    C21 --> |false| PUT21["inMap.put(mskm_dtl_no_err, template.getString(MSKM_DTL_NO_ERR))"]
    C21 --> |true| SKIP21

    SKIP21 --> F22{template.isNull(LINK_STB_FLG_ERR)?}
    F22 --> |false| SKIP22["Skip field"]
    F22 --> |true| C22{inMap.containsKey(link_stb_flg_err)?}
    C22 --> |false| PUT22["inMap.put(link_stb_flg_err, template.getString(LINK_STB_FLG_ERR))"]
    C22 --> |true| SKIP22

    SKIP22 --> F23{template.isNull(KIKI_SORYO_UM_ERR)?}
    F23 --> |false| SKIP23["Skip field"]
    F23 --> |true| C23{inMap.containsKey(kiki_soryo_um_err)?}
    C23 --> |false| PUT23["inMap.put(kiki_soryo_um_err, template.getString(KIKI_SORYO_UM_ERR))"]
    C23 --> |true| SKIP23

    SKIP23 --> F24{template.isNull(KIKI_SORYO_SAKSEI_YMD_ERR)?}
    F24 --> |false| SKIP24["Skip field"]
    F24 --> |true| C24{inMap.containsKey(kiki_soryo_saksei_ymd_err)?}
    C24 --> |false| PUT24["inMap.put(kiki_soryo_saksei_ymd_err, template.getString(KIKI_SORYO_SAKSEI_YMD_ERR))"]
    C24 --> |true| SKIP24

    SKIP24 --> F25{template.isNull(KIKI_SOHUS_NM_ERR)?}
    F25 --> |false| SKIP25["Skip field"]
    F25 --> |true| C25{inMap.containsKey(kiki_sohus_nm_err)?}
    C25 --> |false| PUT25["inMap.put(kiki_sohus_nm_err, template.getString(KIKI_SOHUS_NM_ERR))"]
    C25 --> |true| SKIP25

    SKIP25 --> F26{template.isNull(KIKI_SOHUS_KANA_ERR)?}
    F26 --> |false| SKIP26["Skip field"]
    F26 --> |true| C26{inMap.containsKey(kiki_sohus_kana_err)?}
    C26 --> |false| PUT26["inMap.put(kiki_sohus_kana_err, template.getString(KIKI_SOHUS_KANA_ERR))"]
    C26 --> |true| SKIP26

    SKIP26 --> F27{template.isNull(KIKI_SOHUS_AD_CD_ERR)?}
    F27 --> |false| SKIP27["Skip field"]
    F27 --> |true| C27{inMap.containsKey(kiki_sohus_ad_cd_err)?}
    C27 --> |false| PUT27["inMap.put(kiki_sohus_ad_cd_err, template.getString(KIKI_SOHUS_AD_CD_ERR))"]
    C27 --> |true| SKIP27

    SKIP27 --> F28{template.isNull(KIKI_SOHUS_PCD_ERR)?}
    F28 --> |false| SKIP28["Skip field"]
    F28 --> |true| C28{inMap.containsKey(kiki_sohus_pcd_err)?}
    C28 --> |false| PUT28["inMap.put(kiki_sohus_pcd_err, template.getString(KIKI_SOHUS_PCD_ERR))"]
    C28 --> |true| SKIP28

    SKIP28 --> F29{template.isNull(KIKI_SOHUS_STATE_NM_ERR)?}
    F29 --> |false| SKIP29["Skip field"]
    F29 --> |true| C29{inMap.containsKey(kiki_sohus_state_nm_err)?}
    C29 --> |false| PUT29["inMap.put(kiki_sohus_state_nm_err, template.getString(KIKI_SOHUS_STATE_NM_ERR))"]
    C29 --> |true| SKIP29

    SKIP29 --> F30{template.isNull(KIKI_SOHUS_CITY_NM_ERR)?}
    F30 --> |false| SKIP30["Skip field"]
    F30 --> |true| C30{inMap.containsKey(kiki_sohus_city_nm_err)?}
    C30 --> |false| PUT30["inMap.put(kiki_sohus_city_nm_err, template.getString(KIKI_SOHUS_CITY_NM_ERR))"]
    C30 --> |true| SKIP30

    SKIP30 --> F31{template.isNull(KIKI_SOHUS_OAZTSU_NM_ERR)?}
    F31 --> |false| SKIP31["Skip field"]
    F31 --> |true| C31{inMap.containsKey(kiki_sohus_oaztsu_nm_err)?}
    C31 --> |false| PUT31["inMap.put(kiki_sohus_oaztsu_nm_err, template.getString(KIKI_SOHUS_OAZTSU_NM_ERR))"]
    C31 --> |true| SKIP31

    SKIP31 --> F32{template.isNull(KIKI_SOHUS_AZCHO_NM_ERR)?}
    F32 --> |false| SKIP32["Skip field"]
    F32 --> |true| C32{inMap.containsKey(kiki_sohus_azcho_nm_err)?}
    C32 --> |false| PUT32["inMap.put(kiki_sohus_azcho_nm_err, template.getString(KIKI_SOHUS_AZCHO_NM_ERR))"]
    C32 --> |true| SKIP32

    SKIP32 --> F33{template.isNull(KIKI_SOHUS_BNCHIGO_ERR)?}
    F33 --> |false| SKIP33["Skip field"]
    F33 --> |true| C33{inMap.containsKey(kiki_sohus_bnchigo_err)?}
    C33 --> |false| PUT33["inMap.put(kiki_sohus_bnchigo_err, template.getString(KIKI_SOHUS_BNCHIGO_ERR))"]
    C33 --> |true| SKIP33

    SKIP33 --> F34{template.isNull(KIKI_SOHUS_ADRTTM_ERR)?}
    F34 --> |false| SKIP34["Skip field"]
    F34 --> |true| C34{inMap.containsKey(kiki_sohus_adrttm_err)?}
    C34 --> |false| PUT34["inMap.put(kiki_sohus_adrttm_err, template.getString(KIKI_SOHUS_ADRTTM_ERR))"]
    C34 --> |true| SKIP34

    SKIP34 --> F35{template.isNull(KIKI_SOHUS_ADRRM_ERR)?}
    F35 --> |false| SKIP35["Skip field"]
    F35 --> |true| C35{inMap.containsKey(kiki_sohus_adrrm_err)?}
    C35 --> |false| PUT35["inMap.put(kiki_sohus_adrrm_err, template.getString(KIKI_SOHUS_ADRRM_ERR))"]
    C35 --> |true| SKIP35

    SKIP35 --> F36{template.isNull(KIKI_SOHUS_TELNO_ERR)?}
    F36 --> |false| SKIP36["Skip field"]
    F36 --> |true| C36{inMap.containsKey(kiki_sohus_telno_err)?}
    C36 --> |false| PUT36["inMap.put(kiki_sohus_telno_err, template.getString(KIKI_SOHUS_TELNO_ERR))"]
    C36 --> |true| SKIP36

    SKIP36 --> F37{template.isNull(MANSION_BUKKEN_NO_ERR)?}
    F37 --> |false| SKIP37["Skip field"]
    F37 --> |true| C37{inMap.containsKey(mansion_bukken_no_err)?}
    C37 --> |false| PUT37["inMap.put(mansion_bukken_no_err, template.getString(MANSION_BUKKEN_NO_ERR))"]
    C37 --> |true| SKIP37

    SKIP37 --> F38{template.isNull(KIKI_SOHUS_KSH_AD_SAI_FLG_ERR)?}
    F38 --> |false| SKIP38["Skip field"]
    F38 --> |true| C38{inMap.containsKey(kiki_sohus_ksh_ad_sai_flg_err)?}
    C38 --> |false| PUT38["inMap.put(kiki_sohus_ksh_ad_sai_flg_err, template.getString(KIKI_SOHUS_KSH_AD_SAI_FLG_ERR))"]
    C38 --> |true| SKIP38

    SKIP38 --> F39{template.isNull(KIKI_SHS_KBT_SHITEI_FLG_ERR)?}
    F39 --> |false| SKIP39["Skip field"]
    F39 --> |true| C39{inMap.containsKey(kiki_shs_kbt_shitei_flg_err)?}
    C39 --> |false| PUT39["inMap.put(kiki_shs_kbt_shitei_flg_err, template.getString(KIKI_SHS_KBT_SHITEI_FLG_ERR))"]
    C39 --> |true| SKIP39

    SKIP39 --> F40{template.isNull(KIKI_SHS_HSK_CD_1_ERR)?}
    F40 --> |false| SKIP40["Skip field"]
    F40 --> |true| C40{inMap.containsKey(kiki_shs_hsk_cd_1_err)?}
    C40 --> |false| PUT40["inMap.put(kiki_shs_hsk_cd_1_err, template.getString(KIKI_SHS_HSK_CD_1_ERR))"]
    C40 --> |true| SKIP40

    SKIP40 --> F41{template.isNull(KIKI_SHS_HSK_CD_2_ERR)?}
    F41 --> |false| SKIP41["Skip field"]
    F41 --> |true| C41{inMap.containsKey(kiki_shs_hsk_cd_2_err)?}
    C41 --> |false| PUT41["inMap.put(kiki_shs_hsk_cd_2_err, template.getString(KIKI_SHS_HSK_CD_2_ERR))"]
    C41 --> |true| SKIP41

    SKIP41 --> F42{template.isNull(KIKI_SHS_HSK_MEMO_ERR)?}
    F42 --> |false| SKIP42["Skip field"]
    F42 --> |true| C42{inMap.containsKey(kiki_shs_hsk_memo_err)?}
    C42 --> |false| PUT42["inMap.put(kiki_shs_hsk_memo_err, template.getString(KIKI_SHS_HSK_MEMO_ERR))"]
    C42 --> |true| SKIP42

    SKIP42 --> F43{template.isNull(KIKI_STC_SAKI_NM_ERR)?}
    F43 --> |false| SKIP43["Skip field"]
    F43 --> |true| C43{inMap.containsKey(kiki_stc_saki_nm_err)?}
    C43 --> |false| PUT43["inMap.put(kiki_stc_saki_nm_err, template.getString(KIKI_STC_SAKI_NM_ERR))"]
    C43 --> |true| SKIP43

    SKIP43 --> F44{template.isNull(KIKI_STC_SAKI_KANA_ERR)?}
    F44 --> |false| SKIP44["Skip field"]
    F44 --> |true| C44{inMap.containsKey(kiki_stc_saki_kana_err)?}
    C44 --> |false| PUT44["inMap.put(kiki_stc_saki_kana_err, template.getString(KIKI_STC_SAKI_KANA_ERR))"]
    C44 --> |true| SKIP44

    SKIP44 --> F45{template.isNull(KIKI_STC_SAKI_AD_CD_ERR)?}
    F45 --> |false| SKIP45["Skip field"]
    F45 --> |true| C45{inMap.containsKey(kiki_stc_saki_ad_cd_err)?}
    C45 --> |false| PUT45["inMap.put(kiki_stc_saki_ad_cd_err, template.getString(KIKI_STC_SAKI_AD_CD_ERR))"]
    C45 --> |true| SKIP45

    SKIP45 --> F46{template.isNull(KIKI_STC_SAKI_PCD_ERR)?}
    F46 --> |false| SKIP46["Skip field"]
    F46 --> |true| C46{inMap.containsKey(kiki_stc_saki_pcd_err)?}
    C46 --> |false| PUT46["inMap.put(kiki_stc_saki_pcd_err, template.getString(KIKI_STC_SAKI_PCD_ERR))"]
    C46 --> |true| SKIP46

    SKIP46 --> F47{template.isNull(KIKI_STC_SAKI_STATE_NM_ERR)?}
    F47 --> |false| SKIP47["Skip field"]
    F47 --> |true| C47{inMap.containsKey(kiki_stc_saki_state_nm_err)?}
    C47 --> |false| PUT47["inMap.put(kiki_stc_saki_state_nm_err, template.getString(KIKI_STC_SAKI_STATE_NM_ERR))"]
    C47 --> |true| SKIP47

    SKIP47 --> F48{template.isNull(KIKI_STC_SAKI_CITY_NM_ERR)?}
    F48 --> |false| SKIP48["Skip field"]
    F48 --> |true| C48{inMap.containsKey(kiki_stc_saki_city_nm_err)?}
    C48 --> |false| PUT48["inMap.put(kiki_stc_saki_city_nm_err, template.getString(KIKI_STC_SAKI_CITY_NM_ERR))"]
    C48 --> |true| SKIP48

    SKIP48 --> F49{template.isNull(KIKI_STC_SAKI_OAZTSU_NM_ERR)?}
    F49 --> |false| SKIP49["Skip field"]
    F49 --> |true| C49{inMap.containsKey(kiki_stc_saki_oaztsu_nm_err)?}
    C49 --> |false| PUT49["inMap.put(kiki_stc_saki_oaztsu_nm_err, template.getString(KIKI_STC_SAKI_OAZTSU_NM_ERR))"]
    C49 --> |true| SKIP49

    SKIP49 --> F50{template.isNull(KIKI_STC_SAKI_AZCHO_NM_ERR)?}
    F50 --> |false| SKIP50["Skip field"]
    F50 --> |true| C50{inMap.containsKey(kiki_stc_saki_azcho_nm_err)?}
    C50 --> |false| PUT50["inMap.put(kiki_stc_saki_azcho_nm_err, template.getString(KIKI_STC_SAKI_AZCHO_NM_ERR))"]
    C50 --> |true| SKIP50

    SKIP50 --> F51{template.isNull(KIKI_STC_SAKI_BNCHIGO_ERR)?}
    F51 --> |false| SKIP51["Skip field"]
    F51 --> |true| C51{inMap.containsKey(kiki_stc_saki_bnchigo_err)?}
    C51 --> |false| PUT51["inMap.put(kiki_stc_saki_bnchigo_err, template.getString(KIKI_STC_SAKI_BNCHIGO_ERR))"]
    C51 --> |true| SKIP51

    SKIP51 --> F52{template.isNull(KIKI_STC_SAKI_ADRTTM_ERR)?}
    F52 --> |false| SKIP52["Skip field"]
    F52 --> |true| C52{inMap.containsKey(kiki_stc_saki_adrttm_err)?}
    C52 --> |false| PUT52["inMap.put(kiki_stc_saki_adrttm_err, template.getString(KIKI_STC_SAKI_ADRTTM_ERR))"]
    C52 --> |true| SKIP52

    SKIP52 --> F53{template.isNull(KIKI_STC_SAKI_ADRRM_ERR)?}
    F53 --> |false| SKIP53["Skip field"]
    F53 --> |true| C53{inMap.containsKey(kiki_stc_saki_adrrm_err)?}
    C53 --> |false| PUT53["inMap.put(kiki_stc_saki_adrrm_err, template.getString(KIKI_STC_SAKI_ADRRM_ERR))"]
    C53 --> |true| SKIP53

    SKIP53 --> F54{template.isNull(KIKI_STC_SK_KSH_AD_SAI_FLG_ERR)?}
    F54 --> |false| SKIP54["Skip field"]
    F54 --> |true| C54{inMap.containsKey(kiki_stc_sk_ksh_ad_sai_flg_err)?}
    C54 --> |false| PUT54["inMap.put(kiki_stc_sk_ksh_ad_sai_flg_err, template.getString(KIKI_STC_SK_KSH_AD_SAI_FLG_ERR))"]
    C54 --> |true| SKIP54

    SKIP54 --> F55{template.isNull(KIKI_STC_SK_TELNO_ERR)?}
    F55 --> |false| SKIP55["Skip field"]
    F55 --> |true| C55{inMap.containsKey(kiki_stc_sk_telno_err)?}
    C55 --> |false| PUT55["inMap.put(kiki_stc_sk_telno_err, template.getString(KIKI_STC_SK_TELNO_ERR))"]
    C55 --> |true| SKIP55

    SKIP55 --> F56{template.isNull(KIKI_STS_KKK_SEIRI_CHU_FLG_ERR)?}
    F56 --> |false| SKIP56["Skip field"]
    F56 --> |true| C56{inMap.containsKey(kiki_sts_kkk_seiri_chu_flg_err)?}
    C56 --> |false| PUT56["inMap.put(kiki_sts_kkk_seiri_chu_flg_err, template.getString(KIKI_STS_KKK_SEIRI_CHU_FLG_ERR))"]
    C56 --> |true| SKIP56

    SKIP56 --> F57{template.isNull(KIKI_STS_HSK_CD_1_ERR)?}
    F57 --> |false| SKIP57["Skip field"]
    F57 --> |true| C57{inMap.containsKey(kiki_sts_hsk_cd_1_err)?}
    C57 --> |false| PUT57["inMap.put(kiki_sts_hsk_cd_1_err, template.getString(KIKI_STS_HSK_CD_1_ERR))"]
    C57 --> |true| SKIP57

    SKIP57 --> F58{template.isNull(KIKI_STS_HSK_CD_2_ERR)?}
    F58 --> |false| SKIP58["Skip field"]
    F58 --> |true| C58{inMap.containsKey(kiki_sts_hsk_cd_2_err)?}
    C58 --> |false| PUT58["inMap.put(kiki_sts_hsk_cd_2_err, template.getString(KIKI_STS_HSK_CD_2_ERR))"]
    C58 --> |true| SKIP58

    SKIP58 --> F59{template.isNull(KIKI_STS_HSK_MEMO_ERR)?}
    F59 --> |false| SKIP59["Skip field"]
    F59 --> |true| C59{inMap.containsKey(kiki_sts_hsk_memo_err)?}
    C59 --> |false| PUT59["inMap.put(kiki_sts_hsk_memo_err, template.getString(KIKI_STS_HSK_MEMO_ERR))"]
    C59 --> |true| SKIP59

    SKIP59 --> F60{template.isNull(FTRIAL_KANYU_YMD_ERR)?}
    F60 --> |false| SKIP60["Skip field"]
    F60 --> |true| C60{inMap.containsKey(ftrial_kanyu_ymd_err)?}
    C60 --> |false| PUT60["inMap.put(ftrial_kanyu_ymd_err, template.getString(FTRIAL_KANYU_YMD_ERR))"]
    C60 --> |true| SKIP60

    SKIP60 --> F61{template.isNull(HONKANYU_YMD_ERR)?}
    F61 --> |false| SKIP61["Skip field"]
    F61 --> |true| C61{inMap.containsKey(honkanyu_ymd_err)?}
    C61 --> |false| PUT61["inMap.put(honkanyu_ymd_err, template.getString(HONKANYU_YMD_ERR))"]
    C61 --> |true| SKIP61

    SKIP61 --> F62{template.isNull(HONKANYU_IKO_KIGEN_YMD_ERR)?}
    F62 --> |false| SKIP62["Skip field"]
    F62 --> |true| C62{inMap.containsKey(honkanyu_iko_kigen_ymd_err)?}
    C62 --> |false| PUT62["inMap.put(honkanyu_iko_kigen_ymd_err, template.getString(HONKANYU_IKO_KIGEN_YMD_ERR))"]
    C62 --> |true| SKIP62

    SKIP62 --> F63{template.isNull(HOSHO_CD_ERR)?}
    F63 --> |false| SKIP63["Skip field"]
    F63 --> |true| C63{inMap.containsKey(hosho_cd_err)?}
    C63 --> |false| PUT63["inMap.put(hosho_cd_err, template.getString(HOSHO_CD_ERR))"]
    C63 --> |true| SKIP63

    SKIP63 --> F64{template.isNull(HOSHO_STAYMD_ERR)?}
    F64 --> |false| SKIP64["Skip field"]
    F64 --> |true| C64{inMap.containsKey(hosho_staymd_err)?}
    C64 --> |false| PUT64["inMap.put(hosho_staymd_err, template.getString(HOSHO_STAYMD_ERR))"]
    C64 --> |true| SKIP64

    SKIP64 --> F65{template.isNull(PNLTY_HASSEI_CD_ERR)?}
    F65 --> |false| SKIP65["Skip field"]
    F65 --> |true| C65{inMap.containsKey(pnlty_hassei_cd_err)?}
    C65 --> |false| PUT65["inMap.put(pnlty_hassei_cd_err, template.getString(PNLTY_HASSEI_CD_ERR))"]
    C65 --> |true| SKIP65

    SKIP65 --> F66{template.isNull(IDO_DIV_ERR)?}
    F66 --> |false| SKIP66["Skip field"]
    F66 --> |true| C66{inMap.containsKey(ido_div_err)?}
    C66 --> |false| PUT66["inMap.put(ido_div_err, template.getString(IDO_DIV_ERR))"]
    C66 --> |true| SKIP66

    SKIP66 --> F67{template.isNull(CAS_CARD_USE_KYODAK_YMD_ERR)?}
    F67 --> |false| SKIP67["Skip field"]
    F67 --> |true| C67{inMap.containsKey(cas_card_use_kyodak_ymd_err)?}
    C67 --> |false| PUT67["inMap.put(cas_card_use_kyodak_ymd_err, template.getString(CAS_CARD_USE_KYODAK_YMD_ERR))"]
    C67 --> |true| SKIP67

    SKIP67 --> F68{template.isNull(SEIKY_KEI_NO_ERR)?}
    F68 --> |false| SKIP68["Skip field"]
    F68 --> |true| C68{inMap.containsKey(seiky_kei_no_err)?}
    C68 --> |false| PUT68["inMap.put(seiky_kei_no_err, template.getString(SEIKY_KEI_NO_ERR))"]
    C68 --> |true| SKIP68

    SKIP68 --> F69{template.isNull(KIKI_SHS_AD_MAN_INPUT_FLG_ERR)?}
    F69 --> |false| SKIP69["Skip field"]
    F69 --> |true| C69{inMap.containsKey(kiki_shs_ad_man_input_flg_err)?}
    C69 --> |false| PUT69["inMap.put(kiki_shs_ad_man_input_flg_err, template.getString(KIKI_SHS_AD_MAN_INPUT_FLG_ERR))"]
    C69 --> |true| SKIP69

    SKIP69 --> RETURN["Return param"]
    SKIP69 --> END["Return param"]
```

**Constant Resolution Reference:**

| Constant | Actual Value | Business Meaning |
|----------|-------------|------------------|
| `RETURN_MESSAGE_STRING` | `"RETURN_MESSAGE_"` | Prefix for lookup key of return message text in the message resource bundle |
| `RETURN_MESSAGE_FORMAT` | `"%1$04d"` | Format pattern for zero-padded 4-digit return status code |
| `EKK0341D010CBSMsg.STATUS` | `"status"` | CBS response status code field name |

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|---------------------|
| 1 | `param` | `IRequestParameterReadWrite` | The request parameter container that holds all screen input data and control map settings. It carries the HashMap data identified by `fixedText` (e.g., `"EKK0341D010Tv"`) where error fields are stored, and is also used to write back the resolved `RETURN_CODE` and `RETURN_MESSAGE` control map entries. |
| 2 | `template` | `CAANMsg` | The CBS response message object containing error field data. It carries approximately 60 error item fields (status, service codes, pricing codes, address data, equipment information, billing data, etc.) as populated by the CBS layer. If any field is null/empty, that field is skipped during transfer. |
| 3 | `returnCode` | `int` | The CBS return code from the service call. If non-zero, it overrides the template status to `9000`, forcing the error propagation branch to activate. A value of `0` means the CBS call succeeded and normal status resolution applies. |
| 4 | `fixedText` | `String` | A string key used to identify and retrieve the target HashMap from the request parameter. Examples: `"EKK0341D010Tv"` for TV service, `"EKK0341D010Mob"` for mobile. Different service types pass different keys to segregate their error data. |

## 4. CRUD Operations / Called Services

This method does **not** perform any direct database or SC (Service Component) operations. It is a pure data mapping/transformation method that reads from templates and writes to parameter maps. All operations are read/write on in-memory data structures.

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| - | `JCMAPLConstMgr.getString` | - | - | Looks up a localized error message string from the resource bundle using the concatenation of `RETURN_MESSAGE_STRING` and the formatted `templateStatus` as the key |
| R | `param.getControlMapData` | - | - | Reads the existing `RETURN_CODE` control map entry to compare against the incoming template status |
| R | `param.getData` | - | - | Retrieves the HashMap identified by `fixedText` key; this is the target data container for all error field mappings |
| W | `param.setControlMapData` | - | - | Writes the resolved return code (`formatStatus`) and error message into the control map for downstream screen processing |
| W | `inMap.put` (x69) | - | - | Copies each non-null error field value from the CBS template into the in-memory HashMap, only if the key is not already present (preserves existing caller-supplied values) |

## 5. Dependency Trace

### Callers of `editErrInfoEKK0341D010`

The pre-computed caller search returned zero direct calls to `JFUAddSvcKeiNetCC.editErrInfoEKK0341D010`. However, many classes define **private wrapper methods** named `editErrInfoEKK0341D010` that delegate to the original. The following callers are found:

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | CBS:JKKAddKeishaServiceCC | `JKKAddKeishaServiceCC.editErrInfoEKK0341D010` (private wrapper) -> calls original on same class? No - this IS the wrapper. Actual: `JKKAddSvcKeiNetCC.editErrInfoEKK0341D010` -> calls `JFUAddSvcKeiNetCC.editErrInfoEKK0341D010` | Direct call to this method from CBS layer |
| 2 | CBS:JKKAddKktkSvcKeiUtil | `JKKAddKktkSvcKeiUtil.editErrInfoEKK0341D010Msg` -> calls `editErrInfoEKK0341D010` (likely delegation) | Maps error data with custom prefix |
| 3 | CBS:JKKAddSvcKeiMobileCC | `JKKAddSvcKeiMobileCC.editErrInfoEKK0341D010` (private wrapper) -> calls original | Delegates to shared common component |
| 4 | CBS:JFUAddSvcKeiTvCC | `JFUAddSvcKeiTvCC.editErrInfoEKK0341D010` (private wrapper) -> iterates over template array | TV service error handling |
| 5 | CBS:JFUAddSvcKeiMobCC | `JFUAddSvcKeiMobCC.editErrInfoEKK0341D010` (private wrapper) -> iterates over template array | Mobile service error handling |

These wrapper classes each wrap the original method in their own context, adding additional parameters (like `dataMap`, `prefix`, `index`) or looping over multiple templates.

### What `editErrInfoEKK0341D010` ultimately calls

This method has no downstream service calls. It operates entirely on in-memory objects:
- Reads from `CAANMsg` template
- Reads/writes `IRequestParameterReadWrite` parameter map
- Reads from `HashMap` (retrieved via `param.getData(fixedText)`)
- Reads localized strings via `JCMAPLConstMgr.getString`

## 6. Per-Branch Detail Blocks

**Block 1** — [IF] `if (returnCode != 0)` (L~2978)

> If the CBS call returned a non-zero return code, override the template status to `9000` (generic error). This forces error propagation regardless of what the template status says.

| # | Type | Code |
|---|------|------|
| 1 | SET | `templateStatus = 9000` // Override with generic error status |

**Block 2** — [IF] `if (JCMAPLConstMgr.getString(...) == null)` (L~2982)

> Validates that the message lookup key exists in the resource bundle. `RETURN_MESSAGE_STRING` + `String.format(RETURN_MESSAGE_FORMAT, templateStatus)` forms the lookup key. If the key is not found (returns null), reset `templateStatus` to `0` (success/no-error).

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus))` // Returns null if key not found |
| 2 | SET | `templateStatus = 0` // Reset to success if message key invalid |

**Block 3** — [IF/ELSE] `bpStatus resolution` (L~2987)

> Reads the existing BP-level return code from the control map. This establishes the baseline against which the incoming template status will be compared.

| # | Type | Code |
|---|------|------|
| 1 | SET | `bpStatus = -1` // If RETURN_CODE not set in control map |
| 2 | SET | `bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE))` // Parse existing BP status |

**Block 4** — [IF] `if (templateStatus > bpStatus)` (L~2995)

> Only propagate the template status if it is more severe than the existing BP-level status. This implements a **status escalation** pattern: the CBS error code takes precedence when it exceeds the local error tracking.

| # | Type | Code |
|---|------|------|
| 1 | SET | `formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus)` // Zero-padded 4-digit format, e.g., "9000" |
| 2 | EXEC | `message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus)` // Lookup localized error message |
| 3 | EXEC | `param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus)` // Set resolved return code |
| 4 | EXEC | `param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message)` // Set resolved error message |

**Block 5** — [SET] `HashMap retrieval` (L~2999)

> Retrieves the target HashMap from the request parameter using `fixedText` as the key. All subsequent error field mappings write into this HashMap.

| # | Type | Code |
|---|------|------|
| 1 | SET | `inMap = (HashMap)param.getData(fixedText)` // e.g., key "EKK0341D010Tv" |

**Block 6 through Block 74** — [IF/IF-Nested] Error field mapping (L~3005-3612)

> For each of the 69 error fields, the method follows an identical pattern:
> 1. Check if the template field is NOT null using `template.isNull(EKK0341D010CBSMsg.FIELD_NAME_ERR)`
> 2. If not null, check if the target map already contains the key using `inMap.containsKey("field_name_err")`
> 3. Only if the key is NOT present, copy the value from template to map using `inMap.put("field_name_err", template.getString(EKK0341D010CBSMsg.FIELD_NAME_ERR))`

> **Business purpose**: This is a **defensive copy** pattern. The CBS layer provides error field data, but a caller may have already populated some fields (e.g., from a previous iteration or from screen input). This ensures the caller-supplied values are preserved while still pulling in any new error fields the CBS returned.

| # | Type | Code | Business Description |
|---|------|------|---------------------|
| 1 | EXEC | `template.isNull(KKTK_SVC_CD_ERR)` | Check: 機器提供サービスコード (Equipment-provided service code) |
| 2 | SET | `inMap.put("kktk_svc_cd_err", template.getString(...))` | Copy: Equipment-provided service code error |
| 3 | EXEC | `template.isNull(PCRS_CD_ERR)` | Check: 料金コースコード (Pricing course code) |
| 4 | SET | `inMap.put("pcrs_cd_err", template.getString(...))` | Copy: Pricing course code error |
| 5 | EXEC | `template.isNull(PPLAN_CD_ERR)` | Check: 料金プランコード (Pricing plan code) |
| 6 | SET | `inMap.put("pplan_cd_err", template.getString(...))` | Copy: Pricing plan code error |
| 7 | EXEC | `template.isNull(KKTK_SBT_CD_ERR)` | Check: 機器提供種類コード (Equipment-provided type code) |
| 8 | SET | `inMap.put("kktk_sbt_cd_err", template.getString(...))` | Copy: Equipment-provided type code error |
| 9 | EXEC | `template.isNull(HDD_CAPA_CD_ERR)` | Check: HDD容量コード (HDD capacity code) |
| 10 | SET | `inMap.put("hdd_capa_cd_err", template.getString(...))` | Copy: HDD capacity code error |
| 11 | EXEC | `template.isNull(SVC_USE_STA_KIBO_YMD_ERR)` | Check: サービス利用開始希望年月日 (Service start preference YMD) |
| 12 | SET | `inMap.put("svc_use_sta_kibo_ymd_err", template.getString(...))` | Copy: Service start preference YMD error |
| 13 | EXEC | `template.isNull(RSV_TSTA_KIBO_YMD_ERR)` | Check: 予約適用開始希望年月日 (Reservation application start preference YMD) |
| 14 | SET | `inMap.put("rsv_tsta_kibo_ymd_err", template.getString(...))` | Copy: Reservation application start preference YMD error |
| 15 | EXEC | `template.isNull(KIBO_MAKER_CD_ERR)` | Check: 希望メーカーコード (Preferred manufacturer code) |
| 16 | SET | `inMap.put("kibo_maker_cd_err", template.getString(...))` | Copy: Preferred manufacturer code error |
| 17 | EXEC | `template.isNull(HAMBAI_SBT_CD_ERR)` | Check: 販売種類コード (Sales type code) |
| 18 | SET | `inMap.put("hambai_sbt_cd_err", template.getString(...))` | Copy: Sales type code error |
| 19 | EXEC | `template.isNull(TSUSHIN_KIKI_SET_CD_ERR)` | Check: 通信機器セットコード (Communication device set code) |
| 20 | SET | `inMap.put("tsushin_kiki_set_cd_err", template.getString(...))` | Copy: Communication device set code error |
| 21-69 | (Same pattern) | See Glossary for field details | Remaining fields: indoor device codes, delivery address fields, installation address fields, trial/install dates, guarantee data, penalty codes, migration division, CAS card, billing contract, and manual input flag |

**Block 75** — [RETURN] (L~3618)

| # | Type | Code |
|---|------|------|
| 1 | RETURN | `return param;` // Return the enriched parameter map with all error fields |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `kktk_svc_cd_err` | Field | Equipment-provided service code error — error value for the service code provided by equipment manufacturer |
| `pcrs_cd_err` | Field | Pricing course code error — error value for the subscription pricing course |
| `pplan_cd_err` | Field | Pricing plan code error — error value for the pricing plan selection |
| `kktk_sbt_cd_err` | Field | Equipment-provided type code error — error value for the type of equipment-provided service |
| `hdd_capa_cd_err` | Field | HDD capacity code error — error value for HDD capacity selection |
| `svc_use_sta_kibo_ymd_err` | Field | Service start preference YMD error — customer's desired service activation date (year-month-day) |
| `rsv_tsta_kibo_ymd_err` | Field | Reservation application start YMD error — customer's preferred date for reservation application to take effect |
| `kibo_maker_cd_err` | Field | Preferred manufacturer code error — customer's equipment manufacturer preference |
| `hambai_sbt_cd_err` | Field | Sales type code error — error value for the sales channel/type classification |
| `tsushin_kiki_set_cd_err` | Field | Communication device set code error — error value for bundled communication device package |
| `taknkiki_sbt_cd_err` | Field | Indoor device type code error — error value for indoor equipment type |
| `taknkiki_model_cd_err` | Field | Indoor device model code error — error value for indoor equipment model |
| `taknkiki_sethin_model_cd_err` | Field | Indoor device product model code error — error value for specific indoor device product model |
| `huzokuhin_sbt_cd_err` | Field | Accessory type code error — error value for service accessories |
| `kiki_stc_saki_place_no_err` | Field | Equipment installation site location number error — location number at installation address |
| `svc_kei_no_err` | Field | Service contract number error — the main service contract number |
| `svc_kei_ucwk_no_err` | Field | Service contract detail number error — line-item detail number within the service contract |
| `svc_kei_kaisen_ucwk_no_err` | Field | Service contract wiring detail number error — wiring detail number within the service contract |
| `op_svc_kei_no_err` | Field | Optional service contract number error — optional/add-on service contract number |
| `sysid_err` | Field | SYSID error — system identifier for the service account |
| `mskm_dtl_no_err` | Field | Application detail number error — detail number of the application record |
| `link_stb_flg_err` | Field | Link STB flag error — flag indicating set-top-box link status (STB = Set-Top Box) |
| `kiki_soryo_um_err` | Field | Equipment delivery charge existence error — whether delivery charges apply |
| `kiki_soryo_saksei_ymd_err` | Field | Equipment delivery charge creation YMD error — date when delivery charge was created |
| `kiki_sohus_nm_err` | Field | Equipment delivery recipient name error — name of the person receiving the equipment |
| `kiki_sohus_kana_err` | Field | Equipment delivery recipient katakana name error — katakana spelling of the delivery recipient |
| `kiki_sohus_ad_cd_err` | Field | Equipment delivery recipient address code error — coded address of delivery recipient |
| `kiki_sohus_pcd_err` | Field | Equipment delivery recipient postal code error — postal code of delivery recipient |
| `kiki_sohus_state_nm_err` | Field | Equipment delivery recipient prefecture name error — prefecture of delivery recipient |
| `kiki_sohus_city_nm_err` | Field | Equipment delivery recipient city name error — city/town/village of delivery recipient |
| `kiki_sohus_oaztsu_nm_err` | Field | Equipment delivery recipient district name error — district within the city |
| `kiki_sohus_azcho_nm_err` | Field | Equipment delivery recipient chome/error — block/cho-level address of delivery recipient |
| `kiki_sohus_bnchigo_err` | Field | Equipment delivery recipient lot number error — lot/banchi number of delivery recipient address |
| `kiki_sohus_adrttm_err` | Field | Equipment delivery recipient address supplement building name error — building name in supplementary address |
| `kiki_sohus_adrrm_err` | Field | Equipment delivery recipient address supplement room number error — room number in supplementary address |
| `kiki_sohus_telno_err` | Field | Equipment delivery recipient phone number error — phone number of delivery recipient |
| `mansion_bukken_no_err` | Field | Mansion property number error — apartment/condominium property identification number |
| `kiki_sohus_ksh_ad_sai_flg_err` | Field | Equipment delivery recipient vs contract address difference flag error — flag indicating if delivery address differs from contract address |
| `kiki_shs_kbt_shitei_flg_err` | Field | Equipment delivery individual designation flag error — flag for individually specified delivery instructions |
| `kiki_shs_hsk_cd_1_err` | Field | Equipment delivery supplementary code 1 error — supplementary delivery code field 1 |
| `kiki_shs_hsk_cd_2_err` | Field | Equipment delivery supplementary code 2 error — supplementary delivery code field 2 |
| `kiki_shs_hsk_memo_err` | Field | Equipment delivery supplementary memo error — free-text delivery instructions |
| `kiki_stc_saki_nm_err` | Field | Equipment installation site recipient name error — name at installation location |
| `kiki_stc_saki_kana_err` | Field | Equipment installation site recipient katakana name error — katakana of installation recipient |
| `kiki_stc_saki_ad_cd_err` | Field | Equipment installation site address code error — coded address at installation location |
| `kiki_stc_saki_pcd_err` | Field | Equipment installation site postal code error — postal code at installation location |
| `kiki_stc_saki_state_nm_err` | Field | Equipment installation site prefecture name error — prefecture at installation location |
| `kiki_stc_saki_city_nm_err` | Field | Equipment installation site city name error — city at installation location |
| `kiki_stc_saki_oaztsu_nm_err` | Field | Equipment installation site district name error — district at installation location |
| `kiki_stc_saki_azcho_nm_err` | Field | Equipment installation site chome error — block at installation location |
| `kiki_stc_saki_bnchigo_err` | Field | Equipment installation site lot number error — lot number at installation location |
| `kiki_stc_saki_adrttm_err` | Field | Equipment installation site building name error — building at installation location |
| `kiki_stc_saki_adrrm_err` | Field | Equipment installation site room number error — room at installation location |
| `kiki_stc_sk_ksh_ad_sai_flg_err` | Field | Equipment installation site vs contract address difference flag error — flag for address mismatch |
| `kiki_stc_sk_telno_err` | Field | Equipment installation site phone number error — phone at installation location |
| `kiki_sts_kkk_seiri_chu_flg_err` | Field | Equipment installation status processing flag error — flag indicating processing status at installation |
| `kiki_sts_hsk_cd_1_err` | Field | Equipment installation supplementary code 1 error — supplementary code for installation site |
| `kiki_sts_hsk_cd_2_err` | Field | Equipment installation supplementary code 2 error — supplementary code for installation site |
| `kiki_sts_hsk_memo_err` | Field | Equipment installation supplementary memo error — memo for installation site |
| `ftrial_kanyu_ymd_err` | Field | Trial installation date error — date of trial/fake installation (仮加入年月日) |
| `honkanyu_ymd_err` | Field | Actual installation date error — date of real installation (本加入年月日) |
| `honkanyu_iko_kigen_ymd_err` | Field | Actual installation deadline YMD error — deadline for completing actual installation |
| `hosho_cd_err` | Field | Guarantee code error — guarantee/collateral type code |
| `hosho_staymd_err` | Field | Guarantee start YMD error — date when guarantee begins |
| `pnlty_hassei_cd_err` | Field | Penalty occurrence code error — code for when penalty/liquidated damages are triggered |
| `ido_div_err` | Field | Migration division error — classification of service migration type |
| `cas_card_use_kyodak_ymd_err` | Field | CAS card usage contract YMD error — date of CAS (Customer Authentication Service) card usage contract |
| `seiky_kei_no_err` | Field | Billing contract number error — billing/contract number for invoicing |
| `kiki_shs_ad_man_input_flg_err` | Field | Equipment delivery address manual input flag error — flag indicating address was manually entered |
| CAANMsg | Technical | Fujitsu message class used for CBS request/response communication; provides `isNull()` and `getString()` accessors |
| IRequestParameterReadWrite | Technical | Interface for bidirectional request parameter container holding form data and control map entries |
| HashMap | Technical | Java utility class for key-value storage; used here as the error field accumulator |
| CBS | Acronym | Component-Based Service — the service layer that communicates with downstream systems |
| BP | Acronym | Business Process / Business Program — the BP-level error tracking system |
| SC | Acronym | Service Component — a modular service unit in the tiered architecture |
| RETURN_CODE | Constant | Control map key for the return/error code; maps to screen-level error status |
| RETURN_MESSAGE | Constant | Control map key for the localized error message text |
| RETURN_MESSAGE_STRING | Constant | `"RETURN_MESSAGE_"` — prefix for resource bundle message key lookup |
| RETURN_MESSAGE_FORMAT | Constant | `"%1$04d"` — format for zero-padded 4-digit status codes |