/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKAddUsePlaceInfoCC
*   ソースファイル名：JKKAddUsePlaceInfoCC.java
*   作成者          ：富士通
*   日付            ：2011年06月14日
*＜機能概要＞
*   利用場所情報登録部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/06/14   FJ）土屋    新規作成
*   V4.00.00    2012/09/12   FJ) 関      【ANK-0519-00-00】マンション親機器対応
*   v4.01.00    2012/10/31   FJ）多田    【IT1-2012-0001640】住所手動入力対応
*   v5.00.00    2013/01/18   FJ) 川島    【KAD-2012-0001108】書面での受付番号の申込イメージの紐付けについて
*   v5.01.00    2013/04/15   FJ) 中山    【OT-2013-0000647】機器送付先更新対象機器アラートの表示制御の修正
*   v6.00.00    2013/11/27   FJ) 中山    【IT2-2013-0000768】照査前のキャンセル回線機器の回復対応
*   v7.00.00    2013/10/07   FJ) 北浦    【ANK-1578-00-00】多機能ルーター(機器追加)
*   v51.00.00	2020/09/03	 FJ)西窪	 【ANK-3885-00-00】光化マンションの自動設計対応
*   v60.00.00	2022/06/06	 FJ)平野	 【ANK-4244-00-00】【eo定期】MT既設賃貸対応
*   v72.00.00	2024/09/24	 FJ)吉川	 【ANK-4577-00-00】eo光ネット「シンプルプラン」追加対応(Step2)
*   v73.00.00	2024/10/17   FJ)舘山	 【ANK-4427-00-00】NTT卸対応
*   v73.00.00	2025/02/25   FJ)舘山     【#83584】HGW瑕疵内障害
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

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.CCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.ErrorInfoMapKeys;
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 eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKCommonUtil;
import eo.ejb.cbs.cbsmsg.EKK0251D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2321B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2321B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2811D010CBSMsg;

/**
 * 利用場所情報登録部品
 * <br>
 * @author 富士通
 */
public class JKKAddUsePlaceInfoCC extends AbstractCommonComponent
{
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** エラー用 */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME = "JKKAddUsePlaceInfoCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_KEISHA = "JKKAddKeishaServiceCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_MSKM = "JKKAddMskmServiceCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_MSKM_LIST = "JKKAddMskmServiceCCWorkList";	
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_TV = "JKKAddSvcKeiTvCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_TEL = "JKKAddSvcKeiTelCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_NET = "JKKAddSvcKeiNetCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_PAYWAY = "JKKAddSvcPaywayCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME_ADSL = "JKKAddSvcKeiAdslExeCCWork";
	/** 機器提供サービス契約リスト */
	private static final String KKTK_SVC_KEI_LIST = "kktk_svc_kei_list";
	/** 機器提供サービス契約リストのプレフィックス */
	private static final String PREFIX_KKTK_SVC_ADD = "kk0341_";
	/** 作業領域項目　サービス契約番号 */
	private static final String WK_SVC_KEI_NO = "svc_kei_no";
	/** 作業領域項目　サービス契約回線内訳番号 */
	private static final String WK_KAISEN_UCWK = "svc_kei_kaisen_ucwk_no";
	/** 作業領域項目　ＳＹＳＩＤ */
	private static final String WK_SYSID = "sysid";
	/** 作業領域項目　請求契約番号 */
	private static final String WK_SEIKY_KEI_NO = "seiky_kei_no";
	/** 申込明細番号（ネット） */
	private static final String MSKM_DTL_NO_NET = "mskm_dtl_no_net";
	/** 申込明細番号（テレビ） */
	private static final String MSKM_DTL_NO_TV = "mskm_dtl_no_tv";
	/** 申込明細番号（電話） */
	private static final String MSKM_DTL_NO_TEL = "mskm_dtl_no_tel";
	/** 申込明細番号（ADSL） */
	private static final String MSKM_DTL_NO_ADSL = "mskm_dtl_no_adsl";
	/** ArrayList名 機器オプションサービス契約登録リスト */
	private static final String KKOP_SVC_ADD_LIST = "kkop_svc_add_list";

	/** マンション回線提供方式 光配線方式 */
	private static final String MANS_KAISEN_HSK_HIKARI_HAISEN = "2";
	/** マンション回線提供方式 ＶＤＳＬ */
	private static final String MANS_KAISEN_HSK_VDSL = "3";

	/** 機器送付先判定対象リスト */
	private static final String[] KKSHS_JDG_TG_LIST = {
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_ad_cd",			// 機器送付先住所コード
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_pcd",				// 機器送付先郵便番号
		PREFIX_KKTK_SVC_ADD + "kiki_shs_ad_man_input_flg",	// 機器送付先住所手動入力フラグ
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_state_nm",		// 機器送付先都道府県名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_city_nm",			// 機器送付先市区町村名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_oaztsu_nm",		// 機器送付先大字通称名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_azcho_nm",		// 機器送付先字丁目名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_bnchigo",			// 機器送付先番地号
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_adrttm",			// 機器送付先住所補記・建物名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_adrrm",			// 機器送付先住所補記・部屋番号
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_nm",				// 機器送付先名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_kana",			// 機器送付先カナ名
		PREFIX_KKTK_SVC_ADD + "kiki_sohus_telno"			// 機器送付先電話番号
	};
	
	/** 契約者＿機器送付先判定対象リスト */
	private static final String[] KSH_KKSHS_JDG_TG_LIST = {
		"ksh_kiki_sohus_ad_cd",				// 契約者＿機器送付先住所コード
		"ksh_kiki_sohus_pcd",				// 契約者＿機器送付先郵便番号
		"ksh_kiki_shs_ad_man_input_flg",	// 契約者＿機器送付先住所手動入力フラグ
		"ksh_kiki_sohus_state_nm",			// 契約者＿機器送付先都道府県名
		"ksh_kiki_sohus_city_nm",			// 契約者＿機器送付先市区町村名
		"ksh_kiki_sohus_oaztsu_nm",			// 契約者＿機器送付先大字通称名
		"ksh_kiki_sohus_azcho_nm",			// 契約者＿機器送付先字丁目名
		"ksh_kiki_sohus_bnchigo",			// 契約者＿機器送付先番地号
		"ksh_kiki_sohus_adrttm",			// 契約者＿機器送付先住所補記・建物名
		"ksh_kiki_sohus_adrrm",				// 契約者＿機器送付先住所補記・部屋番号
		"ksh_kiki_sohus_nm",				// 契約者＿機器送付先名
		"ksh_kiki_sohus_kana",				// 契約者＿機器送付先カナ名
		"ksh_kiki_sohus_telno"				// 契約者＿機器送付先電話番号
	};
	
	/** サービス契約番号（eo光ネット） */
	private String netSvcKeiNo = null;
	/** サービス契約番号（eo光電話） */
	private String telSvcKeiNo = null;
	/** サービス契約番号（eo光テレビ） */
	private String tvSvcKeiNo = null;
	/** サービス契約番号（eoADSL） */
	private String adslSvcKeiNo = null;
	
	/** 機器送付先同一フラグ */
	private boolean isSameKkshs = false;
	
// ANK-4427-00-00 ADD START
	/** ネットブランドタイプ（typeN）*/
	public static final String BRAND_TYPE_TYPEN = "2";
// ANK-4427-00-00 ADD END
	/**
	 * ワーク領域に格納されている項目値の取得を行います。
	 * <br>
	 * @param param
	 * @param mapName マップ名
	 * @param key マップの項目キー
	 * @return 指定されたマップに格納されている項目値
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getWorkMapValue(IRequestParameterReadWrite param, String mapName, String key) throws RequestParameterException
	{
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			return null;
		}

		HashMap ccWorkMap = (HashMap)workMap.get(mapName);
		if (ccWorkMap == null)
		{
			return null;
		}
		
		String workValue = (String)ccWorkMap.get(key);
		if ("".equals(workValue))
		{
			return null;
		}
		
		return workValue;
	}

	/**
	 * 利用場所情報登録処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite addUsePlaceInfo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		if (JPCModelConstant.FUNC_CD_1.equals(inMap.get(JCMConstants.FUNC_CODE_KEY)))
		{
			addRun(handle, param, fixedText);
		}
		else
		{
			addChk(handle, param, fixedText);
		}

		return param;
	}

	/**
	 * 利用場所情報登録処理。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void addRun(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;
		
		HashMap inMap = (HashMap)param.getData(fixedText);

		// サービス契約番号設定
		setSvcKeiNo(param);
		
		// 排他制御部品にサービス契約、申込明細番号設定
		setExcCtrl(param);

		if(null != netSvcKeiNo || null != telSvcKeiNo || null != tvSvcKeiNo || null != adslSvcKeiNo)
		{	// eo光ネット、eo光電話、eo光テレビ、eoADSLのいずれかが登録されている場合
			
			//**********↓障害対応(IT2-2012-0001185)**********/
			if(inMap.containsKey("key_pcd"))
			{
				// 郵便番号別関電営業所候補一覧照会
				template = editInEKK2321B010(param, fixedText); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK2321B010(result, param, fixedText); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
			//**********↑障害対応(IT2-2012-0001185)**********/
			
			// サービス回線内訳登録
			template = editInEKK0251D010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0251D010(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			ArrayList<HashMap<String, Object>> kikiList = (ArrayList<HashMap<String, Object>>)inMap.get(KKTK_SVC_KEI_LIST);
			if(null != kikiList)
			{
				String kktkSvcCd = null;
				for(HashMap<String, Object> kikiMap : kikiList)
				{
					String mskmDtlNo = null;
					
					kktkSvcCd = String.valueOf(kikiMap.get(PREFIX_KKTK_SVC_ADD + "kktk_svc_cd"));
					
					// 機器提供サービスコードが未設定の場合、次の要素を処理する。
					if(JKKCommonUtil.isNull(kktkSvcCd))
					{
						continue;
					}
					// 機器提供サービスコードがONUの場合
					else if(JKKStrConst.CD00132_ONU.equals(kktkSvcCd))
					{
						// ONU登録不可の場合、次の要素を処理する。
						if(!isAddONU(param, fixedText))
						{
							continue;
						}
						mskmDtlNo = getNetTelMskmDtlNo(param);
					}
					// 機器提供サービスコードがV-ONUの場合
					else if(JKKStrConst.CD00132_VONU.equals(kktkSvcCd))
					{
						// V-ONU登録不可の場合、次の要素を処理する。
						if(!isAddVONU(param, fixedText))
						{
							continue;
						}
						mskmDtlNo = getTvMskmDtlNo(param);
					}
					// 機器提供サービスコードがVDSLの場合
					else if(JKKStrConst.CD00132_MODEM.equals(kktkSvcCd))
					{
						// VDSL登録不可の場合、次の要素を処理する。
						if(!isAddVDSL(param, fixedText))
						{
							continue;
						}
						mskmDtlNo = getNetTelMskmDtlNo(param);
					}
					// 機器提供サービスコードが多機能ルーターの場合
					else if(JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kktkSvcCd))
					{
						// 多機能ルーター登録不可の場合、次の要素を処理する。
						if(!isAddTKNRTL(param, fixedText))
						{
							continue;
						}
						mskmDtlNo = getMskmDtlNoTakinort(param, fixedText);
					}
					// ANK-4315-00-00 ADD START
					// 機器提供サービスコードがHGWの場合
					else if(JKKStrConst.KKTK_SVC_CD_HGW.equals(kktkSvcCd))
					{
						// HGW登録不可の場合、次の要素を処理する。
						if(!isAddTKNRTL(param, fixedText) && !isAddONU(param, fixedText))
						{
							continue;
						}
						mskmDtlNo = getMskmDtlNoHgw(param, fixedText);
					}
					// ANK-4315-00-00 ADD END
					// ANK-4577-00-00 ADD START
					// 機器提供サービスコードがメッシュWiFi・無線LAN中継器の場合
					else if(JKKStrConst.CD00132_PLC.equals(kktkSvcCd))
					{
						mskmDtlNo = getNetTelMskmDtlNo(param);
					}
					// ANK-4577-00-00 ADD END
					
					// 対象外の機器の場合、次の要素を処理する。
					else
					{
						continue;
					}
					
					// 機器送付先チェック
					chkKkshs(param, fixedText, kikiMap);
					
					// 機器登録フラグ判定処理
					JKKBpCommon.judgeWkKikiAddFlg(param, kktkSvcCd, 
							(String)kikiMap.get(PREFIX_KKTK_SVC_ADD + "kktk_sbt_cd"));
					
					// 機器提供サービス契約登録
					editInAddKktkSvcKei(param, fixedText, kikiMap, PREFIX_KKTK_SVC_ADD, mskmDtlNo);
					JKKBpCommon.addKktkSvcKei(handle, param, kikiMap, PREFIX_KKTK_SVC_ADD);
					editRetAddKktkSvcKei(param, kikiMap, PREFIX_KKTK_SVC_ADD);
				}
			}
			// 機器オプションサービス契約登録リストを取得する。
			ArrayList<HashMap<String, Object>> kikiOpList = getList(param, fixedText, KKOP_SVC_ADD_LIST);
			String kkopSvcCd = null;
			
			for(HashMap<String, Object> kikiOpMap : kikiOpList)
			{
				kkopSvcCd = String.valueOf(kikiOpMap.get("kk2811_kkop_svc_cd"));
				
				if(JKKStrConst.KKOP_SVC_CD_ROUTER.equals(kkopSvcCd))
				{	//ｅｏ光多機能ルーター ルーター機能
					// が登録不要の場合、次の要素を処理する。
					if(!(netSvcKeiNo != null &&  "true".equals(String.valueOf(inMap.get("router_mskm_flg")))))
					{
						continue;
					}
				}
				else if(JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals(kkopSvcCd))
				{	//ｅｏ光多機能ルーター 電話アダプター機能
					// が登録不要の場合、次の要素を処理する。
					if(telSvcKeiNo == null)
					{
						continue;
					}
				}
				else
				{
					continue;
				}
				
				// 機器オプションサービス契約登録
				template = editInEKK2811D010(param, fixedText, kikiOpMap);
				result = scCall.run(putParamMap(paramMap, template), handle);
				editRetEKK2811D010(result, param, kikiOpMap);
				// ステータスが単項目エラー以上であれば例外をスロー
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}
		
		// 機器送付先の更新がない場合、エラーを発生させる
		Boolean isRunKkshsChk = (Boolean)inMap.get("kkshs_chk_run_flg");
		if(isRunKkshsChk && !isSameKkshs)
		{
			// 機器送付先チェック結果設定
			inMap.put("kkshs_chk_rslt", isSameKkshs);
			editErrInfoKkshs(param);
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}
	
	/**
	 * eo光ネットもしくはeo光電話の申込明細番号を取得します。
	 * <br>
	 * @param param リクエストパラーメータ
	 * @return eo光ネットもしくはeo光電話の申込明細番号
	 * @throws RequestParameterException
	 */
	private String getNetTelMskmDtlNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		String mskmDtlNo = null;
		
		mskmDtlNo = JKKBpCommon.getWkMskmDtlNoNet(param);
		if (null == mskmDtlNo || "".equals(mskmDtlNo))
		{
			mskmDtlNo = JKKBpCommon.getWkMskmDtlNoTel(param);
		}
		return mskmDtlNo;
	}
	
