/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKCreateEohTvOpChCC
*	ソースファイル名：JKKCreateEohTvOpChCC.java
*	作成者			：FJ
*	日付			：2011年07月28日
*＜機能概要＞
*	eo光テレビオプションチャンネル登録の共通コンポーネント
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/07/28	FJ			新規作成
*	v4.00.00	2011/08/29	FJ			ANK-0524-00-00対応
*	v7.00.00    2014/01/15  FJ)石橋		【ANK-1673-00-00】コース変更後の不要オプション登録確認を追加
*   v74.00.00   2025/02/05  FJ）謝      【ANK-4592-00-00】テレビ新コース（スカパー用）導入対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
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.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021C060CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0381C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0381C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0381D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0591B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0591B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0811B501CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0811B501CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0821A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1681B001CBSMsg;

/**
 * eo光テレビオプションチャンネル登録CC部品
 * <br>
 * @author 富士通
 */
public class JKKCreateEohTvOpChCC extends AbstractCommonComponent
{
	
	/** テンプレートID(EKK0381D010) */
	private static final String TEMPLATE_ID_EKK0381D010 = "EKK0381D010";
	/** テンプレートID(EKK0381C030) */
	private static final String TEMPLATE_ID_EKK0381C030 = "EKK0381C030";
	/** テンプレートID(EKK0381C040) */
	private static final String TEMPLATE_ID_EKK0381C040 = "EKK0381C040";
	/** テンプレートID(EKK1091D010) */
	private static final String TEMPLATE_ID_EKK1091D010 = "EKK1091D010";
	/** テンプレートID(EKK0011D020) */
	private static final String TEMPLATE_ID_EKK0011D020 = "EKK0011D020";
	/** テンプレートID(EKK0021C060) */
	private static final String TEMPLATE_ID_EKK0021C060 = "EKK0021C060";
	/** テンプレートID(EKK0591B001) */
	private static final String TEMPLATE_ID_EKK0591B001 = "EKK0591B001";
	
	/* ++++++++++ v7.00.00 追加開始 ++++++++++ */
	/** テンプレートID(EKK0811B501) 料金コース_オプションサービス一覧照会（料金コースコード２） */
	private static final String TEMPLATE_ID_EKK0811B501 = "EKK0811B501";
	/** テンプレートID(EKK1681B001) 異動予約一覧照会(コース変更、コース変更(STB)) */
	private static final String TEMPLATE_ID_EKK1681B001 = "EKK1681B001";
	/* ++++++++++ v7.00.00 追加終了 ++++++++++ */

	/* ++++++++++ v4.00.00 削除開始 ++++++++++ */
//	/** オプションサービス契約＜TV＞登録マップ 親契約識別コード(03：サービス契約内訳) */
//	private static final String OYA_KEI_SKBT_CD_03 = "03";
	/* ++++++++++ v4.00.00 削除終了 ++++++++++ */
	/** オプションサービス契約＜TV＞開始マップ 即時/翌月(01：即時) */
	private static final String SKJ_YKGT_01 = "01";
	/** オプションサービス契約＜TV＞開始マップ 即時/翌月(02：翌月) */
	private static final String SKJ_YKGT_02 = "02";
	/* ++++++++++ v4.00.00 追加開始 ++++++++++ */
	/** オプションサービス契約＜TV＞開始マップ 即時/翌月(03：翌々月) */
	private static final String SKJ_YKGT_03 = "03";
	/* ++++++++++ v4.00.00 追加終了 ++++++++++ */
//	/** 進捗登録マップ 異動区分(00031：オプション設定) */
//	private static final String IDO_DIV_00031 = "00031";
//	/** 進捗登録マップ 進捗ステータス(5101：オプション情報申請中) */
//	private static final String PRG_STAT_5101 = "5101";
	/** 進捗登録マップ 進捗ステータス(5102：オプション設定完了) */
	private static final String PRG_STAT_5102 = "5102";
//	/** 進捗登録マップ 異動理由コード(F7：オプション契約したため) */
//	private static final String IDO_RSN_CD_F7 = "F7";
	/** 申込内容承認登録マップ 申込種別コード(00026：オプション申込) */
	private static final String MSKM_SBT_CD_00026 = "00026";
	/** 申込内容承認登録マップ 申込形態コード(05：書面) */
	private static final String MSKM_FROM_CD_05 = "05";
	/** オプションチャンネルオペレーション方法コード(1：自動) */
	private static final String OP_CHANNEL_OPRTN_WAY_CD_1 = "1";
	/** コンシューマ営業用申込状態識別コード(04：承認済) */
	private static final String CONSMBSN_MSKM_STAT_SKBT_CD_04 = "04";
//	/** ガイド誌発送方法コード(070001：業務１) */
//	private static final String GUIDEMG_HASSO_WAY_CD_070001 = "070001";
	/* ++++++++++ v7.00.00 追加開始 ++++++++++ */
	/** 異動区分（コース変更） */
	private static final String CD00576_00009 = "00009";
	/** 異動区分（コース変更(STB)） */
	private static final String CD00576_00068 = "00068";
	/* ++++++++++ v7.00.00 追加終了 ++++++++++ */
	

	/**
	 * CAANMsgに必要なデータのマッピング処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return パラメータマップ
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite createEohTvOpCh(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
		throws Throwable
	{

		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;
		CAANMsg[] templates = null;
		String rtnCode = "";
		int status = 0;
		
		HashMap inMap = (HashMap)(param.getData(fixedText));
		if (inMap == null)
		{
			return param;
		}
		
		/* ++++++++++ v7.00.00 追加開始 ++++++++++ */
		chkPcrsCdOptSvc(handle, param, paramMap, fixedText);
		/* ++++++++++ v7.00.00 追加終了 ++++++++++ */
// ANK-4592-00-00 ADD START
		ArrayList<HashMap<String, Object>> opInfoList = new ArrayList<HashMap<String,Object>>();
// ANK-4592-00-00 ADD END
		
		ArrayList dataList = (ArrayList)inMap.get("eo_op_list");
		
		getParamData(param);
		
		// 上りマッピング処理
		List<CAANMsg> templateEKK0011D020 = editInMsgEKK0011D020(param);
		List<CAANMsg> templateEKK0591B001 = editInMsgEKK0591B001(param);
		List<CAANMsg> templateEKK0381D010 = editInMsgEKK0381D010(param);
		List<CAANMsg> templateEKK0381C030 = editInMsgEKK0381C030(param);
		List<CAANMsg> templateEKK0381C040 = editInMsgEKK0381C040(param);
		List<CAANMsg> templateEKK1091D010 = editInMsgEKK1091D010(param);
		List<CAANMsg> templateEKK0021C060 = editInMsgEKK0021C060(param);
		
		template = templateEKK0011D020.get(0);
		// SC呼出実行 (申込内容承認登録サービスI/F)
		result = scCall.run(putParamMap(paramMap, template), handle);
		// 下りマッピング処理
		editResultEKK0011D020(result, param);
		// 処理結果の判定
		templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		status = templates[0].getInt(EKK0011D020CBSMsg.STATUS);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			throw new SCCallException("戻り値不正", rtnCode, status);
		}
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < dataList.size(); i++)
		{
			// オプションチャンネル情報
			HashMap childMap = (HashMap)dataList.get(i);
			
			template = templateEKK0591B001.get(i);
			// SC呼出実行 (料金プラン一覧照会（オプションサービスコード）サービスI/F)
			result = scCall.run(putParamMap(paramMap, template), handle);
			// 下りマッピング処理
			editResultEKK0591B001(result, param);
			// 処理結果の判定
			templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
			rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
			status = templates[0].getInt(EKK0591B001CBSMsg.STATUS);
			// 異常の場合、SCCallExceptionを生成してスローする
			if(!("0".equals(rtnCode) && 0 == status))
			{
				throw new SCCallException("戻り値不正", rtnCode, status);
			}
			
			// リクエストパラメータを引数に上りマッピング処理メソッドを実行
			template = setParamEkk0381D010(templateEKK0381D010.get(i), param);
			// SC呼出実行 (オプションサービス契約＜TV＞登録サービスI/F)
			result = scCall.run(putParamMap(paramMap, template), handle);
			// 下りマッピング処理
			editResultEKK0381D010(result, param);
			// 処理結果の判定
			templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
			rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
			status = templates[0].getInt(EKK0381D010CBSMsg.STATUS);
			// 異常の場合、SCCallExceptionを生成してスローする
			if(!("0".equals(rtnCode) && 0 == status))
			{
				throw new SCCallException("戻り値不正", rtnCode, status);
			}
// ANK-4592-00-00 ADD START
			HashMap<String, Object> opInfo = new HashMap<String, Object>();
			opInfo.put("op_svc_cd", childMap.get("op_svc_cd"));
			opInfo.put("op_svc_kei_no", inMap.get("ekk0381d010_op_svc_kei_no"));
			opInfoList.add(opInfo);
// ANK-4592-00-00 ADD END
			
			if (OP_CHANNEL_OPRTN_WAY_CD_1.equals((String)childMap.get(EKK0821A010CBSMsg1List.OP_CHANNEL_OPRTN_WAY_CD)))
			{
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				template = setParamEkk0381C030(templateEKK0381C030.get(i), param);
				// SC呼出実行 (オプションサービス契約＜TV＞照査締結サービスI/F)
				result = scCall.run(putParamMap(paramMap, template), handle);
				// 下りマッピング処理
				editResultEKK0381C030(result, param);
				// 処理結果の判定
				templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
				// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
				rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
				status = templates[0].getInt(EKK0381C030CBSMsg.STATUS);
				// 異常の場合、SCCallExceptionを生成してスローする
				if(!("0".equals(rtnCode) && 0 == status))
				{
					throw new SCCallException("戻り値不正", rtnCode, status);
				}
				
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				template = setParamEkk0381C040(templateEKK0381C040.get(i), param);
				// SC呼出実行 (オプションサービス契約＜TV＞開始サービスI/F)
				result = scCall.run(putParamMap(paramMap, template), handle);
				// 下りマッピング処理
				editResultEKK0381C040(result, param);
				// 処理結果の判定
				templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
				// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
				rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
				status = templates[0].getInt(EKK0381C040CBSMsg.STATUS);
				// 異常の場合、SCCallExceptionを生成してスローする
				if(!("0".equals(rtnCode) && 0 == status))
				{
					throw new SCCallException("戻り値不正", rtnCode, status);
				}
			}
			
		}
		
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		template = setParamEKK1091D010(templateEKK1091D010.get(0), param);
		// SC呼出実行 (進捗登録サービスI/F)
		result = scCall.run(putParamMap(paramMap, template), handle);
		// 下りマッピング処理
		editResultEKK1091D010(result, param);
		// 処理結果の判定
		templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		status = templates[0].getInt(EKK1091D010CBSMsg.STATUS);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			throw new SCCallException("戻り値不正", rtnCode, status);
		}
		
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		template = setParamEkk0021C060(templateEKK0021C060.get(0), param);
		// SC呼出実行 (申込明細照査・後続業務依頼サービスI/F)
		result = scCall.run(putParamMap(paramMap, template), handle);
		// 下りマッピング処理
		editResultEKK0021C060(result, param);
		// 処理結果の判定
		templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		status = templates[0].getInt(EKK0021C060CBSMsg.STATUS);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			throw new SCCallException("戻り値不正", rtnCode, status);
		}
		
// ANK-4592-00-00 ADD START
		inMap.put("op_info_list", opInfoList);
