/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JFUMkmInfoAddFrontiaPreTrnCC
*	ソースファイル名：JFUMkmInfoAddFrontiaPreTrnCC.java
*	作成者			：FJ
*	日付			：2022年01月26日
*＜機能概要＞
*	申込情報登録(フロンティア)事前処理の共通コンポーネントクラスです。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v58.0.0		2022/01/26	FJ			ANK-4217-00-00_一般Webサービス申込機能再構築に伴うAPI作成
*	v58.0.1		2022/03/23	FJ			ANK-4217-02-00_【一般Webサービス申込機能再構築】eo電気同時申込への対応
*	v60.0.0		2022/7/21	FJ			ANK-4231-00-00_OMO構想対応
*	v58.0.2		2022/09/08	FJ) 新谷	ANK-3846-00-00_【クレカ】クリアパス→ペイジェント移行
*	v66.0.0		2023/4/8	FJ) 西川	ANK-4397-00-00_価格COM経由申込のフロンティア巻取り対応
*	v66.0.0		2023/6/8	FJ) 西川	ANK-4412-00-00_FRONTIERからの改善要望対応(2023年6月下旬リリース)
*   v66.0.0     2023/05/24  FJ）張本    ANK-4420-00-00_202307月CP対応
*   v67.0.0     2023/09/05  FJ）美濃原  IT1-2023-0000053
*	v68.0.0		2023/10/30	FJ) 西川    ANK-4416-00-00_紹介コード、提携先企業向けエントリーコード同時入力対応
*	v70.0.0		2024/02/26	FJ) 飯田    ANK-4546-00-00_オプションチャンネル変更対応
*   v67.0.0		2023/08/09	FJ) 西川	ANK-4467-00-00_FRONTIERのマンション導線巻き取りに伴うAPI変更
*	v67.1.0		2024/06/04	FJ) 張本	ANK-4467-00-00_FRONTIERのマンション導線巻き取りに伴うAPI変更
*   v72.0.0		2024/05/08	FJ) 美濃原	ANK-4494-00-00_【eo定期】 双方向番ポ対応
*   v72.0.1		2024/10/16	FJ) 美濃原	ANK-4494-19-00_【双方向番ポ対応】 FRONTIERの利用場所住所連携内容変更
*   v73.00      2024/11/19  FJ) 張本    【ANK-4427-00-00】NTT卸対応
*   v75.0.0		2025/05/07	FJ) 橋本	ANK-4619-00-00_3Dセキュア対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JFUMkmInfoAddFrontiaConstCC;
import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.model.common.check.LengthCheck;
import com.fujitsu.futurity.model.common.check.MixCharCheck;
import com.fujitsu.futurity.model.ejb.common.JSYejbLog;

import eo.common.constant.JFUStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JFUCommonUtil;
import eo.common.util.JFUMkmInfoAddUtil;
import eo.ejb.cbs.cbsmsg.ECK0131B020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0131B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EDK0451A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EDK0451A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EFU0381A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EFU0381A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0311A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0311A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0511A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0511A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0591B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0591B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0841B509CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0841B509CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0841B510CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0841B510CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0851B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1351B501CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1351B501CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1371B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1621B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1621B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2041B501CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2041B501CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3281B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK3281B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ETU0051A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ETU0051A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0111B040CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0111B040CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg1List;


/**
* 申込情報登録(フロンティア)事前処理の共通コンポーネントクラスです。
 * <BR>
 * @author FJ
 */
public class JFUMkmInfoAddFrontiaPreTrnCC extends AbstractCommonComponent
{
	/** インスタンス */
	private JFUMkmInfoAddFrontiaWorkArea workArea = new JFUMkmInfoAddFrontiaWorkArea();
	private JFUMkmInfoAddFrontiaUtil chkUtil = new JFUMkmInfoAddFrontiaUtil();
	private JFUMkmInfoAddFrontiaMapper mapper = new JFUMkmInfoAddFrontiaMapper();
	/** テンプレートID */
	private static final String TEMPLATE_ID_EFU0381A010 = "EFU0381A010";
	private static final String TEMPLATE_ID_ECK0131B020 = "ECK0131B020";
	private static final String TEMPLATE_ID_ETU0051A010 = "ETU0051A010";
	private static final String TEMPLATE_ID_EZM0321A010 = "EZM0321A010";
	private static final String TEMPLATE_ID_EKK2041B501 = "EKK2041B501";
	private static final String TEMPLATE_ID_EKK1621B001 = "EKK1621B001";
	private static final String TEMPLATE_ID_EKK0591B003 = "EKK0591B003";
	private static final String TEMPLATE_ID_EZM0411A010 = "EZM0411A010";
	private static final String TEMPLATE_ID_EKK1351B501 = "EKK1351B501";
	private static final String TEMPLATE_ID_EKK0841B509 = "EKK0841B509";
	private static final String TEMPLATE_ID_EDK0451A010 = "EDK0451A010";
	private static final String TEMPLATE_ID_EKK0511A010 = "EKK0511A010";
	private static final String TEMPLATE_ID_EZM0111B040 = "EZM0111B040";
	private static final String TEMPLATE_ID_EKK3281B010 = "EKK3281B010";
	private static final String TEMPLATE_ID_EKK0851B001 = "EKK0851B001";
	private static final String TEMPLATE_ID_EKK1371B001 = "EKK1371B001";
	private static final String TEMPLATE_ID_EKK0311A010 = "EKK0311A010";
	private static final String TEMPLATE_ID_EKK0841B510 = "EKK0841B510";

	/**
	* 申込情報登録(フロンティア)事前処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return リクエストパラメータ
	 * @throws Throwable 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite execute(SessionHandle handle, 
																IRequestParameterReadWrite param, 
																String fixedText) throws Throwable
	{
		Map<String, Object> ccMsg = (Map<String, Object>) param.getData(fixedText);
		String funcCode = (String) ccMsg.get(JFUMkmInfoAddFrontiaConstCC.FUNC_CODE);
		
		List<Map<String, String>> errorList = new ArrayList<Map<String, String>>();

		// 処理区分が "3":本申込 でない場合はエラー
		if (!JFUMkmInfoAddFrontiaConstCC.FUNC_CODE_CONF.equals(funcCode)) {
			errorList.add(chkUtil.getItemErrInfMap(
					ccMsg,
					JFUMkmInfoAddFrontiaConstCC.FUNC_CODE,
					JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1002));
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return param;
		}
		
		// 登録時に内容設定されていたらエラー
		if (!checkNode(ccMsg))
		{
			errorList.add(chkUtil.getItemErrInfMap(
					ccMsg,
					JFUMkmInfoAddFrontiaConstCC.FUNC_CODE,
					JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1006));
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return param;
		}
		
		String opeDate = JCCBPCommon.getOpeDate(null);
		String opeDateTimeStamp = JCCBPCommon.getOpeDateTimeStamp(null);

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// Web申込内容一時保存一意照会
		// 受付番号
		String mskmsho_no = (String) ccMsg.get(JFUMkmInfoAddFrontiaConstCC.MSKMSHO_NO);
		if (JFUBPCommon.isNull(mskmsho_no))
		{
			// 受付番号がない
			errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MSKMSHO_NO,
					JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1001));
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return param;
		}
		CAANMsg efu0381a010Msg = chkUtil.execEFU0381A010Merge(handle, scCall, param, fixedText, mskmsho_no);
//		CAANMsg[] efu0381a010Msg = execEFU0381A010(handle, scCall, param, fixedText, mskmsho_no);
		String mskmNaiyo = JFUStrConst.EMPTY;
		String upd_dtm_bf = JFUStrConst.EMPTY;
		String mskmStat = JFUStrConst.EMPTY;
		if (efu0381a010Msg != null) {
			mskmNaiyo = efu0381a010Msg.getString(EFU0381A010CBSMsg1List.MSKM_NAIYO);
			upd_dtm_bf = efu0381a010Msg.getString(EFU0381A010CBSMsg1List.UPD_DTM);
			mskmStat = efu0381a010Msg.getString(EFU0381A010CBSMsg1List.WEBMK_STAT);
		} else {
			// 受付番号が存在しない
			errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MSKMSHO_NO,
					JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1101));
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return param;
		}
		
		// Web申込ステータスが010:受付済以外の場合は処理終了
		if (!"010".equals(mskmStat))
		{
			errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MSKMSHO_NO,
					JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1101));
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return param;
		}
		
		// 申込内容をMap形式に変換
		Map<String, Object> mapMskmNaiyo = JFUMkmInfoAddUtil.jsonToMap(mskmNaiyo);

		// データチェック
		/* 単項目チェック */
		boolean chkResult1 = chkUtil.checkUnitParam(mapMskmNaiyo);
		
		/* コード値チェック */
		boolean chkResult2 = chkUtil.checkCodeParam(mapMskmNaiyo);
		
		// すべての処理区分でのチェック
		boolean chkResult6 = chkUtil.checkAllFuncCode(handle, scCall, param, fixedText, mapMskmNaiyo);

		// workエリアへ値をセット
		workArea.setMskmsho_no(mskmsho_no);
		chkUtil.setWorkArea(workArea, mapMskmNaiyo);

		//ANK-4467-00-00 ADD START
		if (JFUMkmInfoAddFrontiaUtil.isTypeMTMZ(workArea))
		{
			// ホームタイプ以外（メゾンタイプ／マンションタイプ）

			// eo光導入物件情報検索基底コモンコンポーネントから物件データ取得
			searchEohDnBkn(handle, param, fixedText, workArea);
		}
		//ANK-4467-00-00 ADD END

		/* 単関連チェック */
		boolean chkResult3 = chkUtil.checkKnrnParam(ccMsg, workArea);
		/* 日付チェック */
		boolean chkResult4 = chkUtil.checkDate(ccMsg, workArea);
		/* コード値チェック(マスタ) */
		boolean chkResult5 = checkCodeToMaster(handle, scCall, param, fixedText, ccMsg);
		if (!chkResult1 || !chkResult2 || !chkResult3 || !chkResult4 || !chkResult5 || !chkResult6)
		{
			return param;
		}

		// データ取得
		// 棚コード
		String shelf_cd = execEDK0451A010(handle, scCall, param, fixedText, opeDate);
		workArea.setShelf_cd(shelf_cd);
		// ストリーミングメディアプレーヤー型番
		String smp_model_no = execEZM0321A010(handle, scCall, param, fixedText, "SMP_MODEL_NO");
		workArea.setSmp_model_no(smp_model_no);
		// 端末購入受付担当者
		String smp_buy_uk_tntsha_nm = execEZM0321A010(handle, scCall, param, fixedText, JFUStrConst.KK_TNMT_BUY_UK_WEB);
		workArea.setSmp_buy_uk_tntsha_nm(smp_buy_uk_tntsha_nm);
		// メッシュＷｉ−Ｆｉ定義
		String mesh_wifi_min_cnt = execEZM0321A010(handle, scCall, param, fixedText, "MESH_WIFI_INFO");
// ANK-4432-00-00 MOD START
		String taknkiki_model_cd = null;
		// 無線LAN中継器かメッシュWi-Fiの申込がある場合
		if("1".equals(workArea.plc_mskm) || "1".equals(workArea.mesh_wifi))
		{
			// 宅内機器型式コード定義
			taknkiki_model_cd = execEKK2041B501(handle, scCall, param, fixedText, workArea.plc_mskm, workArea.mesh_wifi);
			if(JFUCommonUtil.isNull(taknkiki_model_cd)){
				if("1".equals(workArea.plc_mskm))
				{
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.PLC_MSKM,
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_3001));
				}else{
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MESH_WIFI,
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_3001));
				}
				ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
				return param;
			}
		}