	/**
	 * eo光テレビの申込明細番号を取得します。
	 * <br>
	 * @param param リクエストパラーメータ
	 * @return eo光テレビの申込明細番号
	 * @throws RequestParameterException
	 */
	private String getTvMskmDtlNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		return JKKBpCommon.getWkMskmDtlNoTv(param);
	}

	/**
	 * 利用場所情報登録チェック処理。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	private void addChk(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;

		// サービス回線内訳登録
		template = editInEKK0251D010(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0251D010(result, param, fixedText); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}

	/**
	 * SCの実行ステータスの取得処理を行います。
	 * <br>
	 * @param param
	 * @return SCの実行ステータス
	 * @throws Exception
	 */
	private int getReturnCode(IRequestParameterReadWrite param) throws Exception
	{
		return Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
	}

	/**
	 * CAANMsgに必要なデータのマッピング処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return null;
		}
		
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();
		
		//**********↓障害対応(IT2-2012-0001185)**********/
		if(inMap.containsKey("key_pcd"))
		{
			msgList.add(editInEKK2321B010(param, fixedText)); // 郵便番号別関電営業所候補一覧照会
		}
		//**********↑障害対応(IT2-2012-0001185)**********/
		
		msgList.add(editInEKK0251D010(param, fixedText)); // サービス回線内訳登録

		// ONU、V-ONUを登録するための機器提供サービス契約登録サービスIFは呼び出さない
		// （ONU、V-ONUの登録に必要な値は画面入力を行わないのでチェックする必要がないため）
		

		int msgCnt = msgList.size();
		CAANMsg[] templates = new CAANMsg[msgCnt];
		for (int i = 0; i < msgCnt; i++)
		{
			templates[i] = msgList.get(i);
		}

		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 単一CAANMsgのマッピング処理を行います。
	 * <br>
	 * @param paramMap
	 * @param template
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> putParamMap(HashMap<String, Object> paramMap, CAANMsg template) throws RequestParameterException
	{
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * ワーク領域に格納されているArrayListの取得を行います。
	 * <br>
	 * @param param
	 * @param key
	 * @return ワーク領域に格納されているArrayList
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getWorkMapList(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{

		ArrayList dataList = new ArrayList();

		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();

		HashMap inMapTv = null;
		HashMap inMapNet = null;
		HashMap inMapTel = null;
		HashMap inMapAdsl = null;
		/* 作業項目情報 */
		if (workMap != null)
		{
			inMapTv = (HashMap)workMap.get(CC_WORK_AREA_NAME_TV);
			inMapNet = (HashMap)workMap.get(CC_WORK_AREA_NAME_NET);
			inMapTel = (HashMap)workMap.get(CC_WORK_AREA_NAME_TEL);
			inMapAdsl = (HashMap)workMap.get(CC_WORK_AREA_NAME_ADSL);
		}
		else
		{
			inMapTv = null;
			inMapNet = null;
			inMapTel = null;
			inMapAdsl = null;
			dataList = null;
		}

		// TVのサービス契約番号のセット
		if (inMapTv != null)
		{
			dataList.add((String)inMapTv.get(key));
		}
		// NETのサービス契約番号のセット
		if (inMapNet != null)
		{
			dataList.add((String)inMapNet.get(key));
		}
		// TELのサービス契約番号のセット
		if (inMapTel != null)
		{
			dataList.add((String)inMapTel.get(key));
		}
		// ADSLのサービス契約番号のセット
		if (inMapAdsl != null)
		{
			dataList.add((String)inMapAdsl.get(key));
		}

		return dataList;
	}

	/**
	 * SCインプット共通データ設定処理を行います。
	 * <br>
	 * @param param
	 * @param paramMap
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> setSCInputCommonData(IRequestParameterReadWrite param, HashMap<String, Object> paramMap)
			throws RequestParameterException
	{
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文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));

		return paramMap;
	}
	
	//**********↓障害対応(IT2-2012-0001185)**********/
	
	/**
	 * 郵便番号別関電営業所候補一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2321B010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2321B010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK2321B010CBSMsg.TEMPLATEID, "EKK2321B010");

		// 機能コード（デフォルト：１）
		template.set(EKK2321B010CBSMsg.FUNC_CODE, "1");

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// ＫＥＹ＿郵便番号 → 郵便番号別関電営業所候補一覧照会.ＫＥＹ＿郵便番号
		if (inMap == null || inMap.get("key_pcd") == null || "".equals(inMap.get("key_pcd")))
		{
			template.setNull(EKK2321B010CBSMsg.KEY_PCD);
		}
		else
		{
			template.set(EKK2321B010CBSMsg.KEY_PCD, (String)inMap.get("key_pcd"));
		}
		
		return template;
	}
	//**********↑障害対応(IT2-2012-0001185)**********/

	/**
	 * サービス契約回線内訳登録の上りマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0251D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0251D010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0251D010CBSMsg.TEMPLATEID, "EKK0251D010");

		// 機能コード（デフォルト：１）
		template.set(EKK0251D010CBSMsg.FUNC_CODE, "1");

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		//		HashMap inMap = (HashMap)param.getData("EKK0251D010");
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		if (inMap != null)
		{
			template.set(EKK0251D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		}

		// 作業領域のマップを取得
		HashMap workDataMap_Mskm = null;
		HashMap workDataMap_MskmList = null;
		Map workMapMskm = param.getMappingWorkArea();
		if (workMapMskm != null)
		{
			workDataMap_Mskm = (HashMap)workMapMskm.get(CC_WORK_AREA_NAME_MSKM);
			if (workDataMap_Mskm != null)
			{
				ArrayList<HashMap<String, Object>> inList1 = ((ArrayList<HashMap<String, Object>>)workDataMap_Mskm.get(CC_WORK_AREA_NAME_MSKM_LIST));
				int lv = 0;
				for(HashMap<String, Object> mp : inList1)
				{
					if(mp.containsKey(MSKM_DTL_NO_NET))
					{	// ネット
						workDataMap_MskmList = mp;
						break;
					}
					else if(mp.containsKey(MSKM_DTL_NO_TV))
					{	// テレビ
						workDataMap_MskmList = mp;
						lv = 3;
						continue;
					}
					else if(mp.containsKey(MSKM_DTL_NO_TEL))
					{	// 電話
						if(lv < 3)
						{	// テレビが設定されている場合は、設定しない
							workDataMap_MskmList = mp;
							lv = 2;
						}
						continue;
					}
					else if(mp.containsKey(MSKM_DTL_NO_ADSL))
					{	// ADSL
						if(lv < 2)
						{	// テレビ、電話が設定されている場合は、設定しない
							workDataMap_MskmList = mp;
							lv = 1;
						}
						continue;
					}
					// モバイルの場合は処理なし
				}
			}
		}


		// サービス契約回線内訳のデータを設定
		setEKK0251D010(param, template, inMap, workDataMap_MskmList);
		
		ArrayList dataList = (ArrayList)inMap.get("EKK0251D010CBSMsg1List");
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST);

		if (templateArray == null)
		{
			templateArray = new CAANMsg[dataList.size()];
		}

		ArrayList workDataList = getWorkMapList(param, "svc_kei_no");
		
		// 回線対象サービス契約のデータを設定
		setEKK0251D010CBSMsg1List(template, templateArray, dataList, workDataList);

		return template;
	}
	
	/**
	 * サービス契約回線内訳のデータを設定します。
	 * @param param IRequestParameterReadWrite
	 * @param template 値を設定するメッセージキャリア
	 * @param inMap ユーザデータ情報
	 * @param workDataMap_MskmList 申込明細番号が入っているリスト
	 */
	@SuppressWarnings("unchecked")
	private void setEKK0251D010(IRequestParameterReadWrite param, CAANMsg template
			, HashMap<String, Object> inMap, HashMap workDataMap_MskmList)
	{
		// サービス契約回線内訳登録.申込明細番号 → 申込明細番号
		if (inMap == null || inMap.get("kk0251_mskm_dtl_no") == null || "".equals(inMap.get("kk0251_mskm_dtl_no")))
		{
			if (workDataMap_MskmList == null || workDataMap_MskmList.get("mskm_dtl_no") == null || "".equals(workDataMap_MskmList.get("mskm_dtl_no")))
			{
				template.setNull(EKK0251D010CBSMsg.MSKM_DTL_NO);
			}
			else
			{
				template.set(EKK0251D010CBSMsg.MSKM_DTL_NO, (String)workDataMap_MskmList.get("mskm_dtl_no"));
			}
		}
		else
		{
			template.set(EKK0251D010CBSMsg.MSKM_DTL_NO, (String)inMap.get("kk0251_mskm_dtl_no"));
		}

		// サービス契約回線内訳登録.回線場所住所未確定フラグ → 回線場所住所未確定フラグ
		if (inMap == null || inMap.get("kisn_plc_ad_mi_fix_flg") == null || "".equals(inMap.get("kisn_plc_ad_mi_fix_flg")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_FLG);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_FLG, (String)inMap.get("kisn_plc_ad_mi_fix_flg"));
		}

		// サービス契約回線内訳登録.回線場所住所未確定解除年月日 → 回線場所住所未確定解除年月日
		if (inMap == null || inMap.get("kisn_plc_ad_mi_fix_rls_ymd") == null || "".equals(inMap.get("kisn_plc_ad_mi_fix_rls_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_RLS_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_RLS_YMD, (String)inMap.get("kisn_plc_ad_mi_fix_rls_ymd"));
		}

		// サービス契約回線内訳登録.回線場所_契約者住所差異フラグ → 回線場所_契約者住所差異フラグ
		if (inMap == null || inMap.get("kaisen_plc_ksh_ad_sai_flg") == null || "".equals(inMap.get("kaisen_plc_ksh_ad_sai_flg")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLC_KSH_AD_SAI_FLG);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLC_KSH_AD_SAI_FLG, (String)inMap.get("kaisen_plc_ksh_ad_sai_flg"));
		}

		// サービス契約回線内訳登録.お客様申告住所未確定フラグ → お客様申告住所未確定フラグ
		if (inMap == null || inMap.get("cust_skk_ad_mi_fix_flg") == null || "".equals(inMap.get("cust_skk_ad_mi_fix_flg")))
		{
			template.setNull(EKK0251D010CBSMsg.CUST_SKK_AD_MI_FIX_FLG);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.CUST_SKK_AD_MI_FIX_FLG, (String)inMap.get("cust_skk_ad_mi_fix_flg"));
		}

		// サービス契約回線内訳登録.お客様SOS利用有無 → お客様SOS利用有無
		if (inMap == null || inMap.get("cust_sos_use_um") == null || "".equals(inMap.get("cust_sos_use_um")))
		{
			template.setNull(EKK0251D010CBSMsg.CUST_SOS_USE_UM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.CUST_SOS_USE_UM, (String)inMap.get("cust_sos_use_um"));
		}

		// サービス契約回線内訳登録.回線コード → 回線コード
		if (inMap == null || inMap.get("kaisen_cd") == null || "".equals(inMap.get("kaisen_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_CD, (String)inMap.get("kaisen_cd"));
		}

		// サービス契約回線内訳登録.マンション物件番号 → マンション物件番号
		if (inMap == null || inMap.get("mansion_bukken_no") == null || "".equals(inMap.get("mansion_bukken_no")))
		{
			template.setNull(EKK0251D010CBSMsg.MANSION_BUKKEN_NO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.MANSION_BUKKEN_NO, (String)inMap.get("mansion_bukken_no"));
		}

		// サービス契約回線内訳登録.回線場所電話番号 → 回線場所電話番号
		if (inMap == null || inMap.get("kaisen_place_telno") == null || "".equals(inMap.get("kaisen_place_telno")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_TELNO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_TELNO, (String)inMap.get("kaisen_place_telno"));
		}

		// サービス契約回線内訳登録.回線場所カナ名 → 回線場所カナ名
		if (inMap == null || inMap.get("kaisen_plc_kana") == null || "".equals(inMap.get("kaisen_plc_kana")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLC_KANA);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLC_KANA, (String)inMap.get("kaisen_plc_kana"));
		}

		// サービス契約回線内訳登録.回線場所住所コード → 回線場所住所コード
		if (inMap == null || inMap.get("kaisen_place_ad_cd") == null || "".equals(inMap.get("kaisen_place_ad_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_AD_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_AD_CD, (String)inMap.get("kaisen_place_ad_cd"));
		}

		// サービス契約回線内訳登録.回線場所郵便番号 → 回線場所郵便番号
		if (inMap == null || inMap.get("kaisen_place_pcd") == null || "".equals(inMap.get("kaisen_place_pcd")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_PCD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_PCD, (String)inMap.get("kaisen_place_pcd"));
		}

		// サービス契約回線内訳登録.回線場所都道府県名 → 回線場所都道府県名
		if (inMap == null || inMap.get("kaisen_place_state_nm") == null || "".equals(inMap.get("kaisen_place_state_nm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_STATE_NM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_STATE_NM, (String)inMap.get("kaisen_place_state_nm"));
		}

		// サービス契約回線内訳登録.回線場所市区町村名 → 回線場所市区町村名
		if (inMap == null || inMap.get("kaisen_place_city_nm") == null || "".equals(inMap.get("kaisen_place_city_nm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_CITY_NM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_CITY_NM, (String)inMap.get("kaisen_place_city_nm"));
		}

		// サービス契約回線内訳登録.回線場所大字通称名 → 回線場所大字通称名
		if (inMap == null || inMap.get("kaisen_place_oaztsu_nm") == null || "".equals(inMap.get("kaisen_place_oaztsu_nm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_OAZTSU_NM, (String)inMap.get("kaisen_place_oaztsu_nm"));
		}

		// サービス契約回線内訳登録.回線場所字丁目名 → 回線場所字丁目名
		if (inMap == null || inMap.get("kaisen_place_azcho_nm") == null || "".equals(inMap.get("kaisen_place_azcho_nm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_AZCHO_NM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_AZCHO_NM, (String)inMap.get("kaisen_place_azcho_nm"));
		}

		// サービス契約回線内訳登録.回線場所番地号 → 回線場所番地号
		if (inMap == null || inMap.get("kaisen_place_bnchigo") == null || "".equals(inMap.get("kaisen_place_bnchigo")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_BNCHIGO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_BNCHIGO, (String)inMap.get("kaisen_place_bnchigo"));
		}

		// サービス契約回線内訳登録.回線場所住所補記・建物名 → 回線場所住所補記・建物名
		if (inMap == null || inMap.get("kaisen_place_adrttm") == null || "".equals(inMap.get("kaisen_place_adrttm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_ADRTTM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_ADRTTM, (String)inMap.get("kaisen_place_adrttm"));
		}

		// サービス契約回線内訳登録.回線場所住所補記・部屋番号 → 回線場所住所補記・部屋番号
		if (inMap == null || inMap.get("kaisen_place_adrrm") == null || "".equals(inMap.get("kaisen_place_adrrm")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_ADRRM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_ADRRM, (String)inMap.get("kaisen_place_adrrm"));
		}
		
		// ANK-3885-00-00 ADD START
		// サービス契約回線内訳登録.回線場所棟情報 → 回線場所棟情報
		if (inMap == null || inMap.get("kaisen_place_tou_info") == null || "".equals(inMap.get("kaisen_place_tou_info")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_TOU_INFO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_TOU_INFO, (String)inMap.get("kaisen_place_tou_info"));
		}
		// ANK-3885-00-00 ADD END

		// サービス契約回線内訳登録.回線場所番号 → 回線場所番号
		if (inMap == null || inMap.get("kaisen_place_no") == null || "".equals(inMap.get("kaisen_place_no")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_NO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_NO, (String)inMap.get("kaisen_place_no"));
		}

		// サービス契約回線内訳登録.回線場所区画整理中フラグ → 回線場所区画整理中フラグ
		if (inMap == null || inMap.get("kisn_plc_kkk_seiri_chu_flg") == null || "".equals(inMap.get("kisn_plc_kkk_seiri_chu_flg")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_KKK_SEIRI_CHU_FLG);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_KKK_SEIRI_CHU_FLG, (String)inMap.get("kisn_plc_kkk_seiri_chu_flg"));
		}

		// サービス契約回線内訳登録.回線場所補足コード1 → 回線場所補足コード1
		if (inMap == null || inMap.get("kisn_plc_hsk_cd_1") == null || "".equals(inMap.get("kisn_plc_hsk_cd_1")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_1);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_1, (String)inMap.get("kisn_plc_hsk_cd_1"));
		}

		// サービス契約回線内訳登録.回線場所補足コード2 → 回線場所補足コード2
		if (inMap == null || inMap.get("kisn_plc_hsk_cd_2") == null || "".equals(inMap.get("kisn_plc_hsk_cd_2")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_2);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_2, (String)inMap.get("kisn_plc_hsk_cd_2"));
		}

		// サービス契約回線内訳登録.回線場所補足メモ → 回線場所補足メモ
		if (inMap == null || inMap.get("kisn_plc_hsk_memo") == null || "".equals(inMap.get("kisn_plc_hsk_memo")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_PLC_HSK_MEMO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_PLC_HSK_MEMO, (String)inMap.get("kisn_plc_hsk_memo"));
		}

		// サービス契約回線内訳登録.住所形態コード → 住所形態コード
		if (inMap == null || inMap.get("ad_form_cd") == null || "".equals(inMap.get("ad_form_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.AD_FORM_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.AD_FORM_CD, (String)inMap.get("ad_form_cd"));
		}

		// サービス契約回線内訳登録.竣工予定年月日 → 竣工予定年月日
		if (inMap == null || inMap.get("shunko_rsv_ymd") == null || "".equals(inMap.get("shunko_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.SHUNKO_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SHUNKO_RSV_YMD, (String)inMap.get("shunko_rsv_ymd"));
		}

		// サービス契約回線内訳登録.電力送電予定年月日 → 電力送電予定年月日
		if (inMap == null || inMap.get("epower_soden_rsv_ymd") == null || "".equals(inMap.get("epower_soden_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.EPOWER_SODEN_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.EPOWER_SODEN_RSV_YMD, (String)inMap.get("epower_soden_rsv_ymd"));
		}

		// サービス契約回線内訳登録.入居予定年月日 → 入居予定年月日
		if (inMap == null || inMap.get("nyukyo_rsv_ymd") == null || "".equals(inMap.get("nyukyo_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.NYUKYO_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.NYUKYO_RSV_YMD, (String)inMap.get("nyukyo_rsv_ymd"));
		}

		// サービス契約回線内訳登録.引渡し予定年月日 → 引渡し予定年月日
		if (inMap == null || inMap.get("hikiwatashi_rsv_ymd") == null || "".equals(inMap.get("hikiwatashi_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.HIKIWATASHI_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.HIKIWATASHI_RSV_YMD, (String)inMap.get("hikiwatashi_rsv_ymd"));
		}

		// サービス契約回線内訳登録.引越し予定年月日 → 引越し予定年月日
		if (inMap == null || inMap.get("hikkoshi_rsv_ymd") == null || "".equals(inMap.get("hikkoshi_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.HIKKOSHI_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.HIKKOSHI_RSV_YMD, (String)inMap.get("hikkoshi_rsv_ymd"));
		}

		// サービス契約回線内訳登録.X座標 → X座標
		if (inMap == null || inMap.get("xzahyo") == null || "".equals(inMap.get("xzahyo")))
		{
			template.setNull(EKK0251D010CBSMsg.XZAHYO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.XZAHYO, (String)inMap.get("xzahyo"));
		}

		// サービス契約回線内訳登録.Y座標 → Y座標
		if (inMap == null || inMap.get("yzahyo") == null || "".equals(inMap.get("yzahyo")))
		{
			template.setNull(EKK0251D010CBSMsg.YZAHYO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.YZAHYO, (String)inMap.get("yzahyo"));
		}

		// サービス契約回線内訳登録.経度 → 経度
		if (inMap == null || inMap.get("lgtd") == null || "".equals(inMap.get("lgtd")))
		{
			template.setNull(EKK0251D010CBSMsg.LGTD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.LGTD, (String)inMap.get("lgtd"));
		}

		// サービス契約回線内訳登録.緯度 → 緯度
		if (inMap == null || inMap.get("lttd") == null || "".equals(inMap.get("lttd")))
		{
			template.setNull(EKK0251D010CBSMsg.LTTD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.LTTD, (String)inMap.get("lttd"));
		}

		// サービス契約回線内訳登録.座標補正有無 → 座標補正有無
		if (inMap == null || inMap.get("zahyo_hosei_um") == null || "".equals(inMap.get("zahyo_hosei_um")))
		{
			//**********↓障害対応(IT1-2012-0000024)**********/
//			template.setNull(EKK0251D010CBSMsg.ZAHYO_HOSEI_UM);
			template.set(EKK0251D010CBSMsg.ZAHYO_HOSEI_UM, JKKStrConst.CD_DIV_UM_NASHI);
			//**********↑障害対応(IT1-2012-0000024)**********/
		}
		else
		{
			template.set(EKK0251D010CBSMsg.ZAHYO_HOSEI_UM, (String)inMap.get("zahyo_hosei_um"));
		}

		// サービス契約回線内訳登録.テレビ個別対応コード → テレビ個別対応コード
		if (inMap == null || inMap.get("tv_kobet_taio_cd") == null || "".equals(inMap.get("tv_kobet_taio_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.TV_KOBET_TAIO_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.TV_KOBET_TAIO_CD, (String)inMap.get("tv_kobet_taio_cd"));
		}

		// サービス契約回線内訳登録.TVアンテナ有無 → TVアンテナ有無
		if (inMap == null || inMap.get("tv_antenna_um") == null || "".equals(inMap.get("tv_antenna_um")))
		{
			template.setNull(EKK0251D010CBSMsg.TV_ANTENNA_UM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.TV_ANTENNA_UM, (String)inMap.get("tv_antenna_um"));
		}

		// サービス契約回線内訳登録.方角コード1 → 方角コード1
		if (inMap == null || inMap.get("direction_cd_1") == null || "".equals(inMap.get("direction_cd_1")))
		{
			template.setNull(EKK0251D010CBSMsg.DIRECTION_CD_1);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.DIRECTION_CD_1, (String)inMap.get("direction_cd_1"));
		}

		// サービス契約回線内訳登録.方角コード2 → 方角コード2
		if (inMap == null || inMap.get("direction_cd_2") == null || "".equals(inMap.get("direction_cd_2")))
		{
			template.setNull(EKK0251D010CBSMsg.DIRECTION_CD_2);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.DIRECTION_CD_2, (String)inMap.get("direction_cd_2"));
		}

		// サービス契約回線内訳登録.戸建建築階数コード → 戸建建築階数コード
		if (inMap == null || inMap.get("kodate_kcku_flr_cnt_cd") == null || "".equals(inMap.get("kodate_kcku_flr_cnt_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KODATE_KCKU_FLR_CNT_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KODATE_KCKU_FLR_CNT_CD, (String)inMap.get("kodate_kcku_flr_cnt_cd"));
		}

		// サービス契約回線内訳登録.集合住宅入居階数コード → 集合住宅入居階数コード
		if (inMap == null || inMap.get("shugj_nyukyo_flr_cnt_cd") == null || "".equals(inMap.get("shugj_nyukyo_flr_cnt_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.SHUGJ_NYUKYO_FLR_CNT_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SHUGJ_NYUKYO_FLR_CNT_CD, (String)inMap.get("shugj_nyukyo_flr_cnt_cd"));
		}

		// サービス契約回線内訳登録.PON種別コード → PON種別コード
		if (inMap == null || inMap.get("pon_sbt_cd") == null || "".equals(inMap.get("pon_sbt_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.PON_SBT_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.PON_SBT_CD, (String)inMap.get("pon_sbt_cd"));
		}

		// サービス契約回線内訳登録.回線提供会社コード → 回線提供会社コード
		if (inMap == null || inMap.get("kaisen_tk_comp_cd") == null || "".equals(inMap.get("kaisen_tk_comp_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD, (String)inMap.get("kaisen_tk_comp_cd"));
		}

		// サービス契約回線内訳登録.VDSL利用電話回線種別コード → VDSL利用電話回線種別コード
		if (inMap == null || inMap.get("vdsl_use_tel_kisn_sbt_cd") == null || "".equals(inMap.get("vdsl_use_tel_kisn_sbt_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.VDSL_USE_TEL_KISN_SBT_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.VDSL_USE_TEL_KISN_SBT_CD, (String)inMap.get("vdsl_use_tel_kisn_sbt_cd"));
		}

		// サービス契約回線内訳登録.VDSL利用電話回線切替予定年月日 → VDSL利用電話回線切替予定年月日
		if (inMap == null || inMap.get("vdsl_use_dksn_swch_rsv_ymd") == null || "".equals(inMap.get("vdsl_use_dksn_swch_rsv_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.VDSL_USE_DKSN_SWCH_RSV_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.VDSL_USE_DKSN_SWCH_RSV_YMD, (String)inMap.get("vdsl_use_dksn_swch_rsv_ymd"));
		}

		// サービス契約回線内訳登録.VDSL利用対象電話番号回線種別コード → VDSL利用対象電話番号回線種別コード
		if (inMap == null || inMap.get("vdsl_use_tg_dbksn_sbt_cd") == null || "".equals(inMap.get("vdsl_use_tg_dbksn_sbt_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.VDSL_USE_TG_DBKSN_SBT_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.VDSL_USE_TG_DBKSN_SBT_CD, (String)inMap.get("vdsl_use_tg_dbksn_sbt_cd"));
		}

		// サービス契約回線内訳登録.VDSL利用対象電話番号 → VDSL利用対象電話番号
		if (inMap == null || inMap.get("vdsl_use_tg_telno") == null || "".equals(inMap.get("vdsl_use_tg_telno")))
		{
			template.setNull(EKK0251D010CBSMsg.VDSL_USE_TG_TELNO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.VDSL_USE_TG_TELNO, (String)inMap.get("vdsl_use_tg_telno"));
		}

		// サービス契約回線内訳登録.該当エリアサービス開始年月日 → 該当エリアサービス開始年月日
		if (inMap == null || inMap.get("gaito_area_svc_staymd") == null || "".equals(inMap.get("gaito_area_svc_staymd")))
		{
			template.setNull(EKK0251D010CBSMsg.GAITO_AREA_SVC_STAYMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.GAITO_AREA_SVC_STAYMD, (String)inMap.get("gaito_area_svc_staymd"));
		}

		// サービス契約回線内訳登録.起点変電所コード → 起点変電所コード
		if (inMap == null || inMap.get("kiten_hdsho_cd") == null || "".equals(inMap.get("kiten_hdsho_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KITEN_HDSHO_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KITEN_HDSHO_CD, (String)inMap.get("kiten_hdsho_cd"));
		}

		// サービス契約回線内訳登録.集約局コード → 集約局コード
		if (inMap == null || inMap.get("shyakk_cd") == null || "".equals(inMap.get("shyakk_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.SHYAKK_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SHYAKK_CD, (String)inMap.get("shyakk_cd"));
		}

		// サービス契約回線内訳登録.関電営業所コード → 関電営業所コード
		if (inMap == null || inMap.get("kepco_busioffice_cd") == null || "".equals(inMap.get("kepco_busioffice_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KEPCO_BUSIOFFICE_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KEPCO_BUSIOFFICE_CD, (String)inMap.get("kepco_busioffice_cd"));
		}

		// サービス契約回線内訳登録.請求書用回線場所住所部屋番号 → 請求書用回線場所住所部屋番号
		if (inMap == null || inMap.get("sks_yo_kisn_place_ad_rm_no") == null || "".equals(inMap.get("sks_yo_kisn_place_ad_rm_no")))
		{
			template.setNull(EKK0251D010CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO, (String)inMap.get("sks_yo_kisn_place_ad_rm_no"));
		}
		
		// サービス契約回線内訳登録.請求書送付先住所変更有無 → 請求書送付先住所変更有無
		if (inMap == null || inMap.get("sks_shs_ad_chg_um") == null || "".equals(inMap.get("sks_shs_ad_chg_um")))
		{
			template.setNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_UM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_UM, (String)inMap.get("sks_shs_ad_chg_um"));
		}
		
		// サービス契約回線内訳登録.請求書送付先住所変更希望年月日 → 請求書送付先住所変更希望年月日
		if (inMap == null || inMap.get("sks_shs_ad_chg_kibo_ymd") == null || "".equals(inMap.get("sks_shs_ad_chg_kibo_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD, (String)inMap.get("sks_shs_ad_chg_kibo_ymd"));
		}
		
		// サービス契約回線内訳登録.契約者住所変更有無 → 契約者住所変更有無
		if (inMap == null || inMap.get("kshad_chg_um") == null || "".equals(inMap.get("kshad_chg_um")))
		{
			template.setNull(EKK0251D010CBSMsg.KSHAD_CHG_UM);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KSHAD_CHG_UM, (String)inMap.get("kshad_chg_um"));
		}
		
		// サービス契約回線内訳登録.契約者住所変更希望年月日 → 契約者住所変更希望年月日
		if (inMap == null || inMap.get("kshad_chg_kibo_ymd") == null || "".equals(inMap.get("kshad_chg_kibo_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD, (String)inMap.get("kshad_chg_kibo_ymd"));
		}
		
		// サービス契約回線内訳登録.回線場所住所チェックレベル → 回線場所住所チェックレベル
		if (inMap == null || inMap.get("kisn_ad_chk_lv") == null || "".equals(inMap.get("kisn_ad_chk_lv")))
		{
			template.setNull(EKK0251D010CBSMsg.KISN_AD_CHK_LV);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KISN_AD_CHK_LV, (String)inMap.get("kisn_ad_chk_lv"));
		}
		// ANK-4244-00-00 ADD START
		// サービス契約回線内訳登録.回線場所連番 → 回線場所連番
		if (inMap == null || inMap.get("kaisen_place_renban") == null || "".equals(inMap.get("kaisen_place_renban")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_PLACE_RENBAN);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_PLACE_RENBAN, (String)inMap.get("kaisen_place_renban"));
		}
		// ANK-4244-00-00 ADD END
	}
	
	/**
	 * 回線対象サービス契約のデータを設定します。<br>
	 * 　�@workDataList内にデータが存在しない場合、dataList内のデータを設定します。<br>
	 * 　�A上記以外の場合、workDataList内のデータを設定します。
	 * @param template 値を設定するメッセージキャリア
	 * @param templateArray 値を設定するメッセージキャリア配列
	 * @param dataList マッピング情報リスト
	 * @param workDataList 作業領域リスト
	 */
	@SuppressWarnings("unchecked")
	private void setEKK0251D010CBSMsg1List(CAANMsg template, CAANMsg[] templateArray
			, ArrayList dataList, ArrayList workDataList)
	{
		CAANMsg[] tmpArray = templateArray;
		if (dataList != null)
		{

			if (workDataList.size() != 0)
			{

				for (int iCnt = 0; iCnt < workDataList.size(); iCnt++)
				{

					CAANMsg childTemplate = tmpArray[iCnt];
					if (childTemplate == null)
					{
						childTemplate = new CAANMsg(EKK0251D010CBSMsg1List.class.getName());
					}

					// サービス契約回線内訳登録.サービス契約番号 → サービス契約回線内訳登録.サービス契約番号 のエラー情報返却
					if ((String)workDataList.get(iCnt) == null || "".equals((String)workDataList.get(iCnt)))
					{
						childTemplate.setNull(EKK0251D010CBSMsg1List.SVC_KEI_NO);
					}
					else
					{
						childTemplate.set(EKK0251D010CBSMsg1List.SVC_KEI_NO, (String)workDataList.get(iCnt));
					}
					tmpArray[iCnt] = childTemplate;
				}

			}
			else
			{

				for (int i = 0; i < dataList.size(); i++)
				{
					HashMap childMap = (HashMap)dataList.get(i);

					CAANMsg childTemplate = tmpArray[i];
					if (childTemplate == null)
					{
						childTemplate = new CAANMsg(EKK0251D010CBSMsg1List.class.getName());
					}
					// サービス契約回線内訳登録.サービス契約番号 → サービス契約回線内訳登録.サービス契約番号
					if (childMap == null || childMap.get("svc_kei_no") == null || "".equals(childMap.get("svc_kei_no")))
					{
						childTemplate.setNull(EKK0251D010CBSMsg1List.SVC_KEI_NO);
					}
					else
					{
						childTemplate.set(EKK0251D010CBSMsg1List.SVC_KEI_NO, (String)childMap.get("svc_kei_no"));
					}
					tmpArray[i] = childTemplate;
				}
			}

		}
		template.set(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST, templateArray);
	}
	
	//**********↓障害対応(IT2-2012-0001185)**********/
	
	/**
	 * 郵便番号別関電営業所候補一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK2321B010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK2321B010CBSMsg.EKK2321B010CBSMSG1LIST);
		ArrayList msg1List = (ArrayList)dataMap.get("EKK2321B010CBSMsg1List");

		if (msg1List == null)
		{
			msg1List = new ArrayList();
			dataMap.put("EKK2321B010CBSMsg1List", msg1List);
		}

		// 関電営業所コード格納変数
		String kepcoBusiofficeCd = null;
		
		boolean kepcoBOCdOneFlg = true;
		
		if (templateArray != null && 1 <= templateArray.length)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				HashMap childMap = new HashMap();
				
				// 郵便番号別関電営業所候補番号 ← 郵便番号別関電営業所候補一覧照会.郵便番号別関電営業所候補番号
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KOHO_NO))
				{
					childMap.put("pcdb_kpcofc_koho_no", "");
				}
				else
				{
					childMap.put("pcdb_kpcofc_koho_no", childTemplate.getString(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KOHO_NO));
				}
				
				// 郵便番号 ← 郵便番号別関電営業所候補一覧照会.郵便番号
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCD))
				{
					childMap.put("pcd", "");
				}
				else
				{
					childMap.put("pcd", childTemplate.getString(EKK2321B010CBSMsg1List.PCD));
				}
				
				// 郵便番号住所説明1 ← 郵便番号別関電営業所候補一覧照会.郵便番号住所説明1
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCD_AD_SETMEI_1))
				{
					childMap.put("pcd_ad_setmei_1", "");
				}
				else
				{
					childMap.put("pcd_ad_setmei_1", childTemplate.getString(EKK2321B010CBSMsg1List.PCD_AD_SETMEI_1));
				}
				
				// 郵便番号住所説明2 ← 郵便番号別関電営業所候補一覧照会.郵便番号住所説明2
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCD_AD_SETMEI_2))
				{
					childMap.put("pcd_ad_setmei_2", "");
				}
				else
				{
					childMap.put("pcd_ad_setmei_2", childTemplate.getString(EKK2321B010CBSMsg1List.PCD_AD_SETMEI_2));
				}
				
				// 光エリアサービス開始年月日 ← 郵便番号別関電営業所候補一覧照会.光エリアサービス開始年月日
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.HIKARI_AREA_SVC_STAYMD))
				{
					childMap.put("hikari_area_svc_staymd", "");
				}
				else
				{
					childMap.put("hikari_area_svc_staymd", childTemplate.getString(EKK2321B010CBSMsg1List.HIKARI_AREA_SVC_STAYMD));
				}
				
				// 関電営業所コード ← 郵便番号別関電営業所候補一覧照会.関電営業所コード
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.KEPCO_BUSIOFFICE_CD))
				{
					childMap.put("kepco_busioffice_cd", "");
				}
				else
				{
					// 照会されたレコード群のなかで異なる関電営業所コードの存在が検出できた場合、フラグをオフにする。
					if (kepcoBusiofficeCd != null && !kepcoBusiofficeCd.equals(childTemplate.getString(EKK2321B010CBSMsg1List.KEPCO_BUSIOFFICE_CD)))
					{
						kepcoBOCdOneFlg = false;
					}
					childMap.put("kepco_busioffice_cd", childTemplate.getString(EKK2321B010CBSMsg1List.KEPCO_BUSIOFFICE_CD));
					kepcoBusiofficeCd = childTemplate.getString(EKK2321B010CBSMsg1List.KEPCO_BUSIOFFICE_CD);
				}
				
				// 郵便番号別関電営業所候補適用開始年月日 ← 郵便番号別関電営業所候補一覧照会.郵便番号別関電営業所候補適用開始年月日
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KHO_TSTAYMD))
				{
					childMap.put("pcdb_kpcofc_kho_tstaymd", "");
				}
				else
				{
					childMap.put("pcdb_kpcofc_kho_tstaymd", childTemplate.getString(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KHO_TSTAYMD));
				}
				
				// 郵便番号別関電営業所候補適用終了年月日 ← 郵便番号別関電営業所候補一覧照会.郵便番号別関電営業所候補適用終了年月日
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KHO_TENDYMD))
				{
					childMap.put("pcdb_kpcofc_kho_tendymd", "");
				}
				else
				{
					childMap.put("pcdb_kpcofc_kho_tendymd", childTemplate.getString(EKK2321B010CBSMsg1List.PCDB_KPCOFC_KHO_TENDYMD));
				}
				
				// コード区分名 ← 郵便番号別関電営業所候補一覧照会.コード区分名
				if (childTemplate.isNull(EKK2321B010CBSMsg1List.CD_DIV_NM))
				{
					childMap.put("cd_div_nm", "");
				}
				else
				{
					childMap.put("cd_div_nm", childTemplate.getString(EKK2321B010CBSMsg1List.CD_DIV_NM));
				}
				
				msg1List.add(childMap);
			}
		}
		
		if(msg1List.size() > 0 && kepcoBOCdOneFlg)
		{
			// 郵便番号別関電営業所候補一覧照会の取得レコードで関電営業所コードが一意である場合、関電営業所コードを設定
			dataMap.put("kepco_busioffice_cd", kepcoBusiofficeCd);
		}
			
		// エラー情報の設定
		editErrInfoEKK2321B010(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}
	//**********↑障害対応(IT2-2012-0001185)**********/
	
	/**
	 * サービス回線内訳登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0251D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		HashMap ccWorkMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (ccWorkMap == null)
		{
			ccWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, ccWorkMap);
		}

		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// サービス契約回線内訳登録.サービス契約回線内訳番号 ← サービス契約回線内訳番号
		if (template.isNull(EKK0251D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO))
		{
			dataMap.put("svc_kei_kaisen_ucwk_no", "");
			ccWorkMap.put(WK_KAISEN_UCWK, "");
		}
		else
		{
			dataMap.put("svc_kei_kaisen_ucwk_no", template.getString(EKK0251D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO));
			ccWorkMap.put(WK_KAISEN_UCWK, template.getString(EKK0251D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO));
		}

		// サービス契約回線内訳登録.世代登録年月日時分秒 ← 世代登録年月日時分秒
		if (template.isNull(EKK0251D010CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("gene_add_dtm", "");
		}
		else
		{
			dataMap.put("gene_add_dtm", template.getString(EKK0251D010CBSMsg.GENE_ADD_DTM));
		}

		// サービス契約回線内訳登録.サービス契約回線内訳ステータス ← サービス契約回線内訳ステータス
		if (template.isNull(EKK0251D010CBSMsg.SVC_KEI_KAISEN_UCWK_STAT))
		{
			dataMap.put("svc_kei_kaisen_ucwk_stat", "");
		}
		else
		{
			dataMap.put("svc_kei_kaisen_ucwk_stat", template.getString(EKK0251D010CBSMsg.SVC_KEI_KAISEN_UCWK_STAT));
		}

		// サービス契約回線内訳登録.登録年月日時分秒 ← 登録年月日時分秒
		if (template.isNull(EKK0251D010CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(EKK0251D010CBSMsg.ADD_DTM));
		}

		// サービス契約回線内訳登録.登録オペレータアカウント ← 登録オペレータアカウント
		if (template.isNull(EKK0251D010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(EKK0251D010CBSMsg.ADD_OPEACNT));
		}

		// サービス契約回線内訳登録.更新年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(EKK0251D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0251D010CBSMsg.UPD_DTM));

			String lastDtm = template.getString(EKK0251D010CBSMsg.UPD_DTM);
			setLastUpdateDate(param, lastDtm);
		}

		// サービス契約回線内訳登録.更新オペレータアカウント ← 更新オペレータアカウント
		if (template.isNull(EKK0251D010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(EKK0251D010CBSMsg.UPD_OPEACNT));
		}

		// サービス契約回線内訳登録.無効フラグ ← 無効フラグ
		if (template.isNull(EKK0251D010CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(EKK0251D010CBSMsg.MK_FLG));
		}

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		editErrInfoEKK0251D010(param, template, (Integer)returnCode, fixedText);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}

	/**
	 * 機器提供サービス契約登録部品の上りマッピングを行います。(登録用)
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param inMap 設定先マップ
	 * @param prefix 設定先マップ用のプレフィックス
	 * @param mskmDtlNo 申込明細番号
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private void editInAddKktkSvcKei(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> inMap
			, String prefix, String mskmDtlNo) throws RequestParameterException
	{
		HashMap<String, Object> mp = (HashMap<String, Object>)param.getData(fixedText);
		
		// 機能コード設定
		inMap.put("func_code", mp.get(JCMConstants.FUNC_CODE_KEY));
		
		// ANK-4577-00-00 MOD START
		// 機器提供サービスコード
		String kktkSvcCd = String.valueOf(inMap.get(PREFIX_KKTK_SVC_ADD + "kktk_svc_cd"));
		
		// 機器提供サービスコードがメッシュWiFi・無線LAN中継器の場合
		if(JKKStrConst.CD00132_PLC.equals(kktkSvcCd))
		{
			// サービス契約番号
			String svcKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_NET, WK_SVC_KEI_NO);
			inMap.put(prefix + "svc_kei_no", svcKeiNo);
		}
		else
		{
			// サービス契約回線内訳番号
			String svcKeiKaisenUcwkNo = getWorkMapValue(param, CC_WORK_AREA_NAME, WK_KAISEN_UCWK);
			inMap.put(prefix + "svc_kei_kaisen_ucwk_no", svcKeiKaisenUcwkNo);
		}
//		// サービス契約回線内訳番号
//		String svcKeiKaisenUcwkNo = getWorkMapValue(param, CC_WORK_AREA_NAME, WK_KAISEN_UCWK);
//		inMap.put(prefix + "svc_kei_kaisen_ucwk_no", svcKeiKaisenUcwkNo);
		// ANK-4577-00-00 MOD END
		
		// SYSID
		if(null == inMap.get(prefix + "sysid") || "".equals(inMap.get(prefix + "sysid")))
		{	// SYSIDが未設定の場合
			String sysid = getWorkMapValue(param, CC_WORK_AREA_NAME_KEISHA, WK_SYSID);
			inMap.put(prefix + "sysid", sysid);
		}
		
		// 請求契約番号
		if(null == inMap.get(prefix + "seiky_kei_no") || "".equals(inMap.get(prefix + "seiky_kei_no")))
		{	// 請求契約番号が未設定の場合
			String seikyKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_PAYWAY, WK_SEIKY_KEI_NO);
			inMap.put(prefix + "seiky_kei_no", seikyKeiNo);
		}
		
		// 更新年月日時分秒(更新前)
		String lastDtm = getLastUpdateDate(param, null);
		inMap.put(prefix + "upd_dtm_bf", lastDtm);
		
		// 申込明細番号
		inMap.put(prefix + "mskm_dtl_no", mskmDtlNo);
	}

	/**
	 * 機器提供サービス契約登録部品の下りマッピングを行います。(登録用)
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param inMap 取得元マップ
	 * @param prefix 取得元マップのプレフィックス
	 * @throws RequestParameterException
	 */
	private void editRetAddKktkSvcKei(IRequestParameterReadWrite param, HashMap<String, Object> inMap
			, String prefix) throws RequestParameterException
	{
		// 最終更新年月日時分秒を設定
		String lastDtm = String.valueOf(inMap.get(prefix + "upd_dtm"));
		setLastUpdateDate(param, lastDtm);
	}

	/**
	 * エラー情報のマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		HashMap inMap = (HashMap)param.getData(fixedText);

		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}
		
		//**********↓障害対応(IT2-2012-0001185)**********/
		if(inMap.containsKey("key_pcd"))
		{
			editErrInfoEKK2321B010(param, templates[0], returnCode, fixedText); // 郵便番号別関電営業所候補一覧照会
		}
		//**********↑障害対応(IT2-2012-0001185)**********/
		
		editErrInfoEKK0251D010(param, templates[0], returnCode, fixedText); // サービス回線内訳登録

		// getInvokeCBS()でONU、V-ONUを登録するための機器提供サービス契約登録サービスIFは呼び出さない。
		// それにあわせて、エラー返却も行わない。

		return param;
	}
	
	//**********↓障害対応(IT2-2012-0001185)**********/
	
	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param itemplateStatus サービスインターフェイスステータス
	 * @param returnCode リターンコード
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite setControlMapErrInfo(IRequestParameterReadWrite param, int itemplateStatus, int returnCode)
			throws RequestParameterException
	{
		int templateStatus = itemplateStatus;

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		return param;
	}
	//**********↑障害対応(IT2-2012-0001185)**********/

	//**********↓障害対応(IT2-2012-0001185)**********/
	
	/**
	 * 郵便番号別関電営業所候補一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template テンプレートリスト
	 * @param returnCode リターンコード
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2321B010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK2321B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 郵便番号別関電営業所候補一覧照会.ＫＥＹ＿郵便番号 → ＫＥＹ＿郵便番号 のエラー情報返却
		if (!template.isNull(EKK2321B010CBSMsg.KEY_PCD_ERR))
		{
			if (!inMap.containsKey("key_pcd_err"))
			{
				inMap.put("key_pcd_err", template.getString(EKK2321B010CBSMsg.KEY_PCD_ERR));
			}
		}
		
		return param;
	}
	//**********↑障害対応(IT2-2012-0001185)**********/
	
	//**********↓障害対応(IT2-2012-0001185)**********/
	
	/**
	 * サービス回線内訳登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0251D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0251D010CBSMsg.STATUS), returnCode);
		//**********↑障害対応(IT2-2012-0001185)**********/

		HashMap inMap = (HashMap<String, Object>)param.getData(fixedText);

		// サービス契約回線内訳のエラー情報を設定
		setErrInfoEKK0251D010(template, inMap);

		ArrayList dataList = (ArrayList)inMap.get("EKK0251D010CBSMsg1List");
		if (dataList == null)
		{
			dataList = new ArrayList();
			inMap.put("EKK0251D010CBSMsg1List", dataList);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST);

		// 回線対象サービス契約のエラー情報を設定
		setErrEKK0251D010CBSMsg1List(template, templateArray, dataList, inMap);

		return param;
	}
	
	/**
	 * サービス契約回線内訳のエラー情報を設定します。
	 * @param template エラーを設定するメッセージキャリア
	 * @param inMap ユーザデータ情報
	 */
	@SuppressWarnings("unchecked")
	private void setErrInfoEKK0251D010(CAANMsg template, HashMap inMap)
	{
		// サービス契約回線内訳登録.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0251D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所住所未確定フラグ → 回線場所住所未確定フラグ のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_FLG_ERR))
		{
			if (!inMap.containsKey("kisn_plc_ad_mi_fix_flg_err"))
			{
				inMap.put("kisn_plc_ad_mi_fix_flg_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_FLG_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所住所未確定解除年月日 → 回線場所住所未確定解除年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_RLS_YMD_ERR))
		{
			if (!inMap.containsKey("kisn_plc_ad_mi_fix_rls_ymd_err"))
			{
				inMap.put("kisn_plc_ad_mi_fix_rls_ymd_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_AD_MI_FIX_RLS_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所_契約者住所差異フラグ → 回線場所_契約者住所差異フラグ のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLC_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kaisen_plc_ksh_ad_sai_flg_err"))
			{
				inMap.put("kaisen_plc_ksh_ad_sai_flg_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLC_KSH_AD_SAI_FLG_ERR));
			}
		}

		// サービス契約回線内訳登録.お客様申告住所未確定フラグ → お客様申告住所未確定フラグ のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.CUST_SKK_AD_MI_FIX_FLG_ERR))
		{
			if (!inMap.containsKey("cust_skk_ad_mi_fix_flg_err"))
			{
				inMap.put("cust_skk_ad_mi_fix_flg_err", template.getString(EKK0251D010CBSMsg.CUST_SKK_AD_MI_FIX_FLG_ERR));
			}
		}

		// サービス契約回線内訳登録.お客様SOS利用有無 → お客様SOS利用有無 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.CUST_SOS_USE_UM_ERR))
		{
			if (!inMap.containsKey("cust_sos_use_um_err"))
			{
				inMap.put("cust_sos_use_um_err", template.getString(EKK0251D010CBSMsg.CUST_SOS_USE_UM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線コード → 回線コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_CD_ERR))
		{
			if (!inMap.containsKey("kaisen_cd_err"))
			{
				inMap.put("kaisen_cd_err", template.getString(EKK0251D010CBSMsg.KAISEN_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.マンション物件番号 → マンション物件番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.MANSION_BUKKEN_NO_ERR))
		{
			if (!inMap.containsKey("mansion_bukken_no_err"))
			{
				inMap.put("mansion_bukken_no_err", template.getString(EKK0251D010CBSMsg.MANSION_BUKKEN_NO_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所電話番号 → 回線場所電話番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_TELNO_ERR))
		{
			if (!inMap.containsKey("kaisen_place_telno_err"))
			{
				inMap.put("kaisen_place_telno_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_TELNO_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所カナ名 → 回線場所カナ名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLC_KANA_ERR))
		{
			if (!inMap.containsKey("kaisen_plc_kana_err"))
			{
				inMap.put("kaisen_plc_kana_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLC_KANA_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所住所コード → 回線場所住所コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_AD_CD_ERR))
		{
			if (!inMap.containsKey("kaisen_place_ad_cd_err"))
			{
				inMap.put("kaisen_place_ad_cd_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_AD_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所郵便番号 → 回線場所郵便番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_PCD_ERR))
		{
			if (!inMap.containsKey("kaisen_place_pcd_err"))
			{
				inMap.put("kaisen_place_pcd_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_PCD_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所都道府県名 → 回線場所都道府県名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_state_nm_err"))
			{
				inMap.put("kaisen_place_state_nm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_STATE_NM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所市区町村名 → 回線場所市区町村名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_city_nm_err"))
			{
				inMap.put("kaisen_place_city_nm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_CITY_NM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所大字通称名 → 回線場所大字通称名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_oaztsu_nm_err"))
			{
				inMap.put("kaisen_place_oaztsu_nm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所字丁目名 → 回線場所字丁目名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_azcho_nm_err"))
			{
				inMap.put("kaisen_place_azcho_nm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所番地号 → 回線場所番地号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kaisen_place_bnchigo_err"))
			{
				inMap.put("kaisen_place_bnchigo_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_BNCHIGO_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所住所補記・建物名 → 回線場所住所補記・建物名 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_adrttm_err"))
			{
				inMap.put("kaisen_place_adrttm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_ADRTTM_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所住所補記・部屋番号 → 回線場所住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_ADRRM_ERR))
		{
			if (!inMap.containsKey("kaisen_place_adrrm_err"))
			{
				inMap.put("kaisen_place_adrrm_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_ADRRM_ERR));
			}
		}

		// ANK-3885-00-00 ADD START
		// サービス契約回線内訳登録.回線場所棟情報 → 回線場所棟情報 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_TOU_INFO_ERR))
		{
			if (!inMap.containsKey("kaisen_place_tou_info_err"))
			{
				inMap.put("kaisen_place_tou_info_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_TOU_INFO_ERR));
			}
		}
		// ANK-3885-00-00 ADD END

		
		// サービス契約回線内訳登録.回線場所番号 → 回線場所番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_NO_ERR))
		{
			if (!inMap.containsKey("kaisen_place_no_err"))
			{
				inMap.put("kaisen_place_no_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_NO_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所区画整理中フラグ → 回線場所区画整理中フラグ のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_KKK_SEIRI_CHU_FLG_ERR))
		{
			if (!inMap.containsKey("kisn_plc_kkk_seiri_chu_flg_err"))
			{
				inMap.put("kisn_plc_kkk_seiri_chu_flg_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_KKK_SEIRI_CHU_FLG_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所補足コード1 → 回線場所補足コード1 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kisn_plc_hsk_cd_1_err"))
			{
				inMap.put("kisn_plc_hsk_cd_1_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_1_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所補足コード2 → 回線場所補足コード2 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kisn_plc_hsk_cd_2_err"))
			{
				inMap.put("kisn_plc_hsk_cd_2_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_HSK_CD_2_ERR));
			}
		}

		// サービス契約回線内訳登録.回線場所補足メモ → 回線場所補足メモ のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_PLC_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kisn_plc_hsk_memo_err"))
			{
				inMap.put("kisn_plc_hsk_memo_err", template.getString(EKK0251D010CBSMsg.KISN_PLC_HSK_MEMO_ERR));
			}
		}

		// サービス契約回線内訳登録.住所形態コード → 住所形態コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.AD_FORM_CD_ERR))
		{
			if (!inMap.containsKey("ad_form_cd_err"))
			{
				inMap.put("ad_form_cd_err", template.getString(EKK0251D010CBSMsg.AD_FORM_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.竣工予定年月日 → 竣工予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SHUNKO_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("shunko_rsv_ymd_err"))
			{
				inMap.put("shunko_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.SHUNKO_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.電力送電予定年月日 → 電力送電予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.EPOWER_SODEN_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("epower_soden_rsv_ymd_err"))
			{
				inMap.put("epower_soden_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.EPOWER_SODEN_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.入居予定年月日 → 入居予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.NYUKYO_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("nyukyo_rsv_ymd_err"))
			{
				inMap.put("nyukyo_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.NYUKYO_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.引渡し予定年月日 → 引渡し予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.HIKIWATASHI_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("hikiwatashi_rsv_ymd_err"))
			{
				inMap.put("hikiwatashi_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.HIKIWATASHI_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.引越し予定年月日 → 引越し予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.HIKKOSHI_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("hikkoshi_rsv_ymd_err"))
			{
				inMap.put("hikkoshi_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.HIKKOSHI_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.X座標 → X座標 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.XZAHYO_ERR))
		{
			if (!inMap.containsKey("xzahyo_err"))
			{
				inMap.put("xzahyo_err", template.getString(EKK0251D010CBSMsg.XZAHYO_ERR));
			}
		}

		// サービス契約回線内訳登録.Y座標 → Y座標 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.YZAHYO_ERR))
		{
			if (!inMap.containsKey("yzahyo_err"))
			{
				inMap.put("yzahyo_err", template.getString(EKK0251D010CBSMsg.YZAHYO_ERR));
			}
		}

		// サービス契約回線内訳登録.経度 → 経度 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.LGTD_ERR))
		{
			if (!inMap.containsKey("lgtd_err"))
			{
				inMap.put("lgtd_err", template.getString(EKK0251D010CBSMsg.LGTD_ERR));
			}
		}

		// サービス契約回線内訳登録.緯度 → 緯度 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.LTTD_ERR))
		{
			if (!inMap.containsKey("lttd_err"))
			{
				inMap.put("lttd_err", template.getString(EKK0251D010CBSMsg.LTTD_ERR));
			}
		}

		// サービス契約回線内訳登録.座標補正有無 → 座標補正有無 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.ZAHYO_HOSEI_UM_ERR))
		{
			if (!inMap.containsKey("zahyo_hosei_um_err"))
			{
				inMap.put("zahyo_hosei_um_err", template.getString(EKK0251D010CBSMsg.ZAHYO_HOSEI_UM_ERR));
			}
		}

		// サービス契約回線内訳登録.テレビ個別対応コード → テレビ個別対応コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.TV_KOBET_TAIO_CD_ERR))
		{
			if (!inMap.containsKey("tv_kobet_taio_cd_err"))
			{
				inMap.put("tv_kobet_taio_cd_err", template.getString(EKK0251D010CBSMsg.TV_KOBET_TAIO_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.TVアンテナ有無 → TVアンテナ有無 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.TV_ANTENNA_UM_ERR))
		{
			if (!inMap.containsKey("tv_antenna_um_err"))
			{
				inMap.put("tv_antenna_um_err", template.getString(EKK0251D010CBSMsg.TV_ANTENNA_UM_ERR));
			}
		}

		// サービス契約回線内訳登録.方角コード1 → 方角コード1 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.DIRECTION_CD_1_ERR))
		{
			if (!inMap.containsKey("direction_cd_1_err"))
			{
				inMap.put("direction_cd_1_err", template.getString(EKK0251D010CBSMsg.DIRECTION_CD_1_ERR));
			}
		}

		// サービス契約回線内訳登録.方角コード2 → 方角コード2 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.DIRECTION_CD_2_ERR))
		{
			if (!inMap.containsKey("direction_cd_2_err"))
			{
				inMap.put("direction_cd_2_err", template.getString(EKK0251D010CBSMsg.DIRECTION_CD_2_ERR));
			}
		}

		// サービス契約回線内訳登録.戸建建築階数コード → 戸建建築階数コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KODATE_KCKU_FLR_CNT_CD_ERR))
		{
			if (!inMap.containsKey("kodate_kcku_flr_cnt_cd_err"))
			{
				inMap.put("kodate_kcku_flr_cnt_cd_err", template.getString(EKK0251D010CBSMsg.KODATE_KCKU_FLR_CNT_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.集合住宅入居階数コード → 集合住宅入居階数コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SHUGJ_NYUKYO_FLR_CNT_CD_ERR))
		{
			if (!inMap.containsKey("shugj_nyukyo_flr_cnt_cd_err"))
			{
				inMap.put("shugj_nyukyo_flr_cnt_cd_err", template.getString(EKK0251D010CBSMsg.SHUGJ_NYUKYO_FLR_CNT_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.PON種別コード → PON種別コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.PON_SBT_CD_ERR))
		{
			if (!inMap.containsKey("pon_sbt_cd_err"))
			{
				inMap.put("pon_sbt_cd_err", template.getString(EKK0251D010CBSMsg.PON_SBT_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.回線提供会社コード → 回線提供会社コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD_ERR))
		{
			if (!inMap.containsKey("kaisen_tk_comp_cd_err"))
			{
				inMap.put("kaisen_tk_comp_cd_err", template.getString(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.VDSL利用電話回線種別コード → VDSL利用電話回線種別コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.VDSL_USE_TEL_KISN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("vdsl_use_tel_kisn_sbt_cd_err"))
			{
				inMap.put("vdsl_use_tel_kisn_sbt_cd_err", template.getString(EKK0251D010CBSMsg.VDSL_USE_TEL_KISN_SBT_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.VDSL利用電話回線切替予定年月日 → VDSL利用電話回線切替予定年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.VDSL_USE_DKSN_SWCH_RSV_YMD_ERR))
		{
			if (!inMap.containsKey("vdsl_use_dksn_swch_rsv_ymd_err"))
			{
				inMap.put("vdsl_use_dksn_swch_rsv_ymd_err", template.getString(EKK0251D010CBSMsg.VDSL_USE_DKSN_SWCH_RSV_YMD_ERR));
			}
		}

		// サービス契約回線内訳登録.VDSL利用対象電話番号回線種別コード → VDSL利用対象電話番号回線種別コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.VDSL_USE_TG_DBKSN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("vdsl_use_tg_dbksn_sbt_cd_err"))
			{
				inMap.put("vdsl_use_tg_dbksn_sbt_cd_err", template.getString(EKK0251D010CBSMsg.VDSL_USE_TG_DBKSN_SBT_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.VDSL利用対象電話番号 → VDSL利用対象電話番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.VDSL_USE_TG_TELNO_ERR))
		{
			if (!inMap.containsKey("vdsl_use_tg_telno_err"))
			{
				inMap.put("vdsl_use_tg_telno_err", template.getString(EKK0251D010CBSMsg.VDSL_USE_TG_TELNO_ERR));
			}
		}

		// サービス契約回線内訳登録.該当エリアサービス開始年月日 → 該当エリアサービス開始年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.GAITO_AREA_SVC_STAYMD_ERR))
		{
			if (!inMap.containsKey("gaito_area_svc_staymd_err"))
			{
				inMap.put("gaito_area_svc_staymd_err", template.getString(EKK0251D010CBSMsg.GAITO_AREA_SVC_STAYMD_ERR));
			}
		}

		// サービス契約回線内訳登録.起点変電所コード → 起点変電所コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KITEN_HDSHO_CD_ERR))
		{
			if (!inMap.containsKey("kiten_hdsho_cd_err"))
			{
				inMap.put("kiten_hdsho_cd_err", template.getString(EKK0251D010CBSMsg.KITEN_HDSHO_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.集約局コード → 集約局コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SHYAKK_CD_ERR))
		{
			if (!inMap.containsKey("shyakk_cd_err"))
			{
				inMap.put("shyakk_cd_err", template.getString(EKK0251D010CBSMsg.SHYAKK_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.関電営業所コード → 関電営業所コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KEPCO_BUSIOFFICE_CD_ERR))
		{
			if (!inMap.containsKey("kepco_busioffice_cd_err"))
			{
				inMap.put("kepco_busioffice_cd_err", template.getString(EKK0251D010CBSMsg.KEPCO_BUSIOFFICE_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.請求書用回線場所住所部屋番号 → 請求書用回線場所住所部屋番号 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO_ERR))
		{
			if (!inMap.containsKey("sks_yo_kisn_place_ad_rm_no_err"))
			{
				inMap.put("sks_yo_kisn_place_ad_rm_no_err", template.getString(EKK0251D010CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO_ERR));
			}
		}
		
		// サービス契約回線内訳登録.請求書送付先住所変更有無 → 請求書送付先住所変更有無 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_UM_ERR))
		{
			if (!inMap.containsKey("sks_shs_ad_chg_um_err"))
			{
				inMap.put("sks_shs_ad_chg_um_err", template.getString(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_UM_ERR));
			}
		}
		
		// サービス契約回線内訳登録.請求書送付先住所変更希望年月日 → 請求書送付先住所変更希望年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("sks_shs_ad_chg_kibo_ymd_err"))
			{
				inMap.put("sks_shs_ad_chg_kibo_ymd_err", template.getString(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD_ERR));
			}
		}
		
		// サービス契約回線内訳登録.契約者住所変更有無 → 契約者住所変更有無 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KSHAD_CHG_UM_ERR))
		{
			if (!inMap.containsKey("kshad_chg_um_err"))
			{
				inMap.put("kshad_chg_um_err", template.getString(EKK0251D010CBSMsg.KSHAD_CHG_UM_ERR));
			}
		}
		
		// サービス契約回線内訳登録.契約者住所変更希望年月日 → 契約者住所変更希望年月日のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("kshad_chg_kibo_ymd_err"))
			{
				inMap.put("kshad_chg_kibo_ymd_err", template.getString(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD_ERR));
			}
		}
		
		// サービス契約回線内訳登録.回線場所住所チェックレベル → 回線場所住所チェックレベルのエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KISN_AD_CHK_LV_ERR))
		{
			if (!inMap.containsKey("kisn_ad_chk_lv_err"))
			{
				inMap.put("kisn_ad_chk_lv_err", template.getString(EKK0251D010CBSMsg.KISN_AD_CHK_LV_ERR));
			}
		}
		// ANK-4244-00-00 ADD START
		// サービス契約回線内訳登録.回線場所連番 → 回線場所連番 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_PLACE_RENBAN_ERR))
		{
			if (!inMap.containsKey("kaisen_place_renban_err"))
			{
				inMap.put("kaisen_place_renban_err", template.getString(EKK0251D010CBSMsg.KAISEN_PLACE_RENBAN_ERR));
			}
		}
		// ANK-4244-00-00 ADD END
	}
	
	/**
	 * 回線対象サービス契約のエラー情報を設定します。
	 * @param template エラーを設定するメッセージキャリア
	 * @param templateArray メッセージキャリア配列
	 * @param dataList 
	 * @param inMap
	 */
	@SuppressWarnings("unchecked")
	private void setErrEKK0251D010CBSMsg1List(CAANMsg template, CAANMsg[] templateArray
			, ArrayList dataList, HashMap inMap)
	{
		if (templateArray != null)
		{

			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= dataList.size())
				{
					dataList.add(new HashMap());
				}

				HashMap childMap = (HashMap)dataList.get(i);
				CAANMsg childTemplate = templateArray[i];

				// サービス契約回線内訳登録.サービス契約番号 → サービス契約回線内訳登録.サービス契約番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0251D010CBSMsg1List.SVC_KEI_NO_ERR))
				{
					if (!childMap.containsKey("svc_kei_no_err"))
					{
						childMap.put("svc_kei_no_err", childTemplate.getString(EKK0251D010CBSMsg1List.SVC_KEI_NO_ERR));
					}
				}
			}
		}
		if (!template.isNull(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("EKK0251D010CBSMsg1List_err"))
			{
				inMap.put("EKK0251D010CBSMsg1List_err", template.getString(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST_ERR));
			}
		}
	}
	
	/**
	 * サービス契約番号を設定します。
	 * @param param IRequestParameterReadWrite
	 * @throws RequestParameterException 
	 */
	private void setSvcKeiNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		netSvcKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_NET, WK_SVC_KEI_NO);
		telSvcKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_TEL, WK_SVC_KEI_NO);
		tvSvcKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_TV, WK_SVC_KEI_NO);
		adslSvcKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_ADSL, WK_SVC_KEI_NO);
	}
	
	/**
	 * 排他制御部品にサービス契約、申込明細番号設定します。
	 * @param param
	 * @throws RequestParameterException
	 */
	private void setExcCtrl(IRequestParameterReadWrite param) throws RequestParameterException
	{
		JKKBpCommon.putMskmDtlNoToSvcKeiNoMap(param, JKKBpCommon.getWkMskmDtlNoTv(param), tvSvcKeiNo);
		JKKBpCommon.putMskmDtlNoToSvcKeiNoMap(param, JKKBpCommon.getWkMskmDtlNoTel(param), telSvcKeiNo);
		JKKBpCommon.putMskmDtlNoToSvcKeiNoMap(param, JKKBpCommon.getWkMskmDtlNoNet(param), netSvcKeiNo);
	}

	/**
	 * 最終更新年月日時分秒を設定します。<br>
	 * （eo光ネット、eo光テレビ、eo光電話、eoADSLで存在するサービスに対し設定します。）
	 * @param param
	 * @param lastDtm
	 * @throws RequestParameterException
	 */
	private void setLastUpdateDate(IRequestParameterReadWrite param, String lastDtm) throws RequestParameterException
	{
		String[] svcKeiNos = {netSvcKeiNo, tvSvcKeiNo, telSvcKeiNo, adslSvcKeiNo};
		
		for(String svcKeiNo : svcKeiNos)
		{
			if(null == svcKeiNo)
			{
				continue;
			}

			JKKBpCommon.setLastDtmBySvcKeiNo(param, svcKeiNo, lastDtm);
		}
	}

	/**
	 * 最終更新年月日時分秒を取得します。<br>
	 * （eo光ネット、eo光テレビ、eo光電話、eoADSLで最大のものを返します。）
	 * @param param IRequestParameterReadWrite
	 * @param lastDtm 画面より渡された最終更新年月日時分秒
	 * @return 最大の最終更新年月日時分秒
	 * @throws RequestParameterException
	 */
	private String getLastUpdateDate(IRequestParameterReadWrite param, String lastDtm) throws RequestParameterException
	{
		String[] svcKeiNos = {netSvcKeiNo, tvSvcKeiNo, telSvcKeiNo, adslSvcKeiNo};
		String no = "";
		String lastDate = "";
		
		for(String svcKeiNo : svcKeiNos)
		{
			lastDate = JKKBpCommon.getLastDtmBySvcKeiNo(param, svcKeiNo, lastDtm);
			
			if(null != lastDate && no.compareTo(lastDate) < 0)
			{
				no = lastDate;
			}
		}
		
		return no;
	}

	/**
	 * ONUの登録可否を判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ指定文字列
	 * @return true：登録可、false：登録不可
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private boolean isAddONU(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		// eo光ネットとeo光電話のサービス契約番号が存在しない場合、登録不可を返却する。
		if(JKKCommonUtil.isNull(netSvcKeiNo) && JKKCommonUtil.isNull(telSvcKeiNo))
		{
			return false;
		}
		
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String mskmshoKind = String.valueOf(inMap.get("mskmsho_kind"));
		String mansionKaisenHoshiki = String.valueOf(inMap.get("mansion_kaisen_hoshiki"));
		
		// 以下の条件に一致しない場合、登録不可を返却する。
		// ・申込書の種類がホームタイプ
		// ・申込書の種類がマンションタイプ AND マンション回線提供方式が光配線方式
		// ・申込書の種類がメゾンタイプ
		if(!(JKKStrConst.MSKM_KIND_HOME.equals(mskmshoKind)
				|| (JKKStrConst.MSKM_KIND_MANSION.equals(mskmshoKind) && MANS_KAISEN_HSK_HIKARI_HAISEN.equals(mansionKaisenHoshiki))
				|| JKKStrConst.MSKM_KIND_MEZON.equals(mskmshoKind)))
		{
			return false;
		}
// ANK-4427-00-00 ADD START
		// typeNの場合はONUを登録しない
		if (BRAND_TYPE_TYPEN.equals(inMap.get("brand_type")))
		{
			return false;
		}
// ANK-4427-00-00 ADD END
		
		return true;
	}

	/**
	 * V-ONUの登録可否を判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ指定文字列
	 * @return true：登録可、false：登録不可
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private boolean isAddVONU(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		// eo光テレビのサービス契約番号が存在しない場合、登録不可を返却する。
		if(JKKCommonUtil.isNull(tvSvcKeiNo))
		{
			return false;
		}
		
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String mskmshoKind = String.valueOf(inMap.get("mskmsho_kind"));
		
		// 以下の条件に一致しない場合、登録不可を返却する。
		// ・申込書の種類がホームタイプ
		// ・申込書の種類がメゾンタイプ
		if(!(JKKStrConst.MSKM_KIND_HOME.equals(mskmshoKind)
				|| JKKStrConst.MSKM_KIND_MEZON.equals(mskmshoKind)))
		{
			return false;
		}
		
		return true;
	}

	/**
	 * ＶＤＳＬ子機の登録可否を判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ指定文字列
	 * @return true：登録可、false：登録不可
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private boolean isAddVDSL(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		// eo光ネットとeo光電話のサービス契約番号が存在しない場合、登録不可を返却する。
		if(JKKCommonUtil.isNull(netSvcKeiNo) && JKKCommonUtil.isNull(telSvcKeiNo))
		{
			return false;
		}
		
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String mskmshoKind = String.valueOf(inMap.get("mskmsho_kind"));
		String mansionKaisenHoshiki = String.valueOf(inMap.get("mansion_kaisen_hoshiki"));
		
		// 以下の条件に一致しない場合、登録不可を返却する。
		// ・申込書の種類がマンションタイプ AND マンション回線提供方式がVDSL方式
		if(!(JKKStrConst.MSKM_KIND_MANSION.equals(mskmshoKind) && MANS_KAISEN_HSK_VDSL.equals(mansionKaisenHoshiki)))
		{
			return false;
		}

		String mansionOyaKikiUm = String.valueOf(inMap.get("mansion_oya_kiki_um"));
		
		// マンション親機器有無が有の場合、登録不可を返却する。
		if(JKKStrConst.CD_DIV_UM_ARI.equals(mansionOyaKikiUm))
		{
			return false;
		}
		
		return true;
	}

	/**
	 * 多機能ルーターの登録可否を判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ指定文字列
	 * @return true：登録可、false：登録不可
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private boolean isAddTKNRTL(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String router_mskm_flg = String.valueOf(inMap.get("router_mskm_flg"));
		
		// eo光ネットのサービス契約番号が存在する場合、かつ
		// ルーター申込フラグが"true"の場合、登録可を返却する。
		if(!JKKCommonUtil.isNull(netSvcKeiNo) && "true".equals(router_mskm_flg))
		{
			return true;
		}
		
		// eo光電話のサービス契約番号が存在する場合、登録可を返却する。
		if(!JKKCommonUtil.isNull(telSvcKeiNo))
		{
			return true;
		}
		
		return false;
	}	
	
	/**
	 * 機器送付先の判定を行います。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ指定文字列
	 * @param kikiMap 機器情報マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void chkKkshs(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kikiMap) throws RequestParameterException
	{
		// 機器送付先チェック実行フラグがfalse(実行しない)の場合、処理を行わない
		// 機器送付先同一フラグがtrue（同一）の場合はすでにチェック済のため処理を行わない
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		Boolean isRunKkshsChk = (Boolean)inMap.get("kkshs_chk_run_flg");
		if(!isRunKkshsChk || isSameKkshs)
		{
			return;
		}
		
		for(int i = 0; i < KKSHS_JDG_TG_LIST.length; i++)
		{
			// 機器送付先と契約者＿機器送付先に差異がある場合、処理を中断する
			if(!kikiMap.get(KKSHS_JDG_TG_LIST[i]).equals(inMap.get(KSH_KKSHS_JDG_TG_LIST[i])))
			{
				return;
			}
		}
		
		// 機器送付先と契約者＿機器送付先が一致しているため、機器送付先同一フラグをtrue（同一）に変更する
		isSameKkshs = true;
	}
	
	/**
	 * 機器送付先更新判定処理のエラー情報を設定します。
	 * @param iparam IRequestParameterReadWrite
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoKkshs(IRequestParameterReadWrite iparam) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, JPCModelConstant.RELATION_ERR, JPCModelConstant.NORMAL_END);
		
		// エラー情報のリストを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		HashMap<String, Object> errorMap = new HashMap<String, Object>();
		HashMap<String, String> errorMapChild = new HashMap<String, String>();
		
		errorMap.put(ErrorInfoMapKeys.RETURN_CODE, JPCModelConstant.NORMAL_END);
		errorMap.put(ErrorInfoMapKeys.STATUS, JPCModelConstant.RELATION_ERR);
		
		errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
		
		errList.add(errorMap);
		
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);
		
		return param;
	}
	
	/**
	 * パラメータから指定したキー名のリストを取得します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param listName 取得リストキー名
	 * @return listNameで指定したリスト<br>
	 *  ※リストが取得できない場合は空のリストを返却します。
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<HashMap<String, Object>> getList(IRequestParameterReadWrite param, String fixedText
			, String listName) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		ArrayList<HashMap<String, Object>> list = (ArrayList<HashMap<String, Object>>)inMap.get(listName);
		
		return null == list ? new ArrayList<HashMap<String, Object>>() : list;
	}
	
	/**
	 * 機器オプションサービス契約登録の上りマッピング処理を行います。
	 * @param param
	 * @param fixedText
	 * @param inMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2811D010(IRequestParameterReadWrite param, String fixedText, HashMap inMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811D010CBSMsg.class.getName());
		
		String prefix = "kk2811_";
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// 多機能ルーターの機器提供サービス契約番号を取得
		ArrayList<HashMap<String, String>> kikiList = null;
		kikiList = (ArrayList)dataMap.get(KKTK_SVC_KEI_LIST);
		String kktkSvcKeiNo = null;
		
		if (null != kikiList)
		{
			for (HashMap<String, String> kikiMap : kikiList)
			{
// ▽▽▽ #83584 Modify START
//				if(!JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kikiMap.get("kk0341_kktk_svc_cd")))
				if(!(JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kikiMap.get("kk0341_kktk_svc_cd")) || JKKStrConst.KKTK_SVC_CD_HGW.equals(kikiMap.get("kk0341_kktk_svc_cd"))))
// △△△ #83584 Modify START
				{
					continue;
				}
				kktkSvcKeiNo = kikiMap.get("kk0341_kktk_svc_kei_no");
				break;
			}
		}

		// テンプレートID
		template.set(EKK2811D010CBSMsg.TEMPLATEID, "EKK2811D010");

		// 機能コード（デフォルト：１）
		template.set(EKK2811D010CBSMsg.FUNC_CODE, "1");

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		HashMap inData = (HashMap)param.getData(fixedText);

		// 機能コード
		if (inData != null)
		{
			template.set(EKK2811D010CBSMsg.FUNC_CODE, inData.get(JCMConstants.FUNC_CODE_KEY));
		}
		
		// 機器オプションサービス契約登録.機器オプションサービスコード → 機器オプションサービスコード
		setTemplate(template, EKK2811D010CBSMsg.KKOP_SVC_CD, inMap, prefix, EKK2811D010CBSMsg.KKOP_SVC_CD);

		// 機器オプションサービス契約登録.料金コースコード → 料金コースコード
		setTemplate(template, EKK2811D010CBSMsg.PCRS_CD, inMap, prefix, EKK2811D010CBSMsg.PCRS_CD);

		// 機器オプションサービス契約登録.料金プランコード → 料金プランコード
		setTemplate(template, EKK2811D010CBSMsg.PPLAN_CD, inMap, prefix, EKK2811D010CBSMsg.PPLAN_CD);

		// 機器オプションサービス契約登録.機器提供サービス契約番号 → 機器提供サービス契約番号
		template.set(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);
		
		// 機器オプションサービス契約登録.SYSID → SYSID
		if(null == inMap.get(prefix + "sysid") || "".equals(inMap.get(prefix + "sysid")))
		{
			// SYSIDが未設定の場合
			String sysid = getWorkMapValue(param, CC_WORK_AREA_NAME_KEISHA, WK_SYSID);
			template.set(EKK2811D010CBSMsg.SYSID, sysid);
		}
		else
		{
			setTemplate(template, EKK2811D010CBSMsg.SYSID, inMap, prefix, EKK2811D010CBSMsg.SYSID);
		}

		// 機器オプションサービス契約登録.申込明細番号 → 申込明細番号
		String kkopSvcCd = String.valueOf(inMap.get("kk2811_kkop_svc_cd"));
		String mskmDtlNo = null;
		
		// ルーターオプションの時、ネットの申込明細番号
		if(JKKStrConst.KKOP_SVC_CD_ROUTER.equals(kkopSvcCd))
		{
			template.set(EKK2811D010CBSMsg.MSKM_DTL_NO, getMskmDtlWorkMapValue(param, "mskm_dtl_no_net"));
			mskmDtlNo = getMskmDtlWorkMapValue(param, "mskm_dtl_no_net");
		}
		// VAオプションの時、電話の申込明細番号
		else if(JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals(kkopSvcCd))
		{
			template.set(EKK2811D010CBSMsg.MSKM_DTL_NO, getMskmDtlWorkMapValue(param, "mskm_dtl_no_tel"));
			mskmDtlNo = getMskmDtlWorkMapValue(param, "mskm_dtl_no_tel");
		}

		// 機器オプションサービス契約登録.試用加入年月日 → 試用加入年月日
		setTemplate(template, EKK2811D010CBSMsg.FTRIAL_KANYU_YMD, inMap, prefix, EKK2811D010CBSMsg.FTRIAL_KANYU_YMD);

		// 機器オプションサービス契約登録.試用期間終了年月日 → 試用期間終了年月日
		setTemplate(template, EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD, inMap, prefix, EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD);

		// 機器オプションサービス契約登録.本加入年月日 → 本加入年月日
		setTemplate(template, EKK2811D010CBSMsg.HONKANYU_YMD, inMap, prefix, EKK2811D010CBSMsg.HONKANYU_YMD);

		// 機器オプションサービス契約登録.本加入移行期限年月日 → 本加入移行期限年月日
		setTemplate(template, EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, inMap, prefix, EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);

		// 機器オプションサービス契約登録.サービス利用開始希望年月日 → サービス利用開始希望年月日
		setTemplate(template, EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD, inMap, prefix, EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD);

		// 機器オプションサービス契約登録.予約適用開始希望年月日 → 予約適用開始希望年月日
		setTemplate(template, EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD, inMap, prefix, EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD);

		// 機器オプションサービス契約登録.違約金発生コード → 違約金発生コード
		setTemplate(template, EKK2811D010CBSMsg.PNLTY_HASSEI_CD, inMap, prefix, EKK2811D010CBSMsg.PNLTY_HASSEI_CD);

		// 機器オプションサービス契約登録.異動区分 → 異動区分
		setTemplate(template, EKK2811D010CBSMsg.IDO_DIV, inMap, prefix, EKK2811D010CBSMsg.IDO_DIV);

		// 機器オプションサービス契約登録.機器連帯契約変更手続中フラグ → 機器連帯契約変更手続中フラグ
		template.set(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG, JKKStrConst.KEI_CHGECHU_FLG_OFF);

		// 機器オプションサービス契約登録.請求契約番号 → 請求契約番号
		if(null == inMap.get(prefix + "seiky_kei_no") || "".equals(inMap.get(prefix + "seiky_kei_no")))
		{	// 請求契約番号が未設定の場合
			String seikyKeiNo = getWorkMapValue(param, CC_WORK_AREA_NAME_PAYWAY, WK_SEIKY_KEI_NO);
			template.set(EKK2811D010CBSMsg.SEIKY_KEI_NO, seikyKeiNo);
		}
		else
		{
			setTemplate(template, EKK2811D010CBSMsg.SEIKY_KEI_NO, inMap, prefix, EKK2811D010CBSMsg.SEIKY_KEI_NO);
		}
		
		// 機器オプションサービス契約登録.料金項目コード → 料金項目コード
		setTemplate(template, EKK2811D010CBSMsg.PRC_KMK_CD, inMap, prefix, EKK2811D010CBSMsg.PRC_KMK_CD);
		
		// 機器オプションサービス契約登録.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String svcKeiNo = JKKBpCommon.cvtMskmDtlNoToSvcKeiNo(param, mskmDtlNo);
		String updDtmBf = JKKBpCommon.getLastDtmBySvcKeiNo(param, svcKeiNo, (String)inMap.get("kk2811_upd_dtm_bf"));
		template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);
		
		return template;
	}
	
	/**
	 * CAANMsgに値を設定します。<br>
	 *  �@inMap内にデータが存在する場合、inMap内のデータを設定します。<br>
	 *  �A上記以外の場合、setNullを呼び出します。<br>
	 * @param template 値を設定するメッセージキャリア
	 * @param setKey 設定先メッセージキャリアのキー名
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報より取得する場合に付加するプレフィックス
	 * @param getKey ユーザデータ情報より取得するキー名
	 */
	private void setTemplate(CAANMsg template, String setKey, HashMap<String, Object> inMap, String prefix, String getKey)
	{
		
		if (null == inMap || null == inMap.get(prefix + getKey) || 0 == ((String)inMap.get(prefix + getKey)).length())
		{
			template.setNull(setKey);
		}
		else
		{
			template.set(setKey, (String)inMap.get(prefix + getKey));
		}
	}
	
	/**
	 * ユーザデータ情報にエラー情報を設定します。<br>
	 * 　※ユーザデータ情報内にすでにキーが存在する場合、値は設定されません。<br>
	 * @param inMap	 ユーザデータ情報
	 * @param setKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアより取得するキー名
	 */
	private void setErrInfo(HashMap<String, Object> inMap, String setKey, CAANMsg template, String getKey)
	{
		if (!template.isNull(getKey))
		{
			if (!inMap.containsKey(setKey))
			{
				inMap.put(setKey, template.getString(getKey));
			}
		}
	}
	
	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getString(getKey));
		}
	}
	
	/**
	 *  機器オプションサービス契約登録の下りマッピング処理を行います。
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK2811D010(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap dataMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		String prefix = "kk2811_";
		
		// 機器オプションサービス契約番号 ← 機器オプションサービス契約登録.機器オプションサービス契約番号
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.KKOP_SVC_KEI_NO, template, EKK2811D010CBSMsg.KKOP_SVC_KEI_NO);

		// 世代登録年月日時分秒 ← 機器オプションサービス契約登録.世代登録年月日時分秒
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.GENE_ADD_DTM, template, EKK2811D010CBSMsg.GENE_ADD_DTM);

		// 機器オプションサービス契約ステータス ← 機器オプションサービス契約登録.機器オプションサービス契約ステータス
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT, template, EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT);

		// 予約適用年月日 ← 機器オプションサービス契約登録.予約適用年月日
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.RSV_APLY_YMD, template, EKK2811D010CBSMsg.RSV_APLY_YMD);

		// 予約適用コード ← 機器オプションサービス契約登録.予約適用コード
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.RSV_APLY_CD, template, EKK2811D010CBSMsg.RSV_APLY_CD);

		// 登録年月日時分秒 ← 機器オプションサービス契約登録.登録年月日時分秒
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.ADD_DTM, template, EKK2811D010CBSMsg.ADD_DTM);

		// 登録オペレータアカウント ← 機器オプションサービス契約登録.登録オペレータアカウント
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.ADD_OPEACNT, template, EKK2811D010CBSMsg.ADD_OPEACNT);

		// 更新年月日時分秒 ← 機器オプションサービス契約登録.更新年月日時分秒
		String svcKeiNo = JKKBpCommon.cvtMskmDtlNoToSvcKeiNo(param, (String)dataMap.get("kk2811_mskm_dtl_no"));
		String lastDtm = template.getString(EKK2811D010CBSMsg.UPD_DTM);
		
		JKKBpCommon.setLastDtmBySvcKeiNo(param, svcKeiNo, lastDtm);
		dataMap.put(prefix + "upd_dtm", lastDtm);
				
		// 更新オペレータアカウント ← 機器オプションサービス契約登録.更新オペレータアカウント
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.UPD_OPEACNT, template, EKK2811D010CBSMsg.UPD_OPEACNT);

		// 無効フラグ ← 機器オプションサービス契約登録.無効フラグ
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.MK_FLG, template, EKK2811D010CBSMsg.MK_FLG);

		// 課金先番号 ← 機器オプションサービス契約登録.課金先番号
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.KAKINS_NO, template, EKK2811D010CBSMsg.KAKINS_NO);

		// 課金先適用開始年月日 ← 機器オプションサービス契約登録.課金先適用開始年月日
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.KAKINS_TSTAYMD, template, EKK2811D010CBSMsg.KAKINS_TSTAYMD);

		// 課金先適用終了年月日 ← 機器オプションサービス契約登録.課金先適用終了年月日
		setDataMap(dataMap, prefix, EKK2811D010CBSMsg.KAKINS_TENDYMD, template, EKK2811D010CBSMsg.KAKINS_TENDYMD);

		// エラー情報の設定
		editErrInfoEKK2811D010(param, template, (Integer)returnCode, dataMap);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}
	
	/**
	 * 機器オプションサービス契約登録のエラー情報マッピング処理を行います。
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param inMap
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode
			, HashMap inMap) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK2811D010CBSMsg.STATUS), returnCode);
		
		String prefix = "kk2811_";

		// 機器オプションサービス契約登録.機器オプションサービスコード → 機器オプションサービスコードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.KKOP_SVC_CD_ERR, template, EKK2811D010CBSMsg.KKOP_SVC_CD_ERR);

		// 機器オプションサービス契約登録.料金コースコード → 料金コースコードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.PCRS_CD_ERR, template, EKK2811D010CBSMsg.PCRS_CD_ERR);

		// 機器オプションサービス契約登録.料金プランコード → 料金プランコードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.PPLAN_CD_ERR, template, EKK2811D010CBSMsg.PPLAN_CD_ERR);

		// 機器オプションサービス契約登録.機器提供サービス契約番号 → 機器提供サービス契約番号のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.KKTK_SVC_KEI_NO_ERR, template, EKK2811D010CBSMsg.KKTK_SVC_KEI_NO_ERR);

		// 機器オプションサービス契約登録.SYSID → SYSIDのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.SYSID_ERR, template, EKK2811D010CBSMsg.SYSID_ERR);

		// 機器オプションサービス契約登録.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.MSKM_DTL_NO_ERR, template, EKK2811D010CBSMsg.MSKM_DTL_NO_ERR);

		// 機器オプションサービス契約登録.試用加入年月日 → 試用加入年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR, template, EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR);

		// 機器オプションサービス契約登録.試用期間終了年月日 → 試用期間終了年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR, template, EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR);

		// 機器オプションサービス契約登録.本加入年月日 → 本加入年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.HONKANYU_YMD_ERR, template, EKK2811D010CBSMsg.HONKANYU_YMD_ERR);

		// 機器オプションサービス契約登録.本加入移行期限年月日 → 本加入移行期限年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR, template, EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);

		// 機器オプションサービス契約登録.サービス利用開始希望年月日 → サービス利用開始希望年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR, template, EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR);

		// 機器オプションサービス契約登録.予約適用開始希望年月日 → 予約適用開始希望年月日のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR, template, EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR);

		// 機器オプションサービス契約登録.違約金発生コード → 違約金発生コードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR, template, EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR);

		// 機器オプションサービス契約登録.異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.IDO_DIV_ERR, template, EKK2811D010CBSMsg.IDO_DIV_ERR);

		// 機器オプションサービス契約登録.機器連帯契約変更手続中フラグ → 機器連帯契約変更手続中フラグのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR, template, EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR);

		// 機器オプションサービス契約登録.請求契約番号 → 請求契約番号のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR, template, EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR);

		// 機器オプションサービス契約登録.料金項目コード → 料金項目コードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811D010CBSMsg.PRC_KMK_CD_ERR, template, EKK2811D010CBSMsg.PRC_KMK_CD_ERR);

		return param;
	}
	
	/**
	 * 作業マップ（申込明細）の値を取得します。
	 * 
	 * <br>
	 * @param param
	 * @param key
	 * @return 取得した値
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getMskmDtlWorkMapValue(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		HashMap inMap = null;
		HashMap workDataMap_Mskm = null;
		String result = null;

		if (workMap != null)
		{
			workDataMap_Mskm = (HashMap)workMap.get(CC_WORK_AREA_NAME_MSKM);
			if (workDataMap_Mskm != null)
			{
				ArrayList inList1 = ((ArrayList)workDataMap_Mskm.get(CC_WORK_AREA_NAME_MSKM_LIST));
				int devCnt = inList1 != null ? inList1.size() : 0;
				for (int i = 0; i < devCnt; i++)
				{
					inMap = (HashMap)(inList1).get(i);

					if (inMap != null)
					{
						result = (String)inMap.get(key);
					}

					if (null != result)
					{
						break;
					}
				}
			}
		}

		return result;
	}
	
	/**
	 * 多機能ルーターに設定する申込明細番号を取得します。
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return 登録の契機となるサービス契約に紐付く申込明細番号
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getMskmDtlNoTakinort(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String router_mskm_flg = String.valueOf(inMap.get("router_mskm_flg"));
		
		// eo光ネットのサービス契約番号が存在する場合、かつ
		// ルーター申込フラグが"true"の場合
		if(!JKKCommonUtil.isNull(netSvcKeiNo) && "true".equals(router_mskm_flg))
		{
			return getMskmDtlWorkMapValue(param, "mskm_dtl_no_net");
		}
		
		// eo光電話のサービス契約番号が存在する場合
		if(!JKKCommonUtil.isNull(telSvcKeiNo))
		{
			return getMskmDtlWorkMapValue(param, "mskm_dtl_no_tel");
		}
		
		return null;
	}
	
	// ANK-4315-00-00 ADD START
	/**
	 * HGWに設定する申込明細番号を取得します。
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return 登録の契機となるサービス契約に紐付く申込明細番号
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getMskmDtlNoHgw(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		String router_mskm_flg = String.valueOf(inMap.get("router_mskm_flg"));
		
		// eo光ネットのサービス契約番号が存在する場合、かつ
		// ルーター申込フラグが"true"の場合
		if(!JKKCommonUtil.isNull(netSvcKeiNo) && "true".equals(router_mskm_flg))
		{
			return getMskmDtlWorkMapValue(param, "mskm_dtl_no_net");
		}
		
		// eo光電話のサービス契約番号が存在する場合
		if(!JKKCommonUtil.isNull(telSvcKeiNo))
		{
			return getMskmDtlWorkMapValue(param, "mskm_dtl_no_tel");
		}
		
		// ONUづかいの場合
		String  mskmDtlNo = JKKBpCommon.getWkMskmDtlNoNet(param);
		if (null == mskmDtlNo || "".equals(mskmDtlNo))
		{
			return JKKBpCommon.getWkMskmDtlNoTel(param);
		}
		
		return null;
	}
	// ANK-4315-00-00 ADD END
}