/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *   システム名      ：eo顧客基幹システム
 *   モジュール名    ：JCHNyukinClRunCC
 *   ソースファイル名：JCHNyukinClRunCC.java
 *   作成者          ：富士通
 *   日付            ：2012年03月09日
 *＜機能概要＞
 *   入金取消実行CC部品です。
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00.00	2012/03/09	富士通		新規作成
 *	v5.00.00	2013/08/13	富士通		【TG-2013-0000806】入金取消時の金庫登録処理を修正
 *	v5.00.01	2013/08/24	FJ)垣内		【OM-2013-0000606】督促異動．督促異動年月日の設定方法修正
 *	v5.00.02	2013/08/26	FJ)小野		【OM-2013-0000978】督促異動が登録できない障害に対応
 *	v5.00.03	2013/09/14	FJ)伊藤		【OM-2013-0002075】消込額（充当額）が0円の場合、金庫登録を行わないように変更。
 *	v5.00.04	2013/09/27	FJ) 林      【OM-2013-0002054/2457】入金登録リスト作成用に電子ファイル管理登録をするよう対応
 *	v5.00.05	2013/10/24	FJ)小野     【OM-2013-0002944】督促債権関連を作成する時、当月債権分は作成しないように変更。
 *	v6.00.00	2013/11/24	FJ)小野		【OM-2013-0003532】入金取消時の債権、債権内訳、請求テーブルの更新処理変更。
 *	v6.00.01	2014/01/27  FJ)小野     【OM-2014-0000223】満額入金(入金登録)で督促ステータスが更新されない事象に対応(料金変更では当月請求額がゼロになった場合)。
 *	v9.00.01	2014/08/28	FJ)中井/古田【OM-2014-0001880,IT2-2014-000167】支払証明書の消費税不正対応。
 *	v10.00.00	2014/11/17	FJ)中山		【OM-2014-0003523】入金取消の料金対応記録処理の修正
 *	v22.00.00	2015/01/22	FJ)宇野		【ANK-2610-00-00】督促ステータス更新時の指示書連携実装
 *	v23.00.00	2016/04/05	FJ)岡田		【OM-2016-0000639】
 *	v27.00.00	2016/10/14	FJ)岡田		【OM-2016-0002053】
 **********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JCHNyukinClMappingConstCC;
import com.fujitsu.futurity.bp.custom.constant.JCHNyukinClRunConstCC;
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.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.common.constant.JACStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JCRUtilCommon;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.ECC0041D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0011B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0011C013CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0111C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0201B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0201B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0201C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0231A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0231A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0231C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0231D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0311B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0311B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0311E010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0341B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0341B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0341D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0361D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg1List;

/**
 * 請求収納の各サービスより呼び出される入金取消実行CC部品です。
 * <p>
 * <BR>
 * 
 * @author 富士通
 */
public class JCHNyukinClRunCC extends AbstractCommonComponent
{
	/** 電子ファイル管理登録情報リスト */
	private ArrayList<CAANMsg> efileInfoList = new ArrayList<CAANMsg>();

	/** 改行文字 */
	private static final String LINE_SEP = "line.separator";

	/**  カンマ区切り */
	private static final String CSV = ",";
	
// v22.00.00 ANK-2610-00-00 ADD START
	/** 料金指示書CC実行パラメータ */
	private static final String ADDSJISHO_MAP = "JCHPRCSHIJISHOCC";
// v22.00.00 ANK-2610-00-00 ADD END