// ANK-4432-00-00 MOD END
		// キャンペーンチェックリスト（Ｎｅｔ）
		String[] camp_chk_list_netsvc = execEZM0321A010(handle, scCall, param, fixedText, "CAMP_CHK_LIST_NETSVC").split(",");

		// 取扱コード1-1
		ccMsg.put(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_1_1, nullToStr((String)mapMskmNaiyo.get(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_1_1)));
		// 取扱コード1-2
		ccMsg.put(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_1_2, nullToStr((String)mapMskmNaiyo.get(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_1_2)));
		// 取扱コード2-1
		ccMsg.put(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_2_1, nullToStr((String)mapMskmNaiyo.get(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_2_1)));
		// 取扱コード2-2
		ccMsg.put(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_2_2, nullToStr((String)mapMskmNaiyo.get(JFUMkmInfoAddFrontiaConstCC.TRAT_CD_2_2)));
// ANK-4619-00-00 ADD START
		//支払方法選択が「2:クレジット」の場合、出力カナ名を取得
		if("2".equals(workArea.getPayway()))
		{
			// クレジットカード名称変換CC
			callJCCCrecardNmChgeCC(handle, param);
			Map<String, Object> creCardNmChgeMap = (HashMap)param.getData("JCCCrecardNmChgeCC");
			if(!JFUBPCommon.isNull(creCardNmChgeMap) && !JFUBPCommon.isNull(creCardNmChgeMap.get("out_kana")))
			{
				// 属性、桁数エラー有の場合
				if(creCardNmChgeMap.containsKey(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO))
				{
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CR_CARDNMKANA,
							(String)creCardNmChgeMap.get(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO)));
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CRECARD_NM_ROMAJI,
							(String)creCardNmChgeMap.get(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO)));
					ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
					return param;
				}
				workArea.setCr_cardNmKana((String)creCardNmChgeMap.get("out_kana"));
			}
		}
// ANK-4619-00-00 ADD END
		
		/** 住所分割処理 **/
		// ■利用場所住所、機器提供サービス利用場所住所の設定
		// ※※※ フロンティアの利用場所住所について ※※※
		// Add2に丁目まで設定。ホームは"丁目"の文字列はセットされない前提。
		// Add3は番地号のみセットされる。

		HashMap<String, Object> inUsePlaceAddress = new HashMap<String, Object>();

		// 共通情報のマッピング
		inUsePlaceAddress.put("func_code", JPCModelConstant.FUNC_CD_1);

		// 都道府県・市区町村
		inUsePlaceAddress.put("state_city", workArea.getAdd1());
		// 字・丁目           旧日本語名称：字
		inUsePlaceAddress.put("aza_chome", workArea.getAdd2());
		// 番地等             旧日本語名称：丁目・番地等
		inUsePlaceAddress.put("bnchi", workArea.getAdd3());

		param.setData("FUSV016006CC", inUsePlaceAddress);
		JFUSplitAddressInfoChomeCC editAddress = new JFUSplitAddressInfoChomeCC();
		editAddress.splitAddressInfo(handle, param, "FUSV016006CC");

		HashMap<String, Object> outUsePlaceAddress = (HashMap)param.getData("FUSV016006CC");
		printlnEjbLog("【editAd 修正分 戻り値】\n" + getMsgEditAd(outUsePlaceAddress));

		// 住所マスタに「字・丁目」が存在する場合は、その文字列"丁目"丁"つきで返却される。
		// 注）「字・丁目」の末尾が数字、かつ、「番地等」の開始文字が数字の場合は、"−"を「字・丁目」がセットされる。
		outUsePlaceAddress.put("bnchigo", outUsePlaceAddress.get("after_bnchi"));
		outUsePlaceAddress.put("pcd", workArea.getZip());
		outUsePlaceAddress.put("adrttm", workArea.getAdd4());
		outUsePlaceAddress.put("adrrm", workArea.getAdd5());
		printlnEjbLog("【editAd in】\n" + getMsgEditAd(inUsePlaceAddress));
		printlnEjbLog("【editAd out】\n" + getMsgEditAd(outUsePlaceAddress));

		// editedLineAddress = JKKBpCommon.editAd(handle, param, lineAddress, fixedText);

		addressEdit(param, "FUSV015211CC", outUsePlaceAddress);
		addressEdit(param, "FUSV016006CC", outUsePlaceAddress);
		// ■契約者住所の設定
		Map<String, Object> editedContractorAddress = null;
		if ("1".equals(workArea.getKshadd_cmf()))
		{
			// 契約者住所選択が「1:利用住所と同じ」の場合
			// 利用場所住所を設定

			addressEdit(param, "FUSV015212CC", outUsePlaceAddress);
		}
		else
		{
			// 契約者住所選択が「2:利用住所と異なる」の場合
			// 契約者住所を設定

			Map<String, Object> contractorAddress = new HashMap<String, Object>();
			contractorAddress.put("edit_mode", "1");
			contractorAddress.put("pcd", workArea.getKsh_pcd());
			contractorAddress.put("state_nm", "");
			contractorAddress.put("city_nm", "");
			contractorAddress.put("oaztsu_nm", "");
			contractorAddress.put("azcho_nm", "");
			contractorAddress.put("bnchigo", workArea.getKsh_Address1() + workArea.getKsh_Address1_bnchigo());
			contractorAddress.put("adrttm", workArea.getKsh_Address2());
			contractorAddress.put("adrrm", workArea.getKsh_Address3());

			editedContractorAddress = JKKBpCommon.editAd(handle, param, contractorAddress, fixedText);

			addressEdit(param, "FUSV015212CC", editedContractorAddress);

		}

		// ■番号ポータビリティ利用住所の設定（1番号目）
		if ("1".equals(workArea.getUse_bmp_1()))
		{
			// 番ポ利用有無＿１が「1:利用する」の場合

			// 番ポ・設置場所住所選択
			String bmpStcPlaceAdChoice = workArea.getBmp_stc_place_ad_choice_1();

			if ("1".equals(bmpStcPlaceAdChoice))
			{
				// 番ポ・設置場所住所選択＿１が「1:利用場所住所と同じ」の場合
				// 利用場所住所を設定
				addressEdit(param, "FUSV016008CC", outUsePlaceAddress);
			}
			else if ("2".equals(bmpStcPlaceAdChoice))
			{
				// 番ポ・設置場所住所選択＿１が「2:契約者住所と同じ」の場合

				if ("1".equals(workArea.getKshadd_cmf()))
				{
					// 契約者住所選択が「1:利用住所と同じ」の場合
					// 利用場所住所を設定
					addressEdit(param, "FUSV016008CC", outUsePlaceAddress);
				}
				else
				{
					// 契約者住所選択が「2:利用住所と異なる」の場合
					// 契約者住所を設定
					addressEdit(param, "FUSV016008CC", editedContractorAddress);
				}
			}
			else
			{
				// 番ポ・設置場所住所選択＿１が「3:その他住所」の場合

				// フロンティアから連携された住所を設定
				Map<String, Object> bmpAddress = new HashMap<String, Object>();
				bmpAddress.put("edit_mode", "1");
				bmpAddress.put("pcd", workArea.getBmp_pcd_1());
				bmpAddress.put("state_nm", "");
				bmpAddress.put("city_nm", "");
				bmpAddress.put("oaztsu_nm", "");
				bmpAddress.put("azcho_nm", "");
				bmpAddress.put("bnchigo", workArea.getBmp_Address1_1() + workArea.getBmp_Address1_1_bnchigo());
				bmpAddress.put("adrttm", workArea.getBmp_Address2_1());
				bmpAddress.put("adrrm", workArea.getBmp_Address3_1());

				Map<String, Object> editedBmpAddress = JKKBpCommon.editAd(handle, param, bmpAddress, fixedText);
				addressEdit(param, "FUSV016008CC", editedBmpAddress);
			}
		}

		// ■番号ポータビリティ利用住所の設定（2番号目）
		if ("1".equals(workArea.getUse_bmp_2()))
		{
			// 番ポ利用有無＿２が「1:利用する」の場合

			// 番ポ・設置場所住所選択
			String bmpStcPlaceAdChoice = workArea.getBmp_stc_place_ad_choice_2();

			if ("1".equals(bmpStcPlaceAdChoice))
			{
				// 番ポ・設置場所住所選択＿２が「1:利用場所住所と同じ」の場合
				// 利用場所住所を設定
				addressEdit(param, "FUSV016009CC", outUsePlaceAddress);
			}
			else if ("2".equals(bmpStcPlaceAdChoice))
			{
				// 番ポ・設置場所住所選択＿２が「2:契約者住所と同じ」の場合

				if ("1".equals(workArea.getKshadd_cmf()))
				{
					// 契約者住所選択が「1:利用住所と同じ」の場合
					// 利用場所住所を設定
					addressEdit(param, "FUSV016009CC", outUsePlaceAddress);

				}
				else
				{
					// 契約者住所選択が「2:利用住所と異なる」の場合
					// 契約者住所を設定
					addressEdit(param, "FUSV016009CC", editedContractorAddress);
				}
			}
			else
			{
				// 番ポ・設置場所住所選択＿２が「3:その他住所」の場合

				// フロンティアから連携された住所を設定
				Map<String, Object> bmpAddress = new HashMap<String, Object>();
				bmpAddress.put("edit_mode", "1");
				bmpAddress.put("pcd", workArea.getBmp_pcd_2());
				bmpAddress.put("state_nm", "");
				bmpAddress.put("city_nm", "");
				bmpAddress.put("oaztsu_nm", "");
				bmpAddress.put("azcho_nm", "");
				bmpAddress.put("bnchigo", workArea.getBmp_Address1_2() + workArea.getBmp_Address1_2_bnchigo());
				bmpAddress.put("adrttm", workArea.getBmp_Address2_2());
				bmpAddress.put("adrrm", workArea.getBmp_Address3_2());

				Map<String, Object> editedBmpAddress = JKKBpCommon.editAd(handle, param, bmpAddress, fixedText);
				addressEdit(param, "FUSV016009CC", editedBmpAddress);
			}
		}

		// DataMap作成
