/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKUpdMskmServiceCC
*   ソースファイル名：JKKUpdMskmServiceCC.java
*   作成者          ：富士通
*   日付            ：2011年06月13日
*＜機能概要＞
*   申込情報変更部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/06/13   FJ）土屋    新規作成
*   v4.00.00    2013/01/15   FJ) 三浦   【IT1-2013-0000015】取扱コード重複チェック不審対応
*   v5.00.00    2013/09/19   FJ) 川島   【OM-2013-0002328】申込書明細番号の重複チェック対応
*   v7.00.00    2014/02/05   FJ) 北浦   【ANK-1974-00-00】紹介コード重複チェック対応
*   v10.00.00   2014/07/23   FJ) 中山   【ANK-2137-00-00】提携住宅会社用WEB受付画面配置
*	v25.00.00	2016/05/23	 FJ) 澤田	【ANK-2679-00-00】eoスタッフ対応 
*   v52.00.00   2021/01/31   FJ) 星野   【ANK-3910-00-00】定額サービスリース品追加対応
*   v63.00.00	2022/11/25	 FJ) 小竹	【ANK-4294-00-00】紹介CPの仕組み変更対応
*	v73.00.00	2024/10/24	 FJ) 舘山	【ANK-4427-00-00】NTT卸対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKCommonUtil;
import eo.ejb.cbs.cbsmsg.EKK0011C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011C050CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011C100CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021B011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021B506CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021B506CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021C014CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0071D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0071E020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B532CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B532CBSMsg1List;

/**
 * 申込情報変更部品.
 * <br>
 * @author user
 */
public class JKKUpdMskmServiceCC extends AbstractCommonComponent
{
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME = "JKKUpdMskmServiceCCWork";
	/** エラー用 */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** 申込コード（申請） */
	private static final String MSKM_MODE_SHINSEI = "2";
	/** 申込コード（本申込） */
	private static final String MSKM_MODE_HON_MSKM = "3";
	/** 申込List */
	private static final String UPD_MSKM_LIST = "UPD_MSKM_LIST";
	/** 申込書明細番号List */
	private static final String MSKMSHODTLNO_LIST = "MskmShoDtlNo_List";
	
	/** 受付番号重複フラグ（受付番号 重複なし） */
	private static final String UKNO_OVERLAP_FLG_NASHI = "0";
	/** 受付番号重複フラグ（受付番号 重複あり） */
	private static final String UKNO_OVERLAP_FLG_ARI = "1";

	/** 自動採番 */
	private static final String MODE_AUTO = "1";
	/** 手入力採番 */
	private static final String MODE_MANUAL = "2";
	/** KKSV008004CC */
	private static final String KKSV008004CC = "KKSV008004CC";
	/** KKSV008204CC */
	private static final String KKSV008204CC = "KKSV008204CC";
	/** サービス体系コード ホームタイプ eo光ネット eo光電話 */
	private static final String SVC_TIKEI_CD_HOME_NET_TEL = "W";
	/** サービス体系コード マンションタイプ eo光ネット eo光電話 */
	private static final String SVC_TIKEI_CD_MANSION_NET_TEL = "K";
	/** サービス体系コード メゾンタイプ eo光ネット eo光電話 */
	private static final String SVC_TIKEI_CD_MEZON_NET_TEL = "Y";
	/** 受付番号変更フラグ（受付番号 変更なし） */
	private static final String MSKM_NO_HENKO_FLG_NASHI = "0";
	/** 受付番号変更フラグ（受付番号 変更あり） */
	private static final String MSKM_NO_HENKO_FLG_ARI = "1";
	/** 申込番号変更フラグ（申込番号 変更なし） */
	private static final String MSKM_DTL_NO_HENKO_FLG_NASHI = "0";
	/** 申込番号変更フラグ（申込番号 変更あり） */
	private static final String MSKM_DTL_NO_HENKO_FLG_ARI = "1";
	