// ANK-4592-00-00 ADD END
		
		return param;
	}

	/**
	 * パラメータオブジェクト情報の取得<br>
	 * <br>
	 * @param param デルグループ、コントロールマップを含むパラメータオブジェクト
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void getParamData(IRequestParameterReadWrite param) throws Throwable
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
//		// ＳＹＳＩＤ
//		sysid = (String)dataMap.get("sysid");
//		// サービス契約番号
//		svcKeiNo = (String)dataMap.get("svc_kei_no");
//		// サービス契約内訳番号
//		svcKeiUcwkNo = (String)dataMap.get("svc_kei_ucwk_no");
//		// 異動年月日時分秒
//		idoDtm = (String)dataMap.get("ido_dtm");
//		// 申込受付年月日時分秒
//		mskmUkDtm = (String)dataMap.get("mskm_uk_dtm");
//		// 申込年月日
//		mskmYmd = (String)dataMap.get("mskm_ymd");
//		// 後続業務依頼年月日
//		kzkwrkReqymd = (String)dataMap.get("kzkwrk_reqymd");
//		// 更新年月日時分秒（更新前）
//		updDtmBf = (String)dataMap.get("upd_dtm_bf");
//		// 機能コード
//		funcCode = (String)dataMap.get("func_code");
//		// 異動区分
//		idoDiv = (String)dataMap.get("ido_div");
//		// 異動理由コード
//		idoRsnCdList = new ArrayList<String>();
//		ArrayList inList = (ArrayList)dataMap.get("EKK1091D010CBSMsg1List");
//		if (inList != null) 
//		{
//			for (int i = 0; i < inList.size(); i++) 
//			{
//				HashMap childMap = (HashMap)inList.get(i);
//				
//				if (!"".equals(childMap.get("ido_rsn_cd"))) 
//				{
//					idoRsnCdList.add((String)childMap.get("ido_rsn_cd"));
//				}
//			}
//		}
		
		// 請求契約番号取得
		HashMap dataMap2 = (HashMap)param.getData("KKSV0192SC");
		ArrayList list = (ArrayList)dataMap2.get("EKK0321B002CBSMsg1List");
		if (list != null && list.size() > 0) {
			HashMap childMap = (HashMap)list.get(0);
			dataMap.put("ekk0321b002_seiky_kei_no", (String)childMap.get("seiky_kei_no"));
		}
		
	}

	/**
	 * チェック処理<br>
	 * サービスコンポーネント実行用CAANMsgを返却します。<br>
	 * <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param (I) 業務データ取得用I/F
	 * @param fixedText (I) ユーザ定義文字列
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception Throwableがスローされます 。
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		getParamData(param);
		
		// エラーチェック用のHashMapを作成
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		List<CAANMsg> templateEKK0011D020 = editInMsgEKK0011D020(param);
		List<CAANMsg> templateEKK0591B001 = editInMsgEKK0591B001(param);
		List<CAANMsg> templateEKK0381D010 = editInMsgEKK0381D010(param);
		List<CAANMsg> templateEKK0381C030 = editInMsgEKK0381C030(param);
		List<CAANMsg> templateEKK0381C040 = editInMsgEKK0381C040(param);
		List<CAANMsg> templateEKK1091D010 = editInMsgEKK1091D010(param);
		List<CAANMsg> templateEKK0021C060 = editInMsgEKK0021C060(param);

		for (CAANMsg msg : templateEKK0011D020)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK0591B001)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK0381D010)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK0381C030)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK0381C040)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK1091D010)
		{
			templateList.add(msg);
		}
		for (CAANMsg msg : templateEKK0021C060)
		{
			templateList.add(msg);
		}
		// リストに追加されたCAANMsgを配列に変換する
		int templateSize = templateList.size();
		if (templateSize > 1)
		{
			CAANMsg[] templates = new CAANMsg[templateSize];
			for (int i = 0; i < templateSize; i++)
			{
				templates[i] = (CAANMsg)templateList.get(i);
			}
			paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		}
		else
		{
			CAANMsg[] templates = new CAANMsg[1];
			templates[0] = (CAANMsg)templateList.get(0);
			paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		}
		return paramMap;
	}
	
	/**
	 * 料金プラン一覧照会（オプションサービスコード）のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private List<CAANMsg> editInMsgEKK0591B001(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < dataList.size(); i++)
		{
			// 料金プラン一覧照会（オプションサービスコード）用テンプレート
			template = new CAANMsg(EKK0591B001CBSMsg.class.getName());
			// テンプレートID
			template.set(EKK0591B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0591B001);
			// 機能コード（デフォルト：１）
			template.set(EKK0591B001CBSMsg.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)dataList.get(i);
			
			// 料金プラン一覧照会（オプションサービスコード）マップ.ＫＥＹ＿オプションサービスコード → オプションサービスコード
			if (inMap == null || inMap.get("op_svc_cd") == null || "".equals(inMap.get("op_svc_cd")))
			{
				template.setNull(EKK0591B001CBSMsg.KEY_OP_SVC_CD);
			}
			else
			{
				template.set(EKK0591B001CBSMsg.KEY_OP_SVC_CD, (String)inMap.get("op_svc_cd"));
			}
			
			templateList.add(template);
		}
		return templateList;
	}
	
	/**
	 * オプションサービス契約＜TV＞登録のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private List<CAANMsg> editInMsgEKK0381D010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < dataList.size(); i++)
		{
			// オプションサービス契約＜TV＞登録用テンプレート
			template = new CAANMsg(EKK0381D010CBSMsg.class.getName());
			// テンプレートID
			template.set(EKK0381D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0381D010);
			// 機能コード（デフォルト：１）
			template.set(EKK0381D010CBSMsg.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);
			// 機能コード
			template.set(EKK0381D010CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
			
			// オプションチャンネル情報
			HashMap inMap = (HashMap)dataList.get(i);
			
			// オプションサービス契約＜TV＞登録マップ.オプションサービスコード → オプションサービスコード
			if (inMap == null || inMap.get("op_svc_cd") == null || "".equals(inMap.get("op_svc_cd")))
			{
				template.setNull(EKK0381D010CBSMsg.OP_SVC_CD);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.OP_SVC_CD, (String)inMap.get("op_svc_cd"));
			}
			/* ++++++++++ v4.00.00 変更開始 ++++++++++ */
//			// 親契約識別コード(03：サービス契約内訳) → 親契約識別コード
//			template.set(EKK0381D010CBSMsg.OYA_KEI_SKBT_CD, OYA_KEI_SKBT_CD_03);
			// 親契約識別コード → 親契約識別コード
			if (dataMap.get("oya_kei_skbt_cd") == null || "".equals(dataMap.get("oya_kei_skbt_cd")))
			{
				template.setNull(EKK0381D010CBSMsg.OYA_KEI_SKBT_CD);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.OYA_KEI_SKBT_CD, (String)dataMap.get("oya_kei_skbt_cd"));
			}
			/* ++++++++++ v4.00.00 変更終了 ++++++++++ */
			// サービス契約番号 → サービス契約番号
			if (dataMap.get("svc_kei_no") == null || "".equals(dataMap.get("svc_kei_no")))
			{
				template.setNull(EKK0381D010CBSMsg.SVC_KEI_NO);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.SVC_KEI_NO, (String)dataMap.get("svc_kei_no"));
			}
			// サービス契約内訳番号 → サービス契約内訳番号
			if (dataMap.get("svc_kei_ucwk_no") == null || "".equals(dataMap.get("svc_kei_ucwk_no")))
			{
				template.setNull(EKK0381D010CBSMsg.SVC_KEI_UCWK_NO);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.SVC_KEI_UCWK_NO, (String)dataMap.get("svc_kei_ucwk_no"));
			}
			// オプションサービス契約＜TV＞登録マップ.SYSID → SYSID
			if (dataMap.get("sysid") == null || "".equals(dataMap.get("sysid")))
			{
				template.setNull(EKK0381D010CBSMsg.SYSID);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.SYSID, (String)dataMap.get("sysid"));
			}
			// 試用加入年月日
			template.setNull(EKK0381D010CBSMsg.FTRIAL_KANYU_YMD);
			// 試用期間終了年月日
			template.setNull(EKK0381D010CBSMsg.FTRIAL_PRD_ENDYMD);
			// 本加入年月日
			template.setNull(EKK0381D010CBSMsg.HONKANYU_YMD);
			// 本加入移行期限年月日
			template.setNull(EKK0381D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
			// オプションサービス契約＜TV＞登録マップ.サービス利用開始希望年月日 → サービス利用開始希望年月日
			if (inMap == null || inMap.get("svc_staymd") == null || "".equals(inMap.get("svc_staymd")))
			{
				template.setNull(EKK0381D010CBSMsg.SVC_USE_STA_KIBO_YMD);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.SVC_USE_STA_KIBO_YMD, (String)inMap.get("svc_staymd"));
			}
			// オプションサービス契約＜TV＞登録マップ.予約適用開始希望年月日 → 予約適用開始希望年月日
			if (inMap == null || inMap.get("svc_staymd") == null || "".equals(inMap.get("svc_staymd")))
			{
				template.setNull(EKK0381D010CBSMsg.RSV_TSTA_KIBO_YMD);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inMap.get("svc_staymd"));
			}
			// 違約金発生コード
			template.setNull(EKK0381D010CBSMsg.PNLTY_HASSEI_CD);
			// 異動区分
			template.set(EKK0381D010CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
			// NHK団体一括支払サイクルコード
			template.setNull(EKK0381D010CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD);
			// 初回請求年月日
			template.setNull(EKK0381D010CBSMsg.FIRST_SEIYMD);
			// ケーブルガイド申込数
			template.setNull(EKK0381D010CBSMsg.CABLE_GUIDE_MSKM_CNT);
//			// ガイド誌種別コード
//			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SBT_CD);
//			// ガイド誌発送方法コード
//			template.set(EKK0381D010CBSMsg.GUIDEMG_HASSO_WAY_CD, GUIDEMG_HASSO_WAY_CD_070001);
			// ガイド誌送付先名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_NM);
			// ガイド誌送付先カナ名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_KANA);
			// ガイド誌送付先住所コード
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AD_CD);
			// ガイド誌送付先郵便番号
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_PCD);
			// ガイド誌送付先都道府県名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_STATE_NM);
			// ガイド誌送付先市区町村名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_CITY_NM);
			// ガイド誌送付先大字通称名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_OAZTSU_NM);
			// ガイド誌送付先字丁目名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AZCHO_NM);
			// ガイド誌送付先番地号
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_BNCHIGO);
			// ガイド誌送付先住所補記・建物名
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRTTM);
			// ガイド誌送付先住所補記・部屋番号
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRRM);
			// ガイド誌送付先電話番号
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_TELNO);
			// ガイド誌送付先個別指定フラグ
			template.setNull(EKK0381D010CBSMsg.GUIDEMG_SHS_KSITEI_FLG);
			// NHKお客様番号
			template.setNull(EKK0381D010CBSMsg.NHK_CUST_NO);
			// NHK団体一括契約変更届年月日
			template.setNull(EKK0381D010CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD);
			// オプションサービス契約＜TV＞登録マップ.赤B−CAS番号 → 赤B−CAS番号
			if (inMap == null || inMap.get("red_bcas_no") == null || "".equals(inMap.get("red_bcas_no")))
			{
				template.setNull(EKK0381D010CBSMsg.RED_BCAS_NO);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.RED_BCAS_NO, (String)inMap.get("red_bcas_no"));
			}
			// OUTPUT請求契約番号 → 請求契約番号
			if (dataMap.get("ekk0321b002_seiky_kei_no") == null || "".equals(dataMap.get("ekk0321b002_seiky_kei_no")))
			{
				template.setNull(EKK0381D010CBSMsg.SEIKY_KEI_NO);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.SEIKY_KEI_NO, (String)dataMap.get("ekk0321b002_seiky_kei_no"));
			}
			// 料金項目コード
			template.setNull(EKK0381D010CBSMsg.PRC_KMK_CD);
			
			// オプションサービス契約＜TV＞登録マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
			if (dataMap.get("upd_dtm_bf") == null || "".equals(dataMap.get("upd_dtm_bf")))
			{
				template.setNull(EKK0381D010CBSMsg.UPD_DTM_BF);
			}
			else
			{
				template.set(EKK0381D010CBSMsg.UPD_DTM_BF, (String)dataMap.get("upd_dtm_bf"));
			}
			
			// NHK団体一括契約NHK締結年月日
			template.setNull(EKK0381D010CBSMsg.NHK_DNTIKTKEI_NHK_CNC_YMD);
			// NHK団体一括契約登録メモ
			template.setNull(EKK0381D010CBSMsg.NHK_DNTIKTKEI_ADD_MEMO);