//		// 住所情報分割CC（利用場所住所）
//		mapper.setFUSV015211CC(workArea, param);
//		// 住所情報分割CC（契約者住所）
//		mapper.setFUSV015212CC(workArea, param);
//		// 住所情報分割CC（機器提供サービス利用場所住所）
//		mapper.setFUSV016006CC(workArea, param);
//		// 住所情報分割CC（番号ポータビリティ利用住所）
//		mapper.setFUSV016008CC(workArea, param);
		// お客様登録変更CC
		mapper.setJFUCustCC(workArea, param);
		if (JFUStrConst.KEI_SBT_KOJINCD.equals(workArea.getKei_sbt()))
		{
			// 個人の場合
			mapper.setECK0021D010(workArea, param, opeDate);		}
		else if (JFUStrConst.KEI_SBT_HOJINCD.equals(workArea.getKei_sbt()))
		{
			// 法人の場合
			mapper.setECK0031D010(workArea, param, opeDate);
		}
		mapper.setECK0201D010(workArea, param);
		// 申込書明細番号採番CC
		mapper.setJFUMskmshoDtlSibnCC(workArea, param);
		// 申込断面登録CC
		mapper.setMskmDmenXmlMap(workArea, param);
		// 申込内容承認登録SC
		mapper.setEKK0011D020(workArea, param, opeDateTimeStamp, opeDate);
		// 請求口座追加CC
		mapper.setJFUAddSeikyKozaCC(workArea, param);
		// 請求契約登録SC
		mapper.setEKK0491D010(workArea, param, opeDate);
		// クレジット会社一覧照会
		mapper.setEKK0531B501(workArea, param);
		// オーソリ実績登録CC
		mapper.setJFUAuthCheckCCWork(workArea, param);
		// 審査済クレジットカード登録SC
		mapper.setEKK0521D020(workArea, param, opeDateTimeStamp);
		// 審査済クレジットカード登録SC
		mapper.setEKK0521D010(workArea, param);
		mapper.setEKK1031D010(workArea, param);
		// eo光ネット登録CC
		if (workArea.getEonet())
		{
			// サービス契約＜eo光ネット＞登録SC
// ANK-4427-00-00 MOD START
//			mapper.setEKK0091D010(workArea, param);
			mapper.setEKK0091D010(workArea, param, opeDate);
// ANK-4427-00-00 MOD END
			// サービス契約内訳＜eo光ネット＞登録SC
			mapper.setEKK0171D010(workArea, param);
			// オプションサービス＜ISP＞登録CC
			mapper.setEKK0361D010(workArea, param);
		}
		// eo光電話登録CC
		if (workArea.getEotel())
		{
			// サービス契約＜eo光電話＞登録SC
			mapper.setEKK0111D010(workArea, param);
			// サービス契約内訳＜eo光電話＞登録SC
			mapper.setEKK0191D010(workArea, param);
			// 機器オプションサービス契約一覧照会(フロント)SC
			mapper.setEKK2811B503(workArea, param);
			// 機器提供サービス契約一覧照会SC
			mapper.setEKK0341B002(workArea, param);
			// 機器提供サービス登録＜eo光電話＞SC
			mapper.setEKK0341D01002(workArea, param);
			// 機器オプションサービス契約登録＜eo光電話＞SC
			mapper.setEKK2811D010(workArea, param);
			// 機器オプションサービス契約登録＜eo光ネット＞SC
			mapper.setEKK2811D01002(workArea, param);
			// 業務パラメータ管理一意照会SC
			// オプションサービス契約登録＜eo光電話＞SC
			mapper.setEZM0321A010(workArea, param);
			// オプションサービス契約登録＜eo光電話＞SC
			mapper.setEKK0371D010_1(workArea, param);
			// 割引サービス契約登録＜eo光電話パック＞
			mapper.setEKK0451D01001(workArea, param, opeDate);
			if ("2".equals(workArea.getEotel_course()))
			{
				mapper.setEKK0451D01002(workArea, param, opeDate);
			}
		}
		else if (workArea.getEotelTypeN())
		{
			// 番号ポータビリティ利用住所情報分割処理上りマッピング
			mapper.setFUSV016008TypeNCC(workArea, param);
			// オプションサービス契約＜ISP＞登録 TypeN用
			mapper.setJKKNttorsNetTelInfOperateCC(workArea, param);
			// データ移送CC TypeN更新用
			mapper.setFUSV035689CC(workArea, param);
		}
		// ONU／モデム登録
		if (workArea.getEonet() || workArea.getEotel())
		{
			// 機器提供サービス登録CC
			mapper.setEKK0341D01005(workArea, param);
			mapper.setEKK0341D01001(workArea, param);
		}
		// eo光テレビ登録CC
		if (workArea.getEotv())
		{
			// サービス契約＜eo光TV＞登録SC
			mapper.setEKK0101D010(workArea, param);
			// 機器提供サービス＜ｅｏ光テレビ＞VONU
			mapper.setEKK0341D01006(workArea, param);
			if ("2".equals(workArea.getEo_tv_course()))
			{
				// サービス契約内訳＜eo光TV＞登録
				mapper.setEKK0181D010(workArea, param);
				// 機器提供サービス＜eo光テレビ＞
				mapper.setEKK0341D01003(workArea, param);
			}
		}
		// 機器提供サービス契約キャンセルSC
		mapper.setEKK0341C330(workArea, param);
		// 割引サービス自動適用CC
		mapper.setJKKWrisvcAutoAplyCC(workArea, param);
		// 機器提供サービス契約登録(多機能ルーター)
		mapper.setEKK0341D010Tkn(workArea, param);
		// 機器オプションサービス契約＜eo光ネット＞
		mapper.setEKK2811D010Net02(workArea, param);
		// 機器オプションサービス契約登録＜eo光電話＞
		mapper.setEKK2811D010Tel02(workArea, param);
		// 機器オプションサービス契約一覧照会(フロント)
		mapper.setEKK2811B50302(workArea, param);
		// 機器提供サービス契約一覧照会
		mapper.setEKK0341B00202(workArea, param);
		// オプションサービス契約＜サポート＞登録
		mapper.setEKK0391D010(workArea, param, opeDate);
		// サービス契約一意照会
		mapper.setEKK0091A010(workArea, param);
		if (!JFUMkmInfoAddFrontiaUtil.isTypeN(workArea))
		{
			// サービス契約内訳＜eo光電話＞情報変更
			mapper.setEKK0191C012(workArea, param);
			// サブオプションサービス契約＜電話＞登録
			mapper.setEKK0431D010(workArea, param);
		}
		// 利用場所情報登録CC
		mapper.setEKK0251D010(workArea, param);
		// 回線対象サービス契約登録
		mapper.setEKK0241D010(workArea, param);
		// サービス契約グループ設定登録
		mapper.setEKK2961D010(workArea, param);
		// 工事費割賦契約登録SC
		mapper.setFUSV015233SC(workArea, param);
		// 工事費割賦契約登録実行判定SC
		mapper.setFUSV015233ReqChk(workArea, param);
		// スターチャンネルセット割CC
		mapper.setFUSV015229CC(workArea, param, opeDate);
		// スターチャンネルセット割実行判定CC
		mapper.setFUSV015229ReqChk(workArea, param);
		// 申込時登録不可契約予約登録CC
		mapper.setFUSV015230CC(workArea, param, opeDate);
		// 申込時登録不可契約予約登録実行判定CC
		mapper.setFUSV015230ReqChk(workArea, param);
		// オプトインメール受信設定登録CC
		mapper.setFUSV015232CC(workArea, param);
// ANK-4432-00-00 MOD START
		// eo光ネットオプション登録CC
		mapper.setEKK0341D010(workArea, param, mesh_wifi_min_cnt, taknkiki_model_cd);
// ANK-4432-00-00 MOD END
		// 機器オプションサービス契約登録フローCC
		mapper.setJFUVaKikiCancelCC(workArea, param);
		// サービス契約<eo光ネット>一意照会
		mapper.setFUSV016040SC(workArea, param);
		// セキュリティパック操作CC
		mapper.setJKKSecurityPackOperateCC(workArea, param);
		if (!JFUMkmInfoAddFrontiaUtil.isTypeN(workArea))
		{
			// サービスIF結果データ移送CC
			mapper.setTransferCC(workArea, param);
			// 番ポ電話番号登録可否チェックCC
			mapper.setJFUBmpTelNoAddChkCC(workArea, param);
			// 同番移転可能エリアチェックCC
			mapper.setJKKChkDobanitenPsbAreaCC(workArea, param);
			// 電話番号マスタ変更(JFUMstTelNoUpdCC) ※電話番号マスタに存在する番ポ電話番号の場合に更新処理を行う。
			mapper.setJFUMstTelNoUpdCC(workArea, param);
			// eo光電話オプション登録 ※電話番号マスタに存在しない番ポ電話番号の登録を行う。
			mapper.setEZM0121D010(workArea, param);
			// エイジング対象登録
			mapper.setEZM0111D010(workArea, param);
			// オプションサービス契約＜電話＞登録
			mapper.setEKK0371D010_2(workArea, param);
		}
		// eo光テレビオプション登録
		mapper.setEKK0381D010(workArea, param);
		// データ抽出項目コード登録CC
		mapper.setFUSV016034CC(workArea, param);
		// 割引サービスコード登録CC
		mapper.setFUSV016033CC(workArea, param, camp_chk_list_netsvc);
		// 進捗登録SC
		mapper.setEKK1091D010(workArea, param);
		// 代理店登録CC
		mapper.setJFUAddAgntCC(workArea, param);
		// 申込画面入力支援ワーク登録SC
		mapper.setEKK2201D010(workArea, param);