	/**
	 * 申込情報変更処理チェック処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();
		HashMap<String, String>saibanMap = new HashMap<String, String>();
		
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 更新用のCCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return null;
		}
		
		String mskmMode = "";
		
		if (inMap.get("mskm_mode") != null)
		{
			mskmMode = inMap.get("mskm_mode").toString();
		}

		ArrayList inList = null;
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		if(KKSV008004CC.equals(fixedText))
		{
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					msgList.add(editInEKK0021C014(param, fixedText, i)); // 申込番号採番
				}
			}
		}
		else if(KKSV008204CC.equals(fixedText))
		{
			// 受付番号重複チェック実行判定
			HashMap inMskmMap = (HashMap)inList.get(0);
			String mskmshoNoHenkoFlg = MSKM_NO_HENKO_FLG_NASHI;
			mskmshoNoHenkoFlg = (String)inMskmMap.get("mskmsho_no_henko_flg");
			
			if(MSKM_NO_HENKO_FLG_ARI.equals(mskmshoNoHenkoFlg))
			{
				msgList.add(editInEKK0021B011(param, fixedText)); // 受付番号重複チェック
			}
			
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					msgList.add(editInEKK0021C014(param, fixedText, i)); // 申込番号採番
				}
				else
				{
					// 申込番号を採番マップにセット
					saibanMap.put((String)childMap.get("svc_kind_cd"), mskmshoDtlNo);
					
					// 申込番号重複チェック実行判定
					String mskmshoDtlNoHenkoFlg = MSKM_DTL_NO_HENKO_FLG_NASHI;
					mskmshoDtlNoHenkoFlg = (String)childMap.get("mskmsho_dtl_no_henko_flg");
					
					if(MSKM_DTL_NO_HENKO_FLG_ARI.equals(mskmshoDtlNoHenkoFlg))
					{
						msgList.add(editInEKK0021B506(param, fixedText, i, saibanMap)); // 申込番号重複チェック
					}
				}
			}
		}
		
		msgList.add(editInEKK0011C020(param, fixedText)); // 申込内容変更

		// 本申込の場合
		if (MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			msgList.add(editInEKK0011C050(param, fixedText)); //仮申込フラグ変更
		}

		// 申込が"申請"の場合
		if (MSKM_MODE_SHINSEI.equals(mskmMode) || MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			msgList.add(editInEKK0011C100(param, fixedText)); //申込内容承認申請
		}

		ArrayList<Object> tokkiDelList = (ArrayList<Object>)inMap.get("tokki_del_list");
		ArrayList<Object> tokkiChgList = (ArrayList<Object>)inMap.get("tokki_chg_list");

		if (tokkiDelList != null)
		{
			for (int i = 0; i < tokkiDelList.size(); i++)
			{
				HashMap tokkiDelDetailMap = (HashMap)tokkiDelList.get(i);

				if (tokkiDelDetailMap != null)
				{
					msgList.add(editInEKK0071E020(param, fixedText, tokkiDelDetailMap)); // 申込_代理店削除
				}
			}
		}

		if (tokkiChgList != null)
		{
			for (int i = 0; i < tokkiChgList.size(); i++)
			{
				HashMap tokkiChgDetailMap = (HashMap)tokkiChgList.get(i);

				if (tokkiChgDetailMap != null)
				{
					msgList.add(editInEKK0071D010(param, fixedText, tokkiChgDetailMap)); // 申込＿代理店登録
				}
			}
		}
		
		// 紹介コード重複チェック
		// 紹介コードが入力されている場合
		String  intrCD = (String)inMap.get("key_intr_cd");
		if (!"".equals(intrCD) && intrCD != null)
		{
			// サービス契約一覧照会（紹介コード）
			msgList.add(editInEKK0081B532(param, fixedText)); 
		}

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

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

		return paramMap;
	}

	/**
	 * 申込情報変更処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite updMskm(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;
		HashMap<String, String>saibanMap = new HashMap<String, String>();

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

		// 更新用のCCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}
		
		String mskmMode = "";

		if (inMap.get("mskm_mode") != null)
		{
			mskmMode = inMap.get("mskm_mode").toString();
		}

		ArrayList inList = null;
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		// サービスの判定 KKSV008004CCの場合
		if(KKSV008004CC.equals(fixedText))
		{
			// 申込新規登録
			boolean mskmshoDtlNoOverlapError = false;
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					// eo光ネット・eo光電話の同時申込チェック
					if(!checkNetTelMskmDtlNoDojiMskm(childMap, saibanMap))
					{
						// 申込番号採番
						template = editInEKK0021C014(param, fixedText, i); // 上りマッピング
						result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
						editRetEKK0021C014(result, param, fixedText, i, saibanMap); // 下りマッピング
						if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
						{ // ステータスが単項目エラー以上であれば例外をスロー
							throw new CCException(SC_ERROR_STRING, new Exception());
						}
						
						// 重複可能マップ内に存在する場合
						if(isDblePsb(inMap, childMap, saibanMap))
						{
							childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
							childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
						}
						else
						{
							// 申込番号重複チェック
							template = editInEKK0021B506(param, fixedText, i, saibanMap); // 上りマッピング
							result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
							editRetEKK0021B506(result, param, fixedText, i, MODE_AUTO); // 下りマッピング
							if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
							{ // ステータスが単項目エラー以上であれば例外をスロー
								throw new CCException(SC_ERROR_STRING, new Exception());
							}
							
							// 申込番号重複フラグ(自動採番)が0:重複なし以外の場合、例外をスロー
							if(!JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals((String)childMap.get("mskmsho_dtl_no_overlap_auot_flg")))
							{
								mskmshoDtlNoOverlapError = true;
							}
						}
					}
				}
				else
				{
					// 申込番号を採番マップにセット
					saibanMap.put((String)childMap.get("svc_kind_cd"), mskmshoDtlNo);
				}
			}
			
			// 申込番号重複チェックエラーの場合、例外をスロー
			if(mskmshoDtlNoOverlapError)
			{
				for (int i = 0; i < inList.size(); i++)
				{
					editRetErrorInfoEKK0021B506(result, param, fixedText, i);
				}
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		else if(KKSV008204CC.equals(fixedText))
		{ // 照査前登録
			
			// 受付番号重複チェック実行判定
			HashMap inMskmMap = (HashMap)inList.get(0);
			String mskmshoNoHenkoFlg = MSKM_NO_HENKO_FLG_NASHI;
			mskmshoNoHenkoFlg = (String)inMskmMap.get("mskmsho_no_henko_flg");
			
			if(MSKM_NO_HENKO_FLG_ARI.equals(mskmshoNoHenkoFlg))
			{
				// 受付番号重複チェック
				template = editInEKK0021B011(param, fixedText); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0021B011(result, param, fixedText); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
			
			boolean mskmshoDtlNoOverlapError = false;
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					// eo光ネット・eo光電話の同時申込チェック
					if(!checkNetTelMskmDtlNoDojiMskm(childMap, saibanMap))
					{
						// 申込番号採番
						template = editInEKK0021C014(param, fixedText, i); // 上りマッピング
						result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
						editRetEKK0021C014(result, param, fixedText, i, saibanMap); // 下りマッピング
						if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
						{ // ステータスが単項目エラー以上であれば例外をスロー
							throw new CCException(SC_ERROR_STRING, new Exception());
						}
						
						// 重複可能マップ内に存在する場合
						if(isDblePsb(inMap, childMap, saibanMap))
						{
							childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
							childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
						}
						else
						{
							// 申込番号重複チェック
							template = editInEKK0021B506(param, fixedText, i, saibanMap); // 上りマッピング
							result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
							editRetEKK0021B506(result, param, fixedText, i, MODE_AUTO); // 下りマッピング
							if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
							{ // ステータスが単項目エラー以上であれば例外をスロー
								throw new CCException(SC_ERROR_STRING, new Exception());
							}
							
							// 申込番号重複フラグ(自動採番)が0:重複なし以外の場合
							if(!JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals((String)childMap.get("mskmsho_dtl_no_overlap_auot_flg")))
							{
								mskmshoDtlNoOverlapError = true;
							}
						}
					}
				}
				else
				{
					String svcKindCd = (String)childMap.get("svc_kind_cd");
					// 申込番号を採番マップにセット
					saibanMap.put(svcKindCd, mskmshoDtlNo);
					
					String mskmshoDtlNoHenkoFlg = (String)childMap.get("mskmsho_dtl_no_henko_flg");
					
					if(MSKM_DTL_NO_HENKO_FLG_ARI.equals(mskmshoDtlNoHenkoFlg))
					{
						// 申込番号重複チェック
						template = editInEKK0021B506(param, fixedText, i, saibanMap); // 上りマッピング
						result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
						editRetEKK0021B506(result, param, fixedText, i, MODE_MANUAL); // 下りマッピング
						if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
						{ // ステータスが単項目エラー以上であれば例外をスロー
							throw new CCException(SC_ERROR_STRING, new Exception());
						}
						
						// 申込番号重複フラグ(手入力採番)が0:重複なし以外の場合
						if(!JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals((String)childMap.get("mskmsho_dtl_no_overlap_manu_flg")))
						{
							mskmshoDtlNoOverlapError = true;
						}
					}
					else
					{
						childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
						childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
					}
				}
			}
			
			// 申込番号重複チェックエラーの場合、例外をスロー
			if(mskmshoDtlNoOverlapError)
			{
				for (int i = 0; i < inList.size(); i++)
				{
					editRetErrorInfoEKK0021B506(result, param, fixedText, i);
				}
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 他の申込番号と同一かチェック
			checkMskmshoDtlNoOverlap(param, fixedText, saibanMap);
			
			// 申込番号重複チェックエラーの場合、例外をスロー
			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号重複フラグ(自動採番)または申込番号重複フラグ(手入力採番)が0:重複なし以外の場合、例外をスロー
				if(!JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals((String)childMap.get("mskmsho_dtl_no_overlap_auot_flg"))
						|| !JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals((String)childMap.get("mskmsho_dtl_no_overlap_manu_flg")))
				{
					editRetErrorInfoEKK0021B506(result, param, fixedText, i);
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}
		
		// 申込番号をワークエリアへ登録
		setWkMskmshoDtlNo(param, fixedText, saibanMap);
		// 申込番号をマップに設定
		setOutMapMskmshoDtlNo(param, fixedText, saibanMap);

		// 申込内容変更
		template = editInEKK0011C020(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0011C020(result, param, fixedText); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{
			// ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}

		// 本申込の場合
		if (MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			// 仮申込フラグ変更
			template = editInEKK0011C050(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0011C050(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				// ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 申込が"申請"の場合
		if (MSKM_MODE_SHINSEI.equals(mskmMode) || MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			// 申込内容承認申請
			template = editInEKK0011C100(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0011C100Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		ArrayList<Object> tokkiDelList = (ArrayList<Object>)inMap.get("tokki_del_list");
		ArrayList<Object> tokkiChgList = (ArrayList<Object>)inMap.get("tokki_chg_list");

		if (tokkiDelList != null)
		{
			for (int i = 0; i < tokkiDelList.size(); i++)
			{
				HashMap tokkiDelDetailMap = (HashMap)tokkiDelList.get(i);

				if (tokkiDelDetailMap != null)
				{
					// 申込_代理店削除
					template = editInEKK0071E020(param, fixedText, tokkiDelDetailMap);
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetEKK0071E020(result, param, fixedText); // 下りマッピング
					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
					{
						// ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
			}
		}

		if (tokkiChgList != null)
		{
			for (int i = 0; i < tokkiChgList.size(); i++)
			{
				HashMap tokkiChgDetailMap = (HashMap)tokkiChgList.get(i);

				if (tokkiChgDetailMap != null)
				{
					// 申込＿代理店登録
					template = editInEKK0071D010(param, fixedText, tokkiChgDetailMap);
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetEKK0071D010(result, param, fixedText); // 下りマッピング
					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
					{
						// ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
			}
		}
		// 紹介コード重複チェック
		// 紹介コードが入力されている場合
		String  intrCD = (String)inMap.get("key_intr_cd");
		if (!"".equals(intrCD) && intrCD != null)
		{
			// サービス契約一覧照会（紹介コード）
			template = editInEKK0081B532(param, fixedText);
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0081B532(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				// ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 紹介コード重複チェックエラーの場合、例外をスロー
			if(JKKStrConst.INTR_CD_DBLE_FLG_ERR.equals((String)inMap.get("intr_cd_overlap_error")))
			{
				editRetErrorInfoEKK0081B532(result, param, fixedText);
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		return param;
	}

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

		return paramMap;
	}

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

	/**
	 * 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 param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0011C020(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0011C020CBSMsg.class.getName());

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		template.set(EKK0011C020CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// 申込内容変更.申込番号 → 申込番号
		if (inMap == null || inMap.get("kk0011_mskm_no") == null || "".equals(inMap.get("kk0011_mskm_no")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_NO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_NO, (String)inMap.get("kk0011_mskm_no"));
		}

		// 申込内容変更.申込種別コード → 申込種別コード
		if (inMap == null || inMap.get("kk0011_mskm_sbt_cd") == null || "".equals(inMap.get("kk0011_mskm_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_SBT_CD, (String)inMap.get("kk0011_mskm_sbt_cd"));
		}

		// 申込内容変更.申込書到着年月日 → 申込書到着年月日
		if (inMap == null || inMap.get("kk0011_mskmsho_ariv_ymd") == null || "".equals(inMap.get("kk0011_mskmsho_ariv_ymd")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKMSHO_ARIV_YMD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKMSHO_ARIV_YMD, (String)inMap.get("kk0011_mskmsho_ariv_ymd"));
		}

		// 申込内容変更.申込受付年月日時分秒 → 申込受付年月日時分秒
		if (inMap == null || inMap.get("kk0011_mskm_uk_dtm") == null || "".equals(inMap.get("kk0011_mskm_uk_dtm")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_UK_DTM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_UK_DTM, (String)inMap.get("kk0011_mskm_uk_dtm"));
		}

		// 申込内容変更.申込受付担当ユーザーID → 申込受付担当ユーザーID
		if (inMap == null || inMap.get("kk0011_mskm_uk_tnt_user_id") == null || "".equals(inMap.get("kk0011_mskm_uk_tnt_user_id")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_UK_TNT_USER_ID);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_UK_TNT_USER_ID, (String)inMap.get("kk0011_mskm_uk_tnt_user_id"));
		}

		// 申込内容変更.申込年月日 → 申込年月日
		if (inMap == null || inMap.get("kk0011_mskm_ymd") == null || "".equals(inMap.get("kk0011_mskm_ymd")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_YMD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_YMD, (String)inMap.get("kk0011_mskm_ymd"));
		}

		// 申込内容変更.総合営業申込契機コード → 総合営業申込契機コード
		if (inMap == null || inMap.get("kk0011_ttl_business_mskm_opt_cd") == null || "".equals(inMap.get("kk0011_ttl_business_mskm_opt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD, (String)inMap.get("kk0011_ttl_business_mskm_opt_cd"));
		}

		// 申込内容変更.申込連絡先電話番号 → 申込連絡先電話番号
		if (inMap == null || inMap.get("kk0011_mskm_rrks_telno") == null || "".equals(inMap.get("kk0011_mskm_rrks_telno")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_RRKS_TELNO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_RRKS_TELNO, (String)inMap.get("kk0011_mskm_rrks_telno"));
		}

		// 申込内容変更.申込実施者種別コード → 申込実施者種別コード
		if (inMap == null || inMap.get("kk0011_mskm_jssis_sbt_cd") == null || "".equals(inMap.get("kk0011_mskm_jssis_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.MSKM_JSSIS_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.MSKM_JSSIS_SBT_CD, (String)inMap.get("kk0011_mskm_jssis_sbt_cd"));
		}

		// 申込内容変更.お客様ご要望事項 → お客様ご要望事項
		if (inMap == null || inMap.get("kk0011_cust_yobo_jiko") == null || "".equals(inMap.get("kk0011_cust_yobo_jiko")))
		{
			template.setNull(EKK0011C020CBSMsg.CUST_YOBO_JIKO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.CUST_YOBO_JIKO, (String)inMap.get("kk0011_cust_yobo_jiko"));
		}

		// 申込内容変更.電話連絡希望年月日 → 電話連絡希望年月日
		if (inMap == null || inMap.get("kk0011_tel_rrk_kibod_sbt_cd") == null || "".equals(inMap.get("kk0011_tel_rrk_kibod_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD, (String)inMap.get("kk0011_tel_rrk_kibod_sbt_cd"));
		}

		// 申込内容変更.電話連絡希望時間帯コード → 電話連絡希望時間帯コード
		if (inMap == null || inMap.get("kk0011_tel_rrk_kibo_time_cd") == null || "".equals(inMap.get("kk0011_tel_rrk_kibo_time_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TEL_RRK_KIBO_TIME_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TEL_RRK_KIBO_TIME_CD, (String)inMap.get("kk0011_tel_rrk_kibo_time_cd"));
		}

		// 申込内容変更.宅内調査希望時間帯コード → 宅内調査希望時間帯コード
		if (inMap == null || inMap.get("kk0011_takcho_kibo_time_cd") == null || "".equals(inMap.get("kk0011_takcho_kibo_time_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TAKCHO_KIBO_TIME_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TAKCHO_KIBO_TIME_CD, (String)inMap.get("kk0011_takcho_kibo_time_cd"));
		}

		// 申込内容変更.リファラー → リファラー
		if (inMap == null || inMap.get("kk0011_referer") == null || "".equals(inMap.get("kk0011_referer")))
		{
			template.setNull(EKK0011C020CBSMsg.REFERER);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.REFERER, (String)inMap.get("kk0011_referer"));
		}

		// 申込内容変更.関西電力お客様情報授受同意有無 → 関西電力お客様情報授受同意有無
		if (inMap == null || inMap.get("kk0011_kepco_custinfo_juju_doi_um") == null || "".equals(inMap.get("kk0011_kepco_custinfo_juju_doi_um")))
		{
			template.set(EKK0011C020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, JKKStrConst.CD_DIV_UM_NASHI);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, (String)inMap.get("kk0011_kepco_custinfo_juju_doi_um"));
		}

		// 申込内容変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		if (inMap == null || inMap.get("kk0011_upd_dtm_bf") == null || "".equals(inMap.get("kk0011_upd_dtm_bf")))
		{
			template.setNull(EKK0011C020CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.UPD_DTM_BF, (String)inMap.get("kk0011_upd_dtm_bf"));
		}

		// 申込内容変更.電話連絡希望日種別コード → 電話連絡希望日種別コード
		if (inMap == null || inMap.get("kk0011_tel_rrk_kibod_sbt_cd") == null || "".equals(inMap.get("kk0011_tel_rrk_kibod_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD, (String)inMap.get("kk0011_tel_rrk_kibod_sbt_cd"));
		}

		// 申込内容変更.宅内調査希望日種別コード → 宅内調査希望日種別コード
		if (inMap == null || inMap.get("kk0011_takcho_kibod_sbt_cd") == null || "".equals(inMap.get("kk0011_takcho_kibod_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TAKCHO_KIBOD_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TAKCHO_KIBOD_SBT_CD, (String)inMap.get("kk0011_takcho_kibod_sbt_cd"));
		}

		// 申込内容変更.利用サービス継続種別コード → 利用サービス継続種別コード
		if (inMap == null || inMap.get("kk0011_use_svc_keizk_sbt_cd") == null || "".equals(inMap.get("kk0011_use_svc_keizk_sbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.USE_SVC_KEIZK_SBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.USE_SVC_KEIZK_SBT_CD, (String)inMap.get("kk0011_use_svc_keizk_sbt_cd"));
		}

		// 申込内容変更.照査前連絡事項要否 → 照査前連絡事項要否
		if (inMap == null || inMap.get("kk0011_shosa_bf_rrk_jiko_yh") == null || "".equals(inMap.get("kk0011_shosa_bf_rrk_jiko_yh")))
		{
			template.setNull(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_YH);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_YH, (String)inMap.get("kk0011_shosa_bf_rrk_jiko_yh"));
		}

		// 申込内容変更.照査前連絡事項 → 照査前連絡事項
		if (inMap == null || inMap.get("kk0011_shosa_bf_rrk_jiko") == null || "".equals(inMap.get("kk0011_shosa_bf_rrk_jiko")))
		{
			template.setNull(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO, (String)inMap.get("kk0011_shosa_bf_rrk_jiko"));
		}

		// 申込内容変更.受付担当者識別コード → 受付担当者識別コード
		if (inMap == null || inMap.get("kk0011_uk_tntsha_skbt_cd") == null || "".equals(inMap.get("kk0011_uk_tntsha_skbt_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.UK_TNTSHA_SKBT_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.UK_TNTSHA_SKBT_CD, (String)inMap.get("kk0011_uk_tntsha_skbt_cd"));
		}

		// 申込内容変更.工事依頼情報連絡事項 → 工事依頼情報連絡事項
		if (inMap == null || inMap.get("kk0011_koji_req_info_rrk_jiko") == null || "".equals(inMap.get("kk0011_koji_req_info_rrk_jiko")))
		{
			template.setNull(EKK0011C020CBSMsg.KOJI_REQ_INFO_RRK_JIKO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.KOJI_REQ_INFO_RRK_JIKO, (String)inMap.get("kk0011_koji_req_info_rrk_jiko"));
		}

		// 申込内容変更.提携住宅会社コード → 提携住宅会社コード
		if (inMap == null || inMap.get("kk0011_tkjcp_cd") == null || "".equals(inMap.get("kk0011_tkjcp_cd")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCP_CD);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCP_CD, (String)inMap.get("kk0011_tkjcp_cd"));
		}

		// 申込内容変更.提携住宅会社名 → 提携住宅会社名
		if (inMap == null || inMap.get("kk0011_tkjcp_nm") == null || "".equals(inMap.get("kk0011_tkjcp_nm")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCP_NM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCP_NM, (String)inMap.get("kk0011_tkjcp_nm"));
		}

		// 申込内容変更.提携住宅会社支店・営業所名 → 提携住宅会社支店・営業所名
		if (inMap == null || inMap.get("kk0011_tkjcp_stnegs_nm") == null || "".equals(inMap.get("kk0011_tkjcp_stnegs_nm")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCP_STNEGS_NM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCP_STNEGS_NM, (String)inMap.get("kk0011_tkjcp_stnegs_nm"));
		}

		// 申込内容変更.提携住宅会社担当者名 → 提携住宅会社担当者名
		if (inMap == null || inMap.get("kk0011_tkjcptts_nm") == null || "".equals(inMap.get("kk0011_tkjcptts_nm")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCPTTS_NM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCPTTS_NM, (String)inMap.get("kk0011_tkjcptts_nm"));
		}

		// 申込内容変更.提携住宅会社担当者職種名 → 提携住宅会社担当者職種名
		if (inMap == null || inMap.get("kk0011_tkjcptts_shksnm") == null || "".equals(inMap.get("kk0011_tkjcptts_shksnm")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCPTTS_SHKSNM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCPTTS_SHKSNM, (String)inMap.get("kk0011_tkjcptts_shksnm"));
		}

		// 申込内容変更.提携住宅会社担当者電話番号 → 提携住宅会社担当者電話番号
		if (inMap == null || inMap.get("kk0011_tkjcptts_tln") == null || "".equals(inMap.get("kk0011_tkjcptts_tln")))
		{
			template.setNull(EKK0011C020CBSMsg.TKJCPTTS_TLN);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TKJCPTTS_TLN, (String)inMap.get("kk0011_tkjcptts_tln"));
		}

		// 申込内容変更.分譲地名 → 分譲地名
		if (inMap == null || inMap.get("kk0011_bunjochi_nm") == null || "".equals(inMap.get("kk0011_bunjochi_nm")))
		{
			template.setNull(EKK0011C020CBSMsg.BUNJOCHI_NM);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.BUNJOCHI_NM, (String)inMap.get("kk0011_bunjochi_nm"));
		}

		// 申込内容変更.分譲地区画番号メモ → 分譲地区画番号メモ
		if (inMap == null || inMap.get("kk0011_bunjochi_kkk_no_memo") == null || "".equals(inMap.get("kk0011_bunjochi_kkk_no_memo")))
		{
			template.setNull(EKK0011C020CBSMsg.BUNJOCHI_KKK_NO_MEMO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.BUNJOCHI_KKK_NO_MEMO, (String)inMap.get("kk0011_bunjochi_kkk_no_memo"));
		}

		// 申込内容変更.入居予定時期 → 入居予定時期
		if (inMap == null || inMap.get("kk0011_nyukyo_rsv_jk") == null || "".equals(inMap.get("kk0011_nyukyo_rsv_jk")))
		{
			template.setNull(EKK0011C020CBSMsg.NYUKYO_RSV_JK);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.NYUKYO_RSV_JK, (String)inMap.get("kk0011_nyukyo_rsv_jk"));
		}
		
		// ANK-2679-00-00 2016/05/23 ADD START
		// 申込内容変更.代理店申込受付eoスタッフユーザーID → 代理店申込受付eoスタッフユーザーID
		if (inMap == null || inMap.get("kk0011_agnt_mkm_uk_eostf_user_id") == null || "".equals(inMap.get("kk0011_agnt_mkm_uk_eostf_user_id")))
		{
			template.setNull(EKK0011C020CBSMsg.AGNT_MKM_UK_EOSTF_USER_ID);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.AGNT_MKM_UK_EOSTF_USER_ID, (String)inMap.get("kk0011_agnt_mkm_uk_eostf_user_id"));
		}
		// 代理店申込受付量販店員カナ名(姓) → 代理店申込受付量販店員カナ名(姓)
		if (inMap == null || inMap.get("kk0011_agnt_mkm_uk_rhstf_kana_sei") == null || "".equals(inMap.get("kk0011_agnt_mkm_uk_rhstf_kana_sei")))
		{
			template.setNull(EKK0011C020CBSMsg.AGNT_MKM_UK_RHSTF_KANA_SEI);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.AGNT_MKM_UK_RHSTF_KANA_SEI, (String)inMap.get("kk0011_agnt_mkm_uk_rhstf_kana_sei"));
		}
		// ANK-2679-00-00 2016/05/23 ADD END
		
// ANK-3910-00-00対応 20210131 星野 ADD START
		// 定額サービス申込機器 → 定額サービス申込機器
		if (inMap == null || inMap.get("tegak_svc_mskm_kiki") == null || "".equals(inMap.get("tegak_svc_mskm_kiki")))
		{
			template.setNull(EKK0011C020CBSMsg.TEGAK_SVC_MSKM_KIKI);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.TEGAK_SVC_MSKM_KIKI, (String)inMap.get("tegak_svc_mskm_kiki"));
		}
// ANK-3910-00-00対応 20210131 星野 ADD END
// ANK-4427-00-00 ADD START
		// 移転元サービス契約番号
		if (inMap == null || inMap.get("itenm_svc_kei_no") == null || "".equals(inMap.get("itenm_svc_kei_no")))
		{
			template.setNull(EKK0011C020CBSMsg.ITENM_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0011C020CBSMsg.ITENM_SVC_KEI_NO, (String)inMap.get("itenm_svc_kei_no"));
		}
// ANK-4427-00-00 ADD END
		
		return template;
	}

	/**
	 * 申込登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0011C020(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

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

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;

		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

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

		dataMap = (HashMap)dataMap.get("EKK0011C020CBSMsg");
		if (dataMap == null)
		{
			dataMap = new HashMap();
		}

		// 申込変更マップ.申込番号 ← 申込番号
		if (template.isNull(EKK0011C020CBSMsg.MSKM_NO))
		{
			dataMap.put("mskm_no", "");
		}
		else
		{
			dataMap.put("mskm_no", template.getString(EKK0011C020CBSMsg.MSKM_NO));
		}

		// 申込変更マップ.世代登録年月日時分秒（申込）　 ← 世代登録年月日時分秒(申込)
		if (template.isNull(EKK0011C020CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("kk0011_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("kk0011_gene_add_dtm", template.getString(EKK0011C020CBSMsg.GENE_ADD_DTM));
		}

		// 申込変更マップ.登録年月日時分秒 ← 登録年月日時分秒
		if (template.isNull(EKK0011C020CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(EKK0011C020CBSMsg.ADD_DTM));
		}

		// 申込変更マップ.登録オペレータアカウント ← 登録オペレータアカウント
		if (template.isNull(EKK0011C020CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(EKK0011C020CBSMsg.ADD_OPEACNT));
		}

		// 申込変更マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(EKK0011C020CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0011C020CBSMsg.UPD_DTM));

			String lastDtm = template.getString(EKK0011C020CBSMsg.UPD_DTM);
			JKKBpCommon.setLastDtmByMskm(param, lastDtm);
		}

		// 申込変更マップ.更新オペレータアカウント ← 更新オペレータアカウント
		if (template.isNull(EKK0011C020CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(EKK0011C020CBSMsg.UPD_OPEACNT));
		}

		// 申込変更マップ.無効フラグ ← 無効フラグ
		if (template.isNull(EKK0011C020CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(EKK0011C020CBSMsg.MK_FLG));
		}

		// エラー情報の設定
		editErrInfoEKK0011C020(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param template (I) CAANMsgクラス
	 * @param returnCode (I) リターンコード
	 * @param fixedText ユーザ定義文字
	 * @return 業務データ取得・書込用I/F
	 * @throws RequestParameterException
	 * @since 2011.06.03
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0011C020(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0011C020CBSMsg.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 = null;

		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);

		// 申込変更マップ.申込種別コード → 申込種別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKM_SBT_CD_ERR))
		{
			if (!inMap.containsKey("mskm_sbt_cd_err"))
			{
				inMap.put("mskm_sbt_cd_err", template.getString(EKK0011C020CBSMsg.MSKM_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.申込書到着年月日 → 申込書到着年月日 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKMSHO_ARIV_YMD_ERR))
		{
			if (!inMap.containsKey("mskmsho_ariv_ymd_err"))
			{
				inMap.put("mskmsho_ariv_ymd_err", template.getString(EKK0011C020CBSMsg.MSKMSHO_ARIV_YMD_ERR));
			}
		}
		// 申込変更マップ.申込受付年月日時分秒 → 申込受付年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKM_UK_DTM_ERR))
		{
			if (!inMap.containsKey("mskm_uk_dtm_err"))
			{
				inMap.put("mskm_uk_dtm_err", template.getString(EKK0011C020CBSMsg.MSKM_UK_DTM_ERR));
			}
		}
		// 申込変更マップ.申込受付担当ユーザーＩＤ → 申込受付担当ユーザーID のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.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(EKK0011C020CBSMsg.MSKM_UK_TNT_USER_ID_ERR));
			}
		}
		// 申込変更マップ.申込年月日 → 申込年月日 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKM_YMD_ERR))
		{
			if (!inMap.containsKey("mskm_ymd_err"))
			{
				inMap.put("mskm_ymd_err", template.getString(EKK0011C020CBSMsg.MSKM_YMD_ERR));
			}
		}
		// 申込変更マップ.総合営業申込契機コード → 総合営業申込契機コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.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(EKK0011C020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD_ERR));
			}
		}
		// 申込変更マップ.申込連絡先電話番号 → 申込連絡先電話番号 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKM_RRKS_TELNO_ERR))
		{
			if (!inMap.containsKey("mskm_rrks_telno_err"))
			{
				inMap.put("mskm_rrks_telno_err", template.getString(EKK0011C020CBSMsg.MSKM_RRKS_TELNO_ERR));
			}
		}
		// 申込変更マップ.申込実施者種別コード → 申込実施者種別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.MSKM_JSSIS_SBT_CD_ERR))
		{
			if (!inMap.containsKey("mskm_jssis_sbt_cd_err"))
			{
				inMap.put("mskm_jssis_sbt_cd_err", template.getString(EKK0011C020CBSMsg.MSKM_JSSIS_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.お客様ご要望事項 → お客様ご要望事項 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.CUST_YOBO_JIKO_ERR))
		{
			if (!inMap.containsKey("cust_yobo_jiko_err"))
			{
				inMap.put("cust_yobo_jiko_err", template.getString(EKK0011C020CBSMsg.CUST_YOBO_JIKO_ERR));
			}
		}
		// 申込変更マップ.電話連絡希望年月日 → 電話連絡希望年月日 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD_ERR))
		{
			if (!inMap.containsKey("tel_rrk_kibo_ymd_err"))
			{
				inMap.put("tel_rrk_kibo_ymd_err", template.getString(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.電話連絡希望時間帯コード → 電話連絡希望時間帯コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.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(EKK0011C020CBSMsg.TEL_RRK_KIBO_TIME_CD_ERR));
			}
		}
		// 申込変更マップ.宅内調査希望時間帯コード → 宅内調査希望時間帯コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TAKCHO_KIBO_TIME_CD_ERR))
		{
			if (!inMap.containsKey("takcho_kibo_time_cd_err"))
			{
				inMap.put("takcho_kibo_time_cd_err", template.getString(EKK0011C020CBSMsg.TAKCHO_KIBO_TIME_CD_ERR));
			}
		}
		// 申込変更マップ.リファラー → リファラー のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.REFERER_ERR))
		{
			if (!inMap.containsKey("referer_err"))
			{
				inMap.put("referer_err", template.getString(EKK0011C020CBSMsg.REFERER_ERR));
			}
		}
		// 申込変更マップ.関西電力お客様情報授受同意有無 → 関西電力お客様情報授受同意有無 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM_ERR))
		{
			if (!inMap.containsKey("kepco_custinfo_juju_doi_um_err"))
			{
				inMap.put("kepco_custinfo_juju_doi_um_err", template.getString(EKK0011C020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM_ERR));
			}
		}

		// 申込変更マップ.電話連絡希望日種別コード → 電話連絡希望日種別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD_ERR))
		{
			if (!inMap.containsKey("tel_rrk_kibod_sbt_cd_err"))
			{
				inMap.put("tel_rrk_kibod_sbt_cd_err", template.getString(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.宅内調査希望日種別コード → 宅内調査希望日種別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TAKCHO_KIBOD_SBT_CD_ERR))
		{
			if (!inMap.containsKey("takcho_kibod_sbt_cd_err"))
			{
				inMap.put("takcho_kibod_sbt_cd_err", template.getString(EKK0011C020CBSMsg.TAKCHO_KIBOD_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.利用サービス継続種別コード → 利用サービス継続種別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.USE_SVC_KEIZK_SBT_CD_ERR))
		{
			if (!inMap.containsKey("takcho_kibod_sbt_cd_err"))
			{
				inMap.put("takcho_kibod_sbt_cd_err", template.getString(EKK0011C020CBSMsg.USE_SVC_KEIZK_SBT_CD_ERR));
			}
		}
		// 申込変更マップ.照査前連絡事項要否 → 照査前連絡事項要否 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_YH_ERR))
		{
			if (!inMap.containsKey("shosa_bf_rrk_jiko_yh_err"))
			{
				inMap.put("shosa_bf_rrk_jiko_yh_err", template.getString(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_YH_ERR));
			}
		}
		// 申込変更マップ.照査前連絡事項 → 照査前連絡事項 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_ERR))
		{
			if (!inMap.containsKey("shosa_bf_rrk_jiko_err"))
			{
				inMap.put("shosa_bf_rrk_jiko_err", template.getString(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_ERR));
			}
		}

		// 申込変更マップ.受付担当者識別コード → 受付担当者識別コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.UK_TNTSHA_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("uk_tntsha_skbt_cd_err"))
			{
				inMap.put("uk_tntsha_skbt_cd_err", template.getString(EKK0011C020CBSMsg.UK_TNTSHA_SKBT_CD_ERR));
			}
		}

		// 申込変更マップ.工事依頼情報連絡事項 → 工事依頼情報連絡事項 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.KOJI_REQ_INFO_RRK_JIKO_ERR))
		{
			if (!inMap.containsKey("koji_req_info_rrk_jiko_err"))
			{
				inMap.put("koji_req_info_rrk_jiko_err", template.getString(EKK0011C020CBSMsg.KOJI_REQ_INFO_RRK_JIKO_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社コード → 提携住宅会社コード のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCP_CD_ERR))
		{
			if (!inMap.containsKey("tkjcp_cd_err"))
			{
				inMap.put("tkjcp_cd_err", template.getString(EKK0011C020CBSMsg.TKJCP_CD_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社名 → 提携住宅会社名 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCP_NM_ERR))
		{
			if (!inMap.containsKey("tkjcp_nm_err"))
			{
				inMap.put("tkjcp_nm_err", template.getString(EKK0011C020CBSMsg.TKJCP_NM_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社支店・営業所名 → 提携住宅会社支店・営業所名 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCP_STNEGS_NM_ERR))
		{
			if (!inMap.containsKey("tkjcp_stnegs_nm_err"))
			{
				inMap.put("tkjcp_stnegs_nm_err", template.getString(EKK0011C020CBSMsg.TKJCP_STNEGS_NM_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社担当者名 → 提携住宅会社担当者名 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCPTTS_NM_ERR))
		{
			if (!inMap.containsKey("tkjcptts_nm_err"))
			{
				inMap.put("tkjcptts_nm_err", template.getString(EKK0011C020CBSMsg.TKJCPTTS_NM_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社担当者職種名 → 提携住宅会社担当者職種名 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCPTTS_SHKSNM_ERR))
		{
			if (!inMap.containsKey("tkjcptts_shksnm_err"))
			{
				inMap.put("tkjcptts_shksnm_err", template.getString(EKK0011C020CBSMsg.TKJCPTTS_SHKSNM_ERR));
			}
		}

		// 申込変更マップ.提携住宅会社担当者電話番号 → 提携住宅会社担当者電話番号 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TKJCPTTS_TLN_ERR))
		{
			if (!inMap.containsKey("tkjcptts_tln_err"))
			{
				inMap.put("tkjcptts_tln_err", template.getString(EKK0011C020CBSMsg.TKJCPTTS_TLN_ERR));
			}
		}

		// 申込変更マップ.分譲地名 → 分譲地名 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.BUNJOCHI_NM_ERR))
		{
			if (!inMap.containsKey("bunjochi_nm_err"))
			{
				inMap.put("bunjochi_nm_err", template.getString(EKK0011C020CBSMsg.BUNJOCHI_NM_ERR));
			}
		}

		// 申込変更マップ.分譲地区画番号メモ → 分譲地区画番号メモ のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.BUNJOCHI_KKK_NO_MEMO_ERR))
		{
			if (!inMap.containsKey("bunjochi_kkk_no_memo_err"))
			{
				inMap.put("bunjochi_kkk_no_memo_err", template.getString(EKK0011C020CBSMsg.BUNJOCHI_KKK_NO_MEMO_ERR));
			}
		}

		// 申込変更マップ.入居予定時期 → 入居予定時期 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.NYUKYO_RSV_JK_ERR))
		{
			if (!inMap.containsKey("nyukyo_rsv_jk_err"))
			{
				inMap.put("nyukyo_rsv_jk_err", template.getString(EKK0011C020CBSMsg.NYUKYO_RSV_JK_ERR));
			}
		}
		
		// ANK-2679-00-00 2016/05/23 ADD START
		// 申込変更マップ.代理店申込受付eoスタッフユーザーID → 代理店申込受付eoスタッフユーザーID のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.AGNT_MKM_UK_EOSTF_USER_ID_ERR))
		{
			if (!inMap.containsKey("agnt_mkm_uk_eostf_user_id_err"))
			{
				inMap.put("agnt_mkm_uk_eostf_user_id_err", template.getString(EKK0011C020CBSMsg.AGNT_MKM_UK_EOSTF_USER_ID_ERR));
			}
		}
		
		// 申込変更マップ.代理店申込受付量販店員カナ名(姓) → 代理店申込受付量販店員カナ名(姓) のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.AGNT_MKM_UK_RHSTF_KANA_SEI_ERR))
		{
			if (!inMap.containsKey("agnt_mkm_uk_rhstf_kana_sei_err"))
			{
				inMap.put("agnt_mkm_uk_rhstf_kana_sei_err", template.getString(EKK0011C020CBSMsg.AGNT_MKM_UK_RHSTF_KANA_SEI_ERR));
			}
		}
		// ANK-2679-00-00 2016/05/23 ADD END
// ANK-3910-00-00対応 20210131 星野 ADD START
		// 申込変更マップ.定額サービス申込機器 → 定額サービス申込機器 のエラー情報返却
		if (!template.isNull(EKK0011C020CBSMsg.TEGAK_SVC_MSKM_KIKI_ERR))
		{
			if (!inMap.containsKey("tegak_svc_mskm_kiki_err"))
			{
				inMap.put("tegak_svc_mskm_kiki_err", template.getString(EKK0011C020CBSMsg.TEGAK_SVC_MSKM_KIKI_ERR));
			}
		}
// ANK-3910-00-00対応 20210131 星野 ADD END

		return param;
	}

	/**
	 * エラー情報のマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param templates CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		int index = 0;
		
		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		String mskmMode = "";
		
		if (inMap.get("mskm_mode") != null)
		{
			mskmMode = inMap.get("mskm_mode").toString();
		}

		ArrayList inList = null;
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		if(KKSV008004CC.equals(fixedText))
		{
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					// 申込番号採番
					editErrInfoEKK0021C014(param, templates[index++], (Integer)returnCode, fixedText, i);
				}
			}
		}
		else if(KKSV008204CC.equals(fixedText))
		{
			// 受付番号重複チェック実行判定
			HashMap inMskmMap = (HashMap)inList.get(0);
			String mskmshoNoHenkoFlg = MSKM_NO_HENKO_FLG_NASHI;
			mskmshoNoHenkoFlg = (String)inMskmMap.get("mskmsho_no_henko_flg");
			
			if(MSKM_NO_HENKO_FLG_ARI.equals(mskmshoNoHenkoFlg))
			{
				editErrInfoEKK0021B011(param, templates[index++], (Integer)returnCode, fixedText); // 受付番号重複チェック
			}
			
			String mskmshoDtlNo = "";

			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);
				
				// 申込番号の取得
				if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
				{
					mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
				}
				
				// 申込番号未入力
				if("".equals(mskmshoDtlNo))
				{
					editErrInfoEKK0021C014(param, templates[index++], (Integer)returnCode, fixedText, i);	// 申込番号採番
				}
				else
				{
					// 申込番号重複チェック実行判定
					String mskmshoDtlNoHenkoFlg = MSKM_DTL_NO_HENKO_FLG_NASHI;
					mskmshoDtlNoHenkoFlg = (String)childMap.get("mskmsho_dtl_no_henko_flg");
					
					if(MSKM_DTL_NO_HENKO_FLG_ARI.equals(mskmshoDtlNoHenkoFlg))
					{
						editErrInfoEKK0021B506(param, templates[index++], (Integer)returnCode, fixedText, i); // 申込番号重複チェック
					}
				}
			}
		}
		
		// 申込情報変更
		editErrInfoEKK0011C020(param, templates[index++], (Integer)returnCode, fixedText); 

		// 本申込の場合
		if (MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			// 仮申込フラグ変更
			editErrInfoEKK0011C050(param, templates[index++], (Integer)returnCode, fixedText); 
		}

		// 申込が"申請"の場合
		if (MSKM_MODE_SHINSEI.equals(mskmMode) || MSKM_MODE_HON_MSKM.equals(mskmMode))
		{
			// 申込内容承認申請
			editErrInfoEKK0011C100Msg(param, templates[index++], (Integer)returnCode, fixedText); 
		}

		return param;
	}

	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param itemplateStatus SCの実行ステータス
	 * @param returnCode リターンコード
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite setControlMapErrInfo(IRequestParameterReadWrite param, int itemplateStatus, int returnCode)
			throws RequestParameterException
	{
		int templateStatus = itemplateStatus;

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

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

		if (templateStatus > bpStatus)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		return param;
	}

	/**
	 * 仮申込フラグ変更の上りマッピング処理
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0011C050(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0011C050CBSMsg.class.getName());

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

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

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

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

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

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

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

		// 申込番号
		if (inMap == null || inMap.get("kk0011_mskm_no") == null || "".equals(inMap.get("kk0011_mskm_no")))
		{
			template.setNull(EKK0011C050CBSMsg.MSKM_NO);
		}
		else
		{
			template.set(EKK0011C050CBSMsg.MSKM_NO, (String)inMap.get("kk0011_mskm_no"));
		}

		// 仮申込フラグ
		if (inMap == null || inMap.get("kk0011_kari_mskm_flg") == null || "".equals(inMap.get("kk0011_kari_mskm_flg")))
		{
			template.setNull(EKK0011C050CBSMsg.KARI_MSKM_FLG);
		}
		else
		{
			template.set(EKK0011C050CBSMsg.KARI_MSKM_FLG, (String)inMap.get("kk0011_kari_mskm_flg"));
		}

		// 更新年月日時分秒(更新前)
		if (JKKBpCommon.getLastDtmByMskm(param, "") == null
				|| JKKBpCommon.getLastDtmByMskm(param, "") == null
				|| "".equals(JKKBpCommon.getLastDtmByMskm(param, "")))
		{
			template.setNull(EKK0011C050CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0011C050CBSMsg.UPD_DTM_BF, JKKBpCommon.getLastDtmByMskm(param, ""));
		}

		return template;
	}

	/**
	 * 仮申込フラグ変更の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0011C050(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

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

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

		// 世代登録年月日時分秒
		if (template.isNull(EKK0011C050CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("gene_add_dtm", "");
		}
		else
		{
			dataMap.put("gene_add_dtm", template.getString(EKK0011C050CBSMsg.GENE_ADD_DTM));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK0011C050CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(EKK0011C050CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK0011C050CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(EKK0011C050CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK0011C050CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0011C050CBSMsg.UPD_DTM));
			JKKBpCommon.setLastDtmByMskm(param, template.getString(EKK0011C050CBSMsg.UPD_DTM));
		}

		// 更新オペレータアカウント
		if (template.isNull(EKK0011C050CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(EKK0011C050CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK0011C050CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(EKK0011C050CBSMsg.MK_FLG));
		}

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		editErrInfoEKK0011C050(param, template, (Integer)returnCode, fixedText);

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

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

		return param;
	}

	/**
	 * 仮申込フラグ変更のエラー情報マッピング処理
	 * <br>
	 * @param iparam リクエストパラ江メータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0011C050(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0011C050CBSMsg.STATUS), returnCode);

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

		// 申込番号 のエラー情報返却
		if (!template.isNull(EKK0011C050CBSMsg.MSKM_NO_ERR))
		{
			if (!inMap.containsKey("mskm_no_err"))
			{
				inMap.put("mskm_no_err", template.getString(EKK0011C050CBSMsg.MSKM_NO_ERR));
			}
		}

		// 仮申込フラグ のエラー情報返却
		if (!template.isNull(EKK0011C050CBSMsg.KARI_MSKM_FLG_ERR))
		{
			if (!inMap.containsKey("kari_mskm_flg_err"))
			{
				inMap.put("kari_mskm_flg_err", template.getString(EKK0011C050CBSMsg.KARI_MSKM_FLG_ERR));
			}
		}

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK0011C050CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0011C050CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 申込内容承認申請の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0011C100(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0011C100CBSMsg.class.getName());

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		template.set(EKK0011C100CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

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

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

		// 申込変更マップ.申込番号 → 申込番号
		if (inMap == null || inMap.get("kk001103_mskm_no") == null || "".equals(inMap.get("kk001103_mskm_no")))
		{
			template.setNull(EKK0011C100CBSMsg.MSKM_NO);
		}
		else
		{
			template.set(EKK0011C100CBSMsg.MSKM_NO, (String)inMap.get("kk001103_mskm_no"));
		}

		// 申込変更マップ.コンシューマ営業用申込状態識別コード → コンシューマ営業用申込状態識別コード
		if (inMap == null || inMap.get("kk001103_consmbsn_mskm_stat_skbt_cd") == null || "".equals(inMap.get("kk001103_consmbsn_mskm_stat_skbt_cd")))
		{
			template.setNull(EKK0011C100CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD);
		}
		else
		{
			template.set(EKK0011C100CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD, (String)inMap.get("kk001103_consmbsn_mskm_stat_skbt_cd"));
		}

		// 更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		if (JKKBpCommon.getLastDtmByMskm(param, "") == null
				|| JKKBpCommon.getLastDtmByMskm(param, "") == null
				|| "".equals(JKKBpCommon.getLastDtmByMskm(param, "")))
		{
			if (inMap == null || inMap.get("kk001103_upd_dtm_bf") == null || "".equals(inMap.get("kk001103_upd_dtm_bf")))
			{
				template.setNull(EKK0011C100CBSMsg.UPD_DTM_BF);
			}
			else
			{
				template.set(EKK0011C100CBSMsg.UPD_DTM_BF, (String)workDataMap.get("kk001103_upd_dtm_bf"));
			}
		}
		else
		{
			template.set(EKK0011C100CBSMsg.UPD_DTM_BF, JKKBpCommon.getLastDtmByMskm(param, ""));
		}

		return template;
	}

	/**
	 * 申込内容承認申請の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK0011C100Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// 世代登録年月日時分秒
		if (template.isNull(EKK0011C100CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("kk001103_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("kk001103_gene_add_dtm", template.getString(EKK0011C100CBSMsg.GENE_ADD_DTM));
		}

		// 申込内容承認申請年月日
		if (template.isNull(EKK0011C100CBSMsg.MSKM_NYO_SHONIN_SHIN_YMD))
		{
			dataMap.put("kk001103_mskm_nyo_shonin_shin_ymd", "");
		}
		else
		{
			dataMap.put("kk001103_mskm_nyo_shonin_shin_ymd", template.getString(EKK0011C100CBSMsg.MSKM_NYO_SHONIN_SHIN_YMD));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK0011C100CBSMsg.ADD_DTM))
		{
			dataMap.put("kk001103_add_dtm", "");
		}
		else
		{
			dataMap.put("kk001103_add_dtm", template.getString(EKK0011C100CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK0011C100CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("kk001103_add_opeacnt", "");
		}
		else
		{
			dataMap.put("kk001103_add_opeacnt", template.getString(EKK0011C100CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK0011C100CBSMsg.UPD_DTM))
		{
			dataMap.put("kk001103_upd_dtm", "");
		}
		else
		{
			dataMap.put("kk001103_upd_dtm", template.getString(EKK0011C100CBSMsg.UPD_DTM));
			JKKBpCommon.setLastDtmByMskm(param, (String)template.getString(EKK0011C100CBSMsg.UPD_DTM));
		}

		// 更新オペレータアカウント
		if (template.isNull(EKK0011C100CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("kk001103_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("kk001103_upd_opeacnt", template.getString(EKK0011C100CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK0011C100CBSMsg.MK_FLG))
		{
			dataMap.put("kk001103_mk_flg", "");
		}
		else
		{
			dataMap.put("kk001103_mk_flg", template.getString(EKK0011C100CBSMsg.MK_FLG));
		}

		// エラー情報の設定
		editErrInfoEKK0011C100Msg(param, template, (Integer)returnCode, fixedText);

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

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

		return param;
	}

	/**
	 * 申込内容承認申請のエラー情報マッピング処理
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0011C100Msg(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0011C100CBSMsg.STATUS), returnCode);

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

		// 申込番号 のエラー情報返却
		if (!template.isNull(EKK0011C100CBSMsg.MSKM_NO_ERR))
		{
			if (!inMap.containsKey("kk001103_mskm_no_err"))
			{
				inMap.put("kk001103_mskm_no_err", template.getString(EKK0011C100CBSMsg.MSKM_NO_ERR));
			}
		}

		// コンシューマ営業用申込状態識別コード のエラー情報返却
		if (!template.isNull(EKK0011C100CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("kk001103_consmbsn_mskm_stat_skbt_cd_err"))
			{
				inMap.put("kk001103_consmbsn_mskm_stat_skbt_cd_err",
						template.getString(EKK0011C100CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD_ERR));
			}
		}

		// 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0011C100CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("kk001103_upd_dtm_bf_err"))
			{
				inMap.put("kk001103_upd_dtm_bf_err",
						template.getString(EKK0011C100CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 申込_代理店削除の上りマッピング処理
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param tokkiDelDetailMap 特記削除マップ
	 * @return CAANMsg
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0071E020(
			IRequestParameterReadWrite param,
			String fixedText,
			HashMap tokkiDelDetailMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0071E020CBSMsg.class.getName());

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

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

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

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

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

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

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

		// 申込番号
		if (inMap == null || inMap.get("kk0011_mskm_no") == null || "".equals(inMap.get("kk0011_mskm_no")))
		{
			template.setNull(EKK0071E020CBSMsg.MSKM_NO);
		}
		else
		{
			template.set(EKK0071E020CBSMsg.MSKM_NO, (String)inMap.get("kk0011_mskm_no"));
		}

		// 代理店コード
		if (tokkiDelDetailMap == null || tokkiDelDetailMap.get("agnt_cd") == null || "".equals(tokkiDelDetailMap.get("agnt_cd")))
		{
			template.setNull(EKK0071E020CBSMsg.AGNT_CD);
		}
		else
		{
			template.set(EKK0071E020CBSMsg.AGNT_CD, tokkiDelDetailMap.get("agnt_cd"));
		}
		
		// 申込_代理店番号
		if (tokkiDelDetailMap == null || tokkiDelDetailMap.get("mskm_agnt_no") == null || "".equals(tokkiDelDetailMap.get("mskm_agnt_no")))
		{
			template.setNull(EKK0071E020CBSMsg.MSKM_AGNT_NO);
		}
		else
		{
			template.set(EKK0071E020CBSMsg.MSKM_AGNT_NO, tokkiDelDetailMap.get("mskm_agnt_no"));
		}

		// 更新年月日時分秒(更新前)
		if (tokkiDelDetailMap == null || tokkiDelDetailMap.get("upd_dtm_bf") == null || "".equals(tokkiDelDetailMap.get("upd_dtm_bf")))
		{
			template.setNull(EKK0071E020CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0071E020CBSMsg.UPD_DTM_BF, tokkiDelDetailMap.get("upd_dtm_bf"));
		}

		return template;
	}

	/**
	 * 申込_代理店削除の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0071E020(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

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

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

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		editErrInfoEKK0071E020(param, template, (Integer)returnCode, fixedText);

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

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

		return param;
	}

	/**
	 * 申込_代理店削除のエラー情報マッピング処理
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0071E020(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0071E020CBSMsg.STATUS), returnCode);

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

		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		// 申込番号 のエラー情報返却
		if (!template.isNull(EKK0071E020CBSMsg.MSKM_NO_ERR))
		{
			if (!inMap.containsKey("mskm_no_err"))
			{
				inMap.put("mskm_no_err", template.getString(EKK0071E020CBSMsg.MSKM_NO_ERR));
			}
		}

		// 代理店コード のエラー情報返却
		if (!template.isNull(EKK0071E020CBSMsg.AGNT_CD_ERR))
		{
			if (!inMap.containsKey("agnt_cd_err"))
			{
				inMap.put("agnt_cd_err", template.getString(EKK0071E020CBSMsg.AGNT_CD_ERR));
			}
		}
		
		//申込_代理店番号
		setErrInfo(inMap, EKK0071E020CBSMsg.MSKM_AGNT_NO_ERR, template, EKK0071E020CBSMsg.MSKM_AGNT_NO_ERR);

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK0071E020CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0071E020CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 申込_代理店登録の上りマッピング処理
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param tokkiChgDetailMap 特記変更マップ
	 * @return CAANMsg
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0071D010(IRequestParameterReadWrite param,
			String fixedText,
			HashMap tokkiChgDetailMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0071D010CBSMsg.class.getName());

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

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

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

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

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

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

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

		// 申込番号
		if (inMap == null || inMap.get("kk0011_mskm_no") == null || "".equals(inMap.get("kk0011_mskm_no")))
		{
			template.setNull(EKK0071D010CBSMsg.MSKM_NO);
		}
		else
		{
			template.set(EKK0071D010CBSMsg.MSKM_NO, (String)inMap.get("kk0011_mskm_no"));
		}

		// 代理店コード
		if (tokkiChgDetailMap == null || tokkiChgDetailMap.get("agnt_cd") == null || "".equals(tokkiChgDetailMap.get("agnt_cd")))
		{
			template.setNull(EKK0071D010CBSMsg.AGNT_CD);
		}
		else
		{
			template.set(EKK0071D010CBSMsg.AGNT_CD, tokkiChgDetailMap.get("agnt_cd"));
		}
		
		//申込_代理店番号
		if (tokkiChgDetailMap == null || tokkiChgDetailMap.get("mskm_agnt_no") == null || "".equals(tokkiChgDetailMap.get("mskm_agnt_no")))
		{
			template.setNull(EKK0071D010CBSMsg.MSKM_AGNT_NO);
		}
		else
		{
			template.set(EKK0071D010CBSMsg.MSKM_AGNT_NO, tokkiChgDetailMap.get("mskm_agnt_no"));
		}
		
		// 表示順序
		if (tokkiChgDetailMap == null || tokkiChgDetailMap.get("dsp_jun") == null || "".equals(tokkiChgDetailMap.get("dsp_jun")))
		{
			template.setNull(EKK0071D010CBSMsg.DSP_JUN);
		}
		else
		{
			template.set(EKK0071D010CBSMsg.DSP_JUN, tokkiChgDetailMap.get("dsp_jun"));
		}

		return template;
	}
	
	/**
	 * サービス契約一覧照会（紹介コード）の上りマッピング処理
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return CAANMsg サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081B532(
			IRequestParameterReadWrite param,
			String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B532CBSMsg.class.getName());

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

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

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

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

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

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

		// 機能コード
		if (inMap != null)
		{
			template.set(EKK0081B532CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		}
		
		// サービス契約一覧照会（紹介コード）マップ.ＫＥＹ＿紹介コード → ＫＥＹ＿紹介コード
		if (inMap == null || inMap.get("key_intr_cd") == null || "".equals(inMap.get("key_intr_cd")))
		{
			template.setNull(EKK0081B532CBSMsg.KEY_INTR_CD);
		}
		else
		{
			template.set(EKK0081B532CBSMsg.KEY_INTR_CD, (String)inMap.get("key_intr_cd"));
		}
		
		return template;
	}

	/**
	 * 申込_代理店登録の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0071D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

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

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

		// 登録年月日時分秒
		if (template.isNull(EKK0071D010CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(EKK0071D010CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK0071D010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(EKK0071D010CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK0071D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0071D010CBSMsg.UPD_DTM));
		}

		// 更新オペレータアカウント
		if (template.isNull(EKK0071D010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(EKK0071D010CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK0071D010CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(EKK0071D010CBSMsg.MK_FLG));
		}

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		editErrInfoEKK0071D010(param, template, (Integer)returnCode, fixedText);

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

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

		return param;
	}
	
	/**
	 * サービス契約一覧照会（紹介コード）の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @exception Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081B532(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		HashMap inMap = (HashMap)param.getData(fixedText);
		String sysid = null;
		String mskm_no = null;
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		String prefix = "kk0081_";
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0081B532CBSMsg.EKK0081B532CBSMSG1LIST);
		ArrayList<HashMap<String, Object>> dataList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> childMap = null;
		
		// サービス契約一覧照会（紹介コード）マップ.SYSID → SYSID
		if (inMap == null || inMap.get("sysid") == null || "".equals(inMap.get("sysid")))
		{
			sysid = "";
		}
		else
		{
			sysid = (String)inMap.get("sysid");
		}
		
		// サービス契約一覧照会（紹介コード）マップ.申込番号 → 申込番号
		if (inMap == null || inMap.get("kk0011_mskm_no") == null || "".equals(inMap.get("kk0011_mskm_no")))
		{
			mskm_no = "";
		}
		else
		{
			mskm_no =  (String)inMap.get("kk0011_mskm_no");
		}
		
		if(!JKKCommonUtil.isNull(templateArray))
		{
			for(CAANMsg childTemplate : templateArray)
			{
				childMap = new HashMap<String, Object>();
				
				// SYSIDが同じ場合は、スキップ
				if(sysid.equals(childTemplate.getString(EKK0081B532CBSMsg1List.SYSID)))
				{
					continue;
				}
				
				// 申込番号が同じ場合は、スキップ
				if(mskm_no.equals(childTemplate.getString(EKK0081B532CBSMsg1List.MSKM_NO)))
				{
					continue;
				}

				// サービス契約番号
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.SVC_KEI_NO, childTemplate);
				// サービス契約ステータス
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.SVC_KEI_STAT, childTemplate);
				// 申込番号
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.MSKM_NO, childTemplate);
				// SYSID
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.SYSID, childTemplate);
				// 仮申込フラグ
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.KARI_MSKM_FLG, childTemplate);
				// 紹介コード
				setDataMap(childMap, prefix, EKK0081B532CBSMsg1List.INTR_CD, childTemplate);
				
				dataList.add(childMap);
				
				String svcKeiStat =  childTemplate.getString(EKK0081B532CBSMsg1List.SVC_KEI_STAT);
				String kariMskmFlg =  childTemplate.getString(EKK0081B532CBSMsg1List.KARI_MSKM_FLG);
				// ANK-4294-00-00 ADD START
				String isintrcd_chk_tg = (String)inMap.get("isintrcd_chk_tg");
				if (isintrcd_chk_tg.equals("1"))
				{
					// エラー条件
					// サービス契約ステータスが受付済み 或いは
					// サービス契約ステータスが照査済以上かつ、解約済未満の場合
					// サービス契約ステータスが解約済 或いは
					// サービス契約ステータスがキャンセル済
					if (JKKStrConst.CD00037_UK_ZM.equals(svcKeiStat)
							|| (JKKStrConst.CD00037_SHOSA_ZUMI.compareTo(svcKeiStat) <= 0 && 0 < JKKStrConst.CD00037_DSL_ZM.compareTo(svcKeiStat))
							|| JKKStrConst.CD00037_DSL_ZM.equals(svcKeiStat) 
							|| JKKStrConst.CD00037_CANCEL_ZM.equals(svcKeiStat))
					{
						dataMap.put("intr_cd_overlap_error", JKKStrConst.INTR_CD_DBLE_FLG_ERR);
					}
					
				}
				else
				{
				// ANK-4294-00-00 ADD END
					// サービス契約ステータスが受付済みかつ、仮申込フラグが１以外　或いは
					// サービス契約ステータスが照査済以上かつ、解約済未満の場合
					if (JKKStrConst.CD00037_UK_ZM.equals(svcKeiStat) && !JKKStrConst.KARI_MSKM_FLG_KARI_MSKM.equals(kariMskmFlg)
						|| (JKKStrConst.CD00037_SHOSA_ZUMI.compareTo(svcKeiStat) <= 0 && 0 < JKKStrConst.CD00037_DSL_ZM.compareTo(svcKeiStat)))
					{
						dataMap.put("intr_cd_overlap_error", JKKStrConst.INTR_CD_DBLE_FLG_ERR);
					}
				// ANK-4294-00-00 ADD START
				}
				// ANK-4294-00-00 ADD END
			}
		}
		
		dataMap.put(EKK0081B532CBSMsg.EKK0081B532CBSMSG1LIST, dataList);
		
		param.setData(fixedText, dataMap);
		
		// エラー情報の設定
		editErrInfoEKK0081B532(param, template, (Integer)returnCode, fixedText);

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

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

		return param;
	}

	/**
	 * 申込_代理店削除のエラー情報マッピング処理
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0071D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0071D010CBSMsg.STATUS), returnCode);

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

		// 申込番号 のエラー情報返却
		if (!template.isNull(EKK0071D010CBSMsg.MSKM_NO_ERR))
		{
			if (!inMap.containsKey("mskm_no_err"))
			{
				inMap.put("mskm_no_err", template.getString(EKK0071D010CBSMsg.MSKM_NO_ERR));
			}
		}

		// 代理店コード のエラー情報返却
		if (!template.isNull(EKK0071D010CBSMsg.AGNT_CD_ERR))
		{
			if (!inMap.containsKey("agnt_cd_err"))
			{
				inMap.put("agnt_cd_err", template.getString(EKK0071D010CBSMsg.AGNT_CD_ERR));
			}
		}
		
		//申込_代理店番号
		setErrInfo(inMap, EKK0071D010CBSMsg.MSKM_AGNT_NO_ERR, template, EKK0071D010CBSMsg.MSKM_AGNT_NO_ERR);
		
		// 表示順序 のエラー情報返却
		if (!template.isNull(EKK0071D010CBSMsg.DSP_JUN_ERR))
		{
			if (!inMap.containsKey("dsp_jun_err"))
			{
				inMap.put("dsp_jun_err", template.getString(EKK0071D010CBSMsg.DSP_JUN_ERR));
			}
		}

		return param;
	}
	
// --> ANK-1199-00-00
	
	/**
	 * サービス契約一覧照会（紹介コード）のエラー情報マッピング処理
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template テンプレート
	 * @param returnCode リターンコード
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @exception RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0081B532(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0081B532CBSMsg.STATUS), returnCode);

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

		// 紹介コード のエラー情報返却
		if (!template.isNull(EKK0081B532CBSMsg.KEY_INTR_CD_ERR))
		{
			if (!inMap.containsKey("key_intr_cd_err"))
			{
				inMap.put("key_intr_cd_err", template.getString(EKK0081B532CBSMsg.KEY_INTR_CD_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 受付番号重複チェックの上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0021B011(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		ArrayList inList = null;
		CAANMsg template = new CAANMsg(EKK0021B011CBSMsg.class.getName());

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 機能コード
		template.set(EKK0021B011CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		
		// 受付番号
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		if (inList != null)
		{
			HashMap childMap = (HashMap)inList.get(0);
			
			// 申込内容承認登録マップ.申込内容承認登録明細.申込書番号 → 申込内容承認登録明細.申込書番号
			if (childMap == null || childMap.get("mskmsho_no") == null || "".equals(childMap.get("mskmsho_no")))
			{
				template.setNull(EKK0021B011CBSMsg.KEY_MSKMSHO_NO);
			}
			else
			{
				template.set(EKK0021B011CBSMsg.KEY_MSKMSHO_NO, childMap.get("mskmsho_no"));
			}
		}

		return template;
	}

	/**
	 * 受付番号重複チェックの下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0021B011(Map<?, ?> msgList, 
															IRequestParameterReadWrite param, 
															String fixedText) throws Exception
	{
		// 戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;

		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		// 申込書明細番号重複フラグを設定する
		templateArray = template.getCAANMsgList(EKK0021B011CBSMsg.EKK0021B011CBSMSG1LIST);
		if (templateArray != null)
		{
			if (templateArray.length == 0)
			{
				dataMap.put("ukno_overlap_manu_flg", UKNO_OVERLAP_FLG_NASHI);
				dataMap.put("ukno_overlap_auot_flg", UKNO_OVERLAP_FLG_NASHI);
			}
			else
			{
				dataMap.put("ukno_overlap_auot_flg", UKNO_OVERLAP_FLG_NASHI);
				dataMap.put("ukno_overlap_manu_flg", UKNO_OVERLAP_FLG_ARI);
			}
		}

		int templateStatus = template.getInt(EKK0021B011CBSMsg.STATUS);
		
		if(templateStatus == 0 && !UKNO_OVERLAP_FLG_NASHI.equals(dataMap.get("ukno_overlap_manu_flg")))
		{
			template.set(EKK0021B011CBSMsg.KEY_MSKMSHO_NO_ERR, "E1");
			template.set(EKK0021B011CBSMsg.STATUS, 1000);
		}
		
		// エラー情報の設定
		editErrInfoEKK0021B011(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param template (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText ユーザ定義文字
	 * @return 業務データ取得・書込用I/F
	 * @throws RequestParameterException
	 * @since 2011.06.03
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0021B011(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0021B011CBSMsg.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(fixedText);
		
		ArrayList inList = null;
		HashMap childMap = null;
		String listKey = "";

		listKey = UPD_MSKM_LIST;

		inList = (ArrayList)inMap.get(listKey);
		
		if(inList == null)
		{
			inList = new ArrayList();
			inList.add(new HashMap());
			inMap.put(listKey, inList);
		}
		
		childMap = (HashMap)inList.get(0);
		
		// ＫＥＹ＿申込書番号 のエラー情報返却
		setErrInfo(childMap, "key_mskmsho_no_err", template, EKK0021B011CBSMsg.KEY_MSKMSHO_NO_ERR);
		
		return param;
	}
	
	/**
	 * 申込番号採番の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param idx index
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0021C014(IRequestParameterReadWrite param, 
										String fixedText, 
										int idx) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0021C014CBSMsg.class.getName());
		ArrayList inList = null;

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 機能コード
		template.set(EKK0021C014CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		if (inList != null)
		{
			HashMap childMap = (HashMap)inList.get(idx);
			
			// サービス体系コード
			template.set(EKK0021C014CBSMsg.SVC_TIKI_CD, childMap.get("svc_tiki_cd"));
			
			// 申込形態コード
			template.set(EKK0021C014CBSMsg.MSKM_FORM_CD, childMap.get("mskm_form_cd"));
			
			// 年月日
			template.set(EKK0021C014CBSMsg.YMD, childMap.get("ymd"));
		}
		return template;
	}

	/**
	 * 申込番号採番の下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param idx index
	 * @param saibanMap 採番マップ
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0021C014(Map<?, ?> msgList, 
															IRequestParameterReadWrite param, 
															String fixedText, 
															int idx, 
															HashMap saibanMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

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

		dataList = (ArrayList)dataMap.get(UPD_MSKM_LIST);

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		HashMap childMap = (HashMap)dataList.get(idx);
		
		if (childMap == null)
		{
			childMap = new HashMap();
		}

		// 申込番号
		if (!template.isNull(EKK0021C014CBSMsg.MSKMSHO_DTL_NO))
		{
			saibanMap.put((String)childMap.get("svc_kind_cd"), template.getString(EKK0021C014CBSMsg.MSKMSHO_DTL_NO));
		}

		// エラー情報の設定
		editErrInfoEKK0021C014(param, template, (Integer)returnCode, fixedText, idx);

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

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param template (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText ユーザ定義文字
	 * @param idx 申込明細リストのindex
	 * @return 業務データ取得・書込用I/F
	 * @throws RequestParameterException
	 * @since 2011.06.03
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0021C014(IRequestParameterReadWrite param, 
															CAANMsg template, 
															int returnCode, 
															String fixedText, 
															int idx) throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0021C014CBSMsg.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(fixedText);
		
		ArrayList inList = null;
		HashMap childMap = null;
		String listKey = "";
		
		listKey = UPD_MSKM_LIST;
		
		inList = (ArrayList)inMap.get(listKey);
		
		if (inList == null)
		{
			inList = new ArrayList();
			inList.add(new HashMap());
			inMap.put(listKey, inList);

			childMap = (HashMap)inList.get(0);
		}
		else
		{
			childMap = (HashMap)inList.get(idx);
		}
		
		// サービス体系コードのエラー情報返却
		setErrInfo(childMap, "svc_tiki_cd_err", template, EKK0021C014CBSMsg.SVC_TIKI_CD_ERR);
		
		// 申込形態コードのエラー情報返却
		setErrInfo(childMap, "mskm_form_cd_err", template, EKK0021C014CBSMsg.MSKM_FORM_CD_ERR);
		
		// 年月日のエラー情報返却
		setErrInfo(childMap, "ymd_err", template, EKK0021C014CBSMsg.YMD_ERR);
		
		return param;
	}
	
	/**
	 * 申込番号重複チェックの上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param idx index
	 * @param saibanMap 採番マップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0021B506(IRequestParameterReadWrite param, 
										String fixedText, 
										int idx, 
										HashMap saibanMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0021B506CBSMsg.class.getName());
		ArrayList inList = null;

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		template.set(EKK0021B506CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		
		inList = (ArrayList)inMap.get(UPD_MSKM_LIST);
		
		if (inList != null)
		{
			HashMap childMap = (HashMap)inList.get(idx);
			
			// 申込書明細番号
			template.set(EKK0021B506CBSMsg.KEY_MSKMSHO_DTL_NO, saibanMap.get((String)childMap.get("svc_kind_cd")));
		}
		return template;
	}

	/**
	 * 申込番号重複チェックの下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param idx index
	 * @param saibanMode 採番モード
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0021B506(Map<?, ?> msgList, 
															IRequestParameterReadWrite param, 
															String fixedText, 
															int idx, 
															String saibanMode) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

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

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		HashMap childMap = (HashMap)dataList.get(idx);
		
		if (childMap == null)
		{
			childMap = new HashMap();
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0021B506CBSMsg.EKK0021B506CBSMSG1LIST);
		
		String mskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;
		if(!JKKCommonUtil.isNull(templateArray))
		{
			String svcKeiNo = null;
			for(CAANMsg childTemplate : templateArray)
			{
				svcKeiNo = childTemplate.getString(EKK0021B506CBSMsg1List.SVC_KEI_NO);
				
				// 紐付き不明は画面では警告だが登録時には正常とみなす。
				// 他契約に紐付く場合は重複エラーとする。
				if(!JKKCommonUtil.isNull(svcKeiNo))
				{
					mskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
					break;
				}
			}
		}
		
		// 自動採番
		if(MODE_AUTO.equals(saibanMode))
		{
			childMap.put("mskmsho_dtl_no_overlap_auot_flg", mskmshoDtlNoOverlapFlg);
			childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
		}
		else
		{
			childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
			childMap.put("mskmsho_dtl_no_overlap_manu_flg", mskmshoDtlNoOverlapFlg);
		}
		
		dataMap.put(UPD_MSKM_LIST, dataList);

		// エラー情報の設定
		editErrInfoEKK0021B506(param, template, (Integer)returnCode, fixedText, idx);

		//エラー情報のマップを取得
		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 リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param idx index
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetErrorInfoEKK0021B506(Map<?, ?> msgList, 
															IRequestParameterReadWrite param, 
															String fixedText, 
															int idx) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

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

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		HashMap childMap = (HashMap)dataList.get(idx);
		
		if (childMap == null)
		{
			childMap = new HashMap();
		}
		
		int templateStatus = template.getInt(EKK0021B506CBSMsg.STATUS);
		
		if(templateStatus == 0 
				&& (!JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals(dataMap.get("mskmsho_dtl_no_overlap_auot_flg")) 
						|| !JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL.equals(dataMap.get("mskmsho_dtl_no_overlap_manu_flg"))))
		{
			template.set(EKK0021B506CBSMsg.KEY_MSKMSHO_DTL_NO_ERR, "E1");
			template.set(EKK0021B506CBSMsg.STATUS, 1000);
		}
		
		// エラー情報の設定
		editErrInfoEKK0021B506(param, template, (Integer)returnCode, fixedText, idx);

		//エラー情報のマップを取得
		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 リクエストパラメータ
	 * @param fixedText ユーザ指定文字列
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetErrorInfoEKK0081B532(Map<?, ?> msgList, 
															IRequestParameterReadWrite param, 
															String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;

		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
	
		int templateStatus = template.getInt(EKK0081B532CBSMsg.STATUS);
		
		if(templateStatus == 0 
				&& (JKKStrConst.INTR_CD_DBLE_FLG_ERR.equals((String)dataMap.get("intr_cd_overlap_error"))))
		{
			template.set(EKK0081B532CBSMsg.KEY_INTR_CD_ERR, "EA");
			template.set(EKK0081B532CBSMsg.STATUS, 1100);
		}
		
		// エラー情報の設定
		editErrInfoEKK0081B532(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param template (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText ユーザ定義文字
	 * @param idx 申込明細リストのindex
	 * @return 業務データ取得・書込用I/F
	 * @throws RequestParameterException
	 * @since 2011.06.03
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0021B506(IRequestParameterReadWrite param, 
															CAANMsg template, 
															int returnCode, 
															String fixedText, 
															int idx) throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0021B506CBSMsg.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(fixedText);
			
		ArrayList inList = null;
		HashMap childMap = null;
		String listKey = "";
		
		listKey = UPD_MSKM_LIST;
		
		inList = (ArrayList)inMap.get(listKey);
		
		if (inList == null)
		{
			inList = new ArrayList();
			inList.add(new HashMap());
			inMap.put(listKey, inList);

			childMap = (HashMap)inList.get(0);
		}
		else
		{
			childMap = (HashMap)inList.get(idx);
		}
		
		// ＫＥＹ＿申込書明細番号 のエラー情報返却
		setErrInfo(childMap, "key_mskmsho_dtl_no_err", template, EKK0021B506CBSMsg.KEY_MSKMSHO_DTL_NO_ERR);
		
		return param;
	}
	
	/**
	 * ユーザデータ情報にエラー情報を設定します。<br>
	 * 　※ユーザデータ情報内にすでにキーが存在する場合、値は設定されません。<br>
	 * @param inMap	 ユーザデータ情報
	 * @param setKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアより取得するキー名
	 */
	private void setErrInfo(HashMap<String, Object> inMap, String setKey, CAANMsg template, String getKey)
	{
		if (!template.isNull(getKey))
		{
			if (!inMap.containsKey(setKey))
			{
				inMap.put(setKey, template.getString(getKey));
			}
		}
	}
	