//			// ガイド誌送付先住所手動入力フラグ サービスIFで必須になっているため固定で設定 IF修正後削除
//			template.set(EKK0381D010CBSMsg.GUDMG_SHS_AD_MAN_INPUT_FLG, "0");
			templateList.add(template);
		}
		return templateList;
	}

	/**
	 * オプションサービス契約＜TV＞照査締結のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private List<CAANMsg> editInMsgEKK0381C030(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < dataList.size(); i++)
		{
			template = new CAANMsg(EKK0381C030CBSMsg.class.getName());
			// テンプレートID
			template.set(EKK0381C030CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0381C030);
			// 機能コード（デフォルト：１）
			template.set(EKK0381C030CBSMsg.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);
			// 機能コード
			template.set(EKK0381C030CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
			// 異動区分
			template.set(EKK0381C030CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
				templateList.add(template);
		}
		return templateList;
	}

	/**
	 * オプションサービス契約＜TV＞開始のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private List<CAANMsg> editInMsgEKK0381C040(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < dataList.size(); i++)
		{
			// オプションチャンネル情報
			HashMap inMap = (HashMap)dataList.get(i);
			
			template = new CAANMsg(EKK0381C040CBSMsg.class.getName());
			// テンプレートID
			template.set(EKK0381C040CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0381C040);
			// 機能コード（デフォルト：１）
			template.set(EKK0381C040CBSMsg.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);
			// 機能コード
			template.set(EKK0381C040CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
			
			// オプションサービス契約＜TV＞開始マップ.サービス開始年月日 → サービス開始年月日
			if (inMap == null || inMap.get("svc_staymd") == null || "".equals(inMap.get("svc_staymd")))
			{
				template.setNull(EKK0381C040CBSMsg.SVC_STAYMD);
			}
			else
			{
				template.set(EKK0381C040CBSMsg.SVC_STAYMD, (String)inMap.get("svc_staymd"));
			}
			// 異動区分
			template.set(EKK0381C040CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
			// 即時/翌月
			if ("0".equals((String)inMap.get("staymd")))
			{
				template.set(EKK0381C040CBSMsg.SKJ_YKGT, SKJ_YKGT_01);
			}
			/* ++++++++++ v4.00.00 変更開始 ++++++++++ */