//		if (JFUStrConst.ELEC_GUIDE_KIBO_ARI.equals(workArea.getElec_guide_kibo()))
//		{
//			// CASEファイル作成ワーク登録SC
//			mapper.setECR0511D010(workArea, param, opeDate);
//		}
		if ("1".equals(workArea.getKk_comp_pc_mskm()) || "1".equals(workArea.getKk_comp_pcw_mskm()) || "1".equals(workArea.getKk_comp_tv_mskm()))
		{
			// おうちの機器補償サービス登録CC
			mapper.setJKKTmcpOperateCC(workArea, param, opeDate);
		}

		if (workArea.getEonet())
		{
			if (!JFUBPCommon.isNull(workArea.getRed_introduce()) && workArea.getRed_introduce().matches("[A-Z][0-9]{9}"))
			{
				// 紹介一意照会SC
				mapper.setFUSV016044SC(workArea, param);
				// 紹介更新SC
				mapper.setFUSV016043SC(workArea, param);
			}
			if (!JFUBPCommon.isNull(workArea.getCoupon_cd()) && isUpdAbleCouponCd(handle, scCall, param, fixedText))
			{
				// クーポンコードの登録
				// 紹介一意照会SC
				mapper.setFUSV015216SC(workArea, param);
				// 紹介更新SC
				mapper.setFUSV015218SC(workArea, param);
			}
		}
		mapper.setEFU0381C020(workArea, param, upd_dtm_bf, opeDateTimeStamp);
		return param;
	}

	/**
	 * 下りマッピング
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite getDatamap(SessionHandle handle, 
			IRequestParameterReadWrite param, 
			String fixedText) throws Throwable
	{
		Map<String, Object> fusv035601ccMsg = (Map<String, Object>) param.getData("FUSV035601CC");

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// Web申込内容一時保存一意照会
		// 受付番号
		String mskmsho_no = (String) fusv035601ccMsg.get(JFUMkmInfoAddFrontiaConstCC.MSKMSHO_NO);
		CAANMsg efu0381a010Msg = chkUtil.execEFU0381A010Merge(handle, scCall, param, fixedText, mskmsho_no);
//		CAANMsg[] efu0381a010Msg = execEFU0381A010(handle, scCall, param, fixedText, mskmsho_no);
		String mskmNaiyo = JFUStrConst.EMPTY;
		mskmNaiyo = efu0381a010Msg.getString(EFU0381A010CBSMsg1List.MSKM_NAIYO);

		// 申込内容をMap形式に変換
		Map<String, Object> mapMskmNaiyo = JFUMkmInfoAddUtil.jsonToMap(mskmNaiyo);

		// workエリアへ値をセット
		workArea.setMskmsho_no(mskmsho_no);
		chkUtil.setWorkArea(workArea, mapMskmNaiyo);
		
		if (JFUMkmInfoAddFrontiaUtil.isTypeMTMZ(workArea))
		{
			// ホームタイプ以外（メゾンタイプ／マンションタイプ）

			// マンション検索結果リスト
			List<Map<String, Object>> resultList = (List<Map<String, Object>>)fusv035601ccMsg.get(JFUEohDnBknSearchBaseCC.RES_MANSION_SEARCH_LIST);

			if (resultList != null && resultList.size() == 1)
			{
				// 物件データをworkAreaにセットする
				chkUtil.setWorkAreaFromBknData(workArea, resultList.get(0));
			}
		}

		HashMap<String, Object> parentMap = new HashMap<String, Object>();
		HashMap<String, Object> childMap = new HashMap<String, Object>();
		
		// SYSID
		String kei_sbt = workArea.getKei_sbt();
		parentMap = (HashMap)param.getData("FUSV015201CC");
		
		if (JFUStrConst.KEI_SBT_KOJINCD.equals(kei_sbt))
		{
			childMap = (HashMap)param.getData("ECK0021D010");
		}
		else if (JFUStrConst.KEI_SBT_HOJINCD.equals(kei_sbt))
		{
			childMap = (HashMap)param.getData("ECK0031D010");
		}
		workArea.setSysid((String)childMap.get("sysid"));
		fusv035601ccMsg.put("sysid", workArea.getSysid());
		
		// サービス契約番号(eo光ネット)
		String okid_net = "";
		if (workArea.getEonet())
		{
			parentMap = new HashMap<String, Object>();
			parentMap = (HashMap)param.getData("EKK0091D010");
			okid_net = (String)parentMap.get("svc_kei_no");
		}
		workArea.setSvc_kei_no_net(okid_net);
		// サービス契約番号(eo光電話)
		String okid_tel = "";
		if (workArea.getEotel())
		{
			parentMap = new HashMap<String, Object>();
			parentMap = (HashMap)param.getData("EKK0111D010");
			okid_tel = (String)parentMap.get("svc_kei_no");
		}
		workArea.setSvc_kei_no_tel(okid_tel);
		// サービス契約番号(eo光TV)
		String okid_tv = "";
		if (workArea.getEotv())
		{
			parentMap = new HashMap<String, Object>();
			parentMap = (HashMap)param.getData("EKK0101D010");
			okid_tv = (String)parentMap.get("svc_kei_no");
		}
		workArea.setSvc_kei_no_tv(okid_tv);

		// サービス契約番号（ネット）
		fusv035601ccMsg.put("okid_net", okid_net);
		// サービス契約番号（電話）
		fusv035601ccMsg.put("okid_tel", okid_tel);
		// サービス契約番号（テレビ）
		fusv035601ccMsg.put("okid_tv", okid_tv);

		// 申込
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("FUSV035614SC");
		if (parentMap != null)
		{
			// 申込番号
			workArea.setMskm_no((String)parentMap.get("mskm_no"));
			// 申込書明細番号
			workArea.setMskm_dtl_no_net((String)parentMap.get("ekk0091_mskm_dtl_no"));
			workArea.setMskm_dtl_no_tel((String)parentMap.get("ekk0111_mskm_dtl_no"));
			workArea.setMskm_dtl_no_tv((String)parentMap.get("ekk0101_mskm_dtl_no"));
		}
		
		// サービス契約内訳(eo光ネット)
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("EKK0171D010");
		if (parentMap != null)
		{
			workArea.setSvc_kei_ucwk_no_net((String)parentMap.get("svc_kei_ucwk_no"));
		}
		// サービス契約内訳(eo光電話)
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("EKK0191D010");
		int cntAry = 0;
		childMap = new HashMap();
		if (parentMap != null)
		{
			cntAry = ((ArrayList)parentMap.get("EKK0191D010List")).size();
			for (int i = 0; i < cntAry; i++)
			{
				childMap = (HashMap)((ArrayList)parentMap.get("EKK0191D010List")).get(i);
				if (i == 0)
				{
					workArea.setSvc_kei_ucwk_no_tel1((String)childMap.get("svc_kei_ucwk_no"));
				} else {
					workArea.setSvc_kei_ucwk_no_tel2((String)childMap.get("svc_kei_ucwk_no"));
				}
			}
		}
		// サービス契約内訳(eo光TV)
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("EKK0181D010");
		if (parentMap != null)
		{
			childMap = new HashMap();
			childMap = (HashMap)((ArrayList)parentMap.get("EKK0181D010List")).get(0);
			workArea.setSvc_kei_ucwk_no_tv((String)childMap.get("svc_kei_ucwk_no"));
		}
		
		// 回線内訳番号
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("EKK0251D010");
		// 1回線しか対応しないので1番目の未取得
		if (parentMap != null)
		{
			childMap = new HashMap();
			childMap = (HashMap)((ArrayList)parentMap.get("EKK0251D010List")).get(0);
			workArea.setSvc_kei_kaisen_ucwk_no((String)childMap.get("svc_kei_kaisen_ucwk_no"));
		}

		// 請求契約番号
		parentMap = new HashMap<String, Object>();
		parentMap = (HashMap)param.getData("EKK0491D010");
		if (parentMap != null)
		{
			workArea.setSeiky_kei_no((String)parentMap.get("seiky_kei_no"));
		}
		
		/** SYSID等が必要な処理はここでマッピング */
		String opeDateTimeStamp = JCCBPCommon.getOpeDateTimeStamp(null);

		// 割引サービス自動適用CC
		mapper.setJKKWrisvcAutoAplyCC(workArea, param);
		if (!JFUBPCommon.isNull(workArea.getMineo_setplan_kbn())
				&& workArea.getEonet())
		{
			// mineoセット割申込割引情報取得CC
			parentMap = new HashMap<String, Object>();
			callJFUMineoSetPlanWribCC(handle, param);
			parentMap = (HashMap)param.getData("JFUMineoSetPlanWribCC");
			if (parentMap != null)
			{
				String dsp_campaign_cd = (String)parentMap.get("dsp_campaign_cd");
				workArea.setMineoSetCampaign_cd(dsp_campaign_cd);
				String uk_end_ymdhm = (String)parentMap.get("uk_end_ymdhm");
				workArea.setMineoSetCampaign_end_ymd(uk_end_ymdhm);
			}
			// mineoセット割適用可否照会・変更依頼CC
			mapper.setJFUMineoSetPlanRenkeiCC(workArea, param, mskmsho_no, opeDateTimeStamp);
		}
		// コンテンツ申込情報登録SC
		mapper.setFUSV016046SC(workArea, param);
		// eoID入力情報登録CC 上がりマッピング
		mapper.setJFUEoidInputInfoAddCC(workArea, param);

		return param;
	}
	/**
	 * Web申込内容一時保存一意照会サービスIFを行う。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param sbtKey
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private CAANMsg[] execEFU0381A010(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String mskmshoNo)
			throws Exception {
		CAANMsg[] result = null;
		CAANMsg efu0381a010Msg = null;

		// Web申込内容一時保存一意照会の上りマッピング
		Object[][] efu0381a010 = {
				{ EFU0381A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EFU0381A010 },
				{ EFU0381A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
				{ EFU0381A010CBSMsg.KEY_MSKMSHO_NO, nullToStr(mskmshoNo) } };

		// サービスIF実行

		efu0381a010Msg = callSC(handle, scCall, param, fixedText, efu0381a010);
		result = efu0381a010Msg
				.getCAANMsgList(EFU0381A010CBSMsg.EFU0381A010CBSMSG1LIST);

		return result;
	}
	
	/**
	 * 登録時に内容設定されていたらエラー
	 * 
	 * @param ccMsg
	 * @return
	 */
	private boolean checkNode(Map<String, Object> ccMsg)
	{
		boolean ret = true;
		
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.USEPLACE_INFO))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.KSH_INFO))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.EONET))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.EOTEL_COURSE))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.EOTEL_1))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.EOTEL_2))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.EOTV))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.PAYWAY_INFO))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.ELSE_INFO))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD_LIST))
		{
			return false;
		}
		if (ccMsg.containsKey(JFUMkmInfoAddFrontiaConstCC.CONT_SVC_LIST))
		{
			return false;
		}
		
		return ret;
	}
	
	/**
	 * コード値をマスタとチェック
	 * 
	 * @return
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private boolean checkCodeToMaster(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText,
			Map<String, Object> ccMsg) throws Throwable
	{

		List<Map<String, String>> errorList = new ArrayList<Map<String, String>>();
		if (!JFUBPCommon.isNull(ccMsg.get(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO))) {
			errorList = (List<Map<String, String>>) ccMsg.get(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO);
		}

		// オプトインメール番号
		// 上りマッピング処理(オプトインメール一覧照会(PMP連携用))
		Object[][] eck131b020In = {
				{ECK0131B020CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0131B020},
				{ECK0131B020CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1}
		};
		// 公開オプトインメールの取得
		CAANMsg[] eck131b020Out = callSC(handle, scCall, param, fixedText, eck131b020In).getCAANMsgList(ECK0131B020CBSMsg.ECK0131B020CBSMSG1LIST);
		if (eck131b020Out != null && eck131b020Out.length != 0)
		{
			List<Map<String, Object>> mail_jusin_settei_list = workArea.getMail_jusin_settei_list();
			for (Map<String, Object> tmpMap : mail_jusin_settei_list)
			{
				boolean findFlg = false;
				for (int k = 0; k < eck131b020Out.length; k++)
				{
					if (eck131b020Out[k].getString(ECK0131B020CBSMsg1List.OPTINM_NO).equals(tmpMap.get(JFUMkmInfoAddFrontiaConstCC.MAIL_JUSIN_SETTEI_NO)))
					{
						findFlg = true;
						break;
					}
				}
				if (!findFlg)
				{
					// メール受信設定（番号）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MAIL_JUSIN_SETTEI_NO + ":" + tmpMap.get(JFUMkmInfoAddFrontiaConstCC.MAIL_JUSIN_SETTEI_NO),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
		}
		// 番ポ・電話サービス提供事業者コード
		if (!JFUBPCommon.isNull(workArea.getBmp_tel_svctk_jgs_1()))
		{
			// 通信事業者一意照会
			String jgs[] = execETU0051A010(handle, scCall, param, fixedText, workArea.getBmp_tel_svctk_jgs_1());
			if (jgs[0] == null)
			{
				// 番ポ・電話サービス提供事業者コード＿１が存在しない
				errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.BMP_TEL_SVCTK_JGS_1 + ":" + workArea.getBmp_tel_svctk_jgs_1(),
						JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
			} else {
				workArea.setBmp_tel_svctk_jgs_nm_1(jgs[1]);
			}
		}
		if (!JFUBPCommon.isNull(workArea.getBmp_tel_svctk_jgs_2()))
		{
			// 通信事業者一意照会
			String jgs[] = execETU0051A010(handle, scCall, param, fixedText, workArea.getBmp_tel_svctk_jgs_2());
			if (jgs[0] == null)
			{
				// 番ポ・電話サービス提供事業者コード＿１が存在しない
				errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.BMP_TEL_SVCTK_JGS_2 + ":" + workArea.getBmp_tel_svctk_jgs_2(),
						JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
			} else {
				workArea.setBmp_tel_svctk_jgs_nm_2(jgs[1]);
			}
		}
		// ｅｏ光テレビ
		if (workArea.getEotv()) {
			String val = workArea.getEo_tv_course();
			// テレビコース（ｅｏ光テレビ入力）
			if (!JFUBPCommon.isNull(val)) {
				// 地デジ・BSコース スターチャンネルセットの場合
				if("3".equals(val)){
					// 2024年4月22日以降
					String opeDate = JCCBPCommon.getOpeDate(null);
					if("20240422".compareTo(opeDate) <= 0){
						errorList
						.add(chkUtil.setErrInfMap(
								JFUMkmInfoAddFrontiaConstCC.EO_TV_COURSE + ":" + val,
								JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
					}
				}
			}
		}
		if ("2".equals(workArea.getEo_tv_course()))
		{
			// テレビチューナー・機器（１）
			if (!JFUBPCommon.isNull(workArea.getStb_hd1_kiki()))
			{
				if (!getStbInfo(handle, scCall, param, fixedText, workArea.getStb_hd1_kiki(), JFUMkmInfoAddFrontiaConstCC.STB_HD1_KIKI))
				{
					// テレビチューナー・機器（１）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.STB_HD1_KIKI + ":" + workArea.getStb_hd1_kiki(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
			// テレビチューナー・機器（２）
			if (!JFUBPCommon.isNull(workArea.getStb_hd2_kiki()))
			{
				if (!getStbInfo(handle, scCall, param, fixedText, workArea.getStb_hd2_kiki(), JFUMkmInfoAddFrontiaConstCC.STB_HD2_KIKI))
				{
					// テレビチューナー・機器（２）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.STB_HD2_KIKI + ":" + workArea.getStb_hd2_kiki(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
			// テレビチューナー・機器（３）
			if (!JFUBPCommon.isNull(workArea.getStb_hd3_kiki()))
			{
				if (!getStbInfo(handle, scCall, param, fixedText, workArea.getStb_hd3_kiki(), JFUMkmInfoAddFrontiaConstCC.STB_HD3_KIKI))
				{
					// テレビチューナー・機器（３）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.STB_HD3_KIKI + ":" + workArea.getStb_hd3_kiki(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
			// テレビチューナー・機器（４）
			if (!JFUBPCommon.isNull(workArea.getStb_hd4_kiki()))
			{
				if (!getStbInfo(handle, scCall, param, fixedText, workArea.getStb_hd4_kiki(), JFUMkmInfoAddFrontiaConstCC.STB_HD4_KIKI))
				{
					// テレビチューナー・機器（４）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.STB_HD4_KIKI + ":" + workArea.getStb_hd4_kiki(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
			// テレビチューナー・機器（５）
			if (!JFUBPCommon.isNull(workArea.getStb_hd5_kiki()))
			{
				if (!getStbInfo(handle, scCall, param, fixedText, workArea.getStb_hd5_kiki(), JFUMkmInfoAddFrontiaConstCC.STB_HD5_KIKI))
				{
					// テレビチューナー・機器（５）が存在しない
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.STB_HD5_KIKI + ":" + workArea.getStb_hd5_kiki(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
		}
		// キャンペーンコード
		for (Map<String, Object> tmpMap : workArea.getCampaign_cd_list())
		{
			String campaignCd = (String)tmpMap.get(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD);
			if (!JFUBPCommon.isNull(campaignCd))
			{
				String campaignSvcCd = JFUStrConst.EMPTY;
				if ("1".equals(tmpMap.get(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_SBT_CD)))
				{
					// 上りマッピング処理(データ抽出項目一覧照会（表示データ抽出項目ＣＤ）)
					Object[][] ekk1351b501In = {
							{ EKK1351B501CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1351B501 },
							{ EKK1351B501CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
							{ EKK1351B501CBSMsg.KEY_DSP_DCHSKM_CD, campaignCd }
					};
					// SC呼出実行
					CAANMsg[] ekk1351b501Out = callSC(handle, scCall, param, fixedText, ekk1351b501In).getCAANMsgList(EKK1351B501CBSMsg.EKK1351B501CBSMSG1LIST);
					if(ekk1351b501Out == null || ekk1351b501Out.length == 0)
					{
						errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
								JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
					} else {
						campaignSvcCd = ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.DCHSKM_CD);
						String sta_ymdhm = ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.SET_PSB_STA_YMDHM);
						String end_ymdhm = ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.SET_PSB_END_YMDHM);
						if (JCCBPCommon.getOpeDateTime(null).compareTo(sta_ymdhm) < 0 || JCCBPCommon.getOpeDateTime(null).compareTo(end_ymdhm) > 0)
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
						} else {

							// 上りマッピング処理(データ抽出項目対象サービス一覧照会)
							Object[][] ekk1371b001In = {
									{EKK1371B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1371B001},
									{EKK1371B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
									{EKK1371B001CBSMsg.KEY_DCHSKM_CD, campaignSvcCd},
									{EKK1371B001CBSMsg.KEY_PRC_GRP_CD, JFUMkmInfoAddFrontiaUtil.getNetPrcGrpCd(workArea)},
									{EKK1371B001CBSMsg.KEY_PCRS_CD, JFUMkmInfoAddFrontiaUtil.getPcrsCdNet(workArea)},
									{EKK1371B001CBSMsg.KEY_PPLAN_CD, JFUMkmInfoAddFrontiaUtil.getPplanCdNet(workArea)},
									{EKK1371B001CBSMsg.KEY_KJN_YMD, JCCBPCommon.getOpeDate(null)},
									{EKK1371B001CBSMsg.MAX_SEARCH_NUM, JFUStrConst.MAX_SEARCH_NUM}
							};
							// SC呼出実行
							CAANMsg[] ekk1371b001Out = callSC(handle, scCall, param, fixedText, ekk1371b001In).getCAANMsgList(EKK1371B001CBSMsg.EKK1371B001CBSMSG1LIST);
							if(ekk1371b001Out == null || ekk1371b001Out.length == 0)
							{
								errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
										JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
							} else {
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_SVC_CD, ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.DCHSKM_CD));
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_STA_DTM, ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.SET_PSB_STA_YMDHM));
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_END_DTM, ekk1351b501Out[0].getString(EKK1351B501CBSMsg1List.SET_PSB_END_YMDHM));
							}
						}
					}
				} else {
					// 上りマッピング処理(割引サービス対象サービス一覧照会(表示用ＣＰ))
					Object[][] ekk0841b509In = {
							{EKK0841B509CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0841B509},
							{EKK0841B509CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
							{EKK0841B509CBSMsg.KEY_DSP_CAMPAIGN_CD, campaignCd },
							{EKK0841B509CBSMsg.KEY_RSV_APLY_YMD, JCCBPCommon.getOpeDate(null)}
					};
					// SC呼出実行
					CAANMsg[] ekk0841b509Out = callSC(handle, scCall, param, fixedText, ekk0841b509In).getCAANMsgList(EKK0841B509CBSMsg.EKK0841B509CBSMSG1LIST);
					if(ekk0841b509Out == null || ekk0841b509Out.length == 0)
					{
						errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
								JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
					} else {
						campaignSvcCd = ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.WRIB_SVC_CD);
						String sta_ymdhm = ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.UK_STA_YMDHM);
						String end_ymdhm = ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.UK_END_YMDHM);
						if (JCCBPCommon.getOpeDateTime(null).compareTo(sta_ymdhm) < 0 || JCCBPCommon.getOpeDateTime(null).compareTo(end_ymdhm) > 0)
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
						} else {

							// 上りマッピング処理(割引サービス対象サービス一覧照会)
							Object[][] ekk0851b001In = {
									{EKK0851B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0851B001},
									{EKK0851B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
									{EKK0851B001CBSMsg.KEY_WRIB_SVC_CD, campaignSvcCd},
									{EKK0851B001CBSMsg.KEY_PRC_GRP_CD, JFUMkmInfoAddFrontiaUtil.getNetPrcGrpCd(workArea)},
									{EKK0851B001CBSMsg.KEY_PCRS_CD, JFUMkmInfoAddFrontiaUtil.getPcrsCdNet(workArea)},
									{EKK0851B001CBSMsg.KEY_PPLAN_CD, JFUMkmInfoAddFrontiaUtil.getPplanCdNet(workArea)},
									{EKK0851B001CBSMsg.KEY_KJNYMD, JCCBPCommon.getOpeDate(null)},
									{EKK0851B001CBSMsg.MAX_SEARCH_NUM, JFUStrConst.MAX_SEARCH_NUM}
							};
							// SC呼出実行
							CAANMsg[] ekk0851b001Out = callSC(handle, scCall, param, fixedText, ekk0851b001In).getCAANMsgList(EKK0851B001CBSMsg.EKK0851B001CBSMSG1LIST);
							if(ekk0851b001Out == null || ekk0851b001Out.length == 0)
							{
								errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
										JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2005));
							} else {
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_SVC_CD, ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.WRIB_SVC_CD));
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_STA_DTM, ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.UK_STA_YMDHM));
								tmpMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_END_DTM, ekk0841b509Out[0].getString(EKK0841B509CBSMsg1List.UK_END_YMDHM));
							}
						}
					}
				}
				if (!JFUBPCommon.isNull(campaignSvcCd))
				{
					// NetflixパックではないのにNetflix必須のキャンペーンはエラー
					if (!Arrays.asList(JFUMkmInfoAddFrontiaConstCC.NET_COURSE_NF).contains(workArea.getNet_course()))
					{
						if (Arrays.asList(JFUMkmInfoAddFrontiaConstCC.NETFLIX_CAMPAIGN).contains(campaignSvcCd))
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1006));
						}
					}
					// メッシュwifi申込んでないのにメッシュwifi必須のキャンペーンはエラー
					if (!"1".equals(workArea.getMesh_wifi()))
					{
						if (Arrays.asList(JFUMkmInfoAddFrontiaConstCC.MESHWIFI_CAMPAIGN).contains(campaignSvcCd))
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1006));
						}
					}
					// SMP申込んでないのにSMP必須のキャンペーンはエラー
					if (!"1".equals(workArea.getNet_stick_stb_mskm()))
					{
						if (Arrays.asList(JFUMkmInfoAddFrontiaConstCC.SMP_CAMPAIGN).contains(campaignSvcCd))
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1006));
						}
					}
					// 即割申込んでないのに月額割引キャンペーンはエラー
					if (!"1".equals(workArea.getNet_sokuwari()))
					{
						if (Arrays.asList(JFUMkmInfoAddFrontiaConstCC.GETUWARI_CAMPAIGN).contains(campaignSvcCd))
						{
							errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_CD + ":" + campaignCd,
									JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1006));
						}
					}
				}
			}
		}
		// コンテンツサービスコード
		// 上りマッピング処理(開通前申込可能コンテンツサービス一覧照会)
		if (workArea.getCont_svc_list().size() > 0)
		{
			Object[][] ekk3281b010In = {
					{EKK3281B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3281B010},
					{EKK3281B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
					{EKK3281B010CBSMsg.KEY_UNYO_YMD, JCCBPCommon.getOpeDate(null) }
			};
			// SC呼出実行
			CAANMsg[] ekk3281b010Out = callSC(handle, scCall, param, fixedText, ekk3281b010In).getCAANMsgList(EKK3281B010CBSMsg.EKK3281B010CBSMSG1LIST);
			ArrayList<String> arrayList = new ArrayList<String>();
			if(ekk3281b010Out != null && ekk3281b010Out.length > 0)
			{
				for (CAANMsg ekk3281b010 : ekk3281b010Out)
				{
					arrayList.add(ekk3281b010.getString(EKK3281B010CBSMsg1List.CONT_SVC_CD));
				}
			}
			for (Map<String, Object> tmpMap : workArea.getCont_svc_list())
			{
				String cont_svc_cd = (String)tmpMap.get(JFUMkmInfoAddFrontiaConstCC.CONT_SVC_CD);
				if (arrayList.size() > 0)
				{
					if (!arrayList.contains(cont_svc_cd))
					{
						errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CONT_SVC_CD + ":" + cont_svc_cd,
								JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
					}
				} else {
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.CONT_SVC_CD + ":" + cont_svc_cd,
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
		}
		
		if ("1".equals(workArea.getPayway()))
		{
			if (!JFUBPCommon.isNull(workArea.getBank_cd()) && !JFUBPCommon.isNull(workArea.getBranch_cd()))
			{
				String branch_cd = workArea.getBranch_cd();
				if (JFUStrConst.BANK_CD_POSTAL.equals(workArea.getBank_cd()))
				{
					branch_cd = "001";
				}
				// 上りマッピング処理(金融機関一意照会)
				Object[][] ekk0511a010In = {
						{EKK0511A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0511A010},
						{EKK0511A010CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_2},
						{EKK0511A010CBSMsg.KEY_BANK_CD, workArea.getBank_cd()},
						{EKK0511A010CBSMsg.KEY_BANK_SHITEN_CD, branch_cd},
						{EKK0511A010CBSMsg.KEY_RSV_APLY_YMD, JCCBPCommon.getOpeDate(null)}
				};
				// 金融機関の取得
				CAANMsg[] ekk0511a010Out = callSC(handle, scCall, param, fixedText, ekk0511a010In).getCAANMsgList(EKK0511A010CBSMsg.EKK0511A010CBSMSG1LIST);
				if (ekk0511a010Out != null && ekk0511a010Out.length > 0)
				{
					workArea.setBank_nm(ekk0511a010Out[0].getString(EKK0511A010CBSMsg1List.BANK_NM));
					workArea.setShiten_nm(ekk0511a010Out[0].getString(EKK0511A010CBSMsg1List.BANK_SHITEN_NM));
				} else {
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.BANK_CD + ":" + workArea.getBank_cd() + ","
							+ JFUMkmInfoAddFrontiaConstCC.BRANCH_CD + ":" + workArea.getBranch_cd(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1004));
				}
			}
		}
		if (!JFUBPCommon.isNull(workArea.getEoid()))
		{
			// 上りマッピング処理(エイジング一覧照会（ユニーク）)
			Object[][] ezm0111b040In = {
					{EZM0111B040CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0111B040},
					{EZM0111B040CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1},
					{EZM0111B040CBSMsg.KEY_AGING_TG_VALUE, workArea.getEoid()},
					{EZM0111B040CBSMsg.KEY_AGING_SBT_CD, JFUStrConst.CD00412_004}
			};
			// エイジング一覧の取得
			CAANMsg[] ezm0111b040Out = callSC(handle, scCall, param, fixedText, ezm0111b040In).getCAANMsgList(EZM0111B040CBSMsg.EZM0111B040CBSMSG1LIST);
			if (ezm0111b040Out != null && ezm0111b040Out.length > 0)
			{
				String eagingStat = ezm0111b040Out[0].getString(EZM0111B040CBSMsg1List.AGING_STAT);
				if (JFUStrConst.CD00063_100.equals(eagingStat) || JFUStrConst.CD00063_200.equals(eagingStat) || JFUStrConst.CD00063_300.equals(eagingStat))
				{
					// eoID使用中
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.EOID + ":" + workArea.getEoid(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2006));
				}
			}
		}
		
		// mineoセット割申込割引情報取得CC
		if (!JFUBPCommon.isNull(workArea.getMineo_setplan_kbn()))
		{
			Map<String, Object> parentMap = new HashMap<String, Object>();
			callJFUMineoSetPlanWribCC(handle, param);
			parentMap = (HashMap)param.getData("JFUMineoSetPlanWribCC");
			if (parentMap != null)
			{
				String dsp_campaign_cd = (String)parentMap.get("dsp_campaign_cd");
				workArea.setMineoSetCampaign_cd(dsp_campaign_cd);
				String uk_end_ymdhm = (String)parentMap.get("uk_end_ymdhm");
				workArea.setMineoSetCampaign_end_ymd(uk_end_ymdhm);
				
				if (JFUBPCommon.isNull(dsp_campaign_cd))
				{
					// mineoセット割キャンペーンコードが取得できない場合はエラー
					errorList.add(chkUtil.setErrInfMap(JFUMkmInfoAddFrontiaConstCC.MINEO_SETPLAN_NO + ":" + workArea.getMineo_setplan_no(),
							JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_2303));
				}
			}
		}

		if (errorList.size() > 0) {
			ccMsg.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, errorList);
			return false;
		}

		return true;
	}


	/**
	 * ＳＴＢ機器の存在チェックと情報取得
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param taknkikiModelCd
	 * @param target
	 * @return
	 * @throws Exception
	 */
	private boolean getStbInfo(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String taknkikiModelCd, String target) throws Exception
	{
		String pcrsCd = JFUStrConst.EMPTY;
		String pplanCd = JFUStrConst.EMPTY;
		String stbMdlNm = JFUStrConst.EMPTY;
		String hddCapaCd = JFUStrConst.EMPTY;
		String opeDate = JCCBPCommon.getOpeDate(null);
		// 上りマッピング処理(機器型式対象料金コース一覧照会)
		Object[][] ekk1621b001In = {
				{ EKK1621B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1621B001 },
				{ EKK1621B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
				{ EKK1621B001CBSMsg.KEY_BASE_YMD, opeDate },
				{ EKK1621B001CBSMsg.KEY_TAKNKIKI_MODEL_CD, taknkikiModelCd }
		};
		// SC呼出実行
		CAANMsg[] ekk1621b001Out = callSC(handle, scCall, param, fixedText, ekk1621b001In).getCAANMsgList(EKK1621B001CBSMsg.EKK1621B001CBSMSG1LIST);
		if(ekk1621b001Out != null && ekk1621b001Out.length > 0)
		{
			// 料金コース
			pcrsCd = ekk1621b001Out[0].getString(EKK1621B001CBSMsg1List.PCRS_CD);
		} else {
			return false;
		}
		// 上りマッピング処理(料金プラン一覧照会)
		Object[][] ekk0591b003In = {
				{ EKK0591B003CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0591B003 },
				{ EKK0591B003CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
				{ EKK0591B003CBSMsg.KEY_PCRS_CD, pcrsCd },
				};
		// SC呼出実行
		CAANMsg[] ekk0591b003Out = callSC(handle, scCall, param, fixedText, ekk0591b003In).getCAANMsgList(EKK0591B003CBSMsg.EKK0591B003CBSMSG1LIST);
		if(ekk0591b003Out != null && ekk0591b003Out.length > 0)
		{
			// 料金プラン
			pplanCd = ekk0591b003Out[0].getString(EKK0591B003CBSMsg1List.PPLAN_CD);
			stbMdlNm = ekk0591b003Out[0].getString(EKK0591B003CBSMsg1List.PPLAN_NM);
		} else {
			return false;
		}
		// 上りマッピング処理(宅内機器型式一意照会)
		Object[][] ezm0411a010In = {
				{ EZM0411A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0411A010 },
				{ EZM0411A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
				{ EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD, taknkikiModelCd }
				};
		// SC呼出実行
		CAANMsg[] ezm0411a010Out = callSC(handle, scCall, param, fixedText, ezm0411a010In).getCAANMsgList(EZM0411A010CBSMsg.EZM0411A010CBSMSG1LIST);

		if(ezm0411a010Out != null && ezm0411a010Out.length > 0)
		{
			hddCapaCd = ezm0411a010Out[0].getString(EZM0411A010CBSMsg1List.HDD_CAPA_CD);
		} else {
			return false;
		}
		// 共通領域に設定
		if (JFUMkmInfoAddFrontiaConstCC.STB_HD1_KIKI.equals(target))
		{
			workArea.setStb_hd1_pcrs_cd(pcrsCd);
			workArea.setStb_hd1_pplan_cd(pplanCd);
			workArea.setStb_hd1_hdd_capa_cd(hddCapaCd);
			workArea.setStb_hd1_model_nm(stbMdlNm);
		} else if (JFUMkmInfoAddFrontiaConstCC.STB_HD2_KIKI.equals(target))
		{
			workArea.setStb_hd2_pcrs_cd(pcrsCd);
			workArea.setStb_hd2_pplan_cd(pplanCd);
			workArea.setStb_hd2_hdd_capa_cd(hddCapaCd);
			workArea.setStb_hd2_model_nm(stbMdlNm);
		} else if (JFUMkmInfoAddFrontiaConstCC.STB_HD3_KIKI.equals(target))
		{
			workArea.setStb_hd3_pcrs_cd(pcrsCd);
			workArea.setStb_hd3_pplan_cd(pplanCd);
			workArea.setStb_hd3_hdd_capa_cd(hddCapaCd);
			workArea.setStb_hd3_model_nm(stbMdlNm);
		} else if (JFUMkmInfoAddFrontiaConstCC.STB_HD4_KIKI.equals(target))
		{
			workArea.setStb_hd4_pcrs_cd(pcrsCd);
			workArea.setStb_hd4_pplan_cd(pplanCd);
			workArea.setStb_hd4_hdd_capa_cd(hddCapaCd);
			workArea.setStb_hd4_model_nm(stbMdlNm);
		} else if (JFUMkmInfoAddFrontiaConstCC.STB_HD5_KIKI.equals(target))
		{
			workArea.setStb_hd5_pcrs_cd(pcrsCd);
			workArea.setStb_hd5_pplan_cd(pplanCd);
			workArea.setStb_hd5_hdd_capa_cd(hddCapaCd);
			workArea.setStb_hd5_model_nm(stbMdlNm);
		}
		
		return true;
	}

	/**
	 * 引当棚から棚コードを取得
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param opeDate
	 * @return
	 * @throws Exception
	 */
	private String execEDK0451A010(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String opeDate)
			throws Exception {

		String shelf_cd = null;

		// 引当棚一意照会の上りマッピング
		Object[][] edk0451a010In =
		{
			{EDK0451A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EDK0451A010},
			{EDK0451A010CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1},
			{EDK0451A010CBSMsg.KEY_HAMBAI_SBT_CD, "10"},
			{EDK0451A010CBSMsg.KEY_UNYO_YMD, opeDate}
		};
		
		// 引当棚一意照会SIF実行
		CAANMsg[] ezm0321a010Out = callSC(handle, scCall, param, fixedText, edk0451a010In).getCAANMsgList(EDK0451A010CBSMsg.EDK0451A010CBSMSG1LIST);
		
		if (ezm0321a010Out != null && ezm0321a010Out.length > 0)
		{
			shelf_cd = ezm0321a010Out[0].getString(EDK0451A010CBSMsg1List.SHELF_CD);
		}

		return shelf_cd;
	}
	
	/**
	 * 業務パラメータ管理一意照会
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param sbtKey
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private String execEZM0321A010(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String paramID)
			throws Exception {

		String work_param_sette_value = null;

		// 業務パラメータ管理一意照会の上りマッピング
		Object[][] ezm0321a010In = {
				{EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010},
				{EZM0321A010CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1},
				{EZM0321A010CBSMsg.KEY_WORK_PARAM_ID,  paramID}
		};
		// サービスIF実行
		CAANMsg[] ezm0321a010Out = callSC(handle, scCall, param, fixedText, ezm0321a010In).getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
		if (ezm0321a010Out != null && ezm0321a010Out.length > 0)
		{
			work_param_sette_value = ezm0321a010Out[0].getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
		}

		return work_param_sette_value;
	}

// ANK-4432-00-00 ADD START	
	/**
	 * 宅内機器型式コード照会
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param sbtKey
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private String execEKK2041B501(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String plc_mskm, String mesh_wifi)
			throws Exception {

		String taknkiki_model_cd = null;
		String key_kktk_svc_cd = null;
		String key_pcrs_cd = null;
		String key_pplan_cd = null;
		String key_svc_type_skbt_cd = null;
		
		// 無線LAN中継器の場合
		if("1".equals(plc_mskm))
		{
			key_kktk_svc_cd = JFUStrConst.KK0771_KKTK_SVC_CD_C015;
			key_pcrs_cd = JFUStrConst.CD00134_CA1;
			key_pplan_cd = JFUStrConst.CD00565_PCA101;
			key_svc_type_skbt_cd = "HF";
			
		}
		// メッシュWi-Fiの場合
		else if("1".equals(mesh_wifi))
		{
			key_kktk_svc_cd = JFUStrConst.KK0771_KKTK_SVC_CD_C015;
			key_pcrs_cd = JFUStrConst.CD00134_CA2;
			key_pplan_cd = JFUStrConst.CD00565_PCA201;
			key_svc_type_skbt_cd = "HF";
		};
		
		// 宅内機器型式コード照会の上りマッピング
		Object[][] ekk2041b501In = {
				{EKK2041B501CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK2041B501},
				{EKK2041B501CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1},
				{EKK2041B501CBSMsg.KEY_KKTK_SVC_CD, key_kktk_svc_cd},
				{EKK2041B501CBSMsg.KEY_PCRS_CD, key_pcrs_cd},
				{EKK2041B501CBSMsg.KEY_PPLAN_CD, key_pplan_cd},
				{EKK2041B501CBSMsg.KEY_SVC_TYPE_SKBT_CD, key_svc_type_skbt_cd}
		};
		// サービスIF実行
		CAANMsg[] ekk2041b501Out = callSC(handle, scCall, param, fixedText, ekk2041b501In).getCAANMsgList(EKK2041B501CBSMsg.EKK2041B501CBSMSG1LIST);
		
		if (ekk2041b501Out != null && ekk2041b501Out.length > 0)
		{
			taknkiki_model_cd = ekk2041b501Out[0].getString(EKK2041B501CBSMsg1List.TAKNKIKI_MODEL_CD);
		}
		
		return taknkiki_model_cd;
	}
// ANK-4432-00-00 ADD END
	
	/**
	 * mineoセット割申込割引情報取得CC実行
	 * 
	 * @param handle
	 * @param param
	 * @return
	 * @throws Throwable
	 */
	private IRequestParameterReadWrite callJFUMineoSetPlanWribCC(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		JFUMineoSetPlanWribCC jfumineosetplanwribcc = new JFUMineoSetPlanWribCC();
		
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", JPCModelConstant.FUNC_CD_1);

		// ＫＥＹ＿更新区分　"1"（新規系）
		parentMap.put("key_upd_kbn", "1");

		param.setData("JFUMineoSetPlanWribCC", parentMap);
		
		jfumineosetplanwribcc.execute(handle, param, "JFUMineoSetPlanWribCC");
		
		return param;
	}
// ANK-4619-00-00 ADD START
	/**
	 * クレジットカード名称変換CC実行
	 * 
	 * @param param
	 * @return
	 * @throws Throwable
	 */
	private IRequestParameterReadWrite callJCCCrecardNmChgeCC(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		JCCCrecardNmChgeCC crecardNmChgeCC = new JCCCrecardNmChgeCC();
		
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 入力カナ名（変更前）
		parentMap.put("in_kana_bf", JFUStrConst.EMPTY);
		// 入力カナ名（変更後）
		parentMap.put("in_kana_af", workArea.getCr_cardNmKana());
		// 入力ローマ字（変更前）
		parentMap.put("in_romaji_bf", JFUStrConst.EMPTY);
		// 入力ローマ字（変更後）
		parentMap.put("in_romaji_af", workArea.getCrecard_nm_romaji());
		param.setData("JCCCrecardNmChgeCC", parentMap);
		
		crecardNmChgeCC.execute(handle, param, "JCCCrecardNmChgeCC");
		
		// 属性チェック
		if (!MixCharCheck.isMeigiNinKanaCheck((String)parentMap.get("out_kana")))
		{
			parentMap.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1002);
		}
		// 桁数チェック
		else if (!LengthCheck.isLength2Check((String)parentMap.get("out_kana"), 1, 90))
		{
			parentMap.put(JFUMkmInfoAddFrontiaConstCC.ERROR_INFO, JFUMkmInfoAddFrontiaConstCC.RES_KEY_ERROR_CODE_1003);
		}
		return param;
	}
// ANK-4619-00-00 ADD END
	
	/**
	 * 通信事業者一意照会
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param paramID
	 * @return
	 * @throws Exception 
	 */
	private String[] execETU0051A010(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText, String jgs_cd) throws Exception
	{
		String ret[] = new String[2];
		
		// 上りマッピング処理(通信事業者一意照会)
		Object[][] etu0051a010In = {
				{ETU0051A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ETU0051A010},
				{ETU0051A010CBSMsg.FUNC_CODE,  JPCModelConstant.FUNC_CD_1},
				{ETU0051A010CBSMsg.KEY_TSJGS_CD,  jgs_cd}
		};
		// 通信事業者の取得
		CAANMsg[] etu0051a010Out = callSC(handle, scCall, param, fixedText, etu0051a010In).getCAANMsgList(ETU0051A010CBSMsg.ETU0051A010CBSMSG1LIST);
		
		if (etu0051a010Out != null && etu0051a010Out.length > 0){
			ret[0] = etu0051a010Out[0].getString(ETU0051A010CBSMsg1List.TSJGS_CD);
			ret[1] = etu0051a010Out[0].getString(ETU0051A010CBSMsg1List.TSJGS_NM);
		}
		return ret;
	}

	/**
	 * クーポンコード情報の更新判定
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param couponCd
	 * @return
	 * @throws Exception
	 */
	private boolean isUpdAbleCouponCd(SessionHandle handle, ServiceComponentRequestInvoker scCall, IRequestParameterReadWrite param, String fixedText)
			throws Exception
	{
		// 紹介一意照会の上りマッピング
		Object[][] ekk0311a010In =
				{ { EKK0311A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0311A010 }, { EKK0311A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 },
						{ EKK0311A010CBSMsg.KEY_INTR_CD, workArea.getCoupon_cd() } };

		CAANMsg caanMsg = callSC(handle, scCall, param, fixedText, ekk0311a010In);

		if (caanMsg != null)
		{
			// 紹介一意照会SIF実行
			CAANMsg[] ekk0311a010Out = caanMsg.getCAANMsgList(EKK0311A010CBSMsg.EKK0311A010CBSMSG1LIST);
			if (ekk0311a010Out != null && ekk0311a010Out.length > 0)
			{
				String cdSkbts = ekk0311a010Out[0].getString(EKK0311A010CBSMsg1List.CD_SKBTS);
				String svcKeiNoMskmsha = ekk0311a010Out[0].getString(EKK0311A010CBSMsg1List.SVC_KEI_NO_MSKMSHA);
				if (JFUStrConst.COUPON_CD_CD_SKBTS.equals(cdSkbts) && JFUBPCommon.isNull(svcKeiNoMskmsha))
				{
					// 紹介スキーマのコード識別子が「01:クーポンコード」且つサービス契約（申込者）が未設定（未使用）のため更新可能
					return true;
				}
			}
		}
		// データなし、コード識別子未設定、使用済のため、更新不可（入力から更新までタイムラグがあるため見ない）
		return false;
	}

	/**
	 * 住所分割結果を設定
	 * 
	 * @param param
	 * @param fixedText
	 * @param addMap
	 * @throws Throwable
	 */
	private void addressEdit(IRequestParameterReadWrite param, String fixedText, Map<String, Object> addMap) throws Throwable
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();
		
		if (!JFUBPCommon.isNull(addMap.get("ad_cd")))
		{
			parentMap.put("ad_cd", addMap.get("ad_cd"));
		} else {
			parentMap.put("ad_cd", "00000000000");
		}
		parentMap.put("state_nm", addMap.get("state_nm"));
		parentMap.put("city_nm", addMap.get("city_nm"));
		parentMap.put("oaztsu_nm", addMap.get("oaztsu_nm"));
		parentMap.put("azcho_nm", addMap.get("azcho_nm"));
		if (addMap.containsKey("bnchigo"))
		{
			parentMap.put("after_bnchi", addMap.get("bnchigo"));
		}
		else if (addMap.containsKey("after_bnchi"))
		{
			parentMap.put("after_bnchi", addMap.get("after_bnchi"));
		}
		parentMap.put("pcd", addMap.get("pcd"));
		parentMap.put("adrttm", addMap.get("adrttm"));
		parentMap.put("adrrm", addMap.get("adrrm"));

		param.setData(fixedText, parentMap);
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param mappingData
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle,
			ServiceComponentRequestInvoker scCall,
			IRequestParameterReadWrite param, String fixedText,
			Object[][] mappingData) throws Exception {
		HashMap<String, Object> paramMap = editInMsg(param, mappingData);

		Map<?, ?> result = scCall.run(paramMap, handle);

		CAANMsg[] templates = (CAANMsg[]) result
				.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];

		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);

		editErrorInfoCom(param, templates, (Integer) return_code, fixedText,
				mappingData);

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>) param
				.getControlMapData(SCControlMapKeys.ERROR_INFO);

		/* エラー情報のマップないとき、新しいエラー情報をイニシャライズする */
		if (errList == null) {
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil
				.getErrorInfo(result, errList));

		/* 異常の場合、SCCallExceptionを生成してスローする */
		if (!("0".equals(return_code.toString()) && 0 == status)) {
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		return msg;
	}

	/**
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param fixedText
	 * @param mappingData
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCom(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			int returnCode, String fixedText, Object[][] mappingData)
			throws RequestParameterException {
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);

		/* 0以外のとき */
		if (returnCode != 0) {
			templateStatus = 9000;
		}

		/* nullのとき */
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_"
				+ String.format("%1$04d", templateStatus)) == null) {
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		/* nullの場合 */
		if (obj == null) {
			bpStatus = -1;
		}
		/* 他の場合 */
		else {
			bpStatus = Integer.parseInt((String) param
					.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		/* セクタが比べる */
		if (templateStatus > bpStatus) {
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_"
					+ formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, String> inMap = null;

		// ユーザデータ情報
		inMap = (HashMap<String, String>) param.getData(fixedText);

		for (int i = 0; i < mappingData.length; i++) {
			/* nullチェック　 */
			if (!template.isNull(mappingData[i][0] + "_err")) {
				/* ユーザデータ情報にエラーを確認する　 */
				if (!inMap.containsKey(mappingData[i][0] + "_err")) {
					inMap.put(mappingData[i][0] + "_err", template
							.getString(mappingData[i][0] + "_err"));
				}
			}
		}
		return param;
	}

	/**
	 * @param param
	 * @param mappingData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,
			Object[][] mappingData) throws RequestParameterException {
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// 【取得元：ユーザエリア(コントロールマップ)】
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param
				.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param
				.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param
				.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param
				.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		String svcIf = (String) mappingData[0][1];

		CAANMsg template = new CAANMsg(String.format(
				"eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));

		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param
				.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param
				.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param
				.getControlMapData(SCControlMapKeys.OPE_TIME));

		for (int i = 0; i < mappingData.length; i++) {
			/* CAANMsg[]の場合 */
			if (mappingData[i][1] instanceof CAANMsg[]) {
				template.set((String) mappingData[i][0],
						(CAANMsg[]) mappingData[i][1]);
			}
			/* CAANMsg[]の以外 */
			else {
				/* nullの場合 */
				if ("".equals(mappingData[i][1])) {
					template.setNull((String) mappingData[i][0]);
				}
				/* 他の場合 */
				else {
					template.set((String) mappingData[i][0], mappingData[i][1]);
				}
			}
		}

		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * eo光導入物件情報検索基底コモンコンポーネントから物件データ取得
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param workArea 申込情報
	 * @throws Throwable
	 */
	private void searchEohDnBkn(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, JFUMkmInfoAddFrontiaWorkArea workArea) throws Throwable
	{

		Map<String, Object> ccMsg = (Map<String, Object>)param.getData(fixedText);

		// eo光導入物件情報検索コモンコンポーネントから物件データ取得
		JFUEohDnBknSearchCC eohDnBknSearch = new JFUEohDnBknSearchCC();

		// 物件管理番号
		ccMsg.put(JFUEohDnBknSearchBaseCC.KEY_BKN_KNRI_NO, workArea.getBkn_knri_no());
		// ネット用回線使用契約番号
		ccMsg.put(JFUEohDnBknSearchBaseCC.KEY_NET_KAISEN_USE_KEI_NO, workArea.getNet_kaisen_use_kei_no());
		// テレビ用回線使用契約番号
		ccMsg.put(JFUEohDnBknSearchBaseCC.KEY_TV_KAISEN_USE_KEI_NO, workArea.getTv_kaisen_use_kei_no());
		// ネット用提供方式契約番号
		ccMsg.put(JFUEohDnBknSearchBaseCC.KEY_NET_TK_HOSHIKI_KEI_NO, workArea.getNet_tk_hoshiki_kei_no());
		// テレビ用提供方式契約番号
		ccMsg.put(JFUEohDnBknSearchBaseCC.KEY_TV_TK_HOSHIKI_KEI_NO, workArea.getTv_tk_hoshiki_kei_no());

		Map<String, Object> resutEohDnBkn = eohDnBknSearch.searchEohDnBkn(handle, param, fixedText);
		// マンション検索結果リスト
		List<Map<String, Object>> resultList = (List<Map<String, Object>>)resutEohDnBkn.get(JFUEohDnBknSearchBaseCC.RES_MANSION_SEARCH_LIST);

		if (resultList != null && resultList.size() == 1)
		{
			// 物件データをworkAreaにセットする
			chkUtil.setWorkAreaFromBknData(workArea, resultList.get(0));

			for (int i = 0; i < resultList.size(); i++)
			{
				Map<String, Object> resMansionSearch = resultList.get(i);

				if (resMansionSearch != null && resMansionSearch.size() > 0)
				{

					List<Map<String, Object>> netCampList = (List<Map<String, Object>>)resMansionSearch.get(JFUEohDnBknSearchBaseCC.RES_NET_MANS_CAMPAIGN_LIST);
					if (netCampList != null && netCampList.size() > 0)
					{

						String mskmPcrsCd = JFUMkmInfoAddFrontiaUtil.getPcrsCdNet(workArea);
						String mskmPplanCd = JFUMkmInfoAddFrontiaUtil.getPplanCdNet(workArea);

						for (int j = 0; j < netCampList.size(); j++)
						{
							Map<String, Object> campMap = netCampList.get(j);
							String campCd = (String)campMap.get(JFUEohDnBknSearchBaseCC.RES_NET_MANS_CAMPAIGN_CD);
							CAANMsg ekk0841b509Out = execEkk0841b510(handle, param, fixedText, campCd, mskmPcrsCd, mskmPplanCd);
							if (!JFUBPCommon.isNull(ekk0841b509Out))
							{
								// マンション割引サービスコード（ＮＥＴ）
								campMap.put(JFUEohDnBknSearchBaseCC.RES_NET_MANS_WRIB_SVC_CD, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.WRIB_SVC_CD));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_NM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.WRIB_SVC_NM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_STA_DTM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.UK_STA_YMDHM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_END_DTM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.UK_END_YMDHM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_SBT_CD, "2");
							}
							else
							{
								String dchskmCd = execEkk1351b501(handle, param, fixedText, campCd, mskmPcrsCd, mskmPplanCd);
								if (!JFUBPCommon.isNull(dchskmCd))
								{
									// マンションデータ抽出項目コード（ＮＥＴ）
									campMap.put(JFUEohDnBknSearchBaseCC.RES_NET_MANS_DCHSKM_CD, dchskmCd);
								}
							}
						}
					}

					List<Map<String, Object>> tvCampList = (List<Map<String, Object>>)resMansionSearch.get(JFUEohDnBknSearchBaseCC.RES_TV_MANS_CAMPAIGN_LIST);
					if (tvCampList != null && tvCampList.size() > 0)
					{
						String mskmPcrsCd = JFUStrConst.CD00134_A39;
						String mskmPplanCd = JFUStrConst.CD00565_PA3901;

						for (int j = 0; j < tvCampList.size(); j++)
						{
							Map<String, Object> campMap = tvCampList.get(j);
							String campCd = (String)campMap.get(JFUEohDnBknSearchBaseCC.RES_TV_MANS_CAMPAIGN_CD);
							CAANMsg ekk0841b509Out = execEkk0841b510(handle, param, fixedText, campCd, mskmPcrsCd, mskmPplanCd);
							if (!JFUBPCommon.isNull(ekk0841b509Out))
							{
								// マンション割引サービスコード（ＴＶ）
								campMap.put(JFUEohDnBknSearchBaseCC.RES_TV_MANS_WRIB_SVC_CD, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.WRIB_SVC_CD));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_NM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.WRIB_SVC_NM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_STA_DTM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.UK_STA_YMDHM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_END_DTM, ekk0841b509Out.getString(EKK0841B510CBSMsg1List.UK_END_YMDHM));
								campMap.put(JFUMkmInfoAddFrontiaConstCC.CAMPAIGN_SBT_CD, "2");
							}
							else
							{
								String dchskmCd = execEkk1351b501(handle, param, fixedText, campCd, mskmPcrsCd, mskmPplanCd);
								if (!JFUBPCommon.isNull(dchskmCd))
								{
									// マンションデータ抽出項目コード（ＴＶ）
									campMap.put(JFUEohDnBknSearchBaseCC.RES_TV_MANS_DCHSKM_CD, dchskmCd);
								}
							}
						}
					}
				}
			}

			// 物件データをworkAreaにセットする