	/**
	 * 申込番号のワークエリア登録
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param saibanMap 採番マップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite setWkMskmshoDtlNo(IRequestParameterReadWrite param, String fixedText, HashMap saibanMap) throws Exception
	{
		HashMap dataMap = null;
		ArrayList dataList = null;
		
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			return param;
		}
		
		dataList = (ArrayList)dataMap.get(UPD_MSKM_LIST);
		
		if(dataList == null)
		{
			return param;
		}
		
		// 申込番号をワークエリアへ登録
		for (int i = 0; i < dataList.size(); i++)
		{
			HashMap childMap = (HashMap)dataList.get(i);
			
			// eo光ネット
			if(JKKStrConst.CD00684_NET.equals(childMap.get("svc_kind_cd")))
			{
				if(saibanMap.get(JKKStrConst.CD00684_NET) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_NET)))
				{
					JKKBpCommon.setWkMskmshoDtlNoNetTel(param, (String)saibanMap.get(JKKStrConst.CD00684_NET));
				}
			}
			
			// eo光電話
			if(JKKStrConst.CD00684_TEL.equals(childMap.get("svc_kind_cd")))
			{
				if(saibanMap.get(JKKStrConst.CD00684_TEL) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_TEL)))
				{
					JKKBpCommon.setWkMskmshoDtlNoNetTel(param, (String)saibanMap.get(JKKStrConst.CD00684_TEL));
				}
			}
			
			// eo光テレビ
			if(JKKStrConst.CD00684_TV.equals(childMap.get("svc_kind_cd")))
			{
				if(saibanMap.get(JKKStrConst.CD00684_TV) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_TV)))
				{
					JKKBpCommon.setWkMskmshoDtlNoTv(param, (String)saibanMap.get(JKKStrConst.CD00684_TV));
				}
			}
			
			// eoモバイル
			if(JKKStrConst.CD00684_MOBA.equals(childMap.get("svc_kind_cd")))
			{
				if(saibanMap.get(JKKStrConst.CD00684_MOBA) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_MOBA)))
				{
					JKKBpCommon.setWkMskmshoDtlNoMbl(param, (String)saibanMap.get(JKKStrConst.CD00684_MOBA));
				}
			}
			
			// ADSL
			if(JKKStrConst.CD00684_ADSL.equals(childMap.get("svc_kind_cd")))
			{
				if(saibanMap.get(JKKStrConst.CD00684_ADSL) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_ADSL)))
				{
					JKKBpCommon.setWkMskmshoDtlNoAdsl(param, (String)saibanMap.get(JKKStrConst.CD00684_ADSL));
				}
			}
		}
		
		return param;
	}
	

	/**
	 * 申込番号重複チェック
	 * @param param リクエストパラメータ
	 * @param fixedText 機能コード
	 * @param saibanMap 採番マップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite checkMskmshoDtlNoOverlap(IRequestParameterReadWrite param, String fixedText, HashMap saibanMap) throws Exception
	{
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;
		
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		dataList = (ArrayList)dataMap.get(UPD_MSKM_LIST);
		
		if(dataList == null)
		{
			return param;
		}
		
		String netTelMskmshoDtlNo = "";
		String tvMskmshoDtlNo = "";
		String mblMskmshoDtlNo = "";
		String adslMskmshoDtlNo = "";
		
		String netTelMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;
		String tvMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;
		String mblMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;
		String adslMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;

		// 申込番号の取得
		// eo光ネット
		if(saibanMap.get(JKKStrConst.CD00684_NET) != null)
		{
			netTelMskmshoDtlNo = (String)saibanMap.get(JKKStrConst.CD00684_NET);
		}
		
		// eo光電話
		if(saibanMap.get(JKKStrConst.CD00684_TEL) != null)
		{
			netTelMskmshoDtlNo  = (String)saibanMap.get(JKKStrConst.CD00684_TEL);
		}
		
		// eo光テレビ
		if(saibanMap.get(JKKStrConst.CD00684_TV) != null)
		{
			tvMskmshoDtlNo = (String)saibanMap.get(JKKStrConst.CD00684_TV);
		}
		
		// eoモバイル
		if(saibanMap.get(JKKStrConst.CD00684_MOBA) != null)
		{
			mblMskmshoDtlNo = (String)saibanMap.get(JKKStrConst.CD00684_MOBA);
		}
		
		// ADSL
		if(saibanMap.get(JKKStrConst.CD00684_ADSL) != null)
		{
			adslMskmshoDtlNo = (String)saibanMap.get(JKKStrConst.CD00684_ADSL);
		}

		// ネット・電話申込番号
		if(netTelMskmshoDtlNo != null &&  !"".equals(netTelMskmshoDtlNo))
		{
			if(netTelMskmshoDtlNo.equals(tvMskmshoDtlNo))
			{
				netTelMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				tvMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
			if(netTelMskmshoDtlNo.equals(mblMskmshoDtlNo))
			{
				netTelMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				mblMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
			if(netTelMskmshoDtlNo.equals(adslMskmshoDtlNo))
			{
				netTelMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				adslMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
		}
		
		// テレビ申込番号
		if(tvMskmshoDtlNo != null &&  !"".equals(tvMskmshoDtlNo))
		{
			if(tvMskmshoDtlNo.equals(mblMskmshoDtlNo))
			{
				tvMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				mblMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
			if(tvMskmshoDtlNo.equals(adslMskmshoDtlNo))
			{
				tvMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				adslMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
		}
		
		// モバイル申込番号
		if(mblMskmshoDtlNo != null &&  !"".equals(mblMskmshoDtlNo))
		{
			if(mblMskmshoDtlNo.equals(adslMskmshoDtlNo))
			{
				mblMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
				adslMskmshoDtlNoOverlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_ERR;
			}
		}
		
		String overlapFlg = JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL;
		
		// 申込番号重複フラグ(自動採番)に結果を設定
		for(int i = 0; i < dataList.size(); i++)
		{
			HashMap childMap = (HashMap)dataList.get(i);
			
			// サービス種類コード
			String svcKindCd = (String)childMap.get("svc_kind_cd");
			
			if (JKKStrConst.CD00684_NET.equals(svcKindCd) || JKKStrConst.CD00684_TEL.equals(svcKindCd))
			{
				overlapFlg = netTelMskmshoDtlNoOverlapFlg;
			}
			else if (JKKStrConst.CD00684_TV.equals(svcKindCd))
			{
				overlapFlg = tvMskmshoDtlNoOverlapFlg;
			}
			else if (JKKStrConst.CD00684_MOBA.equals(svcKindCd))
			{
				overlapFlg = mblMskmshoDtlNoOverlapFlg;
			}
			else if (JKKStrConst.CD00684_ADSL.equals(svcKindCd))
			{
				overlapFlg = adslMskmshoDtlNoOverlapFlg;
			}
			
			childMap.put("mskmsho_dtl_no_overlap_auot_flg", overlapFlg);
		}

		return param;
	}
	
	/**
	 * eo光ネット・eo光電話の同時申込チェック
	 * @param childMap 申込更新マップ
	 * @param saibanMap 採番マップ
	 * @return 同時申込 true 同時申込以外 false
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean checkNetTelMskmDtlNoDojiMskm(HashMap childMap, HashMap saibanMap) throws Exception
	{
		boolean retCd = false;
		
		// サービス体系コードを取得
		String svcTikiCd = (String)childMap.get("svc_tiki_cd");
		
		// サービス種類コードを取得
		String svckindCd = (String)childMap.get("svc_kind_cd");
		
		// サービス種類コードがeo光ネットまたはeo光電話の場合
		if(JKKStrConst.CD00684_NET.equals(svckindCd) || JKKStrConst.CD00684_TEL.equals(svckindCd))
		{
			// サービス体系コードが ホームタイプのeo光ネットまたはメゾンタイプのeo光ネットまたはマンションタイプのeo光ネットの場合
			if(SVC_TIKEI_CD_HOME_NET_TEL.equals(svcTikiCd) || SVC_TIKEI_CD_MEZON_NET_TEL.equals(svcTikiCd) || SVC_TIKEI_CD_MANSION_NET_TEL.equals(svcTikiCd))
			{
				// 採番マップに登録されているネットまたは電話の申込番号を採番マップに設定
				if(saibanMap.get(JKKStrConst.CD00684_NET) != null &&  !"".equals(saibanMap.get(JKKStrConst.CD00684_NET)))
				{
					saibanMap.put((String)childMap.get("svc_kind_cd"), (String)saibanMap.get(JKKStrConst.CD00684_NET));
					childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
					childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
					retCd = true;
				}
				else if(saibanMap.get(JKKStrConst.CD00684_TEL) != null &&  !"".equals(saibanMap.get(JKKStrConst.CD00684_TEL)))
				{
					saibanMap.put((String)childMap.get("svc_kind_cd"), (String)saibanMap.get(JKKStrConst.CD00684_TEL));
					childMap.put("mskmsho_dtl_no_overlap_auot_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
					childMap.put("mskmsho_dtl_no_overlap_manu_flg", JKKStrConst.MSKMSHO_DTL_NO_DBLE_FLG_NORMAL);
					retCd = true;
				}
			}
		}
		
		return retCd;
	}

	/**
	 * 申込番号のマップ設定
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param saibanMap 採番マップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite setOutMapMskmshoDtlNo(IRequestParameterReadWrite param, String fixedText, HashMap saibanMap) throws Exception
	{
		HashMap dataMap = null;
		ArrayList dataList = null;
		
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			return param;
		}

		dataList = (ArrayList)dataMap.get(UPD_MSKM_LIST);
		
		if(dataList == null)
		{
			return param;
		}
		
		// 申込番号をマップに設定
		for (int i = 0; i < dataList.size(); i++)
		{
			String mskmshoDtlNo = "";
			HashMap childMap = (HashMap)dataList.get(i);
			
			// 申込番号の取得
			if(childMap != null && childMap.get("mskmsho_dtl_no") != null)
			{
				mskmshoDtlNo = (String)childMap.get("mskmsho_dtl_no");
			}
			
			// 申込番号未入力
			if("".equals(mskmshoDtlNo))
			{
				// eo光ネット
				if(JKKStrConst.CD00684_NET.equals(childMap.get("svc_kind_cd")))
				{
					if(saibanMap.get(JKKStrConst.CD00684_NET) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_NET)))
					{
						childMap.put("saiban_mskmsho_dtl_no", (String)saibanMap.get(JKKStrConst.CD00684_NET));
					}
				}
				
				// eo光電話
				if(JKKStrConst.CD00684_TEL.equals(childMap.get("svc_kind_cd")))
				{
					if(saibanMap.get(JKKStrConst.CD00684_TEL) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_TEL)))
					{
						childMap.put("saiban_mskmsho_dtl_no", (String)saibanMap.get(JKKStrConst.CD00684_TEL));
					}
				}
				
				// eo光テレビ
				if(JKKStrConst.CD00684_TV.equals(childMap.get("svc_kind_cd")))
				{
					if(saibanMap.get(JKKStrConst.CD00684_TV) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_TV)))
					{
						childMap.put("saiban_mskmsho_dtl_no", (String)saibanMap.get(JKKStrConst.CD00684_TV));
					}
				}
				
				// eoモバイル
				if(JKKStrConst.CD00684_MOBA.equals(childMap.get("svc_kind_cd")))
				{
					if(saibanMap.get(JKKStrConst.CD00684_MOBA) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_MOBA)))
					{
						childMap.put("saiban_mskmsho_dtl_no", (String)saibanMap.get(JKKStrConst.CD00684_MOBA));
					}
				}
				
				// ADSL
				if(JKKStrConst.CD00684_ADSL.equals(childMap.get("svc_kind_cd")))
				{
					if(saibanMap.get(JKKStrConst.CD00684_ADSL) != null && !"".equals(saibanMap.get(JKKStrConst.CD00684_ADSL)))
					{
						childMap.put("saiban_mskmsho_dtl_no", (String)saibanMap.get(JKKStrConst.CD00684_ADSL));
					}
				}
			}
		}
		dataMap.put(MSKMSHODTLNO_LIST, dataList);
		
		return param;
	}
// <-- ANK-1199-00-00
	
	/**
	 * 重複可能マップに申込書明細番号が存在するか判定します。
	 * @param inMap 申込情報登録マップ
	 * @param childMap 申込情報明細マップ 
	 * @param saibanMap 採番マップ
	 * @return 重複可能マップ内に存在する場合、true<br />
	 *          重複可能マップ内に存在しない場合、false
	 */
	@SuppressWarnings("unchecked")
	private boolean isDblePsb(HashMap inMap, HashMap childMap, HashMap saibanMap)
	{
		String svckindCd = String.valueOf(childMap.get("svc_kind_cd"));
		String[][] keys = {
				{JKKStrConst.CD00684_NET, "net_tel_dble_psb_map"}
				, {JKKStrConst.CD00684_TEL, "net_tel_dble_psb_map"}
				, {JKKStrConst.CD00684_TV, "tv_dble_psb_map"}
				, {JKKStrConst.CD00684_MOBA, "mbl_dble_psb_map"}
				, {JKKStrConst.CD00684_ADSL, "adsl_dble_psb_map"}
		};
		
		String[] key = null;
		for(String[] tmpKey : keys)
		{
			if(tmpKey[0].equals(svckindCd))
			{
				key = tmpKey;
				break;
			}
		}
		
		String mskmshoDtlNo = String.valueOf(saibanMap.get(key[0]));
		HashMap<String, String> dblePsbMap = (HashMap<String, String>)inMap.get(key[1]);
		
		if(!JKKCommonUtil.isNull(dblePsbMap) && dblePsbMap.containsValue(mskmshoDtlNo))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　※CAANMsg内のデータがNullの場合、空文字を設定します。<br>
	 * @param dataMap ユーザデータ情報
	 * @param prefix ユーザデータ情報より取得する場合に付加するプレフィックス
	 * @param getSetKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String prefix, String getSetKey, CAANMsg template)
	{
		setDataMap(dataMap, prefix, getSetKey, template, getSetKey);
	}
	
	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getString(getKey));
		}
	}
}