	// ▼▼ invokeCBSによる単項目チェック処理 ▼▼
	/**
	 * 入金取消処理チェック処理.<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
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// オンライン運用日を取得
		String onlineYmd = com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);
		// MAPリストを取得
		ArrayList<HashMap<String, Object>> inList = this.getMapListItem(param, JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_CL_RUN_LIST);

		if (inList != null)
		{
			// 督促一意照会サービスIF用メッセージ設定処理
			String inSeikyKeiNo = (String) inList.get(0).get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO);
			ArrayList<CAANMsg> templateECH0231A010 = editInMsgECH0231A010(param, inList.get(0), inSeikyKeiNo, onlineYmd);
			for (CAANMsg msg : templateECH0231A010)
			{
				templateList.add(msg);
			}

			//債権番号単位にループ処理
			for (int i = 0; i < inList.size(); i++)
			{
				HashMap<String, Object> nyukinClRunListMap = inList.get(i);

				// 入金取消債権変更サービスIF用メッセージ設定処理
				ArrayList<CAANMsg> templateECH0011C013 = editInMsgECH0011C013(param, nyukinClRunListMap);
				for (CAANMsg msg : templateECH0011C013)
				{
					templateList.add(msg);
				}

				ArrayList<HashMap<String, Object>> ECH0201B010CBSMsg1List = (ArrayList<HashMap<String, Object>>) nyukinClRunListMap
						.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0201B010CBSMSG1LIST);
				if (ECH0201B010CBSMsg1List != null)
				{
					//充当単位にループ処理
					for (int j = 0; j < ECH0201B010CBSMsg1List.size(); j++)
					{
						HashMap<String, Object> jutoIcrnMap = (HashMap<String, Object>) ECH0201B010CBSMsg1List.get(j);

						// 入金番号
						String nyukinNo = (String)jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO);

						if (!JCRUtilCommon.isNull(nyukinNo))
						{
							// 金庫登録サービスIF用メッセージ設定処理
							ArrayList<CAANMsg> templateECH0191D010 = editInMsgECH0191D010(param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);
							for (CAANMsg msg : templateECH0191D010)
							{
								templateList.add(msg);
							}
						}

						// 充当取消変更サービスIF用メッセージ設定処理
						ArrayList<CAANMsg> templateECH0201C010 = editInMsgECH0201C010(param, nyukinClRunListMap, jutoIcrnMap);
						for (CAANMsg msg : templateECH0201C010)
						{
							templateList.add(msg);
						}
					}
				}
			}
		}

		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	// ▲▲ invokeCBSによる単項目チェック処理 ▲▲

	// ▼▼ 入金取消処理 ▼▼
	/**
	 * 入金取消処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
// v22.00.00 ANK-2610-00-00 ADD START
//	public IRequestParameterReadWrite nyukinCl(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	public IRequestParameterReadWrite nyukinCl(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
// v22.00.00 ANK-2610-00-00 ADD END
	{

		String tokusokuNo = JACStrConst.KARA_MOJI;
		// オンライン運用日を取得
		String onlineYmd = JCCBPCommon.getOpeDate(null);
		// MAPリストを取得
		ArrayList<HashMap<String, Object>> inList = this.getMapListItem(param, JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_CL_RUN_LIST);

		// 電子ファイル管理登録情報リストの初期化
		this.efileInfoList = new ArrayList<CAANMsg>();
		String seikyKeiNo = JACStrConst.KARA_MOJI;    // 請求契約番号
		String seikyYm = JACStrConst.KARA_MOJI;       // 請求年月
		String nyukinAmnt = JACStrConst.KARA_MOJI;    // 入金額
		String jutoSbtCd = JACStrConst.KARA_MOJI;    // 充当種別コード

		if (inList != null)
		{
			// 料金スケジュール定義一意照会サービスを呼出し、当月債権年月を取得する
			String togtSaikenYm = execECH0501A010(handle, param, onlineYmd);

			// 督促一意照会サービスを呼出し、督促マップに情報を格納する
			String inSeikyKeiNo = (String) inList.get(0).get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO);
			// 督促マップ
			HashMap<String, Object> tkskMap = new HashMap<String, Object>();

			// 督促番号を取得
			tokusokuNo = execECH0231A010Newest(handle, param, tkskMap, inSeikyKeiNo, onlineYmd);

			// 債権番号配列
			List<String> saikenNoList = new ArrayList<String>();

			// 消込金額合計（督促対象のみ）
			long kskmAmntTotal = 0L;

			//OM-2014-0003523 ADD START
			// 督促番号（入金取消の料金対応履歴マッピング用）
			String mapTokusokuNo = null;
			// 変更前督促ステータス（入金取消の料金対応履歴マッピング用）
			String mapTokusokuStat = null;
			//OM-2014-0003523 ADD END
			
			// v27.00.00 ADD START
			// 入金リスト．入金番号を退避用
			List<String> nyukinList = new ArrayList<String>();
			// v27.00.00 ADD END
			
			//債権番号単位にループ処理
			for (int i = 0; i < inList.size(); i++)
			{
				HashMap<String, Object> nyukinClRunListMap = inList.get(i);

				seikyKeiNo = (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO);
				seikyYm = (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM);
				nyukinAmnt = (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_JUTO_AMNT);

				// 当月の債権以外を督促の消込金額として計算する
				if (seikyYm.compareTo(togtSaikenYm) < 0)
				{
					// 債権番号
					String saikenNo = (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SAIKEN_NO);
					saikenNoList.add(saikenNo);

					if (!JCRUtilCommon.isNull(nyukinAmnt))
					{
						kskmAmntTotal += Long.parseLong(nyukinAmnt);
					}
				}

				// 入金取消債権変更サービスを呼び出す
				execECH0011C013(handle, param, nyukinClRunListMap);

				ArrayList<HashMap<String, Object>> ECH0201B010CBSMsg1List = (ArrayList<HashMap<String, Object>>) nyukinClRunListMap
						.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0201B010CBSMSG1LIST);
				if (ECH0201B010CBSMsg1List != null)
				{
					// 請求種別コード
					String seikySbtCd = (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_SBT_CD);

					// 入金更新フラグ[true:入金を更新する、false:入金を更新しない]
					// 随時入金かつ、金庫充当でない場合のみtrueとする。
					boolean nyukinUpdFlg = true;

					//充当単位にループ処理
					for (int j = 0; j < ECH0201B010CBSMsg1List.size(); j++)
					{
						HashMap<String, Object> jutoIcrnMap = (HashMap<String, Object>) ECH0201B010CBSMsg1List.get(j);
						
						// 金庫番号
						String knkNo = (String)jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_KNK_NO);
						
						// 消込金額
						String amnt = (String)jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT);
						
						// 入金番号
						String nyukinNo = (String)jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO);
						
						// v23.00.00 ADD START
						//充当種別コード
						jutoSbtCd = getNullToStr(jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_JUTO_SBT_CD));
						// v23.00.00 ADD END
						
						if(!amnt.equals("0") && !amnt.equals(JACStrConst.KARA_MOJI))
						{
							if (!JCRUtilCommon.isNull(knkNo))
							{
								// v23.00.00 MOD START
								// 金庫登録サービスを呼び出す
								// execECH0191D010_1(handle, param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);
								// 自動入金、手動入金、預り金充当の場合のみ金庫へ登録します。
								if(JACStrConst.JUTO_SBT_AUTO.equals(jutoSbtCd)
									|| JACStrConst.JUTO_SBT_MANUAL_NKIN.equals(jutoSbtCd)
									|| JACStrConst.JUTO_SBT_AZKIN_JUTO.equals(jutoSbtCd))
								{
									// 金庫登録サービスを呼び出す
									execECH0191D010_1(handle, param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);
								}
								// v23.00.00 MOD END
							}
							else
							{
								// 金庫登録サービスを呼び出す
								execECH0191D010(handle, param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);

								// 随時入金の場合、かつ金庫充当でない場合、入金を更新する。
								// 入金の更新は債権単位で行う。
								if (JACStrConst.SIKYSHBTS_JUIJ_JNYUKIN.equals(seikySbtCd) && nyukinUpdFlg
										&& !JCRUtilCommon.isNull(nyukinNo) )
								{
									// 入金取消変更サービスを呼び出す
									execECH0111C010(handle, param, nyukinClRunListMap, jutoIcrnMap);

									// 入金の更新は債権単位で行うためフラグを戻す。
									nyukinUpdFlg = false;
								}
							}
						}
						
						// v27.00.00 ADD START
						if (amnt.equals("0")
								&& !JCRUtilCommon.isNull(nyukinNo)
								&& !nyukinList.contains(nyukinNo))
						{
							// 入金取消変更サービスを呼び出す
							execECH0111C010(handle, param, nyukinClRunListMap, jutoIcrnMap);
							// 入金番号を退避
							nyukinList.add(nyukinNo);
						}
						// v27.00.00 ADD END
						
						
						//債権番号で削除するため入金番号の有無は判断しない
//						if (!JCRUtilCommon.isNull(nyukinNo))
//						{
							// 領収一覧照会サービスを呼び出す
							execECH0311B010(handle, param, nyukinClRunListMap, jutoIcrnMap);
							// 領収削除照会サービスを呼び出す
//							execECH0311E010(handle, param, nyukinClRunListMap, jutoIcrnMap);
							execRyoshuData(handle, param, nyukinClRunListMap, jutoIcrnMap);
//						}
						
						// v23.00.00 DEL START
						// jutoSbtCd = getNullToStr(jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_JUTO_SBT_CD));
						// v23.00.00 DEL END
						
						// 自動入金、手動入金、預り金充当の場合のみ取り消しします。
						if(JACStrConst.JUTO_SBT_AUTO.equals(jutoSbtCd)
							|| JACStrConst.JUTO_SBT_MANUAL_NKIN.equals(jutoSbtCd)
							|| JACStrConst.JUTO_SBT_AZKIN_JUTO.equals(jutoSbtCd))
						{
							// 充当取消変更サービスを呼び出す
							execECH0201C010(handle, param, nyukinClRunListMap, jutoIcrnMap);
						}
					}
				}

				// 電子ファイル管理登録情報リストに設定
				CAANMsg caEfileInfo = new CAANMsg();
				caEfileInfo.setPrivate(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO, seikyKeiNo);
				caEfileInfo.setPrivate(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM, seikyYm);
				caEfileInfo.setPrivate(JCHNyukinClRunConstCC.MAP_KEY_JUTO_AMNT, nyukinAmnt);
				this.efileInfoList.add(caEfileInfo);
			}

			if (JCRUtilCommon.isNull(tokusokuNo))
			{
				// 督促が存在しない場合、新規登録する
				// 督促登録サービスを呼び出す
				String outTokusokuNo = execECH0231D010(handle, param, seikyKeiNo, String.valueOf(kskmAmntTotal));

				if (!JCRUtilCommon.isNull(outTokusokuNo))
				{
					// リストを逆順に読み、債権番号を取得し督促債権関連を登録
					int index = saikenNoList.size() - 1;
					for (int i = index; i >= 0; i--)
					{
						String inSaikenNo = saikenNoList.get(i);
						// 督促債権関連登録サービスを呼び出す
						execECH0341D010(handle, param, outTokusokuNo, inSaikenNo);
					}
					
					//OM-2014-0003523 ADD START
					// 登録された督促番号を退避する
					mapTokusokuNo = outTokusokuNo;
					// 督促を新規に登録した場合は、変更前督促ステータスは空文字列
					mapTokusokuStat = "";
					//OM-2014-0003523 ADD END
				}
			}
			else
			{
				// 督促が存在する場合、更新する
				// 督促変更サービスを呼び出す
				execECH0231C010(handle, param, tkskMap, String.valueOf(kskmAmntTotal));
				// 督促異動登録サービスを呼び出す
				execECH0361D010(handle, param, tkskMap);

				// 督促債権関連を取得
				List<HashMap<String, Object>> tkskSaikenKnrnList = execECH0341B010(handle, param, tokusokuNo);

				// 督促債権関連マップ(キーに債権番号を保持、値は未使用)
				HashMap<String, Object> tkskSaikenKnrnMap = new HashMap<String, Object>();

				for (HashMap<String, Object> obj : tkskSaikenKnrnList)
				{
					tkskSaikenKnrnMap.put((String)obj.get("saiken_no"), null);
				}

				// リストを逆順に読み、債権番号を取得し督促債権関連を登録
				int index = saikenNoList.size() - 1;
				for (int i = index; i >= 0; i--)
				{
					String inSaikenNo = saikenNoList.get(i);

					// 督促債権関連に登録されていない場合
					if (!tkskSaikenKnrnMap.containsKey(inSaikenNo))
					{
						// 督促債権関連登録サービスを呼び出す
						execECH0341D010(handle, param, tokusokuNo, inSaikenNo);
					}
				}
				
				//OM-2014-0003523 ADD START
				// 更新された督促番号を退避する
				mapTokusokuNo = tokusokuNo;
				// 変更前の督促ステータスを退避する
				ArrayList<HashMap<String, Object>> tmpList = (ArrayList<HashMap<String, Object>>)tkskMap.get(
						JCHNyukinClRunConstCC.MAP_KEY_ECH0231A010CBSMSG1LISTNEWEST);
				if (null != tmpList)
				{
					if (tmpList.size() > 0)
					{
						mapTokusokuStat = (String)tmpList.get(0).get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT);
					}
				}
				//OM-2014-0003523 ADD END
			}
			
			// v22.00.00 ANK-2610-00-00 ADD START
			// 料金指示書登録コンポーネント部品を実行
			execAddShijisho(handle, param, seikyKeiNo);
			// v22.00.00 ANK-2610-00-00 ADD END


			// 電子ファイル管理登録サービスを呼び出す
			execECC0041D010(handle, param);
			
			//OM-2014-0003523 ADD START
			// 督促番号、変更前督促ステータスを退避（入金取消の料金対応履歴のマップ形成で使用）
			HashMap<String, Object> prcTaioKirokTmpMap = (HashMap<String, Object>)param.getData(JCHNyukinClMappingConstCC.MAP_CC_ID_PRC_TAIO_KIROK_TMP);
			if (null != prcTaioKirokTmpMap)
			{
				// 督促番号
				prcTaioKirokTmpMap.put(JCHNyukinClMappingConstCC.MAP_KEY_TOKUSOKU_NO, mapTokusokuNo);
				// 督促ステータス
				prcTaioKirokTmpMap.put(JCHNyukinClMappingConstCC.MAP_KEY_TOKUSOKU_STAT, mapTokusokuStat);
			}
			//OM-2014-0003523 ADD END
		}

		return param;
	}

	// ▼▼ サービスインターフェイス実行処理 ▼▼
	/**
	 * 料金スケジュール定義一意照会サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param onlineYmd オンライン運用日
	 * @return String 当月債権年月
	 * @throws Exception 例外が発生した場合
	 */
	private String execECH0501A010(SessionHandle handle, IRequestParameterReadWrite param, String onlineYmd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501A010 = editInMsgECH0501A010(param, onlineYmd);
		for (CAANMsg msg : templateECH0501A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0501A010(result, param);
	}

	/**
	 * 入金取消債権変更サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param childMap マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0011C013(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> childMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0011C013 = editInMsgECH0011C013(param, childMap);
		for (CAANMsg msg : templateECH0011C013)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0011C013(result, param);
	}

	/**
	 * 金庫登録サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @param onlineYmd オンライン運用日
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0191D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap, String onlineYmd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0191D010 = editInMsgECH0191D010(param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);
		for (CAANMsg msg : templateECH0191D010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0191D010(result, param);
	}
	
	/**
	 * 金庫登録サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @param onlineYmd オンライン運用日
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0191D010_1(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap, String onlineYmd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0191D010 = editInMsgECH0191D010_1(param, nyukinClRunListMap, jutoIcrnMap, onlineYmd);
		for (CAANMsg msg : templateECH0191D010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0191D010(result, param);
	}

	/**
	 * 入金取消変更サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0111C010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0111C010 = editInMsgECH0111C010(param, nyukinClRunListMap, jutoIcrnMap);
		for (CAANMsg msg : templateECH0111C010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0201C010(result, param);
	}

	/**
	 * 充当取消変更サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0201C010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0201C010 = editInMsgECH0201C010(param, nyukinClRunListMap, jutoIcrnMap);
		for (CAANMsg msg : templateECH0201C010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0201C010(result, param);
	}

	/**
	 * 督促登録サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param seikyKeiNo 請求契約番号
	 * @param kskmAmntTotal 消込金額合計
	 * @return String 督促番号
	 * @throws Exception 例外が発生した場合
	 */
	private String execECH0231D010(SessionHandle handle, IRequestParameterReadWrite param, String seikyKeiNo, String kskmAmntTotal) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0231D010 = editInMsgECH0231D010(param, seikyKeiNo, kskmAmntTotal);
		for (CAANMsg msg : templateECH0231D010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0231D010(result, param);
	}

	/**
	 * 督促異動登録サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param childMap 督促マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0361D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> childMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0361D010 = editInMsgECH0361D010(param, childMap);
		for (CAANMsg msg : templateECH0361D010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0361D010(result, param);
	}

	/**
	 * 督促債権関連登録サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param inTokusokuNo 督促番号
	 * @param inSaikenNo 債権番号
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0341D010(SessionHandle handle, IRequestParameterReadWrite param, String inTokusokuNo, String inSaikenNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0341D010 = editInMsgECH0341D010(param, inTokusokuNo, inSaikenNo);
		for (CAANMsg msg : templateECH0341D010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0341D010(result, param);
	}

	/**
	 * 督促変更サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param kshkmAmntTotal 消込金額合計
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0231C010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap, String kshkmAmntTotal) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0231C010 = editInMsgECH0231C010(param, nyukinClRunListMap, kshkmAmntTotal);
		for (CAANMsg msg : templateECH0231C010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0231C010(result, param, nyukinClRunListMap);
	}

	/**
	 * 督促一意照会（最新）サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param tkskMap 督促情報マップ
	 * @param inSeikyKeiNo 請求契約番号
	 * @param onlineYmd オンライン運用日
	 * @return String 督促番号
	 * @throws Exception 例外が発生した場合
	 */
	private String execECH0231A010Newest(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> tkskMap, String inSeikyKeiNo, String onlineYmd)
			throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0231A010 = editInMsgECH0231A010(param, tkskMap, inSeikyKeiNo, onlineYmd);
		for (CAANMsg msg : templateECH0231A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0231A010Newest(result, param, tkskMap);
	}

	/**
	 * 領収一覧照会サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0311B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0311B010 = editInMsgECH0311B010(param, nyukinClRunListMap, jutoIcrnMap);
		for (CAANMsg msg : templateECH0311B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0311B010(handle, result, param, jutoIcrnMap);
	}

	/**
	 * 領収削除サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param eCH0311B010Map 充当一覧マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0311E010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> eCH0311B010Map) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0311E010 = editInMsgECH0311E010(param, nyukinClRunListMap, eCH0311B010Map);
		for (CAANMsg msg : templateECH0311E010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		scCall.run(paramMap, handle);

	}

	/**
	 * 電子ファイル管理登録サービスインタフェイス実行処理 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECC0041D010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		// 上りマッピング
		paramMap = editInMsgECC0041D010(param);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 下りマッピング
		editOutMsgECC0041D010(result, param);
	}

	/**
	 * 督促債権関連一覧照会サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param inTokusokuNo 督促番号
	 * @return 督促債権関連一覧リスト
	 * @throws Exception 例外が発生した場合
	 */
	private List<HashMap<String, Object>> execECH0341B010(SessionHandle handle, IRequestParameterReadWrite param, String inTokusokuNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0341B010 = editInMsgECH0341B010(param, inTokusokuNo);
		for (CAANMsg msg : templateECH0341B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0341B010(result, param);
	}

	// ▲▲ サービスインターフェイス実行処理 ▲▲

	// ▼▼ サービスインターフェイス用メッセージ設定処理 ▼▼
	/**
	 * 上りマッピング（料金スケジュール定義一意照会）
	 * @param param リクエストパラメータ
	 * @param onlineYmd オンライン運用日
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0501A010(IRequestParameterReadWrite param, String onlineYmd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0501A010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0501A010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0501A010,
				ECH0501A010CBSMsg.FUNC_CODE);

		// 機能コード
		template.set(ECH0501A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_4);

		// 請求処理日 → ＫＥＹ＿イベントコード
		template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, JACStrConst.EVENT_CD_SIKY_TRN_DAY);

		// null → ＫＥＹ＿イベント年月日
		template.setNull(ECH0501A010CBSMsg.KEY_EVENT_YMD);

		// オンライン運用日 → ＫＥＹ＿運用日
		template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, onlineYmd);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 督促一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param tkskMap 督促情報マップ
	 * @param inSeikyKeiNo 請求契約番号
	 * @param onlineYmd オンライン運用日
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0231A010(IRequestParameterReadWrite param, HashMap<String, Object> tkskMap, String inSeikyKeiNo, String onlineYmd)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0231A010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0231A010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231A010,
				ECH0231A010CBSMsg.FUNC_CODE);

		if (tkskMap != null)
		{
			// 機能コード
			template.set(ECH0231A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

			// ＫＥＹ＿督促番号 ← null
			template.setNull(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO);

			// ＫＥＹ＿請求契約番号 ← 入金取消実行マップ.請求契約番号
			template.set(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO, inSeikyKeiNo);

			// ＫＥＹ＿督促管理年月日 ← オンライン運用日
			template.set(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD, onlineYmd);

		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 入金取消債権変更サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param childMap マップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0011C013(IRequestParameterReadWrite param, HashMap<String, Object> childMap)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		ArrayList<HashMap<String, Object>> ECH0201B010CBSMsg1List = null;
		HashMap<String, Object> cbsMsgList = new HashMap<String, Object>();
		int kshkmAmntTotal = 0;

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0011C013CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0011C013CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0011C013,
				ECH0011C013CBSMsg.FUNC_CODE);

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

			// 債権番号 ← 入金取消実行マップ.債権番号
			template.set(ECH0011C013CBSMsg.SAIKEN_NO, (String) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_SAIKEN_NO));

			// 債権確定年月 ← 入金取消実行マップ.請求年月
			template.set(ECH0011C013CBSMsg.SAIKEN_FIX_YM, (String) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM));

			// 充当額＿業務機能識別コード ← 固定値：業務機能識別コード（入金取消＿充当額）
			template.set(ECH0011C013CBSMsg.JUTO_APL_KINO_CD, JACStrConst.WORK_KINO_SKBT_NYUKIN_CL_JUTO);

			// 未収額＿業務機能識別コード ← 固定値：未収額（業務機能識別コード）
			template.set(ECH0011C013CBSMsg.MISY_APL_KINO_CD, JACStrConst.WORK_KINO_MISYU_AMNT_NYUKIN_CL);

			ECH0201B010CBSMsg1List = (ArrayList<HashMap<String, Object>>) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0201B010CBSMSG1LIST);
			for (int j = 0; j < ECH0201B010CBSMsg1List.size(); j++)
			{
				cbsMsgList = (HashMap<String, Object>) ECH0201B010CBSMsg1List.get(j);

				if (cbsMsgList != null)
				{
					if ((String) cbsMsgList.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT) != null
							&& !JACStrConst.KARA_MOJI.equals((String) cbsMsgList.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT)))
					{
						// 消込額合計 ← 入金取消実行マップ.充当一覧明細リスト.消込額
						kshkmAmntTotal += Integer.parseInt((String) cbsMsgList.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT));
					}
				}
			}
			// 金額 ← 消込額合計
			template.set(ECH0011C013CBSMsg.AMNT, String.valueOf(kshkmAmntTotal));

			// 更新前債権更新年月日時分秒 ← 入金取消実行マップ.更新前債権更新年月日時分秒
			template.set(ECH0011C013CBSMsg.SAIKEN_UPD_DTM_AF, (String) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF));

			// 請求種別コード ← 入金取消実行マップ.請求種別コード
			template.set(ECH0011C013CBSMsg.SEIKY_SBT_CD, (String) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_SBT_CD));

			// 請求番号 ← 入金取消実行マップ.請求番号
			template.set(ECH0011C013CBSMsg.SEIKY_NO, (String) childMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_NO));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 金庫登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @param onlineYmd オンライン運用日
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0191D010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap, String onlineYmd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0191D010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0191D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0191D010,
				ECH0191D010CBSMsg.FUNC_CODE);

		if (jutoIcrnMap != null)
		{
			// 機能コード
			template.set(ECH0191D010CBSMsg.FUNC_CODE, nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY));

			// 金庫移動コード ← 固定値：金庫移動コード（金庫移動登録）
			template.set(ECH0191D010CBSMsg.KNK_MOVE_CD, JACStrConst.KINKO_IDO_ADD);

			// 請求契約番号 ← 入金取消実行マップ.請求契約番号
			template.set(ECH0191D010CBSMsg.SEIKY_KEI_NO, nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO));

			// 金庫移動年月日 ← オンライン運用日
			template.set(ECH0191D010CBSMsg.KNK_IDO_YMD, onlineYmd);

			// 移動元金庫番号 ← null
			template.setNull(ECH0191D010CBSMsg.IDOMOTO_KNK_NO);

			// 統合先金庫番号 ← null
			template.setNull(ECH0191D010CBSMsg.BNKT_KNK_NO);

			// 入金番号 ← 入金取消実行マップ.充当一覧明細リスト.入金番号
			template.set(ECH0191D010CBSMsg.NYUKIN_NO, jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO));

			// 金庫料金項目コード ← 固定値：料金項目コード（預り金）
			template.set(ECH0191D010CBSMsg.KNK_PRC_KMK_CD, JACStrConst.PRC_KMK_CD_AZUKIN);

			// 金庫金額 ← 入金取消実行マップ.充当一覧明細リスト.消込額
			template.set(ECH0191D010CBSMsg.KNK_AMNT, jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT));

			// 精算方法コード ← null
			template.setNull(ECH0191D010CBSMsg.SSN_WAY_CD);

			// 履歴データフラグ ← 固定値：金庫履歴データフラグ（カレントデータ）
			template.set(ECH0191D010CBSMsg.RIREKI_DATA_FLG, JACStrConst.KNK_RIREKI_DATA_FLG_CURRENT);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 金庫登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @param onlineYmd オンライン運用日
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0191D010_1(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap, String onlineYmd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0191D010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0191D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0191D010,
				ECH0191D010CBSMsg.FUNC_CODE);
		
		String funcCd = (String) nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY);
		
		if(JPCModelConstant.FUNC_CD_1.equals(funcCd))
		{
			funcCd = JPCModelConstant.FUNC_CD_3;
		}

		if (jutoIcrnMap != null)
		{
			// 機能コード
			template.set(ECH0191D010CBSMsg.FUNC_CODE, funcCd);

			// 金庫移動コード ← 固定値：金庫移動コード（金庫移動登録）
			template.set(ECH0191D010CBSMsg.KNK_MOVE_CD, JACStrConst.KINKO_IDO_ADD);

			// 請求契約番号 ← 入金取消実行マップ.請求契約番号
			template.set(ECH0191D010CBSMsg.SEIKY_KEI_NO, nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO));

			// 金庫移動年月日 ← オンライン運用日
			template.set(ECH0191D010CBSMsg.KNK_IDO_YMD, onlineYmd);

			// 移動元金庫番号 ← null
			template.set(ECH0191D010CBSMsg.IDOMOTO_KNK_NO, jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_KNK_NO));

			// 統合先金庫番号 ← null
			template.setNull(ECH0191D010CBSMsg.BNKT_KNK_NO);

			// 入金番号 ← 入金取消実行マップ.充当一覧明細リスト.入金番号
			template.set(ECH0191D010CBSMsg.NYUKIN_NO, jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO));

			// 金庫料金項目コード ← 固定値：料金項目コード（預り金）
			template.set(ECH0191D010CBSMsg.KNK_PRC_KMK_CD, JACStrConst.PRC_KMK_CD_AZUKIN);

			// 金庫金額 ← 入金取消実行マップ.充当一覧明細リスト.消込額
			template.set(ECH0191D010CBSMsg.KNK_AMNT, jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_KSHKM_AMNT));

			// 精算方法コード ← null
			template.setNull(ECH0191D010CBSMsg.SSN_WAY_CD);

			// 履歴データフラグ ← 固定値：金庫履歴データフラグ（カレントデータ）
			template.set(ECH0191D010CBSMsg.RIREKI_DATA_FLG, JACStrConst.KNK_RIREKI_DATA_FLG_CURRENT);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 入金取消変更サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0111C010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0111C010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0111C010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0111C010,
				ECH0111C010CBSMsg.FUNC_CODE);

		if (jutoIcrnMap != null)
		{
			// 機能コード
			template.set(ECH0111C010CBSMsg.FUNC_CODE, nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY));

			// 入金番号 ← 入金取消実行マップ.充当一覧明細リスト.入金番号
			template.set(ECH0111C010CBSMsg.NYUKIN_NO, (String) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO));

			// 入金ステータス ← "090"
			template.set(ECH0111C010CBSMsg.NYUKIN_STAT, JACStrConst.NYUKIN_STAT_CD_NYUKIN_CL);

			// 入金取消年月日 ← オンライン運用日付
			template.set(ECH0111C010CBSMsg.NYUKIN_CL_YMD, JCCBPCommon.getOnlineOpeDate(null));

			// 入金取消理由コード ← "9"
			template.set(ECH0111C010CBSMsg.NYUKIN_CLRE_CD, JACStrConst.NKIN_CL_RSN_CD_OTHER);

			// 更新前更新年月日時分秒 ← 入金取消実行マップ.充当一覧明細リスト.更新前入金更新年月日時分秒
			template.set(ECH0111C010CBSMsg.UPD_DTM_AF, (String) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_UPD_DTM));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 充当取消変更サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0201C010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0201C010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0201C010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0201C010,
				ECH0201C010CBSMsg.FUNC_CODE);

		if (jutoIcrnMap != null)
		{
			// 機能コード
			template.set(ECH0201C010CBSMsg.FUNC_CODE, nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY));

			// 充当番号 ← 入金取消実行マップ.充当一覧明細リスト.充当番号
			template.set(ECH0201C010CBSMsg.JUTO_NO, (String) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_JUTO_NO));

			// 更新前充当更新年月日時分秒 ← 入金取消実行マップ.充当一覧明細リスト.更新前充当更新年月日時分秒
			template.set(ECH0201C010CBSMsg.JUTO_UPD_DTM_BF, (String) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_JUTO_UPD_DTM));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 督促登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param seikyKeiNo 請求契約番号
	 * @param kshkmAmntTotal 消込金額合計（未納分のみ）
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0231D010(IRequestParameterReadWrite param, String seikyKeiNo, String kshkmAmntTotal)
		throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0231D010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0231D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231D010,
				ECH0231D010CBSMsg.FUNC_CODE);

		// 業務データ設定
		HashMap<String, Object> inMap = this.getMap(param);

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

		// 督促ステータス ← 固定値：督促ステータス（督促保留）
		template.set(ECH0231D010CBSMsg.TOKUSOKU_STAT, JACStrConst.TOKUSOKU_STAT_BOGO);

		// 請求契約番号 ← 入金取消実行マップ.請求契約番号
		template.set(ECH0231D010CBSMsg.SEIKY_KEI_NO, seikyKeiNo);

		// 督促金額 ← 消込額合計
		template.set(ECH0231D010CBSMsg.TOKUSOKU_AMNT, String.valueOf(kshkmAmntTotal));

		// 督促異動イベントコード ← 固定値：督促異動イベントコード（入金取消画面）
		template.set(ECH0231D010CBSMsg.TOKUSOKU_IDO_EVENT_CD, JACStrConst.TKSKIDO_EVCD_NYKIN_CLR_DISP);

		// 支払約束年月日 ← null
		template.setNull(ECH0231D010CBSMsg.PAY_YAKUSOKU_YMD);

		// 支払約束履行判定年月日 ← null
		template.setNull(ECH0231D010CBSMsg.PAY_YAKUSOKU_RIKO_JDG_YMD);

		// 債権ステータス ← null
		template.setNull(ECH0231D010CBSMsg.SAIKEN_STAT);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 督促異動登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param onlineYmd オンライン運用日
	 * @param tokusokuNo 督促番号
	 * @param addFlg 追加フラグ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0361D010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0361D010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0361D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0361D010,
				ECH0361D010CBSMsg.FUNC_CODE);

		if (nyukinClRunListMap != null)
		{
			// 業務データ設定
			HashMap<String, Object> inMap = this.getMap(param);

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

			// 呼び出し元(nyukinCl)により検索済であるため1件は存在する
			List<HashMap<String, Object>> ech0231A010CBSMsg1ListNewest =
				(ArrayList<HashMap<String, Object>>) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0231A010CBSMSG1LISTNEWEST);

			HashMap<String, Object> cbsMsgListECH0231A010 = ech0231A010CBSMsg1ListNewest.get(0);

			// 督促番号 ← 督促一意照会マップ.督促番号
			template.set(ECH0361D010CBSMsg.TOKUSOKU_NO, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO));

			// 督促異動イベントコード
			template.set(ECH0361D010CBSMsg.TOKUSOKU_IDO_EVENT_CD, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD));

			// 督促異動年月日
			template.set(ECH0361D010CBSMsg.TOKUSOKU_IDO_YMD, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_YMD));

			// 督促ステータス
			template.set(ECH0361D010CBSMsg.TOKUSOKU_STAT, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT));

			// 督促金額
			template.set(ECH0361D010CBSMsg.TOKUSOKU_AMNT, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_AMNT));

			// 支払約束受付年月日 ← null
			template.set(ECH0361D010CBSMsg.PAY_YAKUSOKU_UK_YMD, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_UK_YMD));

			// 支払約束年月日 ← null
			template.set(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD));

			// 変更支払約束年月日 ← null
			template.set(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_AF, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD));

			// 支払約束履行判定年月日 ← null
			template.set(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD));

			// 変更支払約束履行判定年月日 ← null
			template.set(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF, cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 督促債権関連登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param tokusokuSaikenKnrnAddList 督促債権関連登録リスト
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0341D010(IRequestParameterReadWrite param, String tokusokuNo, String saikenNo) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0341D010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0341D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0341D010,
				ECH0341D010CBSMsg.FUNC_CODE);

		// 業務データ設定
		HashMap<String, Object> inMap = this.getMap(param);

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

		// 督促番号 ← 督促一意照会マップ
		template.set(ECH0341D010CBSMsg.TOKUSOKU_NO, tokusokuNo);

		// 債権番号 ← 入金取消実行マップ.債権番号
		template.set(ECH0341D010CBSMsg.SAIKEN_NO, saikenNo);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 督促変更サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param kshkmAmntTotal 消込金額合計
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0231C010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap, String kshkmAmntTotal)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		ArrayList<HashMap<String, Object>> ech0231A010CBSMsg1ListNewest = null;
		HashMap<String, Object> cbsMsgListECH0231A010 = new HashMap<String, Object>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0231C010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0231C010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231C010,
				ECH0231C010CBSMsg.FUNC_CODE);

		if (nyukinClRunListMap != null)
		{
			// 業務データ設定
			HashMap<String, Object> inMap = this.getMap(param);

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

			// 督促ステータス ← null
			template.setNull(ECH0231C010CBSMsg.TOKUSOKU_STAT);

			// 督促一意照会の結果を取得
			ech0231A010CBSMsg1ListNewest =
				(ArrayList<HashMap<String, Object>>) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0231A010CBSMSG1LISTNEWEST);

			if (ech0231A010CBSMsg1ListNewest != null && ech0231A010CBSMsg1ListNewest.size() > 0)
			{
				cbsMsgListECH0231A010 = ech0231A010CBSMsg1ListNewest.get(0);
				// 督促番号 ← 督促一意照会マップ.督促番号
				template.set(ECH0231C010CBSMsg.TOKUSOKU_NO, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO));
				// 更新前督促金額 ← 督促一意照会マップ.督促金額
				template.set(ECH0231C010CBSMsg.TOKUSOKU_AMNT_BF, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_AMNT));
				// 更新前督促更新年月日時分秒 ← 督促一意照会マップ.更新年月日時分秒
				template.set(ECH0231C010CBSMsg.TOKUSOKU_UPD_DTM_AF, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM));
				// 督促管理終了年月日 ← 督促一意照会マップ.督促管理終了年月日
				template.set(ECH0231C010CBSMsg.TOKUSOKU_ENDYMD, JACStrConst.MAX_DATE);
				// 督促異動年月日 ← 運用日付
				template.set(ECH0231C010CBSMsg.TOKUSOKU_IDO_YMD, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));
				// 支払約束受付年月日 ← 督促一意照会マップ.支払約束受付年月日
				template.set(ECH0231C010CBSMsg.PAY_YAKUSOKU_UK_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_UK_YMD));
				// 支払約束年月日 ← 督促一意照会マップ.支払約束年月日
				template.set(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD));
				// 変更支払約束年月日 ← 督促一意照会マップ.支払約束受付年月日
				template.set(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_AF, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD));
				// 支払約束履行判定年月日 ← 督促一意照会マップ.支払約束履行判定年月日
				template.set(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD,
						(String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD));
				// 変更支払約束履行判定年月日 ← 督促一意照会マップ.支払約束履行判定年月日
				template.set(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF,
						(String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD));
				// 利用停止解除依頼年月日 ← 督促一意照会マップ.利用停止解除依頼年月日
				template.set(ECH0231C010CBSMsg.USE_STP_RLS_REQ_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_RLS_REQ_YMD));
				// 利用停止依頼年月日 ← 督促一意照会マップ.利用停止依頼年月日
				template.set(ECH0231C010CBSMsg.USE_STP_REQ_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_REQ_YMD));
				// 強制解約依頼年月日 ← 督促一意照会マップ.強制解約依頼年月日
				template.set(ECH0231C010CBSMsg.KYOSEI_DSL_REQ_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_KYOSEI_DSL_REQ_YMD));
				// 債権回収委託会社委託処理年月日日 ← 督促一意照会マップ.債権回収委託会社委託処理年月日
				template.set(ECH0231C010CBSMsg.SKNKSITKCM_ITAKU_TRAN_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_SKNKSITKCM_ITAKU_TRAN_YMD));
				// 貸倒処理年月日 ← 督促一意照会マップ.貸倒処理年月日
				template.set(ECH0231C010CBSMsg.KASHID_TRAN_YMD, (String) cbsMsgListECH0231A010.get(JCHNyukinClRunConstCC.MAP_KEY_KASHID_TRAN_YMD));
			}

			// 異動金額 ← 消込額合計
			template.set(ECH0231C010CBSMsg.IDO_AMNT, kshkmAmntTotal);

			// 督促異動イベントコード ← 固定値：督促異動イベントコード（入金取消画面）
			template.set(ECH0231C010CBSMsg.TOKUSOKU_IDO_EVNT_CD, JACStrConst.TKSKIDO_EVCD_NYKIN_CLR_DISP);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 領収一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0311B010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0311B010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0311B010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0311B010,
				ECH0311B010CBSMsg.FUNC_CODE);

		if (jutoIcrnMap != null)
		{
			// 機能コード
//			template.set(ECH0311B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
			template.set(ECH0311B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

			// ＫＥＹ＿請求契約番号 ← 入金取消実行マップ.入金取消実行マップリスト.請求契約番号
			template.set(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO, (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO));
			// ＫＥＹ＿債権年月（開始） ← 入金取消実行マップ.入金取消実行マップリスト.請求年月
			template.set(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA, (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM));
			// ＫＥＹ＿債権年月（終了） ← 入金取消実行マップ.入金取消実行マップリスト.請求年月
			template.set(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END, (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM));
//			// ＫＥＹ＿入金番号 ← 入金取消実行マップ.充当一覧明細リスト.入金番号
//			template.set(ECH0311B010CBSMsg.KEY_NYUKIN_NO, (String) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_NYUKIN_NO));
			// ＫＥＹ＿請求種別コード ← 入金取消実行マップ.充当一覧明細リスト.請求種別コード
			template.set(ECH0311B010CBSMsg.KEY_SEIKY_SBT_CD,  (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_SBT_CD));
			
			String seikySbtCd = JPCUtilCommon.Rtrim((String)nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_SBT_CD));
			// 定例請求の場合
			if(JACStrConst.SIKYSHBTS_TEIGK_SEIKY.equals(seikySbtCd))
			{
				template.setNull(ECH0311B010CBSMsg.KEY_SAIKEN_NO);
			}
			else
			{
				// ＫＥＹ＿債権番号 ← 入金取消実行マップ.充当一覧明細リスト.債権番号
				template.set(ECH0311B010CBSMsg.KEY_SAIKEN_NO, (String) nyukinClRunListMap.get(JCHNyukinClRunConstCC.MAP_KEY_SAIKEN_NO));
			}
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 入金取消変更サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param eCH0311B010Map 充当一覧マップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0311E010(IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> eCH0311B010Map) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0311E010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0311E010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0311E010,
				ECH0311E010CBSMsg.FUNC_CODE);
		
//		if (jutoIcrnMap != null)
//		{
//			// 機能コード
//			template.set(ECH0311E010CBSMsg.FUNC_CODE, nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY));
//
//			eCH0311B010CBSMsg1List = (ArrayList<HashMap<String, Object>>) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0311B010CBSMSG1LIST);
//			if (eCH0311B010CBSMsg1List != null)
//			{
//
//				for (HashMap<String, Object>cbsMsgList: eCH0311B010CBSMsg1List)
//				{
//					if (cbsMsgList != null)
//					{
//						// 領収番号 ← 入金取消実行マップ.充当一覧明細リスト.入金一意照会マップ.領収番号
//						template.set(ECH0311E010CBSMsg.RECEIPT_NO, (String) cbsMsgList.get(ECH0311B010CBSMsg1List.RECEIPT_NO));
//						// 更新前更新年月日時分秒 ← 入金取消実行マップ.充当一覧明細リスト.入金一意照会マップ.更新年月日時分秒
//						template.set(ECH0311E010CBSMsg.UPD_DTM_BF, (String) cbsMsgList.get(ECH0311B010CBSMsg1List.UPD_DTM));
//					}
//					templateList.add(template);
//				}
//			}
//		}
		
		
		// 機能コード
		template.set(ECH0311E010CBSMsg.FUNC_CODE, nyukinClRunListMap.get(JCMConstants.FUNC_CODE_KEY));

		// 領収番号 ← 入金取消実行マップ.充当一覧明細リスト.入金一意照会マップ.領収番号
		template.set(ECH0311E010CBSMsg.RECEIPT_NO, (String) eCH0311B010Map.get(ECH0311B010CBSMsg1List.RECEIPT_NO));
		// 更新前更新年月日時分秒 ← 入金取消実行マップ.充当一覧明細リスト.入金一意照会マップ.更新年月日時分秒
		template.set(ECH0311E010CBSMsg.UPD_DTM_BF, (String) eCH0311B010Map.get(ECH0311B010CBSMsg1List.UPD_DTM));
		
		templateList.add(template);


		return templateList;
	}

	/**
	 * 電子ファイル管理登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECC0041D010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		HashMap<String, Object> inMap = this.getMap(param);

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECC0041D010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECC0041D010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECC0041D010, ECC0041D010CBSMsg.FUNC_CODE);

		// 電子ファイル登録内容生成処理
		byte[] binaryFile = createEfile();

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECC0041D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// システムコード
		template.set(ECC0041D010CBSMsg.SYS_CD, JACStrConst.SYS_CD_CH);

		// ファイルコード
		template.set(ECC0041D010CBSMsg.FILE_CD, JACStrConst.EFILE_KANRI_FILE_CD);

		// ファイル削除年月
		template.set(ECC0041D010CBSMsg.FILE_DEL_YMD, JACStrConst.MAX_DATE);

		// 電子ファイル
		template.set(ECC0041D010CBSMsg.EFILE, binaryFile); 

		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 督促債権関連一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param inTokusokuNo 督促番号
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0341B010(IRequestParameterReadWrite param, String inTokusokuNo)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇テンプレート生成 */
		CAANMsg template = new CAANMsg(ECH0341B010CBSMsg.class.getName());

		this.setTemplateCommonItem(param, template, ECH0341B010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0341B010,
				ECH0341B010CBSMsg.FUNC_CODE);

		// 機能コード
		template.set(ECH0341B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// ＫＥＹ＿督促番号 ← 督促番号
		template.set(ECH0341B010CBSMsg.KEY_TOKUSOKU_NO, inTokusokuNo);

		templateList.add(template);

		return templateList;
	}

	// ▲▲ サービスインターフェイス用メッセージ設定処理 ▲▲

	// ▼▼ サービスインターフェイス用メッセージ取得処理 ▼▼
	/**
	 * 料金スケジュール定義一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return String 当月債権年月
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0501A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>) param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);

		// 返却用債権年月
		String saikenYm = "";

		CAANMsg childTemplate;
		CAANMsg parentTemplate = templates[0];

		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			childTemplate = templateArray[0];
			HashMap<String, Object> tmpMap = new HashMap<String, Object>();
			ArrayList<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();

			// イベントコード
			if (childTemplate.isNull(ECH0501A010CBSMsg1List.EVENT_CD))
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD, new String());
			}
			else
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD, childTemplate.getString(ECH0501A010CBSMsg1List.EVENT_CD));
			}

			// イベントコード名称
			if (childTemplate.isNull(ECH0501A010CBSMsg1List.EVENT_CD_NM))
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD_NM, new String());
			}
			else
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD_NM, childTemplate.getString(ECH0501A010CBSMsg1List.EVENT_CD_NM));
			}

			// イベントコード略称
			if (childTemplate.isNull(ECH0501A010CBSMsg1List.EVENT_CD_ALI))
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD_ALI, new String());
			}
			else
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_CD_ALI, childTemplate.getString(ECH0501A010CBSMsg1List.EVENT_CD_ALI));
			}

			// イベント年月日
			if (childTemplate.isNull(ECH0501A010CBSMsg1List.EVENT_YMD))
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_YMD, new String());
			}
			else
			{
				tmpMap.put(ECH0501A010CBSMsg1List.EVENT_YMD, childTemplate.getString(ECH0501A010CBSMsg1List.EVENT_YMD));
			}

			// 請求年月
			if (childTemplate.isNull(ECH0501A010CBSMsg1List.SEIKY_YM))
			{
				tmpMap.put(ECH0501A010CBSMsg1List.SEIKY_YM, new String());
			}
			else
			{
				saikenYm = childTemplate.getString(ECH0501A010CBSMsg1List.SEIKY_YM);
				tmpMap.put(ECH0501A010CBSMsg1List.SEIKY_YM, saikenYm);
			}

			tmpList.add(tmpMap);
			dataMap.put(JCHNyukinClRunConstCC.MAP_TOGT_SAIKEN_YM, tmpList);
		}

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return saikenYm;
	}

	/**
	 * 入金取消債権変更サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0011C013(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	/**
	 * 金庫登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0191D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	/**
	 * 充当取消変更サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0201C010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	/**
	 * 督促登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param childMap マップ
	 * @return String 督促番号
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0231D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);

		// 返却用督促番号
		String tokusokuNo = new String();

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		CAANMsg parentTemplate = templates[0];

		HashMap<String, Object> tmpMap = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();

		// 督促番号
		if (parentTemplate.isNull(ECH0231D010CBSMsg.TOKUSOKU_NO))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO, parentTemplate.getString(ECH0231D010CBSMsg.TOKUSOKU_NO));
			tokusokuNo = parentTemplate.getString(ECH0231D010CBSMsg.TOKUSOKU_NO);
		}

		// 督促管理開始年月日
		if (parentTemplate.isNull(ECH0231D010CBSMsg.TOKUSOKU_STAYMD))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAYMD, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAYMD, parentTemplate.getString(ECH0231D010CBSMsg.TOKUSOKU_STAYMD));
		}

		// 督促管理終了年月日
		if (parentTemplate.isNull(ECH0231D010CBSMsg.TOKUSOKU_ENDYMD))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_ENDYMD, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_ENDYMD, parentTemplate.getString(ECH0231D010CBSMsg.TOKUSOKU_ENDYMD));
		}

		// 督促異動年月日
		if (parentTemplate.isNull(ECH0231D010CBSMsg.TOKUSOKU_IDO_YMD))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_YMD, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_YMD, parentTemplate.getString(ECH0231D010CBSMsg.TOKUSOKU_IDO_YMD));
		}

		// 登録年月日時分秒
		if (parentTemplate.isNull(ECH0231D010CBSMsg.ADD_DTM))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_ADD_DTM, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_ADD_DTM, parentTemplate.getString(ECH0231D010CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (parentTemplate.isNull(ECH0231D010CBSMsg.ADD_OPEACNT))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_ADD_OPEACNT, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_ADD_OPEACNT, parentTemplate.getString(ECH0231D010CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (parentTemplate.isNull(ECH0231D010CBSMsg.UPD_DTM))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, parentTemplate.getString(ECH0231D010CBSMsg.UPD_DTM));
		}

		// 更新オペレータアカウント
		if (parentTemplate.isNull(ECH0231D010CBSMsg.UPD_OPEACNT))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_OPEACNT, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_OPEACNT, parentTemplate.getString(ECH0231D010CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (parentTemplate.isNull(ECH0231D010CBSMsg.MK_FLG))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_MK_FLG, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_MK_FLG, parentTemplate.getString(ECH0231D010CBSMsg.MK_FLG));
		}

		tmpList.add(tmpMap);
		inMap.put(JCHNyukinClRunConstCC.MAP_KEY_ECH0231D010CBSMSG1LIST, tmpList);

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return tokusokuNo;
	}

	/**
	 * 督促異動登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0361D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	/**
	 * 督促変更サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param childMap マップ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0231C010(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap<String, Object> childMap)
			throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		CAANMsg parentTemplate = templates[0];

		HashMap<String, Object> tmpMap = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();

		// 出力用督促ステータス
		if (parentTemplate.isNull(ECH0231C010CBSMsg.TOKUSOKU_STAT_OUT))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_OUT, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_OUT, parentTemplate.getString(ECH0231C010CBSMsg.TOKUSOKU_STAT_OUT));
		}

		// 更新年月日時分秒
		if (parentTemplate.isNull(ECH0231C010CBSMsg.UPD_DTM))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, parentTemplate.getString(ECH0231C010CBSMsg.UPD_DTM));
		}

		// 更新オペレータアカウント
		if (parentTemplate.isNull(ECH0231C010CBSMsg.UPD_OPEACNT))
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_OPEACNT, new String());
		}
		else
		{
			tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_OPEACNT, parentTemplate.getString(ECH0231C010CBSMsg.UPD_OPEACNT));
		}

		tmpList.add(tmpMap);
		childMap.put(JCHNyukinClRunConstCC.MAP_KEY_ECH0231C010CBSMSG1LIST, tmpList);

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	/**
	 * 督促一意照会（最新）サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param childMap マップ
	 * @return 出力用督促番号
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0231A010Newest(Map<?, ?> msgList, IRequestParameterReadWrite param,
			HashMap<String, Object> childMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		CAANMsg childTemplate;
		CAANMsg parentTemplate = templates[0];

		HashMap<String, Object> tmpMap = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();

		// 出力用督促番号
		String outTokusokuNo = "";

		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			childTemplate = templateArray[0];

			// 督促番号
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_NO))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO, new String());
			}
			else
			{
				outTokusokuNo = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_NO);
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_NO, outTokusokuNo);
			}

			// 督促ステータス
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT));
			}

			// 督促ステータス名称
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_NM))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_NM, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_NM, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_NM));
			}

			// 督促ステータス略称
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_ALI))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_ALI, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAT_ALI, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_ALI));
			}

			// 請求契約番号
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.SEIKY_KEI_NO))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO, childTemplate.getString(ECH0231A010CBSMsg1List.SEIKY_KEI_NO));
			}

			// 督促金額
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_AMNT))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_AMNT, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_AMNT, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_AMNT));
			}

			// 督促管理開始年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAYMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAYMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_STAYMD, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAYMD));
			}

			// 督促管理終了年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_ENDYMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_ENDYMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_ENDYMD, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_ENDYMD));
			}

			// 督促異動年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_YMD));
			}

			// 督促異動イベントコード
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD));
			}

			// 督促異動イベントコード名称
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD_NM))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD_NM, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD_NM, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD_NM));
			}

			// 督促異動イベントコード略称
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD_ALI))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD_ALI, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_TOKUSOKU_IDO_EVNT_CD_ALI, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_IDO_EVNT_CD_ALI));
			}

			// 支払約束受付年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_UK_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_UK_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_UK_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_UK_YMD));
			}

			// 支払約束年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_YMD));
			}

			// 支払約束履行判定日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_RIKO_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_YAKUSOKU_RIKO_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_RIKO_YMD));
			}

			// 利用停止依頼年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.USE_STP_REQ_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_REQ_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_REQ_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.USE_STP_REQ_YMD));
			}

			// 利用停止解除依頼年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.USE_STP_RLS_REQ_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_RLS_REQ_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_PAY_USE_STP_RLS_REQ_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.USE_STP_RLS_REQ_YMD));
			}

			// 強制解約依頼年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.KYOSEI_DSL_REQ_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_KYOSEI_DSL_REQ_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_KYOSEI_DSL_REQ_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.KYOSEI_DSL_REQ_YMD));
			}

			// 債権回収委託会社委託処理年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.SKNKSITKCM_ITAKU_TRAN_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_SKNKSITKCM_ITAKU_TRAN_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_SKNKSITKCM_ITAKU_TRAN_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.SKNKSITKCM_ITAKU_TRAN_YMD));
			}

			// 貸倒処理年月日
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.KASHID_TRAN_YMD))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_KASHID_TRAN_YMD, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_KASHID_TRAN_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.KASHID_TRAN_YMD));
			}

			// 更新年月日時分秒
			if (childTemplate.isNull(ECH0231A010CBSMsg1List.UPD_DTM))
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, new String());
			}
			else
			{
				tmpMap.put(JCHNyukinClRunConstCC.MAP_KEY_UPD_DTM, childTemplate.getString(ECH0231A010CBSMsg1List.UPD_DTM));
			}

			tmpList.add(tmpMap);
			childMap.put(JCHNyukinClRunConstCC.MAP_KEY_ECH0231A010CBSMSG1LISTNEWEST, tmpList);
		}

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return outTokusokuNo;
	}

	/**
	 * 領収一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void editOutMsgECH0311B010(SessionHandle handle, 
										Map<?, ?> msgList, 
										IRequestParameterReadWrite param, 
										HashMap<String, Object> jutoIcrnMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>) param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(JCHNyukinClRunConstCC.MAP_CC_ID, dataMap);
		}

		CAANMsg parentTemplate = templates[0];
		
		ArrayList<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();
		
		String jutoNo = "";
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0311B010CBSMsg.ECH0311B010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			
			int j = 0;
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];
				
				// 充当番号が設定されている場合、充当種別を判別し前受金充当の場合、削除対象にしない。
				jutoNo = getNullToStr(childTemplate.getString(ECH0311B010CBSMsg1List.JUTO_NO));
				if (!"".equals(jutoNo))
				{
					if(isMaeUkeKinJuto(handle, param, jutoNo))
					{
						continue;
					}
				}
				
				if ( j >= tmpList.size()) {
					tmpList.add(new HashMap());
				}
				
				HashMap<String, Object> tmpMap = (HashMap)tmpList.get(j);

				
				// 領収番号
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_NO))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_NO, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_NO, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_NO));
				}
	
				// 入金番号
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_NO))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_NO, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_NO, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_NO));
				}
	
				// 入金処理年月日
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_TRN_YMD))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_TRN_YMD, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_TRN_YMD, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_TRN_YMD));
				}
	
				// 入金処理時分秒
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_TRN_HMS))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_TRN_HMS, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_TRN_HMS, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_TRN_HMS));
				}
	
				// 領収年月日
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_YMD))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_YMD, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_YMD, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_YMD));
				}
	
				// 領収時分秒
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_HMS))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_HMS, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.RECEIPT_HMS, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_HMS));
				}
	
				// 入金経路コード
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD));
				}
	
				// 入金経路コード名称
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM));
				}
	
				// 入金経路コード略称
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_ALI))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_ALI, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_ALI, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_ALI));
				}
	
				// 債権年月
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.SAIKEN_YM))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SAIKEN_YM, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SAIKEN_YM, childTemplate.getString(ECH0311B010CBSMsg1List.SAIKEN_YM));
				}
	
				// 請求方法コード
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.SEIKY_WAY_CD))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD, childTemplate.getString(ECH0311B010CBSMsg1List.SEIKY_WAY_CD));
				}
	
				// 請求方法コード名称
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_NM))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_NM, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_NM, childTemplate.getString(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_NM));
				}
	
				// 請求方法コード略称
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_ALI))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_ALI, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_ALI, childTemplate.getString(ECH0311B010CBSMsg1List.SEIKY_WAY_CD_ALI));
				}
	
				// 充当金額
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.JUTO_AMNT))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.JUTO_AMNT, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.JUTO_AMNT, childTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT));
				}
	
				// 充当金額うち消費税額
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.JUTO_AMNT_UCHI_STAX))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.JUTO_AMNT_UCHI_STAX, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.JUTO_AMNT_UCHI_STAX, childTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT_UCHI_STAX));
				}
	
				// 更新前更新年月日時分秒
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.UPD_DTM))
				{
					tmpMap.put(ECH0311B010CBSMsg1List.UPD_DTM, new String());
				}
				else
				{
					tmpMap.put(ECH0311B010CBSMsg1List.UPD_DTM, childTemplate.getString(ECH0311B010CBSMsg1List.UPD_DTM));
				}

				j++;
			}
			
			jutoIcrnMap.put(JCHNyukinClRunConstCC.MAP_KEY_ECH0311B010CBSMSG1LIST, tmpList);
		}

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

	}

	/**
	 * 督促債権関連一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @return 督促債権関連一覧リスト
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private List<HashMap<String, Object>> editOutMsgECH0341B010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>) param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(JCHNyukinClRunConstCC.MAP_CC_ID, dataMap);
		}

		CAANMsg parentTemplate = templates[0];
		List<HashMap<String, Object>> tmpList = new ArrayList<HashMap<String, Object>>();

		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0341B010CBSMsg.ECH0341B010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				HashMap<String, Object> tmpMap = new HashMap<String, Object>();

				// 督促番号
				if (childTemplate.isNull(ECH0341B010CBSMsg1List.TOKUSOKU_NO))
				{
					tmpMap.put(ECH0341B010CBSMsg1List.TOKUSOKU_NO, new String());
				}
				else
				{
					tmpMap.put(ECH0341B010CBSMsg1List.TOKUSOKU_NO, childTemplate.getString(ECH0341B010CBSMsg1List.TOKUSOKU_NO));
				}

				// 債権番号
				if (childTemplate.isNull(ECH0341B010CBSMsg1List.SAIKEN_NO))
				{
					tmpMap.put(ECH0341B010CBSMsg1List.SAIKEN_NO, new String());
				}
				else
				{
					tmpMap.put(ECH0341B010CBSMsg1List.SAIKEN_NO, childTemplate.getString(ECH0341B010CBSMsg1List.SAIKEN_NO));
				}

				tmpList.add(tmpMap);
			}

			dataMap.put(JCHNyukinClRunConstCC.MAP_KEY_ECH0341B010CBSMSG1LIST, tmpList);
		}

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return tmpList;
	}

	/**
	 * 電子ファイル管理登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECC0041D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];

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

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

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);
		if (dataMap == null) {
			dataMap = new HashMap();
			param.setData(JCHNyukinClRunConstCC.MAP_CC_ID, dataMap);
		}
		// 電子ファイル管理登録マップ.電子ファイル管理番号 ← 電子ファイル管理番号
		if (parentTemplate.isNull(ECC0041D010CBSMsg.EFILE_KANRI_NO)) {
			dataMap.put(JCHNyukinClRunConstCC.MAP_KEY_EFILE_KANRI_NO, new String());
		} else {
			dataMap.put(JCHNyukinClRunConstCC.MAP_KEY_EFILE_KANRI_NO, parentTemplate.getString(ECC0041D010CBSMsg.EFILE_KANRI_NO));
		}

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}
		
		return param;
	}

	/**
	 * 督促債権関連登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0341D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String) param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
		}

		return param;
	}

	// ▲▲ サービスインターフェイス用メッセージ取得処理 ▲▲

	// ▼▼ エラー情報マッピング処理 ▼▼
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{

		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = { template };
			if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231A010.equals(templateId))
			{
				// 督促一意照会
				editErrorInfoECH0231A010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0501A010.equals(templateId))
			{
				// 料金スケジュール定義一意照会
				editErrorInfoECH0501A010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0341B010.equals(templateId))
			{
				// 督促債権関連一覧照会
				editErrorInfoECH0341B010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0011C013.equals(templateId))
			{
				// 入金取消債権変更
				editErrorInfoECH0011C013(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0191D010.equals(templateId))
			{
				// 金庫登録
				editErrorInfoECH0191D010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0111C010.equals(templateId))
			{
				// 入金取消変更
				editErrorInfoECH0111C010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0201C010.equals(templateId))
			{
				// 充当取消変更
				editErrorInfoECH0201C010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231D010.equals(templateId))
			{
				// 督促登録
				editErrorInfoECH0231D010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0361D010.equals(templateId))
			{
				// 督促異動登録
				editErrorInfoECH0361D010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0341D010.equals(templateId))
			{
				// 督促債権関連登録
				editErrorInfoECH0341D010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0231C010.equals(templateId))
			{
				// 督促変更
				editErrorInfoECH0231C010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECC0041D010.equals(templateId))
			{
				// 電子ファイル管理登録
				editErrorInfoECC0041D010(param, workTemplates, returnCode);
			}
			else if (JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0201B010.equals(templateId))
			{
				// 充当一覧照会
				editErrorInfoECH0201B010(param, workTemplates, returnCode);
			}
			
			
		}

		return param;
	}

	/**
	 * 督促一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0231A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0231A010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// ＫＥＹ＿督促番号 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR, template.getString(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR));
			}
		}
		// ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// ＫＥＹ＿督促管理年月日 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD_ERR, template.getString(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD_ERR));
			}
		}
		// 督促一意明細 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST_ERR, template.getString(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST_ERR));
			}
		}

		return param;
	}

	/**
	 * 料金スケジュール定義一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0501A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0501A010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// ＫＥＹ＿イベントコードエラー
		if (!template.isNull(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR, template.getString(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR));
			}
		}

		// ＫＥＹ＿イベント年月日エラー
		if (!template.isNull(ECH0501A010CBSMsg.KEY_EVENT_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.KEY_EVENT_YMD_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.KEY_EVENT_YMD_ERR, template.getString(ECH0501A010CBSMsg.KEY_EVENT_YMD_ERR));
			}
		}

		// ＫＥＹ＿運用日エラー
		if (!template.isNull(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR, template.getString(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR));
			}
		}

		// 料金スケジュール一意明細エラー
		if (!template.isNull(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST_ERR, template.getString(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST_ERR));
			}
		}

		return param;
	}

	/**
	 * 督促債権関連一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0341B010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0341B010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// ＫＥＹ＿督促番号エラー
		if (!template.isNull(ECH0341B010CBSMsg.KEY_TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0341B010CBSMsg.KEY_TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0341B010CBSMsg.KEY_TOKUSOKU_NO_ERR, template.getString(ECH0341B010CBSMsg.KEY_TOKUSOKU_NO_ERR));
			}
		}

		// 督促債権関連一覧照会明細エラー
		if (!template.isNull(ECH0341B010CBSMsg.ECH0341B010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(ECH0341B010CBSMsg.ECH0341B010CBSMSG1LIST_ERR))
			{
				inMap.put(ECH0341B010CBSMsg.ECH0341B010CBSMSG1LIST_ERR, template.getString(ECH0341B010CBSMsg.ECH0341B010CBSMSG1LIST_ERR));
			}
		}

		return param;
	}

	/**
	 * 入金取消債権変更サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0011C013(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0011C013CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 債権番号 のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0011C013CBSMsg.SAIKEN_NO_ERR));
			}
		}
		// 債権年月 のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.SAIKEN_FIX_YM_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.SAIKEN_FIX_YM_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.SAIKEN_FIX_YM_ERR, template.getString(ECH0011C013CBSMsg.SAIKEN_FIX_YM_ERR));
			}
		}
		// 充当額＿業務機能識別コード のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.JUTO_APL_KINO_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.JUTO_APL_KINO_CD_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.JUTO_APL_KINO_CD_ERR, template.getString(ECH0011C013CBSMsg.JUTO_APL_KINO_CD_ERR));
			}
		}
		// 未収額＿業務機能識別コード のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.MISY_APL_KINO_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.MISY_APL_KINO_CD_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.MISY_APL_KINO_CD_ERR, template.getString(ECH0011C013CBSMsg.MISY_APL_KINO_CD_ERR));
			}
		}
		// 金額 のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.AMNT_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.AMNT_ERR, template.getString(ECH0011C013CBSMsg.AMNT_ERR));
			}
		}
		// 更新前債権更新年月日時分秒 のエラー情報返却
		if (!template.isNull(ECH0011C013CBSMsg.SAIKEN_UPD_DTM_AF_ERR))
		{
			if (!inMap.containsKey(ECH0011C013CBSMsg.SAIKEN_UPD_DTM_AF_ERR))
			{
				inMap.put(ECH0011C013CBSMsg.SAIKEN_UPD_DTM_AF_ERR, template.getString(ECH0011C013CBSMsg.SAIKEN_UPD_DTM_AF_ERR));
			}
		}

		return param;
	}

	/**
	 * 金庫登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0191D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0191D010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 金庫移動コード のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.KNK_MOVE_CD_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.KNK_MOVE_CD_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.KNK_MOVE_CD_ERR, template.getString(ECH0191D010CBSMsg.KNK_MOVE_CD_ERR));
			}
		}
		// 請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0191D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 金庫移動年月日 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.KNK_IDO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.KNK_IDO_YMD_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.KNK_IDO_YMD_ERR, template.getString(ECH0191D010CBSMsg.KNK_IDO_YMD_ERR));
			}
		}
		// 移動元金庫番号 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.IDOMOTO_KNK_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.IDOMOTO_KNK_NO_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.IDOMOTO_KNK_NO_ERR, template.getString(ECH0191D010CBSMsg.IDOMOTO_KNK_NO_ERR));
			}
		}
		// 統合先金庫番号 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.BNKT_KNK_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.BNKT_KNK_NO_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.BNKT_KNK_NO_ERR, template.getString(ECH0191D010CBSMsg.BNKT_KNK_NO_ERR));
			}
		}
		// 入金番号 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.NYUKIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.NYUKIN_NO_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.NYUKIN_NO_ERR, template.getString(ECH0191D010CBSMsg.NYUKIN_NO_ERR));
			}
		}
		// 金庫料金項目コード のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.KNK_PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.KNK_PRC_KMK_CD_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.KNK_PRC_KMK_CD_ERR, template.getString(ECH0191D010CBSMsg.KNK_PRC_KMK_CD_ERR));
			}
		}
		// 金庫金額 のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.KNK_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.KNK_AMNT_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.KNK_AMNT_ERR, template.getString(ECH0191D010CBSMsg.KNK_AMNT_ERR));
			}
		}
		// 精算方法コード のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.SSN_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.SSN_WAY_CD_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.SSN_WAY_CD_ERR, template.getString(ECH0191D010CBSMsg.SSN_WAY_CD_ERR));
			}
		}
		// 履歴データフラグ のエラー情報返却
		if (!template.isNull(ECH0191D010CBSMsg.RIREKI_DATA_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0191D010CBSMsg.RIREKI_DATA_FLG_ERR))
			{
				inMap.put(ECH0191D010CBSMsg.RIREKI_DATA_FLG_ERR, template.getString(ECH0191D010CBSMsg.RIREKI_DATA_FLG_ERR));
			}
		}

		return param;
	}

	/**
	 * 入金取消変更サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0111C010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0111C010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 入金番号エラー のエラー情報返却
		if (!template.isNull(ECH0111C010CBSMsg.NYUKIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0111C010CBSMsg.NYUKIN_NO_ERR))
			{
				inMap.put(ECH0111C010CBSMsg.NYUKIN_NO_ERR, template.getString(ECH0111C010CBSMsg.NYUKIN_NO_ERR));
			}
		}

		// 入金ステータスエラー のエラー情報返却
		if (!template.isNull(ECH0111C010CBSMsg.NYUKIN_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0111C010CBSMsg.NYUKIN_STAT_ERR))
			{
				inMap.put(ECH0111C010CBSMsg.NYUKIN_STAT_ERR, template.getString(ECH0111C010CBSMsg.NYUKIN_STAT_ERR));
			}
		}

		// 入金取消年月日エラー のエラー情報返却
		if (!template.isNull(ECH0111C010CBSMsg.NYUKIN_CL_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111C010CBSMsg.NYUKIN_CL_YMD_ERR))
			{
				inMap.put(ECH0111C010CBSMsg.NYUKIN_CL_YMD_ERR, template.getString(ECH0111C010CBSMsg.NYUKIN_CL_YMD_ERR));
			}
		}

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

		return param;
	}

	/**
	 * 充当取消変更サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0201C010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0201C010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 充当番号 のエラー情報返却
		if (!template.isNull(ECH0201C010CBSMsg.JUTO_NO_ERR))
		{
			if (!inMap.containsKey(ECH0201C010CBSMsg.JUTO_NO_ERR))
			{
				inMap.put(ECH0201C010CBSMsg.JUTO_NO_ERR, template.getString(ECH0201C010CBSMsg.JUTO_NO_ERR));
			}
		}
		// 更新前充当更新年月日時分秒 のエラー情報返却
		if (!template.isNull(ECH0201C010CBSMsg.JUTO_UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(ECH0201C010CBSMsg.JUTO_UPD_DTM_BF_ERR))
			{
				inMap.put(ECH0201C010CBSMsg.JUTO_UPD_DTM_BF_ERR, template.getString(ECH0201C010CBSMsg.JUTO_UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 督促登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0231D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0231D010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 督促ステータス のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.TOKUSOKU_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.TOKUSOKU_STAT_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.TOKUSOKU_STAT_ERR, template.getString(ECH0231D010CBSMsg.TOKUSOKU_STAT_ERR));
			}
		}
		// 請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0231D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 督促金額 のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.TOKUSOKU_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.TOKUSOKU_AMNT_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.TOKUSOKU_AMNT_ERR, template.getString(ECH0231D010CBSMsg.TOKUSOKU_AMNT_ERR));
			}
		}
		// 督促異動イベントコード のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR, template.getString(ECH0231D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR));
			}
		}
		// 支払約束年月日 のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.PAY_YAKUSOKU_YMD_ERR, template.getString(ECH0231D010CBSMsg.PAY_YAKUSOKU_YMD_ERR));
			}
		}
		// 支払約束履行判定年月日 のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.PAY_YAKUSOKU_RIKO_JDG_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.PAY_YAKUSOKU_RIKO_JDG_YMD_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.PAY_YAKUSOKU_RIKO_JDG_YMD_ERR, template.getString(ECH0231D010CBSMsg.PAY_YAKUSOKU_RIKO_JDG_YMD_ERR));
			}
		}
		// 債権ステータス のエラー情報返却
		if (!template.isNull(ECH0231D010CBSMsg.SAIKEN_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0231D010CBSMsg.SAIKEN_STAT_ERR))
			{
				inMap.put(ECH0231D010CBSMsg.SAIKEN_STAT_ERR, template.getString(ECH0231D010CBSMsg.SAIKEN_STAT_ERR));
			}
		}

		return param;
	}

	/**
	 * 督促異動登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0361D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0361D010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 督促番号 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.TOKUSOKU_NO_ERR, template.getString(ECH0361D010CBSMsg.TOKUSOKU_NO_ERR));
			}
		}
		// 督促異動イベントコード のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR, template.getString(ECH0361D010CBSMsg.TOKUSOKU_IDO_EVENT_CD_ERR));
			}
		}
		// 督促ステータス のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.TOKUSOKU_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.TOKUSOKU_STAT_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.TOKUSOKU_STAT_ERR, template.getString(ECH0361D010CBSMsg.TOKUSOKU_STAT_ERR));
			}
		}
		// 督促金額 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.TOKUSOKU_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.TOKUSOKU_AMNT_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.TOKUSOKU_AMNT_ERR, template.getString(ECH0361D010CBSMsg.TOKUSOKU_AMNT_ERR));
			}
		}
		// 支払約束受付年月日 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.PAY_YAKUSOKU_UK_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.PAY_YAKUSOKU_UK_YMD_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.PAY_YAKUSOKU_UK_YMD_ERR, template.getString(ECH0361D010CBSMsg.PAY_YAKUSOKU_UK_YMD_ERR));
			}
		}
		// 支払約束年月日 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_ERR, template.getString(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_ERR));
			}
		}
		// 変更支払約束年月日 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR, template.getString(ECH0361D010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR));
			}
		}
		// 支払約束履行判定年月日 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR, template.getString(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR));
			}
		}
		// 変更支払約束履行判定年月日 のエラー情報返却
		if (!template.isNull(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR))
			{
				inMap.put(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR, template.getString(ECH0361D010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR));
			}
		}

		return param;
	}

	/**
	 * 督促変更サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0231C010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0231C010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 督促番号 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.TOKUSOKU_NO_ERR, template.getString(ECH0231C010CBSMsg.TOKUSOKU_NO_ERR));
			}
		}
		// 督促ステータス のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.TOKUSOKU_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.TOKUSOKU_STAT_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.TOKUSOKU_STAT_ERR, template.getString(ECH0231C010CBSMsg.TOKUSOKU_STAT_ERR));
			}
		}
		// 更新前督促金額 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.TOKUSOKU_AMNT_BF_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.TOKUSOKU_AMNT_BF_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.TOKUSOKU_AMNT_BF_ERR, template.getString(ECH0231C010CBSMsg.TOKUSOKU_AMNT_BF_ERR));
			}
		}
		// 異動金額 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.IDO_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.IDO_AMNT_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.IDO_AMNT_ERR, template.getString(ECH0231C010CBSMsg.IDO_AMNT_ERR));
			}
		}
		// 支払約束年月日 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_ERR, template.getString(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_ERR));
			}
		}
		// 変更支払約束年月日 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR, template.getString(ECH0231C010CBSMsg.PAY_YAKUSOKU_YMD_AF_ERR));
			}
		}
		// 支払約束履行判定年月日 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR, template.getString(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_ERR));
			}
		}
		// 変更支払約束履行判定年月日 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR, template.getString(ECH0231C010CBSMsg.PAY_YAKUSOKU_RIKO_YMD_AF_ERR));
			}
		}
		// 督促異動イベントコード のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.TOKUSOKU_IDO_EVNT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.TOKUSOKU_IDO_EVNT_CD_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.TOKUSOKU_IDO_EVNT_CD_ERR, template.getString(ECH0231C010CBSMsg.TOKUSOKU_IDO_EVNT_CD_ERR));
			}
		}
		// 更新前督促更新年月日時分秒 のエラー情報返却
		if (!template.isNull(ECH0231C010CBSMsg.TOKUSOKU_UPD_DTM_AF_ERR))
		{
			if (!inMap.containsKey(ECH0231C010CBSMsg.TOKUSOKU_UPD_DTM_AF_ERR))
			{
				inMap.put(ECH0231C010CBSMsg.TOKUSOKU_UPD_DTM_AF_ERR, template.getString(ECH0231C010CBSMsg.TOKUSOKU_UPD_DTM_AF_ERR));
			}
		}

		return param;
	}

	/**
	 * 電子ファイル管理登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECC0041D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(ECC0041D010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null) 
		{
			bpStatus = -1;
		} 
		else 
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

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

		HashMap<String, Object> inMap = null;
		inMap = this.getMap(param);

		// システムコード のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.SYS_CD_ERR))
		{
			if (!inMap.containsKey(ECC0041D010CBSMsg.SYS_CD_ERR))
			{
				inMap.put(ECC0041D010CBSMsg.SYS_CD_ERR, template.getString(ECC0041D010CBSMsg.SYS_CD_ERR));
			}
		}
		// ファイルコード のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.FILE_CD_ERR))
		{
			if (!inMap.containsKey(ECC0041D010CBSMsg.FILE_CD_ERR))
			{
				inMap.put(ECC0041D010CBSMsg.FILE_CD_ERR, template.getString(ECC0041D010CBSMsg.FILE_CD_ERR));
			}
		}
		// ファイル削除年月 のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.FILE_DEL_YMD_ERR))
		{
			if (!inMap.containsKey(ECC0041D010CBSMsg.FILE_DEL_YMD_ERR))
			{
				inMap.put(ECC0041D010CBSMsg.FILE_DEL_YMD_ERR, template.getString(ECC0041D010CBSMsg.FILE_DEL_YMD_ERR));
			}
		}
		// 電子ファイル のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.EFILE_ERR))
		{
			if (!inMap.containsKey(ECC0041D010CBSMsg.EFILE_ERR))
			{
				inMap.put(ECC0041D010CBSMsg.EFILE_ERR, template.getString(ECC0041D010CBSMsg.EFILE_ERR));
			}
		}

		return param;
	}

	/**
	 * 督促債権関連登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0341D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
			throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0341D010CBSMsg.STATUS);

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

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = this.getMap(param);

		// 督促番号 のエラー情報返却
		if (!template.isNull(ECH0341D010CBSMsg.TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0341D010CBSMsg.TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0341D010CBSMsg.TOKUSOKU_NO_ERR, template.getString(ECH0341D010CBSMsg.TOKUSOKU_NO_ERR));
			}
		}
		// 債権番号 のエラー情報返却
		if (!template.isNull(ECH0341D010CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0341D010CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0341D010CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0341D010CBSMsg.SAIKEN_NO_ERR));
			}
		}

		return param;
	}

	// ▲▲ エラー情報マッピング処理 ▲▲

	// ▼▼ クラス内共通処理 ▼▼
	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。 マップには共通項目である電文ヘッダ、コントロールマップを設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private HashMap<String, Object> createNewParamMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

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

		/* ◇コントロールマップ */
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		return paramMap;
	}

	/**
	 * テンプレートの共通項目を設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param template テンプレート
	 * @param templateIdKey テンプレートIDキー名
	 * @param templateIdVal テンプレートID値
	 * @param templateFuncCdKey テンプレート機能コードキー名
	 * @return CAANMsg
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private CAANMsg setTemplateCommonItem(IRequestParameterReadWrite param, CAANMsg template, String templateIdKey, String templateIdVal,
			String templateFuncCdKey) throws RequestParameterException
	{
		// テンプレートID
		template.set(templateIdKey, templateIdVal);

		// 機能コード（デフォルト：１）
		template.set(templateFuncCdKey, "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);

		return template;
	}

	/**
	 * 入金取消実行マップを取得します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return 入金取消実行マップ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> getMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		return (HashMap<String, Object>) param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);
	}

	/**
	 * マップから指定されたリスト項目名の値を取得します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param key リスト項目名
	 * @return マップ項目値
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<HashMap<String, Object>> getMapListItem(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>) param.getData(JCHNyukinClRunConstCC.MAP_CC_ID);
		return (ArrayList<HashMap<String, Object>>) inMap.get(key);
	}
	
	/**
	 * 電子ファイル登録内容生成処理<br>
	 * 
	 * @return byte[]
	 */
	private byte[] createEfile()
	{
		try
		{
			byte[] fileByte = new byte[0];
			StringBuffer sb = new StringBuffer();
			for (CAANMsg caEfileInfo : efileInfoList)
			{
				sb.append(caEfileInfo.getString(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_KEI_NO))          // 請求契約番号
				  .append(CSV + caEfileInfo.getString(JCHNyukinClRunConstCC.MAP_KEY_SEIKY_YM))        // 請求年月
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // サービス契約番号
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.領収年月日
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.入金処理年月日
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.外部組織収納年月日
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.入金経路コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 料金グループコード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 料金コースコード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 料金サービスコード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 料金項目コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.収納機関コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金額
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 充当額
				  .append(CSV + caEfileInfo.getString(JCHNyukinClRunConstCC.MAP_KEY_JUTO_AMNT))       // 預り金
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.金融機関コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.金融機関支店コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.クレジットカード会社コード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.コンビニエンスストアコード
				  .append(CSV + JACStrConst.KARA_MOJI)                                                // 入金情報.組織コード
				  .append(CSV + JACStrConst.KARA_MOJI) ;                                              // 入金情報.債権回収委託会社コード

				// 改行
				sb.append(System.getProperty(LINE_SEP));
			}

			fileByte = sb.toString().getBytes("Shift_JIS");

			return fileByte;
		}
		catch (UnsupportedEncodingException e)
		{
			return null;
		}
	}
	
	/**
	 * <p>
	 * パラメタの後ろの空白削除
	 * Nullの場合空白を返却します。
	 * </p>
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToStr(Object str)
	{
		return JPCUtilCommon.Rtrim((String)str);
	}
	
	
	/**
	 * 領収充当種別前受金充当判断メソッド
	 * 
	 * @param handle
	 * @param param
	 * @param ryosyuJutoNo
	 * @return boolean true:前受金充当 false:それ以外
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean isMaeUkeKinJuto(SessionHandle handle, IRequestParameterReadWrite param, String ryosyuJutoNo) throws Exception
	{
		
		HashMap<String, Object> resultMap = new HashMap<String, Object>();
		execECH0201B010(handle, param, ryosyuJutoNo, resultMap);
		
		// 検索結果がない場合削除対象
		if(resultMap.isEmpty())
		{
			return true;
		}
		
		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)resultMap.get("ECH0201B010CBSMsg1List");
		
		if(dataList.size() == 0)
		{
			return true;
		}
		
		String jutoSbtCd = "";
		for(HashMap<String, String> jutoMap : dataList)
		{
			jutoSbtCd = getNullToStr(jutoMap.get(ECH0201B010CBSMsg1List.JUTO_SBT_CD));
			if("3".equals(jutoSbtCd))
			{
				return true;
			}
		}
		
		return false;
	}
	
	/**
	 * 充当一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param ryosyuJutoNo 
	 * @param resultMap
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0201B010(SessionHandle handle
									, IRequestParameterReadWrite param
									, String ryosyuJutoNo
									, HashMap<String, Object> resultMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0201B010 = editInMsgECH0201B010(param, ryosyuJutoNo);
		for (CAANMsg msg : templateECH0201B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0201B010(result, param, resultMap);
		
	}
	
	/**
	 * 充当一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0201B010(IRequestParameterReadWrite param, String ryosyuJutoNo) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0201B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0201B010CBSMsg.TEMPLATEID, JCHNyukinClRunConstCC.TEMPLATE_ID_ECH0201B010, ECH0201B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0201B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_3);

		// コード種別コード
		template.set(ECH0201B010CBSMsg.KEY_JUTO_NO, ryosyuJutoNo);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 充当一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param resultMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0201B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param
			, HashMap<String, Object> resultMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		List<HashMap<String, String>> dataList = new ArrayList<HashMap<String, String>>();

		templateArray = parentTemplate.getCAANMsgList(ECH0201B010CBSMsg.ECH0201B010CBSMSG1LIST);
		if (templateArray != null)
		{
			
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];
				if ( i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);

				// 充当種別コード
				if (childTemplate.isNull(ECH0201B010CBSMsg1List.JUTO_SBT_CD)) {
					childMap.put(ECH0201B010CBSMsg1List.JUTO_SBT_CD, new String());
				} else {
					childMap.put(ECH0201B010CBSMsg1List.JUTO_SBT_CD, childTemplate.getString(ECH0201B010CBSMsg1List.JUTO_SBT_CD));
				}
			}
		}

		resultMap.put("ECH0201B010CBSMsg1List", dataList);

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

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

		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);

		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}

		return param;
	}
	
	/**
	 * 帳票生成サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0201B010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0011B010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}

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

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

		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = this.getMap(param);

		// ＫＥＹ＿充当番号
		if (!template.isNull(ECH0201B010CBSMsg.KEY_JUTO_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0201B010CBSMsg.KEY_JUTO_NO_ERR)) 
			{
				inMap.put(ECH0201B010CBSMsg.KEY_JUTO_NO_ERR, template.getString(ECH0201B010CBSMsg.KEY_JUTO_NO_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 領収削除サービスインターフェイス実行処理
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinClRunListMap 入金取消マップ
	 * @param jutoIcrnMap 充当一覧マップ
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	public void execRyoshuData(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> nyukinClRunListMap,
			HashMap<String, Object> jutoIcrnMap) throws Exception
	{
		ArrayList<HashMap<String, Object>> eCH0311B010CBSMsg1List = null;
		
		if (jutoIcrnMap != null)
		{

			eCH0311B010CBSMsg1List = (ArrayList<HashMap<String, Object>>) jutoIcrnMap.get(JCHNyukinClRunConstCC.MAP_KEY_ECH0311B010CBSMSG1LIST);
			if (eCH0311B010CBSMsg1List != null)
			{

				for (HashMap<String, Object>eCH0311B010Map: eCH0311B010CBSMsg1List)
				{
					if (eCH0311B010Map != null)
					{
						execECH0311E010(handle, param, nyukinClRunListMap, eCH0311B010Map);
					}
				}
			}
		}
		
	}

	// ▲▲ クラス内共通処理 ▲▲

// v22.00.00 ANK-2610-00-00 ADD START
	/**
	 * 料金指示書登録実行処理（利用停止、利用停止解除以外の指示書）
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param seikyKeiNo 請求契約番号
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void execAddShijisho(SessionHandle handle, IRequestParameterReadWrite param, String seikyKeiNo) throws Throwable
	{
		param.setData(ADDSJISHO_MAP, new HashMap<String, Object>());
		HashMap<String, Object> sjishoMap = (HashMap<String, Object>)param.getData(ADDSJISHO_MAP);
		
		HashMap<String, Object> inMap = this.getMap(param);
		// 機能コード
		sjishoMap.put("func_code", inMap.get(JCMConstants.FUNC_CODE_KEY));
		// 請求契約番号
		sjishoMap.put("seiky_kei_no", seikyKeiNo);
		
		// 料金指示書登録CCを実行する
		JCHPrcAddShijishoCC addShijisho = new JCHPrcAddShijishoCC();
		addShijisho.addShijisho(handle, param, ADDSJISHO_MAP);
	}
// v22.00.00 ANK-2610-00-00 ADD END
}