//			chkUtil.setWorkAreaFromBknData(workArea, resultList.get(0));
			ccMsg.put(JFUEohDnBknSearchBaseCC.RES_MANSION_SEARCH_LIST, resultList);

			// 物件管理番号
			ccMsg.remove(JFUEohDnBknSearchBaseCC.KEY_BKN_KNRI_NO);
			// ネット用回線使用契約番号
			ccMsg.remove(JFUEohDnBknSearchBaseCC.KEY_NET_KAISEN_USE_KEI_NO);
			// テレビ用回線使用契約番号
			ccMsg.remove(JFUEohDnBknSearchBaseCC.KEY_TV_KAISEN_USE_KEI_NO);
			// ネット用提供方式契約番号
			ccMsg.remove(JFUEohDnBknSearchBaseCC.KEY_NET_TK_HOSHIKI_KEI_NO);
			// テレビ用提供方式契約番号
			ccMsg.remove(JFUEohDnBknSearchBaseCC.KEY_TV_TK_HOSHIKI_KEI_NO);
		}
	}

	/**
	 * キャンペーンコードに対する割引サービスコードを取得
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param campaignCd
	 * @param mskmPcrsCd
	 * @param mskmPplanCd
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg execEkk0841b510(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String campaignCd,String mskmPcrsCd,String mskmPplanCd) throws Exception
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 上りマッピング処理(割引サービス登録制御一覧照会明細)
		Object[][] ekk0841b510In =
				{ { EKK0841B510CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0841B510 }, { EKK0841B510CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 }, { EKK0841B510CBSMsg.KEY_DSP_CAMPAIGN_CD, campaignCd } };

		// SC呼出実行
		CAANMsg[] ekk0841b510Out = callSC(handle, scCall, param, fixedText, ekk0841b510In).getCAANMsgList(EKK0841B510CBSMsg.EKK0841B510CBSMSG1LIST);
		if (ekk0841b510Out != null && ekk0841b510Out.length > 0)
		{
			for (CAANMsg ekk0841b510 : ekk0841b510Out)
			{
				String sta_tstaymd = ekk0841b510.getString(EKK0841B510CBSMsg1List.WRIB_SVC_TRGT_SVC_TSTAYMD);
				String end_tstaymd = ekk0841b510.getString(EKK0841B510CBSMsg1List.WRIB_SVC_TRGT_SVC_TENDYMD);
				if (JCCBPCommon.getOpeDateTime(null).compareTo(sta_tstaymd) >= 0 
						&& JCCBPCommon.getOpeDateTime(null).compareTo(end_tstaymd) <= 0)
				{
					String pcrsCd = ekk0841b510.getString(EKK0841B510CBSMsg1List.PCRS_CD);
					String pplanCd = ekk0841b510.getString(EKK0841B510CBSMsg1List.PPLAN_CD);
					if (nullToStr(mskmPcrsCd).equals(pcrsCd) && nullToStr(mskmPplanCd).equals(pplanCd))
					{
						return ekk0841b510;
					}
				}
			}
		}
		return null;
	}

	/**
	 * キャンペーンコードに対するデータ抽出項目コードを取得
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param campCd
	 * @return
	 * @throws Throwable
	 */
	private String execEkk1351b501(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String campaignCd,String mskmPcrsCd,String mskmPplanCd) throws Exception
	{

		String dchskmCd = JFUStrConst.EMPTY;

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 上りマッピング処理(データ抽出項目一覧照会（表示データ抽出項目ＣＤ）)
		Object[][] ekk1351b501In =
				{ { EKK1351B501CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1351B501 }, { EKK1351B501CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1 }, { EKK1351B501CBSMsg.KEY_DSP_DCHSKM_CD, campaignCd } };
		// SC呼出実行
		CAANMsg[] ekk1351b501Out = callSC(handle, scCall, param, fixedText, ekk1351b501In).getCAANMsgList(EKK1351B501CBSMsg.EKK1351B501CBSMSG1LIST);
		if (ekk1351b501Out != null && ekk1351b501Out.length > 0)
		{
			for (CAANMsg ekk1351b501 : ekk1351b501Out)
			{
				String sta_ymdhm = ekk1351b501.getString(EKK1351B501CBSMsg1List.SET_PSB_STA_YMDHM);
				String end_ymdhm = ekk1351b501.getString(EKK1351B501CBSMsg1List.SET_PSB_END_YMDHM);
				if (JCCBPCommon.getOpeDateTime(null).compareTo(sta_ymdhm) >= 0 && JCCBPCommon.getOpeDateTime(null).compareTo(end_ymdhm) <= 0)
				{
					String pcrsCd = ekk1351b501.getString(EKK1351B501CBSMsg1List.PCRS_CD);
					String pplanCd = ekk1351b501.getString(EKK1351B501CBSMsg1List.PPLAN_CD);
					if (nullToStr(mskmPcrsCd).equals(pcrsCd) && nullToStr(mskmPplanCd).equals(pplanCd))
					{
						dchskmCd = ekk1351b501.getString(EKK1351B501CBSMsg1List.DCHSKM_CD);
					}
				}
			}
		}
		return dchskmCd;
	}

	/**
	 * nullの場合空文字に変更
	 * 
	 * @param str
	 * @return
	 */
	private String nullToStr(String str) {
		/* 項目名がnullかチェック */
		if (str == null) {
			str = "";
		}
		return str;
	}

	/**
	 * メッセージ編集
	 * 
	 * @param chkMap 結果マップ
	 * @return メッセージ
	 */
	private String getMsgEditAd(Map<String, Object> chkMap)
	{
		StringBuffer sb = new StringBuffer();
		try
		{
			if (chkMap == null || chkMap.size() == 0)
			{
				return sb.toString();
			}
			Iterator<String> itr = chkMap.keySet().iterator();
			while (itr.hasNext())
			{
				String key = (String)itr.next();
				Object value = chkMap.get(key);
				if (value == null)
				{
					sb.append(" " + key + "=[]" + "\r\n");
				}
				else if (value instanceof String)
				{
					sb.append( " " + key + "=[" + value + "]" + "\r\n");
				}
			}
		}
		catch (Exception ex)
		{
			// 処理続行
			return sb.toString();
		}

		return sb.toString();
	}

	/**
	 * デバッグログを出力します。<BR>
	 *
	 * @param dumpObj 出力するオブジェクト
	 */
	private void printlnEjbLog(Object dumpObj)
	{
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), dumpObj, null, null, null);
	}

}