//			else
			else if("1".equals((String)inMap.get("staymd")))
			/* ++++++++++ v4.00.00 変更終了 ++++++++++ */
			{
				template.set(EKK0381C040CBSMsg.SKJ_YKGT, SKJ_YKGT_02);
			}
			/* ++++++++++ v4.00.00 追加開始 ++++++++++ */
			else if("2".equals((String)inMap.get("staymd")))
			{
				template.set(EKK0381C040CBSMsg.SKJ_YKGT, SKJ_YKGT_03);
			}
			/* ++++++++++ v4.00.00 追加終了 ++++++++++ */
			
			templateList.add(template);
		}
		return templateList;
	}

	/**
	 * 進捗登録のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private List<CAANMsg> editInMsgEKK1091D010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
//		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
//		
//		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
//		for (int i = 0; i < dataList.size(); i++)
//		{
//		// オプションチャンネル情報
//		HashMap inMap = (HashMap)dataList.get(i);
		
		template = new CAANMsg(EKK1091D010CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK1091D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1091D010);
		// 機能コード（デフォルト：１）
		template.set(EKK1091D010CBSMsg.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);
		// 機能コード
		template.set(EKK1091D010CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
		// 請求契約番号
		template.setNull(EKK1091D010CBSMsg.SEIKY_KEI_NO);
		// 請求方法番号（口座）
		template.setNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA);
		// 請求方法番号（クレジットカード）
		template.setNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD);
		// 進捗登録マップ.サービス契約番号 → サービス契約番号
		if (dataMap.get("svc_kei_no") == null || "".equals(dataMap.get("svc_kei_no")))
		{
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.SVC_KEI_NO, (String)dataMap.get("svc_kei_no"));
		}
		// サービス契約内訳番号
		if (dataMap.get("svc_kei_ucwk_no") == null || "".equals(dataMap.get("svc_kei_ucwk_no")))
		{
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, (String)dataMap.get("svc_kei_ucwk_no"));
		}
		// サービス契約回線内訳番号
		template.setNull(EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
		// 機器提供サービス契約番号
		template.setNull(EKK1091D010CBSMsg.KKTK_SVC_KEI_NO);
		// 進捗登録マップ.オプションサービス契約番号 → オプションサービス契約番号
		if (dataMap.get("ekk0381d010_op_svc_kei_no") == null || "".equals(dataMap.get("ekk0381d010_op_svc_kei_no")))
		{
			template.setNull(EKK1091D010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.OP_SVC_KEI_NO, (String)dataMap.get("ekk0381d010_op_svc_kei_no"));
		}
		// 請求オプションサービス契約番号
		template.setNull(EKK1091D010CBSMsg.SEIOPSVC_KEI_NO);
		// サブオプションサービス契約番号
		template.setNull(EKK1091D010CBSMsg.SBOP_SVC_KEI_NO);
		// 割引サービス契約番号
		template.setNull(EKK1091D010CBSMsg.WRIB_SVC_KEI_NO);
		// 異動区分
		template.set(EKK1091D010CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
		// システム年月日時分秒 → 異動年月日時分秒
//		if (dataMap.get("ido_dtm") == null || "".equals(dataMap.get("ido_dtm")))
//		{
//			template.setNull(EKK1091D010CBSMsg.IDO_DTM);
//		}
//		else
//		{
//			template.set(EKK1091D010CBSMsg.IDO_DTM, (String)dataMap.get("ido_dtm"));
//		}
		template.set(EKK1091D010CBSMsg.IDO_DTM, JPCBPCommon.getSysDateTimeStamp());
		// 進捗ステータス
//		if ("0".equals((String)inMap.get("staymd")) && 
//			OP_CHANNEL_OPRTN_WAY_CD_1.equals((String)inMap.get(EKK0821A010CBSMsg1List.OP_CHANNEL_OPRTN_WAY_CD)))
//		{
//			template.set(EKK1091D010CBSMsg.PRG_STAT, PRG_STAT_5102);
//		}
//		else
//		{
//			template.set(EKK1091D010CBSMsg.PRG_STAT, PRG_STAT_5101);
//		}
		template.set(EKK1091D010CBSMsg.PRG_STAT, PRG_STAT_5102);
		// 進捗メモ
		template.setNull(EKK1091D010CBSMsg.PRG_MEMO);
		// 進捗特記事項1
		if ("".equals(dataMap.get("prg_tkjk_1")))
		{
			template.setNull(EKK1091D010CBSMsg.PRG_TKJK_1);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.PRG_TKJK_1, (String)dataMap.get("prg_tkjk_1"));
		}
		// 進捗特記事項2
		if ("".equals(dataMap.get("prg_tkjk_2")))
		{
			template.setNull(EKK1091D010CBSMsg.PRG_TKJK_2);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.PRG_TKJK_2, (String)dataMap.get("prg_tkjk_2"));
		}
		
		ArrayList<String> inList = new ArrayList<String>();
		ArrayList inMapList = (ArrayList)dataMap.get("EKK1091D010CBSMsg1List");
		if (inMapList != null) 
		{
			for (int j = 0; j < inMapList.size(); j++) 
			{
				HashMap childMap = (HashMap)inMapList.get(j);
				
				if (!"".equals(childMap.get("ido_rsn_cd"))) 
				{
					inList.add((String)childMap.get("ido_rsn_cd"));
				}
			}
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		if (templateArray == null)
		{
			templateArray = new CAANMsg[inList.size()];
		}
		
		if (inList != null) 
		{
			for (int j = 0; j < inList.size(); j++) 
			{
				String idoRsnCd = (String)inList.get(j);
				
				CAANMsg childTemplate = templateArray[j];
				if (childTemplate == null) 
				{
					childTemplate = new CAANMsg(EKK1091D010CBSMsg1List.class.getName());
				}
				
				// 異動理由コード
				childTemplate.set(EKK1091D010CBSMsg1List.IDO_RSN_CD, idoRsnCd);
				// 異動理由メモ
				childTemplate.setNull(EKK1091D010CBSMsg1List.IDO_RSN_MEMO);
				
				templateArray[j] = childTemplate;
			}
		}
		
		template.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, templateArray);
		
//		if (templateArray == null)
//			{
//			templateArray = new CAANMsg[1];
//		}
//		CAANMsg childTemplate = templateArray[0];
//		if (childTemplate == null)
//		{
//			childTemplate = new CAANMsg(EKK1091D010CBSMsg1List.class.getName());
//		}
//		// 異動理由コード(F7：オプション契約したため) → 異動理由明細.異動理由コード
//		childTemplate.set(EKK1091D010CBSMsg1List.IDO_RSN_CD, IDO_RSN_CD_F7);
//		// 異動理由メモ
//		childTemplate.setNull(EKK1091D010CBSMsg1List.IDO_RSN_MEMO);
//		templateArray[0] = childTemplate;
//		template.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, templateArray);
		templateList.add(template);
//		}
		return templateList;
	}

	/**
	 * 申込内容承認登録のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	private List<CAANMsg> editInMsgEKK0011D020(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
//		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
//		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
//		for (int i = 0; i < dataList.size(); i++)
//		{
		template = new CAANMsg(EKK0011D020CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0011D020CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0011D020);
		// 機能コード（デフォルト：１）
		template.set(EKK0011D020CBSMsg.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);
		// 機能コード
		template.set(EKK0011D020CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
		// 申込内容承認登録マップ.SYSID → SYSID
		if (dataMap.get("sysid") == null || "".equals(dataMap.get("sysid")))
		{
			template.setNull(EKK0011D020CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0011D020CBSMsg.SYSID, (String)dataMap.get("sysid"));
		}
		// 申込種別コード(00026：オプション申込) → 申込種別コード
		template.set(EKK0011D020CBSMsg.MSKM_SBT_CD, MSKM_SBT_CD_00026);
		// 申込書到着年月日
		template.setNull(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD);
		// 申込内容承認登録マップ.申込受付年月日時分秒 → 申込受付年月日時分秒
		if (dataMap.get("mskm_uk_dtm") == null || "".equals(dataMap.get("mskm_uk_dtm")))
		{
			template.setNull(EKK0011D020CBSMsg.MSKM_UK_DTM);
		}
		else
		{
			template.set(EKK0011D020CBSMsg.MSKM_UK_DTM, (String)dataMap.get("mskm_uk_dtm"));
		}
		// 申込受付担当ユーザーID
		template.setNull(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID);
		// 申込内容承認登録マップ.申込年月日 → 申込年月日
		if (dataMap.get("mskm_ymd") == null || "".equals(dataMap.get("mskm_ymd")))
		{
			template.setNull(EKK0011D020CBSMsg.MSKM_YMD);
		}
		else
		{
			template.set(EKK0011D020CBSMsg.MSKM_YMD, (String)dataMap.get("mskm_ymd"));
		}
		// 総合営業センター受付番号
		template.setNull(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO);
		// 総合営業申込契機コード
		template.setNull(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD);
		// 申込連絡先電話番号
		template.setNull(EKK0011D020CBSMsg.MSKM_RRKS_TELNO);
		// 申込実施者種別コード
		template.setNull(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD);
		// お客様ご要望事項
		template.setNull(EKK0011D020CBSMsg.CUST_YOBO_JIKO);
		// 電話連絡希望日種別コード
		template.setNull(EKK0011D020CBSMsg.TEL_RRK_KIBOD_SBT_CD);
		// 電話連絡希望時間帯コード
		template.setNull(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD);
		// 宅内調査希望日種別コード
		template.setNull(EKK0011D020CBSMsg.TAKCHO_KIBOD_SBT_CD);
		// 宅内調査希望時間帯コード
		template.setNull(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD);
		// 仮申込フラグ → 仮申込フラグ
		template.setNull(EKK0011D020CBSMsg.KARI_MSKM_FLG);
		// リファラー
		template.setNull(EKK0011D020CBSMsg.REFERER);
		// 関西電力お客様情報授受同意有無
		template.setNull(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM);
		// 照査前連絡事項要否
		template.setNull(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO_YH);
		// 照査前連絡事項
		template.setNull(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO);
		// 利用サービス継続種別コード
		template.setNull(EKK0011D020CBSMsg.USE_SVC_KEIZK_SBT_CD);
		// コンシューマ営業用申込状態識別コード
		template.set(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD, CONSMBSN_MSKM_STAT_SKBT_CD_04);
		// 受付担当者識別コード
		template.setNull(EKK0011D020CBSMsg.UK_TNTSHA_SKBT_CD);
		// 工事依頼情報連絡事項
		template.setNull(EKK0011D020CBSMsg.KOJI_REQ_INFO_RRK_JIKO);
		// 申込経路識別コード
		template.setNull(EKK0011D020CBSMsg.MSKM_ROUTE_SKBT_CD);
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);
		if (templateArray == null)
		{
			templateArray = new CAANMsg[1];
		}
		CAANMsg childTemplate = templateArray[0];
		if (childTemplate == null)
		{
			childTemplate = new CAANMsg(EKK0011D020CBSMsg1List.class.getName());
		}
		// 申込内容承認登録明細.申込書番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKMSHO_NO);
		// 申込内容承認登録明細.WEB受付番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.WEB_UK_NO);
		// 申込形態コード(05：書面) → 申込内容承認登録明細.申込形態コード
		childTemplate.set(EKK0011D020CBSMsg1List.MSKM_FORM_CD, MSKM_FROM_CD_05);
		// 申込内容承認登録明細.申込明細種別コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD);
		// 申込内容承認登録明細.連絡先携帯電話番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO);
		// 申込内容承認登録明細.連絡先勤務先名
		childTemplate.setNull(EKK0011D020CBSMsg1List.RRKS_OFFC_NM);
		// 申込内容承認登録明細.昼間連絡先電話番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.DT_RRKS_TELNO);
		// 申込内容承認登録明細.新規申込種別コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD);
		// 申込内容承認登録明細.申込契機コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD);
		// 申込内容承認登録明細.宅内調査希望アポ期限年月日
		childTemplate.setNull(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD);
		// 申込内容承認登録明細.工事アポ連絡先指定コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD);
		// 申込内容承認登録明細.工事アポ連絡先電話番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO);
		// 申込内容承認登録明細.連絡事項登録年月日時分秒
		childTemplate.setNull(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM);
		// 申込内容承認登録明細.申込連絡先メールアドレス
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD);
		// 申込内容承認登録明細.工事進捗通知メールアドレス
		childTemplate.setNull(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD);
		// 申込内容承認登録明細.連絡事項
		childTemplate.setNull(EKK0011D020CBSMsg1List.RRK_JIKO);
		// 申込内容承認登録明細.工事進捗通知携帯メールアドレス
		childTemplate.setNull(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD);
		// 申込内容承認登録明細.メール送信除外フラグ
		childTemplate.setNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG);
		// 申込内容承認登録明細.メール送信除外理由メモ
		childTemplate.setNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO);
		// 申込内容承認登録明細.番ポ申込連絡先電話番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN);
		// 申込内容承認登録明細.オプションサービス引継有無
		childTemplate.setNull(EKK0011D020CBSMsg1List.OP_SVC_HKTGI_UM);
		// 申込内容承認登録明細.解約書類送付希望有無
		childTemplate.setNull(EKK0011D020CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM);
		// 申込内容承認登録明細.連絡手段補記
		childTemplate.setNull(EKK0011D020CBSMsg1List.RRK_WAY_HOKI);
		// 申込内容承認登録明細.新築物件コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD);
		// 申込内容承認登録明細.復活案件フラグ
		childTemplate.setNull(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG);
		// 申込内容承認登録明細.同一設備再申込コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD);
		// 本人確認書類種別コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD);
		// 申込書種別コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKMSHO_SBT_CD);
		// 地図添付有無
		childTemplate.setNull(EKK0011D020CBSMsg1List.MAP_TEMP_UM);
		// KCNSTB申込台数
		childTemplate.setNull(EKK0011D020CBSMsg1List.KCN_STB_MSKM_CNT);
		// KCNSTB種類コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.KCN_STB_KIND_CD);
		// CAT-ID
		childTemplate.setNull(EKK0011D020CBSMsg1List.CATID);
		// 契約付加コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.KEI_HUKA_CD);
		// マンションID
		childTemplate.setNull(EKK0011D020CBSMsg1List.MANSION_ID);
		// 申込書取扱情報担当者名
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM);
		// マンション設備システム連携用記事欄
		childTemplate.setNull(EKK0011D020CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN);
		// 申込書取扱情報電話番号
		childTemplate.setNull(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TELNO);
		// 申込受付種別コード
		childTemplate.setNull(EKK0011D020CBSMsg1List.MKM_UK_SBT_CD);
		
		templateArray[0] = childTemplate;
		template.set(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST, templateArray);
		templateList.add(template);
//		}
		return templateList;
	}

	/**
	 * 申込明細照査・後続業務依頼のチェック用マッピング処理を行います。
	 * <br>
	 * @param param
	 * @return List<CAANMsg>
	 * @throws RequestParameterException
	 */
	private List<CAANMsg> editInMsgEKK0021C060(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// CAANMsg格納用ArrayList
		List<CAANMsg> templateList = new ArrayList<CAANMsg>();
		CAANMsg template = null;
		
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
//		ArrayList dataList = (ArrayList)dataMap.get("eo_op_list");
		
//		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
//		for (int i = 0; i < dataList.size(); i++)
//		{
		template = new CAANMsg(EKK0021C060CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0021C060CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0021C060);
		// 機能コード（デフォルト：１）
		template.set(EKK0021C060CBSMsg.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);
		// 機能コード
		template.set(EKK0021C060CBSMsg.FUNC_CODE, (String)dataMap.get("func_code"));
		// 連絡事項登録年月日時分秒
		template.setNull(EKK0021C060CBSMsg.RRK_JIKO_ADD_DTM);
		// 申込明細照査・後続業務依頼マップ.後続業務依頼年月日 → 後続業務依頼年月日
		if (dataMap.get("kzkwrk_reqymd") == null || "".equals(dataMap.get("kzkwrk_reqymd")))
		{
			template.setNull(EKK0021C060CBSMsg.KZKWRK_REQYMD);
		}
		else
		{
			template.set(EKK0021C060CBSMsg.KZKWRK_REQYMD, (String)dataMap.get("kzkwrk_reqymd"));
		}
		// 連絡事項
		template.setNull(EKK0021C060CBSMsg.RRK_JIKO);
		// 異動区分
		template.set(EKK0021C060CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
		// 申込明細照査・後続業務依頼マップ.電話番号 → 電話番号
		template.setNull(EKK0021C060CBSMsg.TELNO);
		// 申込明細照査・後続業務依頼マップ.代表電話番号 → 代表電話番号
		template.setNull(EKK0021C060CBSMsg.DAIHYO_TELNO);
		// 申込明細照査・後続業務依頼マップ.電話番号使用場所番号 → 電話番号使用場所番号
		template.setNull(EKK0021C060CBSMsg.TELNO_USE_PLACE_NO);
		// 申込明細照査・後続業務依頼マップ.SIPユーザーID消去済フラグ → SIPユーザーID消去済フラグ
		template.setNull(EKK0021C060CBSMsg.SIP_USER_ID_DEL_ZUMI_FLG);
		// 申込明細照査・後続業務依頼マップ.電話BASホストID → 電話BASホストID
		template.setNull(EKK0021C060CBSMsg.TEL_BAS_HOST_ID);
		// 申込明細照査・後続業務依頼マップ.050オプション電話番号 → 050オプション電話番号
		template.setNull(EKK0021C060CBSMsg.N_050_OP_TELNO);
		// 申込明細照査・後続業務依頼マップ.機器認証ID → 機器認証ID
		template.setNull(EKK0021C060CBSMsg.KIKI_NINSHO_ID);
		// 申込明細照査・後続業務依頼マップ.機器認証IDパスワード → 機器認証IDパスワード
		template.setNull(EKK0021C060CBSMsg.KIKI_NINSHO_ID_PWD);
		templateList.add(template);
//		}
		return templateList;
	}

	/**
	 * サービスインターフェイス処理結果(エラー情報)の取得<br>
	 * 業務データ取得・書込用I/Fをそのまま返却します。<br>
	 * <br>
	 * @param param デルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param templates CAANMsgクラス配列
	 * @param returnCode リターンコード
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode) throws Throwable
	{
		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = {template};
			if (TEMPLATE_ID_EKK0011D020.equals(templateId))
			{
				// 申込内容承認登録
				editErrorInfoEKK0011D020(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0591B001.equals(templateId))
			{
				// 料金プラン一覧照会（オプションサービスコード）
				editErrorInfoEKK0591B001(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0381D010.equals(templateId))
			{
				// オプションサービス契約＜TV＞登録
				editErrorInfoEKK0381D010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0381C030.equals(templateId))
			{
				// オプションサービス契約＜TV＞照査締結
				editErrorInfoEKK0381C030(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0381C040.equals(templateId))
			{
				// オプションサービス契約＜TV＞開始
				editErrorInfoEKK0381C040(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK1091D010.equals(templateId))
			{
				// 進捗登録
				editErrorInfoEKK1091D010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0021C060.equals(templateId))
			{
				// 申込明細照査・後続業務依頼
				editErrorInfoEKK0021C060(param, workTemplates, returnCode);
			}
		}
		return param;
	}

	/**
	 * 料金プラン一覧照会（オプションサービスコード）のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0591B001(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0591B001CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");

		// 料金プラン一覧照会（オプションサービスコード）マップ.ＫＥＹ＿オプションサービスコード → オプションサービスコード のエラー情報返却
		if (!template.isNull(EKK0591B001CBSMsg.KEY_OP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("key_op_svc_cd_err"))
			{
				inMap.put("key_op_svc_cd_err", template.getString(EKK0591B001CBSMsg.KEY_OP_SVC_CD_ERR));
			}
		}
		return param;
	}
	
	/**
	 * オプションサービス契約＜TV＞登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0381D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0381D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");

		// オプションサービス契約＜TV＞登録マップ.オプションサービスコード → オプションサービスコード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.OP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("op_svc_cd_err"))
			{
				inMap.put("op_svc_cd_err", template.getString(EKK0381D010CBSMsg.OP_SVC_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.料金コースコード → 料金コースコード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK0381D010CBSMsg.PCRS_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.料金プランコード → 料金プランコード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK0381D010CBSMsg.PPLAN_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.親契約識別コード → 親契約識別コード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.OYA_KEI_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("oya_kei_skbt_cd_err"))
			{
				inMap.put("oya_kei_skbt_cd_err", template.getString(EKK0381D010CBSMsg.OYA_KEI_SKBT_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK0381D010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK0381D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.SYSID → SYSID のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0381D010CBSMsg.SYSID_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0381D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0381D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK0381D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK0381D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0381D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.サービス利用開始希望年月日 → サービス利用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0381D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0381D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0381D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0381D010CBSMsg.IDO_DIV_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.NHK団体一括支払サイクルコード → NHK団体一括支払サイクルコード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD_ERR))
		{
			if (!inMap.containsKey("nhk_grp_ikt_pay_cycle_cd_err"))
			{
				inMap.put("nhk_grp_ikt_pay_cycle_cd_err", template.getString(EKK0381D010CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.初回請求年月日 → 初回請求年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.FIRST_SEIYMD_ERR))
		{
			if (!inMap.containsKey("first_seiymd_err"))
			{
				inMap.put("first_seiymd_err", template.getString(EKK0381D010CBSMsg.FIRST_SEIYMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ケーブルガイド申込数 → ケーブルガイド申込数 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.CABLE_GUIDE_MSKM_CNT_ERR))
		{
			if (!inMap.containsKey("cable_guide_mskm_cnt_err"))
			{
				inMap.put("cable_guide_mskm_cnt_err", template.getString(EKK0381D010CBSMsg.CABLE_GUIDE_MSKM_CNT_ERR));
			}
		}
//		// オプションサービス契約＜TV＞登録マップ.ガイド誌種別コード → ガイド誌種別コード のエラー情報返却
//		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SBT_CD_ERR))
//		{
//			if (!inMap.containsKey("guidemg_sbt_cd_err"))
//			{
//				inMap.put("guidemg_sbt_cd_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SBT_CD_ERR));
//			}
//		}
//		// オプションサービス契約＜TV＞登録マップ.ガイド誌発送方法コード → ガイド誌発送方法コード のエラー情報返却
//		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_HASSO_WAY_CD_ERR))
//		{
//			if (!inMap.containsKey("guidemg_hasso_way_cd_err"))
//			{
//				inMap.put("guidemg_hasso_way_cd_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_HASSO_WAY_CD_ERR));
//			}
//		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先名 → ガイド誌送付先名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_NM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_nm_err"))
			{
				inMap.put("guidemg_sohus_nm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_NM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先カナ名 → ガイド誌送付先カナ名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_KANA_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_kana_err"))
			{
				inMap.put("guidemg_sohus_kana_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_KANA_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先住所コード → ガイド誌送付先住所コード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AD_CD_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_ad_cd_err"))
			{
				inMap.put("guidemg_sohus_ad_cd_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AD_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先郵便番号 → ガイド誌送付先郵便番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_PCD_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_pcd_err"))
			{
				inMap.put("guidemg_sohus_pcd_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_PCD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先都道府県名 → ガイド誌送付先都道府県名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_state_nm_err"))
			{
				inMap.put("guidemg_sohus_state_nm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_STATE_NM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先市区町村名 → ガイド誌送付先市区町村名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_city_nm_err"))
			{
				inMap.put("guidemg_sohus_city_nm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_CITY_NM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先大字通称名 → ガイド誌送付先大字通称名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_oaztsu_nm_err"))
			{
				inMap.put("guidemg_sohus_oaztsu_nm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_OAZTSU_NM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先字丁目名 → ガイド誌送付先字丁目名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_azcho_nm_err"))
			{
				inMap.put("guidemg_sohus_azcho_nm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_AZCHO_NM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先番地号 → ガイド誌送付先番地号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_bnchigo_err"))
			{
				inMap.put("guidemg_sohus_bnchigo_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_BNCHIGO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先住所補記・建物名 → ガイド誌送付先住所補記・建物名 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_adrttm_err"))
			{
				inMap.put("guidemg_sohus_adrttm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRTTM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先住所補記・部屋番号 → ガイド誌送付先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRRM_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_adrrm_err"))
			{
				inMap.put("guidemg_sohus_adrrm_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_ADRRM_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先電話番号 → ガイド誌送付先電話番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SOHUS_TELNO_ERR))
		{
			if (!inMap.containsKey("guidemg_sohus_telno_err"))
			{
				inMap.put("guidemg_sohus_telno_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SOHUS_TELNO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.ガイド誌送付先個別指定フラグ → ガイド誌送付先個別指定フラグ のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.GUIDEMG_SHS_KSITEI_FLG_ERR))
		{
			if (!inMap.containsKey("guidemg_shs_ksitei_flg_err"))
			{
				inMap.put("guidemg_shs_ksitei_flg_err", template.getString(EKK0381D010CBSMsg.GUIDEMG_SHS_KSITEI_FLG_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.NHKお客様番号 → NHKお客様番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.NHK_CUST_NO_ERR))
		{
			if (!inMap.containsKey("nhk_cust_no_err"))
			{
				inMap.put("nhk_cust_no_err", template.getString(EKK0381D010CBSMsg.NHK_CUST_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.NHK団体一括契約変更届年月日 → NHK団体一括契約変更届年月日 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD_ERR))
		{
			if (!inMap.containsKey("nhk_dntiktkei_hktdk_ymd_err"))
			{
				inMap.put("nhk_dntiktkei_hktdk_ymd_err", template.getString(EKK0381D010CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.赤B−CAS番号 → 赤B−CAS番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.RED_BCAS_NO_ERR))
		{
			if (!inMap.containsKey("red_bcas_no_err"))
			{
				inMap.put("red_bcas_no_err", template.getString(EKK0381D010CBSMsg.RED_BCAS_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK0381D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.料金項目コード → 料金項目コード のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK0381D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}
		// オプションサービス契約＜TV＞登録マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0381D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0381D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 * オプションサービス契約＜TV＞照査締結のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0381C030(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0381C030CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");
		// オプションサービス契約＜TV＞照査締結マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0381C030CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0381C030CBSMsg.IDO_DIV_ERR));
			}
		}
		return param;
	}

	/**
	 * オプションサービス契約＜TV＞開始のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0381C040(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode) 
		throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0381C040CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");
		// オプションサービス契約＜TV＞開始マップ.サービス開始年月日 → サービス開始年月日 のエラー情報返却
		if (!template.isNull(EKK0381C040CBSMsg.SVC_STAYMD_ERR))
		{
			if (!inMap.containsKey("svc_staymd_err"))
			{
				inMap.put("svc_staymd_err", template.getString(EKK0381C040CBSMsg.SVC_STAYMD_ERR));
			}
		}
		// オプションサービス契約＜TV＞開始マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0381C040CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0381C040CBSMsg.IDO_DIV_ERR));
			}
		}
		return param;
	}

	/**
	 * 進捗登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1091D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		int templateStatus = template.getInt(EKK1091D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");
		ArrayList inList = null;

		// 進捗登録マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK1091D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 進捗登録マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK1091D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.請求方法番号（口座） → 請求方法番号（口座） のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA_ERR))
		{
			if (!inMap.containsKey("seiky_way_no_koza_err"))
			{
				inMap.put("seiky_way_no_koza_err", template.getString(EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA_ERR));
			}
		}
		// 進捗登録マップ.請求方法番号（クレジットカード） → 請求方法番号（クレジットカード） のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD_ERR))
		{
			if (!inMap.containsKey("seiky_way_no_crecard_err"))
			{
				inMap.put("seiky_way_no_crecard_err", template.getString(EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD_ERR));
			}
		}
		// 進捗登録マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK1091D010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}
		// 進捗登録マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("svc_kei_kaisen_ucwk_no_err", template.getString(EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}
		// 進捗登録マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK1091D010CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SEIOPSVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiopsvc_kei_no_err"))
			{
				inMap.put("seiopsvc_kei_no_err", template.getString(EKK1091D010CBSMsg.SEIOPSVC_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.SBOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("sbop_svc_kei_no_err"))
			{
				inMap.put("sbop_svc_kei_no_err", template.getString(EKK1091D010CBSMsg.SBOP_SVC_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.WRIB_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("wrib_svc_kei_no_err"))
			{
				inMap.put("wrib_svc_kei_no_err", template.getString(EKK1091D010CBSMsg.WRIB_SVC_KEI_NO_ERR));
			}
		}
		// 進捗登録マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK1091D010CBSMsg.IDO_DIV_ERR));
			}
		}
		// 進捗登録マップ.異動年月日時分秒 → 異動年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.IDO_DTM_ERR))
		{
			if (!inMap.containsKey("ido_dtm_err"))
			{
				inMap.put("ido_dtm_err", template.getString(EKK1091D010CBSMsg.IDO_DTM_ERR));
			}
		}
		// 進捗登録マップ.進捗ステータス → 進捗ステータス のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.PRG_STAT_ERR))
		{
			if (!inMap.containsKey("prg_stat_err"))
			{
				inMap.put("prg_stat_err", template.getString(EKK1091D010CBSMsg.PRG_STAT_ERR));
			}
		}
		// 進捗登録マップ.進捗メモ → 進捗メモ のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.PRG_MEMO_ERR))
		{
			if (!inMap.containsKey("prg_memo_err"))
			{
				inMap.put("prg_memo_err", template.getString(EKK1091D010CBSMsg.PRG_MEMO_ERR));
			}
		}
		// 進捗登録マップ.進捗特記事項1 → 進捗特記事項1 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.PRG_TKJK_1_ERR))
		{
			if (!inMap.containsKey("prg_tkjk_1_err"))
			{
				inMap.put("prg_tkjk_1_err", template.getString(EKK1091D010CBSMsg.PRG_TKJK_1_ERR));
			}
		}
		// 進捗登録マップ.進捗特記事項2 → 進捗特記事項2 のエラー情報返却
		if (!template.isNull(EKK1091D010CBSMsg.PRG_TKJK_2_ERR))
		{
			if (!inMap.containsKey("prg_tkjk_2_err"))
			{
				inMap.put("prg_tkjk_2_err", template.getString(EKK1091D010CBSMsg.PRG_TKJK_2_ERR));
			}
		}
		if (!inMap.containsKey("EKK1091D010CBSMsg1List") || inMap.get("EKK1091D010CBSMsg1List") == null)
		{
			inMap.put("EKK1091D010CBSMsg1List", new ArrayList());
		}
		inList = (ArrayList)inMap.get("EKK1091D010CBSMsg1List");
		templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
// ANK-4592-00-00 MOD START
//				HashMap childMap = null;
//				if (inList.size() < i)
//				{
//					childMap = (HashMap)inList.get(i);
//				}
//				else
//				{
//					childMap = new HashMap();
//					inList.add(childMap);
//				}
				if (i >= inList.size())
				{
					inList.add(new HashMap());
				}
// ANK-4592-00-00 MOD END
				CAANMsg childTemplate = templateArray[i];
				// 進捗登録マップ.異動理由明細.異動理由コード → 異動理由明細.異動理由コード のエラー情報返却
				if (!childTemplate.isNull(EKK1091D010CBSMsg1List.IDO_RSN_CD_ERR))
				{
					if (!inMap.containsKey("ido_rsn_cd_err"))
					{
						inMap.put("ido_rsn_cd_err", childTemplate.getString(EKK1091D010CBSMsg1List.IDO_RSN_CD_ERR));
					}
				}
				// 進捗登録マップ.異動理由明細.異動理由メモ → 異動理由明細.異動理由メモ のエラー情報返却
				if (!childTemplate.isNull(EKK1091D010CBSMsg1List.IDO_RSN_MEMO_ERR))
				{
					if (!inMap.containsKey("ido_rsn_memo_err"))
					{
						inMap.put("ido_rsn_memo_err", childTemplate.getString(EKK1091D010CBSMsg1List.IDO_RSN_MEMO_ERR));
					}
				}
			}
		}
		if (!template.isNull(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("EKK1091D010CBSMsg1List_err"))
			{
				inMap.put("EKK1091D010CBSMsg1List_err", template.getString(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST_ERR));
			}
		}
		return param;
	}

	/**
	 * 申込内容承認登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0011D020(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0011D020CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap)param.getData("KKSV0192CC");

		// 申込内容承認登録マップ.SYSID → SYSID のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0011D020CBSMsg.SYSID_ERR));
			}
		}
		// 申込内容承認登録マップ.申込種別コード → 申込種別コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_SBT_CD_ERR))
		{
			if (!inMap.containsKey("mskm_sbt_cd_err"))
			{
				inMap.put("mskm_sbt_cd_err", template.getString(EKK0011D020CBSMsg.MSKM_SBT_CD_ERR));
			}
		}
		// 申込内容承認登録マップ.申込書到着年月日 → 申込書到着年月日 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD_ERR))
		{
			if (!inMap.containsKey("mskmsho_ariv_ymd_err"))
			{
				inMap.put("mskmsho_ariv_ymd_err", template.getString(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD_ERR));
			}
		}
		// 申込内容承認登録マップ.申込受付年月日時分秒 → 申込受付年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_UK_DTM_ERR))
		{
			if (!inMap.containsKey("mskm_uk_dtm_err"))
			{
				inMap.put("mskm_uk_dtm_err", template.getString(EKK0011D020CBSMsg.MSKM_UK_DTM_ERR));
			}
		}
		// 申込内容承認登録マップ.申込受付担当ユーザーID → 申込受付担当ユーザーID のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID_ERR))
		{
			if (!inMap.containsKey("mskm_uk_tnt_user_id_err"))
			{
				inMap.put("mskm_uk_tnt_user_id_err", template.getString(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID_ERR));
			}
		}
		// 申込内容承認登録マップ.申込年月日 → 申込年月日 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_YMD_ERR))
		{
			if (!inMap.containsKey("mskm_ymd_err"))
			{
				inMap.put("mskm_ymd_err", template.getString(EKK0011D020CBSMsg.MSKM_YMD_ERR));
			}
		}
		// 申込内容承認登録マップ.総合営業センター受付番号 → 総合営業センター受付番号 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO_ERR))
		{
			if (!inMap.containsKey("ttl_business_center_uk_no_err"))
			{
				inMap.put("ttl_business_center_uk_no_err", template.getString(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO_ERR));
			}
		}
		// 申込内容承認登録マップ.総合営業申込契機コード → 総合営業申込契機コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD_ERR))
		{
			if (!inMap.containsKey("ttl_business_mskm_opt_cd_err"))
			{
				inMap.put("ttl_business_mskm_opt_cd_err", template.getString(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD_ERR));
			}
		}
		// 申込内容承認登録マップ.申込連絡先電話番号 → 申込連絡先電話番号 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_RRKS_TELNO_ERR))
		{
			if (!inMap.containsKey("mskm_rrks_telno_err"))
			{
				inMap.put("mskm_rrks_telno_err", template.getString(EKK0011D020CBSMsg.MSKM_RRKS_TELNO_ERR));
			}
		}
		// 申込内容承認登録マップ.申込実施者種別コード → 申込実施者種別コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD_ERR))
		{
			if (!inMap.containsKey("mskm_jssis_sbt_cd_err"))
			{
				inMap.put("mskm_jssis_sbt_cd_err", template.getString(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD_ERR));
			}
		}
		// 申込内容承認登録マップ.お客様ご要望事項 → お客様ご要望事項 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.CUST_YOBO_JIKO_ERR))
		{
			if (!inMap.containsKey("cust_yobo_jiko_err"))
			{
				inMap.put("cust_yobo_jiko_err", template.getString(EKK0011D020CBSMsg.CUST_YOBO_JIKO_ERR));
			}
		}
		// 申込内容承認登録マップ.電話連絡希望時間帯コード → 電話連絡希望時間帯コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD_ERR))
		{
			if (!inMap.containsKey("tel_rrk_kibo_time_cd_err"))
			{
				inMap.put("tel_rrk_kibo_time_cd_err", template.getString(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD_ERR));
			}
		}
		// 申込内容承認登録マップ.宅内調査希望時間帯コード → 宅内調査希望時間帯コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD_ERR))
		{
			if (!inMap.containsKey("takcho_kibo_time_cd_err"))
			{
				inMap.put("takcho_kibo_time_cd_err", template.getString(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD_ERR));
			}
		}
		// 申込内容承認登録マップ.仮申込フラグ → 仮申込フラグ のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.KARI_MSKM_FLG_ERR))
		{
			if (!inMap.containsKey("kari_mskm_flg_err"))
			{
				inMap.put("kari_mskm_flg_err", template.getString(EKK0011D020CBSMsg.KARI_MSKM_FLG_ERR));
			}
		}
		// 申込内容承認登録マップ.リファラー → リファラー のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.REFERER_ERR))
		{
			if (!inMap.containsKey("referer_err"))
			{
				inMap.put("referer_err", template.getString(EKK0011D020CBSMsg.REFERER_ERR));
			}
		}
		// 申込内容承認登録マップ.関西電力お客様情報授受同意有無 → 関西電力お客様情報授受同意有無 のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM_ERR))
		{
			if (!inMap.containsKey("kepco_ctinfo_juju_doi_um_err"))
			{
				inMap.put("kepco_ctinfo_juju_doi_um_err", template.getString(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM_ERR));
			}
		}
		// 申込内容承認登録マップ.コンシューマ営業用申込状態識別コード → コンシューマ営業用申込状態識別コード のエラー情報返却
		if (!template.isNull(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("consmbsn_mskm_stat_skbt_cd_err"))
			{
				inMap.put("consmbsn_mskm_stat_skbt_cd_err", template.getString(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD_ERR));
			}
		}
		if (!inMap.containsKey("EKK0011D020CBSMsg1List") || inMap.get("EKK0011D020CBSMsg1List") == null)
		{
			inMap.put("EKK0011D020CBSMsg1List", new ArrayList());
		}
		ArrayList inList = (ArrayList)inMap.get("EKK0011D020CBSMsg1List");
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
// ANK-4592-00-00 MOD START
//				HashMap childMap = null;
//				if (inList.size() < i)
//				{
//					childMap = (HashMap)inList.get(i);
//				}
//				else
//				{
//					childMap = new HashMap();
//					inList.add(childMap);
//				}
				if (i >= inList.size())
				{
					inList.add(new HashMap());
				}
// ANK-4592-00-00 MOD END
				CAANMsg childTemplate = templateArray[i];
		
				// 申込内容承認登録マップ.申込内容承認登録明細.申込書番号 → 申込内容承認登録明細.申込書番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.MSKMSHO_NO_ERR))
				{
					if (!inMap.containsKey("mskmsho_no_err"))
					{
						inMap.put("mskmsho_no_err", childTemplate.getString(EKK0011D020CBSMsg1List.MSKMSHO_NO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.WEB受付番号 → 申込内容承認登録明細.WEB受付番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.WEB_UK_NO_ERR))
				{
					if (!inMap.containsKey("web_uk_no_err"))
					{
						inMap.put("web_uk_no_err", childTemplate.getString(EKK0011D020CBSMsg1List.WEB_UK_NO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.申込形態コード → 申込内容承認登録明細.申込形態コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_FORM_CD_ERR))
				{
					if (!inMap.containsKey("mskm_form_cd_err"))
					{
						inMap.put("mskm_form_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_FORM_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.申込明細種別コード → 申込内容承認登録明細.申込明細種別コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD_ERR))
				{
					if (!inMap.containsKey("mskm_dtl_sbt_cd_err"))
					{
						inMap.put("mskm_dtl_sbt_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.連絡先携帯電話番号 → 申込内容承認登録明細.連絡先携帯電話番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO_ERR))
				{
					if (!inMap.containsKey("rrks_ktai_telno_err"))
					{
						inMap.put("rrks_ktai_telno_err", childTemplate.getString(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.連絡先勤務先名 → 申込内容承認登録明細.連絡先勤務先名 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.RRKS_OFFC_NM_ERR))
				{
					if (!inMap.containsKey("rrks_offc_nm_err"))
					{
						inMap.put("rrks_offc_nm_err", childTemplate.getString(EKK0011D020CBSMsg1List.RRKS_OFFC_NM_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.昼間連絡先電話番号 → 申込内容承認登録明細.昼間連絡先電話番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.DT_RRKS_TELNO_ERR))
				{
					if (!inMap.containsKey("dt_rrks_telno_err"))
					{
						inMap.put("dt_rrks_telno_err", childTemplate.getString(EKK0011D020CBSMsg1List.DT_RRKS_TELNO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.新規申込種別コード → 申込内容承認登録明細.新規申込種別コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD_ERR))
				{
					if (!inMap.containsKey("new_mskm_sbt_cd_err"))
					{
						inMap.put("new_mskm_sbt_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.申込契機コード → 申込内容承認登録明細.申込契機コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD_ERR))
				{
					if (!inMap.containsKey("mskm_optnty_cd_err"))
					{
						inMap.put("mskm_optnty_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.宅内調査希望アポ期限年月日 → 申込内容承認登録明細.宅内調査希望アポ期限年月日 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD_ERR))
				{
					if (!inMap.containsKey("takcho_kibo_apo_kigen_ymd_err"))
					{
						inMap.put("takcho_kibo_apo_kigen_ymd_err", childTemplate.getString(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.工事アポ連絡先指定コード → 申込内容承認登録明細.工事アポ連絡先指定コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD_ERR))
				{
					if (!inMap.containsKey("koji_apo_rrks_shitei_cd_err"))
					{
						inMap.put("koji_apo_rrks_shitei_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.工事アポ連絡先電話番号 → 申込内容承認登録明細.工事アポ連絡先電話番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO_ERR))
				{
					if (!inMap.containsKey("koji_apo_rrks_telno_err"))
					{
						inMap.put("koji_apo_rrks_telno_err", childTemplate.getString(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.連絡事項登録年月日時分秒 → 申込内容承認登録明細.連絡事項登録年月日時分秒 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM_ERR))
				{
					if (!inMap.containsKey("rrk_jiko_add_dtm_err"))
					{
						inMap.put("rrk_jiko_add_dtm_err", childTemplate.getString(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.申込連絡先メールアドレス → 申込内容承認登録明細.申込連絡先メールアドレス のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD_ERR))
				{
					if (!inMap.containsKey("mskm_rrks_mlad_err"))
					{
						inMap.put("mskm_rrks_mlad_err", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.工事進捗通知メールアドレス → 申込内容承認登録明細.工事進捗通知メールアドレス のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD_ERR))
				{
					if (!inMap.containsKey("koji_prg_tchi_mlad_err"))
					{
						inMap.put("koji_prg_tchi_mlad_err", childTemplate.getString(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.連絡事項 → 申込内容承認登録明細.連絡事項 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.RRK_JIKO_ERR))
				{
					if (!inMap.containsKey("rrk_jiko_err"))
					{
						inMap.put("rrk_jiko_err", childTemplate.getString(EKK0011D020CBSMsg1List.RRK_JIKO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.工事進捗通知携帯メールアドレス
				// 申込内容承認登録明細.工事進捗通知携帯メールアドレス のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD_ERR))
				{
					if (!inMap.containsKey("kjsc_tch_ktai_mlad_err"))
					{
						inMap.put("kjsc_tch_ktai_mlad_err", childTemplate.getString(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.メール送信除外フラグ → 申込内容承認登録明細.メール送信除外フラグ のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG_ERR))
				{
					if (!inMap.containsKey("ml_send_jgi_flg_err"))
					{
						inMap.put("ml_send_jgi_flg_err", childTemplate.getString(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.メール送信除外理由メモ → 申込内容承認登録明細.メール送信除外理由メモ のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO_ERR))
				{
					if (!inMap.containsKey("ml_send_jgi_rsn_memo_err"))
					{
						inMap.put("ml_send_jgi_rsn_memo_err", childTemplate.getString(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.番ポ申込連絡先電話番号 → 申込内容承認登録明細.番ポ申込連絡先電話番号 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN_ERR))
				{
					if (!inMap.containsKey("bmp_mskm_rrks_tln_err"))
					{
						inMap.put("bmp_mskm_rrks_tln_err", childTemplate.getString(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.連絡手段補記 → 申込内容承認登録明細.連絡手段補記 のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.RRK_WAY_HOKI_ERR))
				{
					if (!inMap.containsKey("rrk_way_hoki_err"))
					{
						inMap.put("rrk_way_hoki_err", childTemplate.getString(EKK0011D020CBSMsg1List.RRK_WAY_HOKI_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.新築物件コード → 申込内容承認登録明細.新築物件コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD_ERR))
				{
					if (!inMap.containsKey("newconst_bukken_cd_err"))
					{
						inMap.put("newconst_bukken_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.復活案件フラグ → 申込内容承認登録明細.復活案件フラグ のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG_ERR))
				{
					if (!inMap.containsKey("hukkat_anken_flg_err"))
					{
						inMap.put("hukkat_anken_flg_err", childTemplate.getString(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG_ERR));
					}
				}
				// 申込内容承認登録マップ.申込内容承認登録明細.同一設備再申込コード → 申込内容承認登録明細.同一設備再申込コード のエラー情報返却
				if (!childTemplate.isNull(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD_ERR))
				{
					if (!inMap.containsKey("same_equip_re_mskm_cd_err"))
					{
						inMap.put("same_equip_re_mskm_cd_err", childTemplate.getString(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD_ERR));
					}
				}
			}
		}
		if (!template.isNull(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("EKK0011D020CBSMsg1List_err"))
			{
				inMap.put("EKK0011D020CBSMsg1List_err", template.getString(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST_ERR));
			}
		}
		return param;
	}

	/**
	 * 申込明細照査・後続業務依頼のエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0021C060(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0021C060CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		HashMap inMap = (HashMap)param.getData("KKSV0192CC");
		// 申込明細照査・後続業務依頼マップ.連絡事項登録年月日時分秒 → 連絡事項登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.RRK_JIKO_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("rrk_jiko_add_dtm_err"))
			{
				inMap.put("rrk_jiko_add_dtm_err", template.getString(EKK0021C060CBSMsg.RRK_JIKO_ADD_DTM_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.後続業務依頼年月日 → 後続業務依頼年月日 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.KZKWRK_REQYMD_ERR))
		{
			if (!inMap.containsKey("kzkwrk_reqymd_err"))
			{
				inMap.put("kzkwrk_reqymd_err", template.getString(EKK0021C060CBSMsg.KZKWRK_REQYMD_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.連絡事項 → 連絡事項 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.RRK_JIKO_ERR))
		{
			if (!inMap.containsKey("rrk_jiko_err"))
			{
				inMap.put("rrk_jiko_err", template.getString(EKK0021C060CBSMsg.RRK_JIKO_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0021C060CBSMsg.IDO_DIV_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.電話番号 → 電話番号 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.TELNO_ERR))
		{
			if (!inMap.containsKey("telno_err"))
			{
				inMap.put("telno_err", template.getString(EKK0021C060CBSMsg.TELNO_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.代表電話番号 → 代表電話番号 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.DAIHYO_TELNO_ERR))
		{
			if (!inMap.containsKey("daihyo_telno_err"))
			{
				inMap.put("daihyo_telno_err", template.getString(EKK0021C060CBSMsg.DAIHYO_TELNO_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.電話番号使用場所番号 → 電話番号使用場所番号 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.TELNO_USE_PLACE_NO_ERR))
		{
			if (!inMap.containsKey("telno_use_place_no_err"))
			{
				inMap.put("telno_use_place_no_err", template.getString(EKK0021C060CBSMsg.TELNO_USE_PLACE_NO_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.SIPユーザーID消去済フラグ → SIPユーザーID消去済フラグ のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.SIP_USER_ID_DEL_ZUMI_FLG_ERR))
		{
			if (!inMap.containsKey("sip_user_id_del_zumi_flg_err"))
			{
				inMap.put("sip_user_id_del_zumi_flg_err", template.getString(EKK0021C060CBSMsg.SIP_USER_ID_DEL_ZUMI_FLG_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.電話BASホストID → 電話BASホストID のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.TEL_BAS_HOST_ID_ERR))
		{
			if (!inMap.containsKey("tel_bas_host_id_err"))
			{
				inMap.put("tel_bas_host_id_err", template.getString(EKK0021C060CBSMsg.TEL_BAS_HOST_ID_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.050オプション電話番号 → 050オプション電話番号 のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.N_050_OP_TELNO_ERR))
		{
			if (!inMap.containsKey("n_050_op_telno_err"))
			{
				inMap.put("n_050_op_telno_err", template.getString(EKK0021C060CBSMsg.N_050_OP_TELNO_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.機器認証ID → 機器認証ID のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.KIKI_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_err"))
			{
				inMap.put("kiki_ninsho_id_err", template.getString(EKK0021C060CBSMsg.KIKI_NINSHO_ID_ERR));
			}
		}
		// 申込明細照査・後続業務依頼マップ.機器認証IDパスワード → 機器認証IDパスワード のエラー情報返却
		if (!template.isNull(EKK0021C060CBSMsg.KIKI_NINSHO_ID_PWD_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_pwd_err"))
			{
				inMap.put("kiki_ninsho_id_pwd_err", template.getString(EKK0021C060CBSMsg.KIKI_NINSHO_ID_PWD_ERR));
			}
		}
		return param;
	}

	/**
	 * 単一CAANMsgのマッピング処理
	 * <br>
	 * @param paramMap
	 * @param template
	 * @return putParamMap
	 * @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;
	}

	/**
	 * 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;
	}

	/**
	 * 料金プラン一覧照会（オプションサービスコード）の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0591B001(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		templateArray = parentTemplate.getCAANMsgList(EKK0591B001CBSMsg.EKK0591B001CBSMSG1LIST);
		
		if (templateArray != null)
		{
			// 1レコード目
			CAANMsg childTemplate = templateArray[0];
			
			// 料金プラン一覧照会（オプションサービスコード）明細.料金コースコード
			if (childTemplate.isNull(EKK0591B001CBSMsg1List.PCRS_CD))
			{
				dataMap.put("ekk0591b001_pcrs_cd", new String());
			}
			else
			{
				dataMap.put("ekk0591b001_pcrs_cd", childTemplate.getString(EKK0591B001CBSMsg1List.PCRS_CD));
			}
			
			// 料金プラン一覧照会（オプションサービスコード）明細.料金プランコード
			if (childTemplate.isNull(EKK0591B001CBSMsg1List.PPLAN_CD))
			{
				dataMap.put("ekk0591b001_pplan_cd", new String());
			}
			else
			{
				dataMap.put("ekk0591b001_pplan_cd", childTemplate.getString(EKK0591B001CBSMsg1List.PPLAN_CD));
			}
		}

		// エラー情報の設定
		editErrorInfoEKK0591B001(param, templates, (Integer)returnCode);

		//エラー情報のマップを取得
		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;
	}
	
	/**
	 * オプションサービス契約＜TV＞登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0381D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];

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

		// オプションサービス契約＜TV＞登録マップ.オプションサービス契約番号 ← オプションサービス契約番号
		if (parentTemplate.isNull(EKK0381D010CBSMsg.OP_SVC_KEI_NO))
		{
			dataMap.put("ekk0381d010_op_svc_kei_no", new String());
		}
		else
		{
			dataMap.put("ekk0381d010_op_svc_kei_no", parentTemplate.getString(EKK0381D010CBSMsg.OP_SVC_KEI_NO));
		}
		// オプションサービス契約＜TV＞登録マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (parentTemplate.isNull(EKK0381D010CBSMsg.UPD_DTM))
		{
			dataMap.put("ekk0381d010_upd_dtm", new String());
		}
		else
		{
			dataMap.put("ekk0381d010_upd_dtm", parentTemplate.getString(EKK0381D010CBSMsg.UPD_DTM));
		}
		// オプションサービス契約＜TV＞登録マップ.更新年月日時分秒 ← 更新年月日時分秒（更新前）(2レコード目以降の設定に使用)
		if (parentTemplate.isNull(EKK0381D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm_bf", new String());
		}
		else
		{
			dataMap.put("upd_dtm_bf", parentTemplate.getString(EKK0381D010CBSMsg.UPD_DTM));
		}

		// エラー情報の設定
		editErrorInfoEKK0381D010(param, templates, (Integer)returnCode);

		//エラー情報のマップを取得
		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;
	}

	/**
	 * オプションサービス契約＜TV＞照査締結の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0381C030(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報の設定
		editErrorInfoEKK0381C030(param, templates, (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY));

		//エラー情報のマップを取得
		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;
	}

	/**
	 * オプションサービス契約＜TV＞開始の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0381C040(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報の設定
		editErrorInfoEKK0381C040(param, templates, (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY));

		//エラー情報のマップを取得
		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;
	}

	/**
	 * 進捗登録の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK1091D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報の設定
		editErrorInfoEKK1091D010(param, templates, (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY));

		//エラー情報のマップを取得
		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;
	}

	/**
	 * 申込内容承認登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0011D020(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		// 申込内容承認登録マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (parentTemplate.isNull(EKK0011D020CBSMsg.UPD_DTM))
		{
			dataMap.put("ekk0011d020_upd_dtm", new String());
		}
		else
		{
			dataMap.put("ekk0011d020_upd_dtm", parentTemplate.getString(EKK0011D020CBSMsg.UPD_DTM));
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				
				// 申込内容承認登録マップ.申込内容承認登録明細.申込明細番号 ← 申込内容承認登録明細.申込明細番号
				if (childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_DTL_NO))
				{
					dataMap.put("ekk0011d020_mskm_dtl_no", new String());
				}
				else
				{
					dataMap.put("ekk0011d020_mskm_dtl_no", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO));
				}
			}
		}
		// エラー情報の設定
		editErrorInfoEKK0011D020(param, templates, (Integer)returnCode);

		// エラー情報のマップを取得
		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;
	}

	/**
	 * 申込明細照査・後続業務依頼の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultEKK0021C060(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報の設定
		editErrorInfoEKK0021C060(param, templates, (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY));

		// エラー情報のマップを取得
		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;
	}

	/**
	 * オプションサービス契約＜TV＞登録マッピング処理を行います。
	 * <br>
	 * @param template
	 * @return メッセージキャリアクラス
	 * @throws RequestParameterException 
	 */
	private CAANMsg setParamEkk0381D010(CAANMsg template, IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		// OUTPUT料金コースコード → 料金コースコード
		if (dataMap.get("ekk0591b001_pcrs_cd") == null || "".equals(dataMap.get("ekk0591b001_pcrs_cd")))
		{
			template.setNull(EKK0381D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0381D010CBSMsg.PCRS_CD, (String)dataMap.get("ekk0591b001_pcrs_cd"));
		}
		// OUTPUT料金プランコード → 料金プランコード
		if (dataMap.get("ekk0591b001_pplan_cd") == null || "".equals(dataMap.get("ekk0591b001_pplan_cd")))
		{
			template.setNull(EKK0381D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0381D010CBSMsg.PPLAN_CD, (String)dataMap.get("ekk0591b001_pplan_cd"));
		}
		// OUTPUT申込明細番号 → 申込明細番号
		if (dataMap.get("ekk0011d020_mskm_dtl_no") == null || "".equals(dataMap.get("ekk0011d020_mskm_dtl_no")))
		{
			template.setNull(EKK0381D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0381D010CBSMsg.MSKM_DTL_NO, (String)dataMap.get("ekk0011d020_mskm_dtl_no"));
		}
		// OUTPUT更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)(1レコード目は親情報の、2レコード目以降は前のレコードの更新年月日)
		if (dataMap.get("upd_dtm_bf") == null || "".equals(dataMap.get("upd_dtm_bf")))
		{
			template.setNull(EKK0381D010CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0381D010CBSMsg.UPD_DTM_BF, (String)dataMap.get("upd_dtm_bf"));
		}
		
		return template;
	}
	
	/**
	 * オプションサービス契約＜TV＞照査締結マッピング処理を行います。
	 * <br>
	 * @param template
	 * @return メッセージキャリアクラス
	 * @throws RequestParameterException 
	 */
	private CAANMsg setParamEkk0381C030(CAANMsg template, IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		// OUTPUTオプションサービス契約番号 → オプションサービス契約番号
		if (dataMap.get("ekk0381d010_op_svc_kei_no") == null || "".equals(dataMap.get("ekk0381d010_op_svc_kei_no")))
		{
			template.setNull(EKK0381C030CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0381C030CBSMsg.OP_SVC_KEI_NO, (String)dataMap.get("ekk0381d010_op_svc_kei_no"));
		}
		// OUTPUT更新年月日時分秒 → 更新年月日時分秒（更新前）
		if (dataMap.get("ekk0381d010_upd_dtm") == null || "".equals(dataMap.get("ekk0381d010_upd_dtm")))
		{
			template.setNull(EKK0381C030CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0381C030CBSMsg.UPD_DTM_BF, (String)dataMap.get("ekk0381d010_upd_dtm"));
		}
		return template;
	}

	/**
	 * オプションサービス契約＜TV＞開始マッピング処理を行います。
	 * <br>
	 * @param template
	 * @return メッセージキャリアクラス
	 * @throws RequestParameterException 
	 */
	private CAANMsg setParamEkk0381C040(CAANMsg template, IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		// OUTPUTオプションサービス契約番号 → オプションサービス契約番号
		if (dataMap.get("ekk0381d010_op_svc_kei_no") == null || "".equals(dataMap.get("ekk0381d010_op_svc_kei_no")))
		{
			template.setNull(EKK0381C040CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0381C040CBSMsg.OP_SVC_KEI_NO, (String)dataMap.get("ekk0381d010_op_svc_kei_no"));
		}
		// OUTPUT更新年月日時分秒 → 更新年月日時分秒（更新前）
		if (dataMap.get("ekk0381d010_upd_dtm") == null || "".equals(dataMap.get("ekk0381d010_upd_dtm")))
		{
			template.setNull(EKK0381C040CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0381C040CBSMsg.UPD_DTM_BF, (String)dataMap.get("ekk0381d010_upd_dtm"));
		}
		return template;
	}
	
	/**
	 * 進捗登録マッピング処理を行います。
	 * <br>
	 * @param template
	 * @return メッセージキャリアクラス
	 * @throws RequestParameterException 
	 */
	private CAANMsg setParamEKK1091D010(CAANMsg template, IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		// OUTPUT申込明細番号 → 申込明細番号
		if (dataMap.get("ekk0011d020_mskm_dtl_no") == null || "".equals(dataMap.get("ekk0011d020_mskm_dtl_no")))
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.MSKM_DTL_NO, (String)dataMap.get("ekk0011d020_mskm_dtl_no"));
		}
		// OUTPUTオプションサービス契約番号 → オプションサービス契約番号
		if (dataMap.get("ekk0381d010_op_svc_kei_no") == null || "".equals(dataMap.get("ekk0381d010_op_svc_kei_no")))
		{
			template.setNull(EKK1091D010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.OP_SVC_KEI_NO, (String)dataMap.get("ekk0381d010_op_svc_kei_no"));
		}
		return template;
	}

	/**
	 * 申込明細照査・後続業務依頼マッピング処理を行います。
	 * <br>
	 * @param template
	 * @return メッセージキャリアクラス
	 * @throws RequestParameterException 
	 */
	private CAANMsg setParamEkk0021C060(CAANMsg template, IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap dataMap = (HashMap)param.getData("KKSV0192CC");
		
		// OUTPUT申込明細番号 → 申込明細番号
		if (dataMap.get("ekk0011d020_mskm_dtl_no") == null || "".equals(dataMap.get("ekk0011d020_mskm_dtl_no")))
		{
			template.setNull(EKK0021C060CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0021C060CBSMsg.MSKM_DTL_NO, (String)dataMap.get("ekk0011d020_mskm_dtl_no"));
		}
		// OUTPUT更新年月日時分秒 → 更新年月日時分秒（更新前）
		if (dataMap.get("ekk0011d020_upd_dtm") == null || "".equals(dataMap.get("ekk0011d020_upd_dtm")))
		{
			template.setNull(EKK0021C060CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0021C060CBSMsg.UPD_DTM_BF, (String)dataMap.get("ekk0011d020_upd_dtm"));
		}
		return template;
	}
	
	/* ++++++++++ v7.00.00 追加開始 ++++++++++ */

	/**
	 *  eo光テレビコースのオプションチャンネル解約対象抽出フラグの判定<br>
	 * <br>
	 * @param handle
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void chkPcrsCdOptSvc(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap, String fixedText) throws Throwable
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		param.setData("err_flg", "false");
		
		// 異動予約一覧照会のサービスを呼び出す。(コース変更)
		// EKK1681B001の実行
		CAANMsg[] ekk1681B001Out = execEKK1681B001(handle, scCall, param, fixedText, CD00576_00009);
		
		// 件数があれば、料金コース_オプションサービス一覧照会（料金コースコード２）のサービスを呼び出す。
		if (ekk1681B001Out != null && ekk1681B001Out.length > 0)
		{
			setPcrsCdOptSvcErrorInfo(handle, param, paramMap, fixedText, ekk1681B001Out[0].getString("new_pcrs_cd"));
		}
		// 異動予約一覧照会のサービスを呼び出す。(コース変更(STB))
		// 件数があれば、料金コース_オプションサービス一覧照会（料金コースコード２）のサービスを呼び出す。
		if (param.getData("err_flg").equals("false"))
		{
			// EKK1681B001の実行
			ekk1681B001Out = execEKK1681B001(handle, scCall, param, fixedText, CD00576_00068);
			
			if (ekk1681B001Out != null && ekk1681B001Out.length > 0)
			{
				setPcrsCdOptSvcErrorInfo(handle, param, paramMap, fixedText, ekk1681B001Out[0].getString("new_pcrs_cd"));
			}
		}
	}

	/**
	 *  料金コース_オプションサービス一覧照会（料金コースコード２）のサービスを呼び出す。<br>
	 *  予約中のオプションサービスコードが含まれていればメッセージ出力を行う為のフラグ(true)をセットする。
	 * <br>
	 * @param handle
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @param pcrs_cd
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void setPcrsCdOptSvcErrorInfo(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap, String fixedText, String pcrs_cd) throws Throwable
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// EKK0811B501の実行
		CAANMsg[] ekk0811b501Out = execEKK0811B501(handle, scCall, param, fixedText, pcrs_cd);
		
		ArrayList eoOpList = (ArrayList)inMap.get("eo_op_list");
		
		// eo光テレビオプションチャンネル情報の要素数分、処理を繰り返し行う。
		for (int i = 0; i < eoOpList.size(); i++)
		{
			// オプションチャンネル情報
			HashMap eoOpMap = (HashMap)eoOpList.get(i);
			
			// 料金コース_オプションサービス一覧照会（料金コースコード２）の要素数分、処理を繰り返し行う。
			for(int l = 0 ; l < ekk0811b501Out.length ; l++)
			{
				
				CAANMsg ekk0811b501Output = ekk0811b501Out[l];
				
				String resultOpSvcCd = ekk0811b501Output.getString(EKK0811B501CBSMsg1List.OP_SVC_CD);
				
				if (resultOpSvcCd.
						equals((String)eoOpMap.get(EKK0811B501CBSMsg1List.OP_SVC_CD)))
				{
					// メッセージ出力の際はtrueをセット
					param.setData("err_flg", "true");
					return;
				}
			}
		}
	}

	/**
	 * EKK1681B001_異動予約一覧照会を実行します。
	 * <br>
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param ido_div
	 * @return CAANMsg[] ekk1681B001OUT
	 * @throws Throwable
	 */
	private CAANMsg[] execEKK1681B001(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param, 
										String fixedText,
										String ido_div) throws Throwable
	{
		
		HashMap dataMap = (HashMap)param.getData(fixedText);

		CAANMsg ekk1681B001IN = new CAANMsg(EKK1681B001CBSMsg.class.getName());
		ekk1681B001IN.set(EKK1681B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1681B001);
		ekk1681B001IN.set(EKK1681B001CBSMsg.FUNC_CODE, "1");
		ekk1681B001IN.set(EKK1681B001CBSMsg.KEY_IDO_DIV, ido_div);
		ekk1681B001IN.set(EKK1681B001CBSMsg.KEY_IDO_RSV_DTL_CD, "003");
		ekk1681B001IN.set(EKK1681B001CBSMsg.KEY_IDO_RSV_STAT_CD, "00,03");
		
		// 機器製造番号(STB)がない場合は、「サービス契約内訳番号」は検索条件に含まない。
		if (dataMap.get("kiki_seizo_no") == null || "".equals((String)dataMap.get("kiki_seizo_no")))
		{
			// サービス契約番号
			ekk1681B001IN.set(EKK1681B001CBSMsg.KEY_SVC_KEI_NO, (String)dataMap.get("svc_kei_no"));
		}
		else{
			// サービス契約内訳番号
			ekk1681B001IN.set(EKK1681B001CBSMsg.KEY_SVC_KEI_UCWK_NO, (String)dataMap.get("svc_kei_ucwk_no"));
		}
		
		CAANMsg[] ekk1681B001OUT = callSC(handle, scCall, param, fixedText, ekk1681B001IN).getCAANMsgList(EKK1681B001CBSMsg.EKK1681B001CBSMSG1LIST);
		
		return ekk1681B001OUT;
	}

	/**
	 * EKK0811B501_料金コース_オプションサービス一覧照会２を実行します。
	 * <br>
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param pcrs_cd
	 * @return ekk0811b501OUT
	 * @throws Throwable
	 */
	private CAANMsg[] execEKK0811B501(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param, 
										String fixedText,
										String pcrs_cd) throws Throwable
	{
		CAANMsg ekk0811b501IN = new CAANMsg(EKK0811B501CBSMsg.class.getName());
		ekk0811b501IN.set(EKK0811B501CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0811B501);
		ekk0811b501IN.set(EKK0811B501CBSMsg.FUNC_CODE, "1");
		ekk0811b501IN.set(EKK0811B501CBSMsg.KEY_PCRS_CD, pcrs_cd);
		
		CAANMsg[] ekk0811b501OUT = callSC(handle, scCall, param, fixedText, ekk0811b501IN).getCAANMsgList(EKK0811B501CBSMsg.EKK0811B501CBSMSG1LIST);
		
		return ekk0811b501OUT;
	}

	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @return mappingData
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle, 
							ServiceComponentRequestInvoker scCall, 
							IRequestParameterReadWrite param, 
							String dataMapKey,
							CAANMsg inCAANMsg) throws Exception
	{
		HashMap<String, Object> paramMap = editInMsg(param, inCAANMsg);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];

		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		int status = templates[0].getInt(EKK1681B001CBSMsg.STATUS);

		editErrorInfoCom(param, templates, (Integer)return_code, dataMapKey);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		
		return msg;
	}

	/**
	 * 処理概要:
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param 業務データ取得・書込用I/F
	 * @param templates CAANMsgクラス配列
	 * @param returnCode リターンコード
	 * @param dataMapKey データキー
	 * @return IRequestParameterReadWrite 業務データ取得・書込用I/F
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCom(IRequestParameterReadWrite param,
														CAANMsg[] templates, 
														int returnCode,
														String dataMapKey) throws RequestParameterException
	{
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1681B001CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", 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)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, String> inMap = null;

		// ユーザデータ情報
		inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		Iterator<String> it = template.getHashMap().keySet().iterator();
		while (it.hasNext())
		{
			String key = it.next();
			if (key.endsWith("_err"))
			{
				if (!template.isNull(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}

	/**
	 * @param param
	 * @param mappingData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,
											   CAANMsg msg) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// 【取得元：ユーザエリア(コントロールマップ)】
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		// オペレータID
		msg.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		msg.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		msg.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		setNullToMsg(msg);
		
		CAANMsg[] templates = new CAANMsg[]{msg};
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		return paramMap;
	}
	
	@SuppressWarnings("unchecked")
	private void setNullToMsg(CAANMsg msg)
	{
		Iterator<String> caanMsgKeys = msg.getSchema().getSchemaKeySet().iterator();
		while (caanMsgKeys.hasNext())
		{
			String key = caanMsgKeys.next();
			if (key.endsWith("_err"))
			{
				String tmpKey = key.substring(0, key.length() - 4);
				
				if (!msg.containsKeyOfMsgData(tmpKey) || "".equals(msg.getObject(tmpKey)))
				{
					msg.setNull(tmpKey);
					continue;
				}
				Object obj = msg.getObject(tmpKey);
				if (obj instanceof CAANMsg[])
				{
					for (CAANMsg submsg : (CAANMsg[]) obj)
					{
						setNullToMsg(submsg);
					}
				}
			}
		}
	}

	/* ++++++++++ v7.00.00 追加終了 ++++++++++ */

}