/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *   システム名      ：eo顧客基幹システム
 *   モジュール名    ：JCHZuijiNkinAddCC
 *   ソースファイル名：JCHZuijiNkinAddCC.java
 *   作成者          ：富士通
 *   日付            ：2011年12月22日
 *＜機能概要＞
 *   随時入金登録CC部品です。
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00.00	2011/12/22	富士通		新規作成
 *	v5.00.00	2013/07/09  FJ) 林	   【LT-2013-0000260】未来月の請求は登録させない対応
 *  v5.00.01	2013/08/03  FJ) 吉田   【IT1-2013-0001510】入金系画面強化対応
 *  v5.00.02	2013/08/07  FJ) 小野   【IT2-2013-0000721,0000722】入金経路が郵便振込の場合、郵便自動振込金融機関コード、郵便自動振込金融機関支店コードを
 *                                        郵便自動振込の場合、郵便自動振込金融機関コード、郵便自動振込金融機関支店コードを入金テーブルに登録する。
 *  v5.00.03	2013/08/13  FJ)吉田	   【IT1-2013-0001583】入金経路がクレジットの場合、領収日付に請求年月末営業日を設定するよう修正。
 *  v5.00.04	2013/08/30  FJ) 小野   【OM-2013-0001208】入金経路が金庫充当の場合、充当スキーマ登録時に債権番号と入金番号を設定するように修正。
 *  v5.00.05	2013/09/06  FJ) 垣内   【OM-2013-0001613】現金・総合口座時の金融機関コード設定不備
 *	v5.00.06	2013/09/27	FJ) 林     【OM-2013-0002054/2457】入金登録リスト作成用に電子ファイル管理登録をするよう対応
 *	v6.00.00	2013/10/23	FJ)鈴木	   【OM-2013-0002865】入金経路が総合口座の場合、引落金融機関、支店を選択可能とする
 *	v6.00.01	2013/11/05	FJ)北端	   【OM-2013-0002440】入金経路がコンビニであった場合、EANメーカーコードを設定する様に修正
 *	v8.00.00	2013/12/25  FJ)小野    【ANK-1584-00-00】MVNO（本体）対応
 *	v8.00.01	2014/03/12	FJ) 林	   【TG1-2014-0000004】消費税に伴う料金施策（増税対応）
 *	v9.00.00	2014/04/16	FJ)小野    【ANK-2054-00-00】eoスマートリンク改修(端末補償)。
 *	v9.00.01	2014/05/29	FJ)江森    【IT1-2014-0000164】機器提供サービス契約一覧照会の基準日を請求年月月末日に修正。
 *	v9.00.02	2014/08/20	FJ)桑島    【OM-2014-0002355】充当登録SIFの充当額合計を修正
 *	v10.00.00	2014/08/27  FJ)江森    【OM-2014-0001880,IT2-2014-000167】支払証明書の消費税不正対応。
 *	v32.00.00	2017/04/20	FJ)清原		【ANK-2996-00-00】ＳＭＳを利用した即時決済サービスの導入
 *  v36.00.00	2018/02/04	FJ）清原   【ANK-3296-00-00】標準工事費分割請求
 *	v52.00.00	2020/12/07	FJ) 寺園    【ANK-3838-00-00】窓口払い手数料の顧客負担方式導入
 *	v59.00.00	2022/04/18	FJ)吉田		【ANK-4160-00-00】SMBC即時決済入金会計システム化対応
 *	v67.00.00	2023/05/31	GDC)ml.alcantara	【ANK-4415-00-00】口振請求及びWeb申込システム移行 STEP1
 *  v71.00.00   2024/04/18  FJ)張      【ANK-4543-00-00】【eo定期】NTT卸対応：Step0
 **********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JCHNkinAddSaikenJutoConstCC;
import com.fujitsu.futurity.bp.custom.constant.JCHZuijiNkinAddConstCC;
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.JACCommonUtil;
import eo.common.util.JCRUtilCommon;
import eo.common.util.JPCDateUtil;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.ECC0041D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0011D012CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0041D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0041D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051D011CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051D011CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051D011CBSMsg2List;
import eo.ejb.cbs.cbsmsg.ECH0051D011CBSMsg3List;
import eo.ejb.cbs.cbsmsg.ECH0111D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0201D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0311D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0511B004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0511B004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0291B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0291B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;

/**
 * 随時入金登録サービスより呼び出されるCC部品です。
 * <p>
 * <BR>
 * 
 * @author 富士通
 */
public class JCHZuijiNkinAddCC extends AbstractCommonComponent
{
	/** 充当債権リスト */
	private ArrayList<HashMap<String, Object>> jutoSaikenList = null;

	/** 電子ファイル管理登録情報リスト */
	private ArrayList<CAANMsg> efileInfoList = new ArrayList<CAANMsg>();

	/** 電子ファイル管理登録入金情報マップ */
	private HashMap<String, String> efileNyukinInfoMap = new HashMap<String, String>();

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

	/**  カンマ区切り */
	private static final String CSV = ",";
	
	/**  ゼロ */
	private static final String ZERO = "0";
	
// OM-2014-0001880 ADD START
	/** 充当番号リスト */
	private ArrayList<String> jutoNoList = null;
// OM-2014-0001880 ADD END
	
	/*
	 * ◇ダミー値 invokeCheck時には請求番号、債権番号が採番されず、随時請求登録サービスIFに設定できないことに起因し、 
	 * 単関連チェックでエラーとなる事象を回避する目的でダミー値を設定する。
	 */
	/** ダミー値(請求番号／債権番号) */
	private static final String DUMMY_NO = "000000000000";

	// ▼▼ invokeCBSによる単項目チェック処理 ▼▼
	/**
	 * 登録処理チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	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>();
		
		HashMap<String, Object> inMap = this.getMap(param);

		/* TODO : ダミー設定。単関連が削除されたら、不要となる */
		this.setMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO, DUMMY_NO);
		this.setMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO, DUMMY_NO);
		this.setMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM));
		this.setMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD, JACStrConst.SEIKY_MADOGUCHI);

		/* ◇機能コード判定 */
		if (JPCModelConstant.FUNC_CD_2.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
		{
			// 随時請求登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0051D011 = editInMsgECH0051D011(param);
			for (CAANMsg msg : templateECH0051D011)
			{
				templateList.add(msg);
			}
		}
		else
		{
			// 請求契約一意照会サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param);
			for (CAANMsg msg : templateEKK0491A010)
			{
				templateList.add(msg);
			}

			// 収納済債権登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0011D012 = editInMsgECH0011D012(param);
			for (CAANMsg msg : templateECH0011D012)
			{
				templateList.add(msg);
			}

			// 請求登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0051D010 = editInMsgECH0051D010(param);
			for (CAANMsg msg : templateECH0051D010)
			{
				templateList.add(msg);
			}

			// 随時請求登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0051D011 = editInMsgECH0051D011(param);
			for (CAANMsg msg : templateECH0051D011)
			{
				templateList.add(msg);
			}

			// 入金登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0111D010 = editInMsgECH0111D010(param, null, null, null);
			for (CAANMsg msg : templateECH0111D010)
			{
				templateList.add(msg);
			}
		}
		/* TODO : ダミー設定。単関連が削除されたら、不要となる */
		this.removeMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO);
		this.removeMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO);
		this.removeMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD);

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

		return paramMap;
	}

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

	// ▼▼ 随時入金登録処理 ▼▼
	/**
	 * 登録処理.<br>
	 * 随時入金登録マップに指定された入金情報、随時入金明細リストを基に随時入金登録処理を行います。 <br>
	 * 入金経路が金庫充当である場合は、金庫(預り金)から隋時入金を行います。 <br>
	 * 入金経路が金庫充当以外である場合は、入金登録と共に随時入金を行います。 <br>
	 * なお、請求を登録する際に必要な基本情報として、顧客契約のスキーマを予め照会する。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite add(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param);

		/* ◇機能コード判定 */
		if (JPCModelConstant.FUNC_CD_2.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
		{
			// ◇随時請求登録サービスインターフェイス
			execECH0051D011(handle, param);
		}
		else
		{
			/* ◇収納済債権登録サービスインターフェイス */
			execECH0011D012(handle, param);

			/* ◇請求登録サービスインターフェイス */
			execECH0051D010(handle, param);

			/* ◇随時請求登録サービスインターフェイス */
			execECH0051D011(handle, param);

			/* ◇請求債権関連登録サービスインターフェイス */
			execECH0041D010(handle, param);

			/* ◇入金経路判定 */
			String nyukinRouteCd = getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
			if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_JUTO))
			{
				/* ◇入金経路が"金庫充当"である場合は、金庫移動登録処理を実行 */
				this.execKnkIdoAdd(handle, param);
			}
			else
			{
				/* ◇入金経路が"金庫充当"以外である場合は、入金登録処理を実行 */
				this.execNkinAdd(handle, param);
			}

			/* ◇充当登録処理 */
			execJutoAdd(handle, param);
			
			/* ◇領収登録処理 */
			execReceiptAdd(handle, param);

			/* ◇電子ファイル管理登録処理 */
			execECC0041D010(handle, param);
		}

		return param;
	}
	
	/**
	 * 請求年月取得処理.<br>
	 * 製造番号チェックに使用する請求年月を料金スケジュール定義を参照し、取得する。 <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getSeikyYm(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		/* ◇料金スケジュール定義一意照会サービスインターフェイス */
		execECH0501A010(handle, param);
		
		return param;
	}


	// ▼▼ 金庫移動登録処理 ▼▼
	/**
	 * 金庫移動登録処理<br>
	 * 金庫(預り金)から随時入金登録を行います。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execKnkIdoAdd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 充当債権リストの初期化
		this.jutoSaikenList = new ArrayList<HashMap<String, Object>>();

		// 随時入金明細リスト分繰り返し
		ArrayList<HashMap<String, Object>> zuijiNkinList = getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST);
		for (int idx = 0; idx < zuijiNkinList.size(); idx++)
		{
			HashMap<String, Object> childMap = zuijiNkinList.get(idx);

			// 随時入金明細リスト１件の金庫移動を行う
			this.execKnkIdoForOneNkin(handle, param, childMap);
		}
	}

	/**
	 * 随時入金明細１件分の預り金を金庫移動します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param zuijiNkin 随時入金明細１件のマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execKnkIdoForOneNkin(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> zuijiNkin) throws Exception
	{
		// 預り金明細リスト
		ArrayList<HashMap<String, Object>> azukinList = getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN_LIST);

		// 内訳額
		BigDecimal utwkAmntVal = new BigDecimal((String)zuijiNkin.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT));

		// 預り金
		HashMap<String, Object> azukinMap = azukinList.get(0);
		BigDecimal azukinVal = new BigDecimal((String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));

		if (azukinVal.compareTo(utwkAmntVal) == 0)
		{
			// １件の金庫移動で内訳額を充当でき、かつ金庫額と内訳額が同じである場合
			// 金庫移動を行い、当該の金庫(預り金)をリストから削除する
			execAKnkIdoInAllKnkAmnt(handle, param, azukinMap);
			azukinList.remove(azukinMap);
		}
		else if (azukinVal.compareTo(utwkAmntVal) > 0)
		{
			// １件の金庫移動で内訳額を充当でき、かつ金庫額が内訳額より大きい場合
			// 金庫移動を行い、当該の金庫(預り金)をリストから減額する
			execAKnkIdoInPartKnkAmnt(handle, param, zuijiNkin, azukinMap);
		}
		else
		{
			// Ｎ件の金庫移動で内訳額を充当する必要がある場合
			execNKnkIdo(handle, param, zuijiNkin, azukinList);
		}
	}

	/**
	 * １件の金庫移動(金庫金額の全額)を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param azukinMap 預り金明細１件のマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execAKnkIdoInAllKnkAmnt(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> azukinMap)
			throws Exception
	{

		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// 上りマッピング
		CAANMsg templateECH0191D020 = editInMsgECH0191D020_1(param, azukinMap);
		templateList.add(templateECH0191D020);
		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);

		// 下りマッピング
		// 払い出された金庫番号を取得して、「充当債権リスト」を生成する
		editOutMsgECH0191D020_1(result, param);
	}

	/**
	 * １件の金庫移動(金庫金額の一部)を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param zuijiNkinMap 随時入金明細１件のマップ
	 * @param azukinMap 預り金明細１件のマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execAKnkIdoInPartKnkAmnt(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> zuijiNkinMap, HashMap<String, Object> azukinMap)
			throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// 上りマッピング
		CAANMsg templateECH0191D020 = editInMsgECH0191D020_2(param, zuijiNkinMap, azukinMap);
		templateList.add(templateECH0191D020);
		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);

		// 下りマッピング
		// 払い出された金庫番号を取得して、「充当債権リスト」を生成する
		editOutMsgECH0191D020_2(result, param, azukinMap);
	}

	/**
	 * 債権充当明細１件に対してＮ件の金庫移動を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param zuijiNkinMap 随時入金明細１件のマップ
	 * @param azukinList 預り金明細リスト
	 * @throws Exception 例外が発生した場合
	 */
	private void execNKnkIdo(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> zuijiNkinMap, ArrayList<HashMap<String, Object>> azukinList)
			throws Exception
	{

		// 内訳額がなくなるまで、預り金明細リストの金庫移動
		for (int idxAzukin = 0; idxAzukin < azukinList.size(); idxAzukin++)
		{
			HashMap<String, Object> azukinMap = azukinList.get(idxAzukin);
			// 内訳額
			BigDecimal utwkAmnt = new BigDecimal((String)zuijiNkinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT));
			// 実際の金庫移動額
			BigDecimal azukin = new BigDecimal((String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));

			if (utwkAmnt.compareTo(azukin) > 0)
			{
				// 移動対象となる金庫の金庫額が内訳額に満たない場合
				// 金庫移動を行い、内訳額から移動済みの金庫額を減額して
				// かつ、当該の金庫(預り金)をリストから削除して
				// 金庫移動の処理を継続する
				execAKnkIdoInAllKnkAmnt(handle, param, azukinMap);
				zuijiNkinMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT, String.valueOf(utwkAmnt.subtract(azukin)));
				azukinList.remove(azukinMap);
				idxAzukin--;
			}
			else if (utwkAmnt.compareTo(azukin) == 0)
			{
				// 移動対象となる金庫の金庫額が内訳額と同じである場合
				// 金庫移動を行い、当該の金庫(預り金)をリストから削除して
				// 金庫移動の処理を終了する
				execAKnkIdoInAllKnkAmnt(handle, param, azukinMap);
				azukinList.remove(azukinMap);
				break;
			}
			else
			{
				// 移動対象となる金庫の金庫額が内訳額より大きい場合
				// 金庫移動を行い、当該の金庫(預り金)を減額して
				// 金庫移動の処理を終了する
				execAKnkIdoInPartKnkAmnt(handle, param, zuijiNkinMap, azukinMap);
				break;
			}
		}
	}
	// ▲▲ 金庫移動登録処理 ▲▲

	// ▼▼ 入金登録処理 ▼▼
	/**
	 * 入金登録処理<br>
	 * <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execNkinAdd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 充当債権リストの初期化
		this.jutoSaikenList = new ArrayList<HashMap<String, Object>>();

		/* ◇入金登録処理 */
		execECH0111D010(handle, param);
	}
	// ▲▲ 入金登録処理 ▲▲

	// ▼▼ 充当登録処理 ▼▼
	/**
	 * 充当登録処理.<br>
	 * 金庫移動登録処理、または入金登録処理により予め生成されている充当債権リストを基に充当処理を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execJutoAdd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
// OM-2014-0001880 ADD START
		this.jutoNoList = new ArrayList<String>();
// OM-2014-0001880 ADD END
		// 充当債権リストの件数分、充当登録を行う
		for (int idx = 0; idx < this.jutoSaikenList.size(); idx++)
		{
			/* ◇パラメータマップ生成 */
			HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

			// 上りマッピング
			ArrayList<CAANMsg> templateECH0201D010 = editInMsgECH0201D010(param, jutoSaikenList.get(idx));
			for (CAANMsg msg : templateECH0201D010)
			{
				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);

			// 下りマッピング
			editOutMsgECH0201D010(result, param);
		}
	}
	// ▲▲ 充当登録処理 ▲▲

	/**
	 * 領収登録処理.<br>
	 * 充当債権リストを基に領収処理を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execReceiptAdd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 充当債権リストの件数分、領収登録を行う
		for (int idx = 0; idx < this.jutoSaikenList.size(); idx++)
		{
			/* ◇パラメータマップ生成 */
			HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

// OM-2014-0001880 MOD START
			// 上りマッピング
//			ArrayList<CAANMsg> templateECH0311D010 = editInMsgECH0311D010(param, jutoSaikenList.get(idx));
			ArrayList<CAANMsg> templateECH0311D010 = editInMsgECH0311D010(param, jutoSaikenList.get(idx), jutoNoList.get(idx));
// OM-2014-0001880 MOD END
			for (CAANMsg msg : templateECH0311D010)
			{
				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);

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

	// ▼▼ サービスIF呼び出し ▼▼
	/**
	 * 請求契約一意照会サービスインターフェイス実行処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0491A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param);
		for (CAANMsg msg : templateEKK0491A010)
		{
			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);

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501A010 = editInMsgECH0501A010(param);
		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);

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0011D012 = editInMsgECH0011D012(param);
		for (CAANMsg msg : templateECH0011D012)
		{
			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);

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051D010 = editInMsgECH0051D010(param);
		for (CAANMsg msg : templateECH0051D010)
		{
			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);

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051D011 = editInMsgECH0051D011(param);
		for (CAANMsg msg : templateECH0051D011)
		{
			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);

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0041D010 = editInMsgECH0041D010(param);
		for (CAANMsg msg : templateECH0041D010)
		{
			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);

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

	/**
	 * 入金登録サービスインターフェイス実行処理.<br>
	 * <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void execECH0111D010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		String cvsPayRsvYmd = null;
		
		String nyukinRouteCd = getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
//v32.00.00 Mod Start
//		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE))
//v32.00.01 2017/05/11 Mod Start
//		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE)
//				|| nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_KESSAI_SMBC))
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE))
//v32.00.01 2017/05/11 Mod End
//v32.00.00 Mod End
		{
			// コンビニ支払予定年月日の取得を実行
			cvsPayRsvYmd = getCvsPayRsvYmd(handle, param);
		}
// v59.00.00 2022/04/18 ANK-4160-00-00 DEL START (後続処理で使用できない)
////v32.00.01 2017/05/11 Add Start
//		else if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_KESSAI_SMBC))
//		{
//			//外部収納年月日を取得する
//			HashMap<String, Object> inMap = this.getMap(param);
//			String shunoYmd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD);
//			
//			//共通部品に収納年月日を連携し、収納年月日末日を取得する
//			cvsPayRsvYmd = JACCommonUtil.getKsdkcpCvsPayRsvYmd(shunoYmd);
//		}
////v32.00.01 2017/05/11 Add End
// v59.00.00 2022/04/18 ANK-4160-00-00 DEL END

		String creShunoYmd = null;

		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CREDIT))
		{
			// クレジット用の収納日の取得を実行
			creShunoYmd = getCreShunoYmd(handle, param);
		}

		//ANK-4415-00-00 MOD START
		// 入金経路コードが"郵便振込"または"郵便自動振込（ＣＰ）"または"郵便自動振込"の場合、
		// 金融機関コード、金融機関支店コードを取得する
//		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_FURIKM) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO))
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_FURIKM) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_CP)
				|| nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_SMBCFS))
		//ANK-4415-00-00 MOD END
		{
			// 業務パラメータ管理から金融機関コードを取得
			execEZM0321A010(handle, param);

			HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
			List dataList = (ArrayList)dataMap.get("EZM0321A010CBSMsg1List");

			if (dataList != null && !dataList.isEmpty())
			{
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(0);
				String bankCd = (String)childMap.get("work_param_sette_value");

				if (!JCRUtilCommon.isNull(bankCd))
				{
					// 金融機関から金融機関支店コードを取得
					execEKK0511B004(handle, param, bankCd);
				}
			}

		}

		// 入金経路コードが"現金"または"総合口座"の場合、
		// 払込先金融機関コード、払込先金融機関支店コードを取得する
		HashMap<String, String> hrkmBankCdMap = new HashMap<String, String>();
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_GENKIN) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_TTL_KOZA))
		{
			// 業務パラメータ管理から金融機関コードを取得
			hrkmBankCdMap = getMapEZM0321A010(handle, param);
		}

		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0111D010 = editInMsgECH0111D010(param, cvsPayRsvYmd, creShunoYmd, hrkmBankCdMap);
		for (CAANMsg msg : templateECH0111D010)
		{
			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);

		// 下りマッピング
		editOutMsgECH0111D010(result, param);
	}
	
	/**
	 * 電子ファイル管理登録サービスインタフェイス実行処理 <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 リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception 例外が発生した場合
	 */
	private String execECH0501A010_2(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		String seikyYm = null;
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 下りマッピング
		seikyYm = editOutMsgECH0501A010_2(result, param);
		
		return seikyYm;
	}
	
	/**
	 * 料金スケジュール定義一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception 例外が発生した場合
	 */
	private String execECH0501A010_3(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		String seikyYm = null;
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

	
	/**
	 * 営業日管理一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param seikyYm 請求年月
	 * @return 最終営業日
	 * @throws Exception 例外が発生した場合
	 */
	private String execEZM0291B010(SessionHandle handle, IRequestParameterReadWrite param, String seikyYm) throws Exception
	{
		String endEigyDate = null;
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		// 上りマッピング
		paramMap = editInMsgEZM0291B010(param, seikyYm);

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

	/**
	 * 業務パラメータ管理一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

	/**
	 * 金融機関一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param bankCd 金融機関コード
	 * @return 請求年月
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0511B004(SessionHandle handle, IRequestParameterReadWrite param, String bankCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		// 上りマッピング
		paramMap = editInMsgEKK0511B004(param, bankCd);

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

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

	/**
	 * 業務パラメータ管理一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 
	 * @throws Exception 例外が発生した場合
	 */
	private HashMap<String, String> getMapEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

		// 下りマッピング
		HashMap<String, String> wkParamMap = editOutMsgEZM0321A010_2(result, param);

		return wkParamMap;
	}
	// ▲▲ サービスIF呼び出し ▲▲

	// ▼▼ サービスIF用メッセージ設定処理 ▼▼
	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0491A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// 随時入金登録マップ.請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM);

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		templateList.add(template);

		return templateList;
	}

	/**
	 * 料金スケジュール一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0501A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// 固定値("21"：会計処理日) → ＫＥＹ＿イベントコード
		template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, JACStrConst.EVENT_CD_KAIK_SHORI_YMD);

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

		// 部品呼び出し → ＫＥＹ＿運用日
		template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		templateList.add(template);

		return templateList;
	}

	/**
	 * 収納済債権登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0011D012(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// オンライン運用年月日
		String opeDate = JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);

		// 随時入金登録マップ.請求契約番号 → 請求契約番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0011D012CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0011D012CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		}

		// 固定値(NULL) → サービス契約番号
		template.setNull(ECH0011D012CBSMsg.SVC_KEI_NO);

		// 随時入金登録マップ.請求年月 → 債権年月
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM)))
		{
			template.setNull(ECH0011D012CBSMsg.SAIKEN_YM);
		}
		else
		{
			template.set(ECH0011D012CBSMsg.SAIKEN_YM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM));
		}

		// 固定値("1"：窓口払い) → 請求方法コード
		template.set(ECH0011D012CBSMsg.SEIKY_WAY_CD, JACStrConst.SEIKY_WAY_CD_MDGC);

		// 固定値(：オンライン運用年月日) → 支払期限年月日
		template.set(ECH0011D012CBSMsg.PAY_KIGEN_YMD, opeDate);

		// 固定値(NULL) → 変更支払期限年月日
		template.setNull(ECH0011D012CBSMsg.CHG_PAY_KIGEN_YMD);

		// 固定値("2"：随時入金) → 請求種別コード
		template.set(ECH0011D012CBSMsg.SEIKY_SBT_CD, JACStrConst.SIKYSHBTS_JUIJ_JNYUKIN);

		// 固定値("0"：KOPT債権のみ) → 債権取扱いコード
		template.set(ECH0011D012CBSMsg.SAIKEN_TORIATSU_CD, JACStrConst.SKN_TRAT_CD_KOPT_SKN);

		// 固定値(：オンライン運用年月日) → 債権確定年月日
		template.set(ECH0011D012CBSMsg.SAIKEN_FIX_YMD, opeDate);

		// 固定値(：オンライン運用年月日) → 債権充当年月日
		template.set(ECH0011D012CBSMsg.SAIKEN_JUTO_YMD, opeDate);

		// 固定値(NULL) → 債権調整年月日
		template.setNull(ECH0011D012CBSMsg.SAIKEN_CYOSEI_YMD);

		// 固定値(NULL) → 債権変更年月日
		template.setNull(ECH0011D012CBSMsg.SAIKEN_HENKO_YMD);

		// 固定値(：オンライン運用年月日) → 充当完了年月日
		template.set(ECH0011D012CBSMsg.JUTO_FIN_YMD, opeDate);

		// 固定値(NULL) → 債権償却年月日
		template.setNull(ECH0011D012CBSMsg.SAIKEN_SHOKYAKU_YMD);

		// 固定値(NULL) → 債権償却理由コード
		template.setNull(ECH0011D012CBSMsg.SHOKYAKU_RSN_CD);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求登録サービスIF用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0051D010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// オンライン運用年月日
		String opeDate = JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);

		// 固定値("020"：請求済) → 請求ステータス
		template.set(ECH0051D010CBSMsg.SEIKY_STAT, JACStrConst.SEIKY_STAT_SIKY_ZUMI);

		// 随時入金登録マップ.請求契約番号 → 請求契約番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0051D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		}

		// 固定値(NULL) → 督促番号
		template.setNull(ECH0051D010CBSMsg.TOKUSOKU_NO);

		// 随時入金登録マップ.請求年月 → 請求年月
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM)))
		{
			template.setNull(ECH0051D010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SEIKY_YM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM));
		}

		// オンライン運用年月日 → 請求確定年月日
		template.set(ECH0051D010CBSMsg.SEIKY_FIX_YMD, opeDate);

		// 固定値("2"：随時入金) → 請求種別コード
		template.set(ECH0051D010CBSMsg.SEIKY_SBT_CD, JACStrConst.SIKYSHBTS_JUIJ_JNYUKIN);

		// 随時入金登録マップ.契約請求方法コード → 契約請求方法コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD)))
		{
			template.setNull(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD));
		}

		// 固定値("1"：窓口払い) → 請求方法コード
		template.set(ECH0051D010CBSMsg.SEIKY_WAY_CD, JACStrConst.SEIKY_WAY_CD_MDGC);

		// 固定値("0"：無) → 強制窓口フラグ
		template.set(ECH0051D010CBSMsg.KYOSEI_MADOGUCHI_FLG, JACStrConst.UM_NASHI);

		// 固定値(NULL) → 請求依頼年月日
		template.setNull(ECH0051D010CBSMsg.SEIKY_IRAI_YMD);

		// 固定値(NULL) → 同封コード
		template.setNull(ECH0051D010CBSMsg.DOHU_CD);

		// "09"固定 → 請求書発行シーケンス
		template.set(ECH0051D010CBSMsg.SKS_HAKKO_SEQ, "09");

		// 固定値(NULL) → カスタマーバーコード
		template.setNull(ECH0051D010CBSMsg.CUSTOMER_BARCODE);

		// 固定値(NULL) → インフォメーションパターンコード
		template.setNull(ECH0051D010CBSMsg.INFORMATION_CD);

		// 固定値(NULL) → 請求同封物パターンコード
		template.setNull(ECH0051D010CBSMsg.DOHUBT_CD);

		// 随時入金登録マップ.請求契約番号 → 送付先住所コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_CD)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_AD_CD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_AD_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_CD));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先郵便番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_PCD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_PCD)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_PCD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_PCD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_PCD));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先都道府県名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_STATE_NM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_STATE_NM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_STATE_NM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_STATE_NM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_STATE_NM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先市区町村名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_CITY_NM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_CITY_NM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_CITY_NM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_CITY_NM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_CITY_NM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先大字通称名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_OAZTSU_NM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_OAZTSU_NM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_OAZTSU_NM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先字丁目名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AZCHO_NM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AZCHO_NM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_AZCHO_NM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_AZCHO_NM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AZCHO_NM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先住所番地号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_BNCHIGO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_BNCHIGO)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_BNCHIGO));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先住所補記・建物名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRTTM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRTTM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_ADRTTM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_ADRTTM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRTTM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先住所補記・部屋番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRRM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRRM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_ADRRM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_ADRRM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRRM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先電話番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_TELNO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_TELNO)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_TELNO);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_TELNO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_TELNO));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_NM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_NM)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_NM);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_NM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_NM));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先法人格種別コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_SBT_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_SBT_CD)))
		{
			template.setNull(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_SBT_CD));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先法人格前後指定コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_ZENGO_SHITEI_CD) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_ZENGO_SHITEI_CD)))
		{
			template.setNull(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_ZENGO_SHITEI_CD));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先カナ名
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_KANA) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_KANA)))
		{
			template.setNull(ECH0051D010CBSMsg.SHS_KANA);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SHS_KANA, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_KANA));
		}

		// 随時入金登録マップ.請求契約番号 → 送付先メールアドレス
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_MLAD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_MLAD)))
		{
			template.setNull(ECH0051D010CBSMsg.SOHUS_MLAD);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SOHUS_MLAD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_MLAD));
		}

		// NULL → 請求契約配下サービス契約状態コード
		template.setNull(ECH0051D010CBSMsg.SKHK_SVKEI_STAT_CD);

		// NULL → 請求契約配下サービス契約解約理由識別コード
		template.setNull(ECH0051D010CBSMsg.SKHK_SVKEI_DLRE_SKBT_CD);

		// 随時入金登録マップ.請求契約番号 → 請求書発行要否
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKYUS_HAKKO_YH) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKYUS_HAKKO_YH)))
		{
			template.setNull(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKYUS_HAKKO_YH));
		}

		// 随時入金登録マップ.請求契約番号 → 次回請求方法コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NEXT_SEIKY_WAY_DIV) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NEXT_SEIKY_WAY_DIV)))
		{
			template.setNull(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV);
		}
		else
		{
			template.set(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NEXT_SEIKY_WAY_DIV));
		}

		// 固定値("0"：無) → 領収額出力有無
		template.set(ECH0051D010CBSMsg.RECEIPT_AMNT_OUTPUT_UM, JACStrConst.UM_NASHI);

		// オンライン運用年月日 → 支払期限年月日
		template.set(ECH0051D010CBSMsg.PAY_KIGEN_YMD, opeDate);

		// NULL → 請求書引抜きフラグ
		template.setNull(ECH0051D010CBSMsg.SEIKY_HIKNK_FLG);

		// 固定値("0"：発行対象外) → 請求書発行対象フラグ
		template.set(ECH0051D010CBSMsg.SEIKY_HAKKO_FLG, JACStrConst.SKS_HAK_TG_FLG_TG_GAI);

		// NULL → 請求書発行年月日
		template.setNull(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YMD);

		// NULL → 請求金額調整年月日
		template.setNull(ECH0051D010CBSMsg.SEIKY_CYOSEI_YMD);

		// NULL → 請求金額変更年月日
		template.setNull(ECH0051D010CBSMsg.SEIKY_AMNT_CHGE_YMD);

		// NULL → 請求取消年月日
		template.setNull(ECH0051D010CBSMsg.SEIKY_CL_YMD);

		// NULL → 口座振替＿金融機関コード
		template.setNull(ECH0051D010CBSMsg.KHRI_BANK_CD);

		// NULL → 口座振替＿金融機関支店コード
		template.setNull(ECH0051D010CBSMsg.KHRI_BANK_SHITEN_CD);

		// NULL → 口座振替＿口座種別コード
		template.setNull(ECH0051D010CBSMsg.KHRI_KOZA_SBT_CD);

		// NULL → 口座振替＿口座番号
		template.setNull(ECH0051D010CBSMsg.KHRI_KOZA_NO);

		// NULL → 口座振替＿新規コード
		template.setNull(ECH0051D010CBSMsg.KHRI_NEW_CD);

		// NULL → 口座振替＿通帳記号
		template.setNull(ECH0051D010CBSMsg.KHRI_TSUCHO_SYMBOL);

		// NULL → 口座振替＿通帳番号
		template.setNull(ECH0051D010CBSMsg.KHRI_TSUCHO_NO);

		// NULL → 口座振替＿口座名義人カナ名
		template.setNull(ECH0051D010CBSMsg.KHRI_KOZA_MEIGIN_KANA);

		// NULL → 口座振替＿口振結果返却年月日
		template.setNull(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_RTN_YMD);

		// NULL → 口座振替＿口振結果コード
		template.setNull(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_CD);

		// NULL → クレジット＿フロアリミット超過フラグ
		template.setNull(ECH0051D010CBSMsg.CREDIT_FLORLMT_ORVER_FLG);

		// NULL → クレジット＿クレジット会社コード
		template.setNull(ECH0051D010CBSMsg.CREDIT_CRECARD_COMP_CD);

		// NULL → クレジット＿クレジットカード名義人名
		template.setNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_KANA);

		// NULL → クレジット＿クレジットカード名義人英名
		template.setNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_ROMAJI);

		// NULL → クレジット＿オーソリ結果フラグ
		template.setNull(ECH0051D010CBSMsg.CREDIT_AUTHORI_RESOLT_CD);

		// NULL → クレジット＿加盟店番号
		template.setNull(ECH0051D010CBSMsg.CREDIT_MEMBSTR_CD);

		// NULL → クレジット＿クレジットカード番号
		template.setNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NO);

		// NULL → クレジット＿クレジット交換コード
		template.setNull(ECH0051D010CBSMsg.CREDIT_CREDIT_KOKAN_CD);

		// NULL → クレジット＿取引年月日
		template.setNull(ECH0051D010CBSMsg.CREDIT_DEAL_YMD);

		// NULL → クレジット＿売上オーソリ実施年月日時分秒
		template.setNull(ECH0051D010CBSMsg.CREDIT_SALES_AUTHORI_JSSI_DTM);

		// NULL → クレジット＿オーソリ承認番号
		template.setNull(ECH0051D010CBSMsg.CREDIT_AUTHORI_SHONIN_NO);

		// NULL → クレジット＿取引識別番号
		template.setNull(ECH0051D010CBSMsg.CREDIT_DEAL_SKBT_NO);

		// NULL → クレジット＿売上伝票番号
		template.setNull(ECH0051D010CBSMsg.CREDIT_SALES_DENPYO_NO);

		// NULL → 窓口＿社内使用識別フラグ
		template.setNull(ECH0051D010CBSMsg.MADOGUCHI_SHANAIUSE_FLG);

		// NULL → 窓口＿ＥＡＮバーコード
		template.setNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_BARCODE);

		// NULL → 窓口＿ＥＡＮメーカーコード
		template.setNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_MAKER_CD);

		// NULL → 窓口＿ＥＡＮ取扱期限年月日
		template.setNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_TORI_LIMIT_YMD);

		// NULL → 窓口＿ＯＣＲ番号
		template.setNull(ECH0051D010CBSMsg.MADOGUCHI_OCR_NO);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 随時請求登録サービスIF用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0051D011(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

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

		// 随時入金登録マップ.請求契約番号 → 請求番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO)))
		{
			template.setNull(ECH0051D011CBSMsg.SEIKY_NO);
		}
		else
		{
			template.set(ECH0051D011CBSMsg.SEIKY_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO));
		}

		// 随時入金登録マップ.請求契約番号 → 請求契約番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0051D011CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			seikyKeiNo = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO);
			template.set(ECH0051D011CBSMsg.SEIKY_KEI_NO, seikyKeiNo);
		}

		// 随時入金登録マップ.請求契約番号 → 債権番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO)))
		{
			template.setNull(ECH0051D011CBSMsg.SAIKEN_NO);
		}
		else
		{
			template.set(ECH0051D011CBSMsg.SAIKEN_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
		}

		// 随時入金登録マップ.請求年月 → 請求年月
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM)))
		{
			template.setNull(ECH0051D011CBSMsg.SEIKY_YM);
		}
		else
		{
			seikyYm = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM);
			template.set(ECH0051D011CBSMsg.SEIKY_YM, seikyYm);
		}

		// 随時入金登録マップ.入金額 → 入金額
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT)))
		{
			template.setNull(ECH0051D011CBSMsg.NYUKIN_AMNT);
		}
		else
		{
			nyukinAmnt = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT);
			template.set(ECH0051D011CBSMsg.NYUKIN_AMNT, nyukinAmnt);
		}

		// 随時入金登録マップ.預り金 → 預り金
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN)))
		{
			template.setNull(ECH0051D011CBSMsg.AZUKARI_AMNT);
		}
		else
		{
			template.set(ECH0051D011CBSMsg.AZUKARI_AMNT, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN));
		}

		// 固定値("1"：料金項目名称) → 料金項目名称種別コード
		template.set(ECH0051D011CBSMsg.PRC_KMK_NM_SBT_CD, JACStrConst.PRC_KMK_NM_SBT_CD_PRC_KMK);

		ArrayList<HashMap<String, Object>> inList = this.getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST);
		CAANMsg[] templateArray = template.getCAANMsgList(ECH0051D011CBSMsg.ECH0051D011CBSMSG1LIST);

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

		if (inList != null)
		{
			for (int i = 0; i < inList.size(); i++)
			{
				HashMap<String, Object> childMap = inList.get(i);

				CAANMsg childTemplate = templateArray[i];
				if (childTemplate == null)
				{
					childTemplate = new CAANMsg(ECH0051D011CBSMsg1List.class.getName());
				}
				
				String svcKeiNo = JACStrConst.SEIKY_KEI_NO_SP;  // サービス契約番号
				String prcGrpCd = JACStrConst.PRC_GRP_CD_SP;    // 料金グループコード
				String pcrsCd = JACStrConst.PCRS_CD_SP;         // 料金コースコード
				String prcSvcCd = JACStrConst.PRC_SVC_CD_SP;    // 料金サービスコード
				String prcKmkCd = JACStrConst.KARA_MOJI;        // 料金項目コード
				String ajstAfAmnt =JACStrConst.KARA_MOJI;       // 調整後金額
				
				// 随時入金登録マップ.随時入金明細リスト.サービス契約番号 → 随時請求登録明細.サービス契約番号
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.SVC_KEI_NO);
				}
				else
				{
					svcKeiNo = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO);
					childTemplate.set(ECH0051D011CBSMsg1List.SVC_KEI_NO, svcKeiNo);
				}
				
				// 随時入金登録マップ.随時入金明細リスト.整理番号 → 随時請求登録明細.整理番号
				if (childMap == null || childMap.get("seiri_no") == null || "".equals(childMap.get("seiri_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.SEIRI_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.SEIRI_NO, (String)childMap.get("seiri_no"));
				}
				
				// 随時入金登録マップ.随時入金明細リスト.料金グループコード → 随時請求登録明細.料金グループコード
				if (childMap == null || childMap.get("prc_grp_cd") == null || "".equals(childMap.get("prc_grp_cd")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.PRC_GRP_CD);
				}
				else
				{
					prcGrpCd = (String)childMap.get("prc_grp_cd");
					childTemplate.set(ECH0051D011CBSMsg1List.PRC_GRP_CD, prcGrpCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金コースコード → 随時請求登録明細.料金コースコード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD) == null || "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.PCRS_CD);
				}
				else
				{
					pcrsCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD);
					childTemplate.set(ECH0051D011CBSMsg1List.PCRS_CD, pcrsCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金サービスコード → 随時請求登録明細.料金サービスコード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.PRC_SVC_CD);
				}
				else
				{
					prcSvcCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD);
					childTemplate.set(ECH0051D011CBSMsg1List.PRC_SVC_CD, prcSvcCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金項目コード → 随時請求登録明細.料金項目コード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.PRC_KMK_CD);
				}
				else
				{
					prcKmkCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD);
					childTemplate.set(ECH0051D011CBSMsg1List.PRC_KMK_CD, prcKmkCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.利用開始年月日 → 随時請求登録明細.利用開始年月日
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.USE_STAYMD);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.USE_STAYMD, (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD));
				}

				// 随時入金登録マップ.随時入金明細リスト.利用終了年月日 → 随時請求登録明細.利用終了年月日
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.USE_ENDYMD);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.USE_ENDYMD, (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD));
				}

				// 随時入金登録マップ.随時入金明細リスト.マンションＩＤ → 随時請求登録明細.マンションＩＤ
				if (childMap == null || childMap.get("mansion_id") == null || "".equals(childMap.get("mansion_id")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.MANSION_ID);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.MANSION_ID, (String)childMap.get("mansion_id"));
				}

				// 随時入金登録マップ.随時入金明細リスト.回線場所住所補記＿部屋番号 → 随時請求登録明細.回線場所住所補記＿部屋番号
				if (childMap == null || childMap.get("kaisen_place_adrrm") == null || "".equals(childMap.get("kaisen_place_adrrm")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.KAISEN_PLACE_ADRRM);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.KAISEN_PLACE_ADRRM, (String)childMap.get("kaisen_place_adrrm"));
				}

				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号 → 随時請求登録明細.サービス詳細識別番号
				if (childMap == null || childMap.get("svc_dtl_skbt_no") == null || "".equals(childMap.get("svc_dtl_skbt_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO, (String)childMap.get("svc_dtl_skbt_no"));
				}

				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号区分 → 随時請求登録明細.サービス詳細識別番号区分
				if (childMap == null || childMap.get("svc_dtl_skbt_no_kbn") == null || "".equals(childMap.get("svc_dtl_skbt_no_kbn")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN, (String)childMap.get("svc_dtl_skbt_no_kbn"));
				}

				// 随時入金登録マップ.随時入金明細リスト.請求内訳番号 → 随時請求登録明細.請求内訳番号
				if (childMap == null || childMap.get("seiky_ucwk_no") == null || "".equals(childMap.get("seiky_ucwk_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO, (String)childMap.get("seiky_ucwk_no"));
				}

				// 随時入金登録マップ.随時入金明細リスト.調整後金額 → 随時請求登録明細.調整後金額
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg1List.AJST_AF_AMNT);
				}
				else
				{
					ajstAfAmnt = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT);
					childTemplate.set(ECH0051D011CBSMsg1List.AJST_AF_AMNT, ajstAfAmnt);
				}

				// 固定値："01"（追加） → 随時請求登録明細.料金調整区分
				childTemplate.set(ECH0051D011CBSMsg1List.AJST_DIV, "01");

				// 固定値：null → 随時請求登録明細.調整前金額
				childTemplate.setNull(ECH0051D011CBSMsg1List.AJST_BF_AMNT);

				// 固定値：null → 随時請求登録明細.調整フラグ
				childTemplate.setNull(ECH0051D011CBSMsg1List.AJST_FLG);

				templateArray[i] = childTemplate;

				// 電子ファイル管理登録情報リストに設定
				CAANMsg caEfileInfo = new CAANMsg();
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO, seikyKeiNo);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM, seikyYm);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO, svcKeiNo);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT, nyukinAmnt);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_GRP_CD, prcGrpCd);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD, pcrsCd);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD, prcSvcCd);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD, prcKmkCd);
				caEfileInfo.setPrivate(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT, ajstAfAmnt);
				this.efileInfoList.add(caEfileInfo);
			}
		}
		template.set(ECH0051D011CBSMsg.ECH0051D011CBSMSG1LIST, templateArray);
//v36.00.00 ANK-3296-00-00 Add Start
		ArrayList<HashMap<String, Object>> inList2 = this.getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST2);
		CAANMsg[] templateArray2 = template.getCAANMsgList(ECH0051D011CBSMsg.ECH0051D011CBSMSG3LIST);

		if (templateArray2 == null)
		{
			templateArray2 = new CAANMsg[inList2.size()];
		}

		if (inList2 != null)
		{
			for (int i = 0; i < inList2.size(); i++)
			{
				HashMap<String, Object> childMap = inList2.get(i);

				CAANMsg childTemplate = templateArray2[i];
				if (childTemplate == null)
				{
					childTemplate = new CAANMsg(ECH0051D011CBSMsg3List.class.getName());
				}
				
				String svcKeiNo = JACStrConst.SEIKY_KEI_NO_SP;  // サービス契約番号
				String prcGrpCd = JACStrConst.PRC_GRP_CD_SP;    // 料金グループコード
				String pcrsCd = JACStrConst.PCRS_CD_SP;         // 料金コースコード
				String prcSvcCd = JACStrConst.PRC_SVC_CD_SP;    // 料金サービスコード
				String prcKmkCd = JACStrConst.KARA_MOJI;        // 料金項目コード
				String ajstAfAmnt =JACStrConst.KARA_MOJI;       // 調整後金額
				
				// 随時入金登録マップ.随時入金明細リスト.サービス契約番号 → 随時請求登録明細.サービス契約番号
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.SVC_KEI_NO);
				}
				else
				{
					svcKeiNo = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO);
					childTemplate.set(ECH0051D011CBSMsg3List.SVC_KEI_NO, svcKeiNo);
				}
				
				// 随時入金登録マップ.随時入金明細リスト.整理番号 → 随時請求登録明細.整理番号
				if (childMap == null || childMap.get("seiri_no") == null || "".equals(childMap.get("seiri_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.SEIRI_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.SEIRI_NO, (String)childMap.get("seiri_no"));
				}
				
				// 随時入金登録マップ.随時入金明細リスト.料金グループコード → 随時請求登録明細.料金グループコード
				if (childMap == null || childMap.get("prc_grp_cd") == null || "".equals(childMap.get("prc_grp_cd")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.PRC_GRP_CD);
				}
				else
				{
					prcGrpCd = (String)childMap.get("prc_grp_cd");
					childTemplate.set(ECH0051D011CBSMsg3List.PRC_GRP_CD, prcGrpCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金コースコード → 随時請求登録明細.料金コースコード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD) == null || "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.PCRS_CD);
				}
				else
				{
					pcrsCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD);
					childTemplate.set(ECH0051D011CBSMsg3List.PCRS_CD, pcrsCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金サービスコード → 随時請求登録明細.料金サービスコード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.PRC_SVC_CD);
				}
				else
				{
					prcSvcCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD);
					childTemplate.set(ECH0051D011CBSMsg3List.PRC_SVC_CD, prcSvcCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.料金項目コード → 随時請求登録明細.料金項目コード
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.PRC_KMK_CD);
				}
				else
				{
					prcKmkCd = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD);
					childTemplate.set(ECH0051D011CBSMsg3List.PRC_KMK_CD, prcKmkCd);
				}

				// 随時入金登録マップ.随時入金明細リスト.利用開始年月日 → 随時請求登録明細.利用開始年月日
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.USE_STAYMD);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.USE_STAYMD, (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD));
				}

				// 随時入金登録マップ.随時入金明細リスト.利用終了年月日 → 随時請求登録明細.利用終了年月日
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.USE_ENDYMD);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.USE_ENDYMD, (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD));
				}

				// 随時入金登録マップ.随時入金明細リスト.マンションＩＤ → 随時請求登録明細.マンションＩＤ
				if (childMap == null || childMap.get("mansion_id") == null || "".equals(childMap.get("mansion_id")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.MANSION_ID);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.MANSION_ID, (String)childMap.get("mansion_id"));
				}

				// 随時入金登録マップ.随時入金明細リスト.回線場所住所補記＿部屋番号 → 随時請求登録明細.回線場所住所補記＿部屋番号
				if (childMap == null || childMap.get("kaisen_place_adrrm") == null || "".equals(childMap.get("kaisen_place_adrrm")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.KAISEN_PLACE_ADRRM);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.KAISEN_PLACE_ADRRM, (String)childMap.get("kaisen_place_adrrm"));
				}

				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号 → 随時請求登録明細.サービス詳細識別番号
				if (childMap == null || childMap.get("svc_dtl_skbt_no") == null || "".equals(childMap.get("svc_dtl_skbt_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.SVC_DTL_SKBT_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.SVC_DTL_SKBT_NO, (String)childMap.get("svc_dtl_skbt_no"));
				}

				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号区分 → 随時請求登録明細.サービス詳細識別番号区分
				if (childMap == null || childMap.get("svc_dtl_skbt_no_kbn") == null || "".equals(childMap.get("svc_dtl_skbt_no_kbn")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.SVC_DTL_SKBT_NO_KBN);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.SVC_DTL_SKBT_NO_KBN, (String)childMap.get("svc_dtl_skbt_no_kbn"));
				}

				// 随時入金登録マップ.随時入金明細リスト.請求内訳番号 → 随時請求登録明細.請求内訳番号
				if (childMap == null || childMap.get("seiky_ucwk_no") == null || "".equals(childMap.get("seiky_ucwk_no")))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.SEIKY_UCWK_NO);
				}
				else
				{
					childTemplate.set(ECH0051D011CBSMsg3List.SEIKY_UCWK_NO, (String)childMap.get("seiky_ucwk_no"));
				}

				// 随時入金登録マップ.随時入金明細リスト.調整後金額 → 随時請求登録明細.調整後金額
				if (childMap == null || childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT) == null
						|| "".equals(childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT)))
				{
					childTemplate.setNull(ECH0051D011CBSMsg3List.AJST_AF_AMNT);
				}
				else
				{
					ajstAfAmnt = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT);
					childTemplate.set(ECH0051D011CBSMsg3List.AJST_AF_AMNT, ajstAfAmnt);
				}

				// 固定値："01"（追加） → 随時請求登録明細.料金調整区分
				childTemplate.set(ECH0051D011CBSMsg3List.AJST_DIV, "01");

				// 固定値：null → 随時請求登録明細.調整前金額
				childTemplate.setNull(ECH0051D011CBSMsg3List.AJST_BF_AMNT);

				// 固定値：null → 随時請求登録明細.調整フラグ
				childTemplate.setNull(ECH0051D011CBSMsg3List.AJST_FLG);

				templateArray2[i] = childTemplate;

			}
		}
		template.set(ECH0051D011CBSMsg.ECH0051D011CBSMSG3LIST, templateArray2);
//v36.00.00 ANK-3296-00-00 Add End

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求債権関連登録サービスIF用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0041D010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		CAANMsg[] templateArray = template.getCAANMsgList(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST);
		if (templateArray == null)
		{
			templateArray = new CAANMsg[1];
		}

		for (int i = 0; i < 1; i++)
		{
			CAANMsg childTemplate = templateArray[i];
			if (childTemplate == null)
			{
				childTemplate = new CAANMsg(ECH0041D010CBSMsg1List.class.getName());
			}

			// 随時入金登録マップ.請求番号 → 請求債権関連明細.引き継ぎ元請求番号
			if (inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO)))
			{
				childTemplate.setNull(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO);
			}
			else
			{
				childTemplate.set(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO));
			}

			// NULL固定 → 請求債権関連明細.引き継ぎ先請求番号
			childTemplate.setNull(ECH0041D010CBSMsg1List.TRA_SK_SEIKY_NO);

			// 随時入金登録マップ.債権番号 → 請求債権関連明細.引き継ぎ元債権番号
			if (inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO)))
			{
				childTemplate.setNull(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO);
			}
			else
			{
				childTemplate.set(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
			}
			templateArray[i] = childTemplate;
		}
		template.set(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST, templateArray);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 入金登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param cvsPayRsvYmd コンビニ支払予定年月日
	 * @param creShunoYmd クレジット用の収納日
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0111D010(IRequestParameterReadWrite param, String cvsPayRsvYmd, String creShunoYmd
			, HashMap<String, String> hrkmBankCdMap) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 電子ファイル管理登録入金情報マップの初期化
		this.efileNyukinInfoMap = new HashMap<String, String>();
		String nyukinRouteCd = JACStrConst.KARA_MOJI;  // 入金経路コード
		String shunoKikanCd = JACStrConst.KARA_MOJI;   // 収納機関コード
		String shunoYmd = JACStrConst.KARA_MOJI;       // 外部組織収納年月日
		String nyukinTrnYmd = JACStrConst.KARA_MOJI;   // 入金処理年月日
		String receiptYmd = JACStrConst.KARA_MOJI;     // 領収年月日
		String bankCd = JACStrConst.KARA_MOJI;         // 金融機関コード
		String bankShitenCd = JACStrConst.KARA_MOJI;   // 金融機関支店コード
		String crecardCompCd = JACStrConst.KARA_MOJI;  // クレジットカード会社コード
		String cvstoreCd= JACStrConst.KARA_MOJI;       // コンビニエンスストアコード
		String orgCd = JACStrConst.KARA_MOJI;          // 組織コード
		String sknkSitkcmCd = JACStrConst.KARA_MOJI;   // 債権回収委託会社コード

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

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

		// 入金ステータス(固定：入金済み) → 入金ステータス
		template.set(ECH0111D010CBSMsg.NYUKIN_STAT_CD, JACStrConst.NYUKIN_STAT_ZUMI);

		// 随時入金登録マップ.入金経路コード → 入金経路コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD);
		}
		else
		{
			nyukinRouteCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
			//v52.00.00 Add Start
			//ANK-4415-00-00 DEL START
			//if(JACStrConst.SHNKKNCD_CVSTORE_ETC_NORMAL_CUST.equals(nyukinRouteCd) || JACStrConst.SHNKKNCD_CVSTORE_ETC_NORMAL_COMP.equals(nyukinRouteCd) ||
			//		JACStrConst.SHNKKNCD_CVSTORE_REAL_CUST.equals(nyukinRouteCd) || JACStrConst.SHNKKNCD_CVSTORE_REAL_COMP.equals(nyukinRouteCd))
			//{
			//	nyukinRouteCd = JACStrConst.NYKNKEIRCD_CVSTORE_ETC;
			//}
			//ANK-4415-00-00 DEL END
			//v52.00.00 Add End
			template.set(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD, nyukinRouteCd);
		}

		// 随時入金登録マップ.収納機関コード → 収納機関コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.SHUNOKIKAN_CD);
		}
		else
		{
			shunoKikanCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD);
			template.set(ECH0111D010CBSMsg.SHUNOKIKAN_CD, shunoKikanCd);
		}

		// 随時入金登録マップ.外部組織収納年月日 → 外部組織収納年月日
		if (creShunoYmd != null)
		{
			shunoYmd = creShunoYmd;
			template.set(ECH0111D010CBSMsg.SHUNO_YMD, creShunoYmd);
		}
		else if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD)))
		{
			template.setNull(ECH0111D010CBSMsg.SHUNO_YMD);
		}
		else
		{
			shunoYmd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD);
			template.set(ECH0111D010CBSMsg.SHUNO_YMD, shunoYmd);
		}

		// オンライン運用日 → 入金処理年月日
		nyukinTrnYmd = JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);
		template.set(ECH0111D010CBSMsg.NYUKIN_TRN_YMD, nyukinTrnYmd);

		// 入金処理時分秒
		template.set(ECH0111D010CBSMsg.NYUKIN_TRN_HMS, JCCBPCommon.getOpeDateTimeStamp(null).substring(8, 17));

		// 随時入金登録マップ.領収年月日 → 領収年月日
		if (creShunoYmd != null)
		{
			receiptYmd = creShunoYmd;
			template.set(ECH0111D010CBSMsg.RECEIPT_YMD, creShunoYmd);
		}
		else if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD)))
		{
			template.setNull(ECH0111D010CBSMsg.RECEIPT_YMD);
		}
		else
		{
			receiptYmd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD);
			template.set(ECH0111D010CBSMsg.RECEIPT_YMD, receiptYmd);
		}

		// 領収時分秒
		template.setNull(ECH0111D010CBSMsg.RECEIPT_HMS);

		// 随時入金登録マップ.入金額 → 入金額
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT)))
		{
			template.setNull(ECH0111D010CBSMsg.NYUKIN_AMNT);
		}
		else
		{
			template.set(ECH0111D010CBSMsg.NYUKIN_AMNT, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT));
		}

		// 随時入金登録マップ.請求番号 → 請求番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO)))
		{
			template.setNull(ECH0111D010CBSMsg.SEIKY_NO);
		}
		else
		{
			template.set(ECH0111D010CBSMsg.SEIKY_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO));
		}

		// 随時入金登録マップ.請求契約番号 → 請求契約番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0111D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0111D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		}

		// 入金登録方法コード(固定：入金登録) → 入金登録方法コード
		template.set(ECH0111D010CBSMsg.NYUKIN_ADD_WAY_CD, JACStrConst.NYUKIN_ADD_WAY_ZUIJI_NKIN);

		// 入金処理済フラグ(固定：処理済) → 入金処理済フラグ
		template.set(ECH0111D010CBSMsg.NYUKIN_SYRZM_FLG, JACStrConst.NKIN_SYORI_ZUMI_FLG_SUMI);

		// 随時入金登録マップ.窓口金融機関コード → 窓口金融機関コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_CD) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD);
		}
		else
		{
			bankCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_CD);
			template.set(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD, bankCd);
		}

		// 随時入金登録マップ.窓口金融機関支店コード → 窓口金融機関支店コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_SHITEN_CD) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_SHITEN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD);
		}
		else
		{
			bankShitenCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_MADOGUCHI_BANK_SHITEN_CD);
			template.set(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD, bankShitenCd);
		}

		// 随時入金登録マップ.口座振替金融機関コード → 口座振替金融機関コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.KHRI_BANK_CD);
		}
		else
		{
			bankCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_CD);
			template.set(ECH0111D010CBSMsg.KHRI_BANK_CD, bankCd);
		}

		// 随時入金登録マップ.口座振替金融機関支店コード → 口座振替金融機関支店コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_SHITEN_CD) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_SHITEN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD);
		}
		else
		{
			bankShitenCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KHRI_BANK_SHITEN_CD);
			template.set(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD, bankShitenCd);
		}

		// 随時入金登録マップ.クレジットカード会社コード → クレジットカード会社コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CRECARD_COMP_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CRECARD_COMP_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.CRECARD_COMP_CD);
		}
		else
		{
			crecardCompCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CRECARD_COMP_CD);
			template.set(ECH0111D010CBSMsg.CRECARD_COMP_CD, crecardCompCd);
		}

		// 随時入金登録マップ.債権回収委託会社コード → 債権回収委託会社コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SKNKSITKCM_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SKNKSITKCM_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.SKNKSITKCM_CD);
		}
		else
		{
			sknkSitkcmCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SKNKSITKCM_CD);
			template.set(ECH0111D010CBSMsg.SKNKSITKCM_CD, sknkSitkcmCd);
		}

		// 随時入金登録マップ.指定口座コード → 指定口座コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHITEIKOZA_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHITEIKOZA_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.SHITEIKOZA_CD);
		}
		else
		{
			template.set(ECH0111D010CBSMsg.SHITEIKOZA_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHITEIKOZA_CD));
		}

		// 入金経路コードが窓口（現金）の場合、業務パラメータから取得した値を設定する
		if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_GENKIN))
		{
			String shiteiKozaCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHITEIKOZA_CD);
			
			String hrkmBankCd = null; 
			String hrkmBankStnCd = null; 
			if(shiteiKozaCd != null && !shiteiKozaCd.equals(JACStrConst.KARA_MOJI) 
					&& hrkmBankCdMap != null && hrkmBankCdMap.size() != 0)
			{
				String strHrkmBankCd = hrkmBankCdMap.get(shiteiKozaCd);
				if(strHrkmBankCd != null && !strHrkmBankCd.equals(JACStrConst.KARA_MOJI))
				{
					String[] hrkmBankCdList = hrkmBankCdMap.get(shiteiKozaCd).split(JACStrConst.SLASH);
					if(hrkmBankCdList.length != 0)
					{
						hrkmBankCd = hrkmBankCdList[0];
						hrkmBankStnCd = hrkmBankCdList[1];
					}
				}
			}
			template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD, hrkmBankCd);
			template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD, hrkmBankStnCd);
			
			bankCd = hrkmBankCd;
			bankShitenCd = hrkmBankStnCd;
		}
		else
		{
			// 随時入金登録マップ.払込先金融機関コード → 払込先金融機関コード
			if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_CD) == null
					|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_CD)))
			{
				template.setNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD);
			}
			else
			{
				bankCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_CD);
				template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD, bankCd);
			}
	
			// 随時入金登録マップ.払込先金融機関支店コード → 払込先金融機関支店コード
			if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD) == null
					|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD)))
			{
				template.setNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD);
			}
			else
			{
				bankShitenCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD);
				template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD, bankShitenCd);
			}
		}

		// 随時入金登録マップ.受取組織コード → 受取組織コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UKETORI_ORG_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UKETORI_ORG_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.UKETORI_ORG_CD);
		}
		else
		{
			orgCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UKETORI_ORG_CD);
			template.set(ECH0111D010CBSMsg.UKETORI_ORG_CD, orgCd);
		}

		// 随時入金登録マップ.社内使用分組織コード → 社内使用分組織コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SYAYOBUN_ORG_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SYAYOBUN_ORG_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD);
		}
		else
		{
			orgCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SYAYOBUN_ORG_CD);
			template.set(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD, orgCd);
		}

		// 随時入金登録マップ.コンビニエンスストアコード → コンビニエンスストアコード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CVSTORE_CD) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CVSTORE_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.CVSTORE_CD);
		}
		else
		{
			cvstoreCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CVSTORE_CD);
			template.set(ECH0111D010CBSMsg.CVSTORE_CD, cvstoreCd);
		}

		// 固定(NULL) → コンビニ受付店コード
		template.setNull(ECH0111D010CBSMsg.CVSTORE_UK_TEN_CD);

		// 入金経路コードがコンビニの場合
		if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE))
		{
			// EANメーカーコード（通常) → ＥＡＮメーカーコード
			template.set(ECH0111D010CBSMsg.EAN_MAKER_CD, JACStrConst.EAN_MAKER_CD_NOMAL);
		}
		//v52.00.00 Add Start
		// 入金経路コードがコンビニ等の場合
		else if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE_ETC))
		{
			// 収納機関コードがコンビニ等（通：顧）の場合
			if(JACStrConst.SHNKKNCD_CVSTORE_ETC_NORMAL_CUST.equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))
			{
				// EANメーカーコード（通常・顧客負担・さくら) → ＥＡＮメーカーコード
				template.set(ECH0111D010CBSMsg.EAN_MAKER_CD, JACStrConst.MAKER_CD_NOMAL_CUST_FTN_SAKURA);
			}
			// 収納機関コードがコンビニ等（通：企）の場合
			else if(JACStrConst.SHNKKNCD_CVSTORE_ETC_NORMAL_COMP.equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))
			{
				// EANメーカーコード（通常・企業負担・さくら) → ＥＡＮメーカーコード
				template.set(ECH0111D010CBSMsg.EAN_MAKER_CD, JACStrConst.MAKER_CD_NOMAL_COMP_FTN_SAKURA);
			}
			// 収納機関コードがコンビニ等（リ：顧）の場合
			else if(JACStrConst.SHNKKNCD_CVSTORE_REAL_CUST.equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))
			{
				// EANメーカーコード（リアル・顧客負担・さくら) → ＥＡＮメーカーコード
				template.set(ECH0111D010CBSMsg.EAN_MAKER_CD, JACStrConst.MAKER_CD_REAL_CUST_FTN_SAKURA);
			}
			// 収納機関コードがコンビニ等（リ：企）の場合
			else if(JACStrConst.SHNKKNCD_CVSTORE_REAL_COMP.equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))
			{
				// EANメーカーコード（リアル・企業負担・さくら) → ＥＡＮメーカーコード
				template.set(ECH0111D010CBSMsg.EAN_MAKER_CD, JACStrConst.MAKER_CD_REAL_COMP_FTN_SAKURA);
			}
		}
		//v52.00.00 Add End
		else
		{
			// 入金経路コードがそれ以外
			// 固定(NULL) → ＥＡＮメーカーコード
			template.setNull(ECH0111D010CBSMsg.EAN_MAKER_CD);
		}

		// 固定(NULL) → コンビニリアル業務コード
		template.setNull(ECH0111D010CBSMsg.CVSTORE_REAL_WORK_CD);

		// 固定(NULL) → コンビニリアル速報通知年月日
		template.setNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_YMD);

		// 固定(NULL) → コンビニリアル速報通知時分秒
		template.setNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_HMS);

		// 固定(NULL) → コンビニリアル速報処理済フラグ
		template.setNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_ZUM_FLG);

		// 固定(NULL) → コンビニ速報通知年月日
		template.setNull(ECH0111D010CBSMsg.CVSTORE_SOKHO_TCH_YMD);

		// 固定(NULL) → コンビニ速報処理済フラグ
		template.setNull(ECH0111D010CBSMsg.CVSTORE_SOKHO_ZUM_FLG);

		// 固定(NULL) → コンビニ確報通知年月日
		template.setNull(ECH0111D010CBSMsg.CVSTORE_KAKHO_TCH_YMD);

		//v52.00.00 Mod Start
		// 入金経路コード（コンビニ）
		if (JACStrConst.NYKNKEIRCD_CVSTORE.equals(nyukinRouteCd))
		{
			// パラメータ(コンビニ支払予定年月日) → コンビニ支払予定年月日
			if (cvsPayRsvYmd == null)
			{
				template.setNull(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD);
			}
			else
			{
				template.set(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD, cvsPayRsvYmd);
			}
		}
		// v59.00.00 2022/04/18 ANK-4160-00-00 MOD START
//		else if (JACStrConst.NYKNKEIRCD_CVSTORE_ETC.equals(nyukinRouteCd))
		else if (JACStrConst.NYKNKEIRCD_CVSTORE_ETC.equals(nyukinRouteCd)
				|| JACStrConst.NYKNKEIRCD_KESSAI_SMBC.equals(nyukinRouteCd))
		// v59.00.00 2022/04/18 ANK-4160-00-00 MOD END
		{
			// コンビニ支払予定年月日
			//収納年月日の翌月15日を取得する
			String cvsPayRsvYmd2 = null;
			try {
				cvsPayRsvYmd2 = JPCUtilCommon.addMonth((String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD), 1);
			} catch (ParseException e) {
				e.printStackTrace();
			}
			cvsPayRsvYmd2 = cvsPayRsvYmd2.substring(0, 6) + "15";
			template.set(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD, cvsPayRsvYmd2);
		}
		//v52.00.00 Mod End

		// 固定(NULL) → コンビニ取消通知年月日
		template.setNull(ECH0111D010CBSMsg.CVSTORE_CL_TCH_YMD);

		// 随時入金登録マップ.郵券受取組織コード → 郵券受取組織コード
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_YUKEN_UKETORI_ORG_CD) == null
				|| "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_YUKEN_UKETORI_ORG_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD);
		}
		else
		{
			orgCd = (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_YUKEN_UKETORI_ORG_CD);
			template.set(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD, orgCd);
		}

		//ANK-4415-00-00 MOD START
		// 入金経路コードが"郵便振込"または"郵便自動振込（ＣＰ）"または"郵便自動振込"の場合、マップから金融機関コード、金融機関支店コードを取得
//		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_FURIKM) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO))
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_FURIKM) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_CP)
				|| nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_SMBCFS))
		//ANK-4415-00-00 MOD END
		{
			HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
			List dataList = (ArrayList)dataMap.get("EZM0321A010CBSMsg1List");

			if (dataList != null && !dataList.isEmpty())
			{
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(0);
				bankCd = (String)childMap.get("work_param_sette_value");
			}

			List dataList2 = (ArrayList)dataMap.get("EKK0511B004CBSMsg1List");

			if (dataList2 != null && !dataList2.isEmpty())
			{
				// 1件しか存在しないため1件目を使用
				HashMap<String, Object> childMap2 = (HashMap<String, Object>)dataList2.get(0);
				bankShitenCd = (String)childMap2.get("bank_shiten_cd");
			}
		}

		//ANK-4415-00-00 MOD START
		// 入金経路コードが"郵便自動振込（ＣＰ）"または"郵便自動振込"の場合、
//		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO))
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_CP) || nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_SMBCFS))
		//ANK-4415-00-00 MOD END
		{
			// 郵便自動振込金融機関コード
			template.set(ECH0111D010CBSMsg.YJHRI_BANK_CD, bankCd);

			// 郵便自動振込金融機関支店コード
			template.set(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD, bankShitenCd);
		}
		else
		{
			// 固定(NULL) → 郵便自動振込金融機関コード
			template.setNull(ECH0111D010CBSMsg.YJHRI_BANK_CD);

			// 固定(NULL) → 郵便自動振込金融機関支店コード
			template.setNull(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD);
		}

		// 入金経路コードが"郵便振込"の場合、
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_YUBIN_FURIKM))
		{
			// 郵便振込金融機関コード
			template.set(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD, bankCd);

			// 郵便振込金融機関支店コード
			template.set(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD, bankShitenCd);
		}
		else
		{
			// 固定(NULL) → 郵便振込金融機関コード
			template.setNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD);

			// 固定(NULL) → 郵便振込金融機関支店コード
			template.setNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD);
		}

		templateList.add(template);

		// 電子ファイル管理登録入金情報マップに設定
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD, shunoKikanCd);     // 収納機関コード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD, shunoYmd);             // 外部組織収納年月日
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_TRN_YMD, nyukinTrnYmd);    // 入金処理年月日
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD, receiptYmd);         // 領収年月日
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_BANK_CD, bankCd);                 // 金融機関コード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_BANK_SHITEN_CD, bankShitenCd);    // 金融機関支店コード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_CRECARD_COMP_CD, crecardCompCd);  // クレジットカード会社コード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_CVSTORE_CD, cvstoreCd);           // コンビニエンスストアコード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ORG_CD, orgCd);                   // 組織コード
		efileNyukinInfoMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SKNKSITKCM_CD, sknkSitkcmCd);     // 債権回収委託会社コード

		return templateList;
	}

	/**
	 * 電子ファイル管理登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @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, JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECC0041D010, ECC0041D010CBSMsg.FUNC_CODE);

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

		/* ◇業務データの設定 */
		// 機能コード
		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 azukinMap 預り金明細１件のマップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsgECH0191D020_1(IRequestParameterReadWrite param, HashMap<String, Object> azukinMap) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);

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

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

		// 金庫番号
		template.set(ECH0191D020CBSMsg.KNK_NO, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO));

		// 移動元請求契約番号
		template.set(ECH0191D020CBSMsg.IDO_MT_SEIKY_KEI_NO, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));

		// 入金番号
		template.set(ECH0191D020CBSMsg.NYUKIN_NO, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO));

		// 金庫料金項目コード
		template.set(ECH0191D020CBSMsg.KNK_PRC_KMK_CD, JACStrConst.PRC_KMK_CD_AZUKIN);

		// 精算方法コード
		if (azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD) == null || "".equals(((String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD)).trim()))
		{
			template.setNull(ECH0191D020CBSMsg.SSN_WAY_CD);
		}
		else
		{
			template.set(ECH0191D020CBSMsg.SSN_WAY_CD, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD));
		}

		// 金庫金額
		template.set(ECH0191D020CBSMsg.KNK_AMNT, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));

		// 督促番号
		template.setNull(ECH0191D020CBSMsg.TOKUSOKU_NO);

		// 督促金額
		template.setNull(ECH0191D020CBSMsg.TOKUSOKU_AMNT);

		// 移動元金庫更新年月日時分秒
		template.set(ECH0191D020CBSMsg.KNK_UPD_DTM, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_UPD_DTM));

		// ---金庫移動登録明細
		CAANMsg[] childTemplateArray = new CAANMsg[1];
		template.set(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST, childTemplateArray);

		CAANMsg childTemplate = new CAANMsg(ECH0191D020CBSMsg1List.class.getName());
		// 請求契約番号
		childTemplate.set(ECH0191D020CBSMsg1List.SEIKY_KEI_NO, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));

		// 移動先金庫料金項目コード
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF, JACStrConst.PRC_KMK_CD_ZUMI_AZUKIN_JUTO);

		// 移動先精算方法コード
		childTemplate.set(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF, JACStrConst.SSN_WAY_CD_AZUKIN_JUTO);

		// 移動先金庫金額
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_AMNT_AF, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));

		childTemplateArray[0] = childTemplate;

		return template;
	}

	/**
	 * 金庫移動登録サービスインターフェイス用メッセージ設定処理［金庫金額の一部］<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param zujiNkinMap 随時入金明細１件のマップ
	 * @param azukinMap 預り金明細１件のマップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsgECH0191D020_2(IRequestParameterReadWrite param, HashMap<String, Object> zujiNkinMap, HashMap<String, Object> azukinMap)
			throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);

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

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

		// 移動元請求契約番号
		template.set(ECH0191D020CBSMsg.IDO_MT_SEIKY_KEI_NO, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));

		// 入金番号
		template.set(ECH0191D020CBSMsg.NYUKIN_NO, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO));

		// 金庫番号
		template.set(ECH0191D020CBSMsg.KNK_NO, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO));

		// 金庫料金項目コード
		template.set(ECH0191D020CBSMsg.KNK_PRC_KMK_CD, JACStrConst.PRC_KMK_CD_AZUKIN);

		// 精算方法コード
		if (azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD) == null || "".equals(((String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD)).trim()))
		{
			template.setNull(ECH0191D020CBSMsg.SSN_WAY_CD);
		}
		else
		{
			template.set(ECH0191D020CBSMsg.SSN_WAY_CD, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD));
		}

		// 金庫金額
		template.set(ECH0191D020CBSMsg.KNK_AMNT, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));

		// 督促番号
		template.setNull(ECH0191D020CBSMsg.TOKUSOKU_NO);

		// 督促金額
		template.setNull(ECH0191D020CBSMsg.TOKUSOKU_AMNT);

		// 移動元金庫更新年月日時分秒
		template.set(ECH0191D020CBSMsg.KNK_UPD_DTM, (String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_UPD_DTM));

		// ---金庫移動登録明細---
		CAANMsg childTemplate = null;
		CAANMsg[] childTemplateArray = new CAANMsg[2];
		template.set(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST, childTemplateArray);

		// １件目(内訳額分を処理済みに移動)
		childTemplate = new CAANMsg(ECH0191D020CBSMsg1List.class.getName());
		// 請求契約番号
		childTemplate.set(ECH0191D020CBSMsg1List.SEIKY_KEI_NO, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		// 移動先金庫料金項目コード
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF, JACStrConst.PRC_KMK_CD_ZUMI_AZUKIN_JUTO);
		// 移動先精算方法コード
		childTemplate.set(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF, JACStrConst.SSN_WAY_CD_AZUKIN_JUTO);
		// 移動先金庫金額
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_AMNT_AF, (String)zujiNkinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT));

		childTemplateArray[0] = childTemplate;

		// ２件目(残り金庫額を預り金に移動)
		childTemplate = new CAANMsg(ECH0191D020CBSMsg1List.class.getName());
		BigDecimal jutoAmntVal = new BigDecimal((String)zujiNkinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT));
		BigDecimal azukinVal = new BigDecimal((String)azukinMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT));
		String azukin = String.valueOf((azukinVal.subtract(jutoAmntVal)));

		// 請求契約番号
		childTemplate.set(ECH0191D020CBSMsg1List.SEIKY_KEI_NO, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		// 移動先金庫料金項目コード
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF, JACStrConst.PRC_KMK_CD_AZUKIN);
		// 移動先精算方法コード
		childTemplate.setNull(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF);
		// 移動先金庫金額
		childTemplate.set(ECH0191D020CBSMsg1List.KNK_AMNT_AF, azukin);

		childTemplateArray[1] = childTemplate;

		return template;
	}

	/**
	 * 充当登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param jutoSaikenMap 充当債権リスト１件のマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0201D010(IRequestParameterReadWrite param, HashMap<String, Object> jutoSaikenMap) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// オンライン運用年月日
		String opeDate = JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);

//OM-2014-0002355 DEL START
//		// 随時入金明細リスト.内訳額の合計
//		BigDecimal jutoAmntSum = this.sumUpJutoAmnt(inMap);
//OM-2014-0002355 DEL END

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

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

		/* ++++++++++ v10.00.00 変更開始 ++++++++++ */
//		// 固定値("1"：手動入金) → 充当種別コード
//		template.set(ECH0201D010CBSMsg.JUTO_SBT_CD, JACStrConst.JUTO_SBT_MANUAL_NKIN);
		
		// 充当種別コードを設定する。
		// 入金経路コード
		String nyukinRouteCd = getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
		
		// 金庫充当の場合
		if (JACStrConst.NYKNKEIRCD_JUTO.equals(nyukinRouteCd))
		{
			// 預り金充当
			template.set(ECH0201D010CBSMsg.JUTO_SBT_CD, JACStrConst.JUTO_SBT_AZKIN_JUTO);
		}
		else
		{
			// 固定値("1"：手動入金) → 充当種別コード
			template.set(ECH0201D010CBSMsg.JUTO_SBT_CD, JACStrConst.JUTO_SBT_MANUAL_NKIN);
		}
		/* ++++++++++ v10.00.00 変更完了 ++++++++++ */
		
		// オンライン運用年月日 → 充当年月日
		template.set(ECH0201D010CBSMsg.JUTO_YMD, opeDate);

		// 充当債権マップ.充当額 → 充当額
		if (jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT) == null || "".equals(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT)))
		{
			template.setNull(ECH0201D010CBSMsg.JUTO_AMNT);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.JUTO_AMNT, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT));
		}
		// 充当債権マップマップ.入金番号 → 入金番号
		if (jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO) == null || "".equals(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO)))
		{
			template.setNull(ECH0201D010CBSMsg.NYUKIN_NO);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.NYUKIN_NO, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO));
		}
		// 充当債権マップマップ.金庫番号 → 金庫番号
		if (jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO) == null || "".equals(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO)))
		{
			template.setNull(ECH0201D010CBSMsg.KNK_NO);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.KNK_NO, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO));
		}
		// 随時入金登録マップ.請求契約番号 → 債権番号
		if (jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO) == null || "".equals(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO)))
		{
			template.setNull(ECH0201D010CBSMsg.SAIKEN_NO);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.SAIKEN_NO, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
		}

		// 随時入金登録マップ.入金額 → 入金額
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT)))
		{
			template.setNull(ECH0201D010CBSMsg.NYUKIN_AMNT);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.NYUKIN_AMNT, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT));
		}
//OM-2014-0002355 MOD START
//		// 随時入金登録マップ.随時入金明細リスト.内訳額の合計 → 充当額合計
//		template.set(ECH0201D010CBSMsg.JUTO_AMNT_SUM, String.valueOf(jutoAmntSum));
		// マンションの場合、充当額合計が倍になってしまうので、入金額（＝請求金額）を使用する
		// 随時入金登録マップ.入金額 → 充当額合計
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT)))
		{
			template.setNull(ECH0201D010CBSMsg.JUTO_AMNT_SUM);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.JUTO_AMNT_SUM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT));
		}
//OM-2014-0002355 MOD END

		// 随時入金登録マップ.預り金 → 金庫金額
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN)))
		{
			template.setNull(ECH0201D010CBSMsg.KNK_AMNT);
		}
		else
		{
			template.set(ECH0201D010CBSMsg.KNK_AMNT, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_AZUKIN));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 領収登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param jutoSaikenMap 充当債権リスト１件のマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
// OM-2014-0001880 MOD START
//	private ArrayList<CAANMsg> editInMsgECH0311D010(IRequestParameterReadWrite param, HashMap<String, Object> jutoSaikenMap) throws RequestParameterException
	private ArrayList<CAANMsg> editInMsgECH0311D010(IRequestParameterReadWrite param, HashMap<String, Object> jutoSaikenMap, String jutoNo) throws RequestParameterException
// OM-2014-0001880 MOD END
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		if (inMap == null)
		{
			inMap = new HashMap<String, Object>();
			param.setData(JCHZuijiNkinAddConstCC.MAP_CC_ID, inMap);
		}
		// 随時入金登録マップ.請求契約番号 →請求契約番号 
		if (JCRUtilCommon.isNull(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0311D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO));
		}
		// 随時入金登録マップ.入金経路コード → 入金経路コード
		if (JCRUtilCommon.isNull(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD)))
		{
			template.setNull(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_ROUTE_CD));
		}
		// 随時入金登録マップ.領収年月日 → 領収年月日
		if (JCRUtilCommon.isNull(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD)))
		{
			template.setNull(ECH0311D010CBSMsg.RECEIPT_YMD);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.RECEIPT_YMD, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD));
		}
		// 充当債権マップ.入金番号 → 入金番号
		if (JCRUtilCommon.isNull(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO)))
		{
			template.setNull(ECH0311D010CBSMsg.NYUKIN_NO);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.NYUKIN_NO, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO));
		}
		// 充当債権マップ.充当額 → 充当額
		if (JCRUtilCommon.isNull(jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT)))
		{
			template.setNull(ECH0311D010CBSMsg.JUTO_AMNT);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.JUTO_AMNT, (String)jutoSaikenMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT));
		}

		// 固定値(：オンライン運用年月日) → 入金処理年月日
		template.set(ECH0311D010CBSMsg.NYUKIN_TRN_YMD, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		// 随時入金登録マップ.請求年月 → 債権年月
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM)))
		{
			template.setNull(ECH0311D010CBSMsg.SAIKEN_YM);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.SAIKEN_YM, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM));
		}

		// 固定値("1"：窓口払い) → 請求方法コード→ 請求方法コード
		template.set(ECH0311D010CBSMsg.SEIKY_WAY_CD, JACStrConst.SEIKY_WAY_CD_MDGC);
		
// OM-2014-0001880 MOD START
//		// 固定値("0"：初期値) → 充当額うち消費税額
//		template.set(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX, "0");
		// 随時入金登録マップ.消費税額 →  充当額うち消費税額
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT_UCHI_STAX) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT_UCHI_STAX)))
		{
			template.setNull(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX);
		}
		else
		{
			// 充当が1回の場合は債権額＝充当額となるので債権うち消費税額を充当額うち消費税額に設定
			if (jutoNoList.size() == 1)
			{
				// 随時入金登録マップ.債権うち消費税額 → 充当額うち消費税額
				template.set(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT_UCHI_STAX));
			}
			// 充当が複数
			else if (jutoNoList.size() > 1)
			{
				// 充当金額うち消費税額を初期値"0"で設定し、サービスインターフェイスにて割戻し計算を行う
				template.set(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX, "0");
			}
			else
			{
				template.setNull(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX);
			}
		}
// OM-2014-0001880 MOD END
		
		// 固定値(NULL) → 入金処理時分秒
		template.setNull(ECH0311D010CBSMsg.NYUKIN_TRN_HMS);
		// 固定値(NULL) → 領収時分秒
		template.setNull(ECH0311D010CBSMsg.RECEIPT_HMS);
		
// OM-2014-0001880 ADD START
		// 随時入金登録マップ.債権番号 → 債権番号
		if (inMap == null || inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO) == null || "".equals(inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO)))
		{
			template.setNull(ECH0311D010CBSMsg.SAIKEN_NO);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.SAIKEN_NO, (String)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
		}
		
		// 固定値("3"：随時入金) → 請求種別コードl
		template.set(ECH0311D010CBSMsg.SEIKY_SBT_CD, JACStrConst.SIKYSHBTS_JUIJ_JNYUKIN);
		
		// 充当番号リスト.充当番号 → 充当番号
		if (JCRUtilCommon.isNull(jutoNo))
		{
			template.setNull(ECH0311D010CBSMsg.JUTO_NO);
		}
		else
		{
			template.set(ECH0311D010CBSMsg.JUTO_NO, jutoNo);
		}
// OM-2014-0001880 ADD END

		templateList.add(template);

		return templateList;
	}
	
	
	/**
	 * 上りマッピング（料金スケジュール定義一意照会）
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECH0501A010_2(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		
		CAANMsg template = new CAANMsg(ECH0501A010CBSMsg.class.getName());
				
		// テンプレートID
		template.set(ECH0501A010CBSMsg.TEMPLATEID, "ECH0501A010");

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

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

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

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

		// イベントコード(コンビニ)
		template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, JACStrConst.SHNKKNCD_CVSTORE);
		
		// 料金スケジュール定義一意照会イベント年月日
		template.set(ECH0501A010CBSMsg.KEY_EVENT_YMD, JCCBPCommon.getOpeDate(null));
		
		// 料金スケジュール定義一意照会.運用日
		template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, getMapItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 上りマッピング（料金スケジュール定義一意照会）
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECH0501A010_3(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		
		CAANMsg template = new CAANMsg(ECH0501A010CBSMsg.class.getName());
				
		// テンプレートID
		template.set(ECH0501A010CBSMsg.TEMPLATEID, "ECH0501A010");

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

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

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

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

		// イベントコード(会計処理日)
		template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, JACStrConst.EVENT_CD_KAIK_SHORI_YMD);
		
		// 料金スケジュール定義一意照会イベント年月日
		template.set(ECH0501A010CBSMsg.KEY_EVENT_YMD, JCCBPCommon.getOpeDate(null));
		
		// 料金スケジュール定義一意照会.運用日
		template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, JCCBPCommon.getOpeDate(null));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	
	/**
	 * 上りマッピング（営業日管理一覧照会）
	 * @param param リクエストパラメータ
	 * @param param 請求年月
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0291B010(IRequestParameterReadWrite param, String seikyYm) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		
		CAANMsg template = new CAANMsg(EZM0291B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EZM0291B010CBSMsg.TEMPLATEID, "EZM0291B010");

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

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

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

		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// 検索結果最大件数
		template.set(EZM0291B010CBSMsg.MAX_SEARCH_NUM, String.valueOf(Integer.MAX_VALUE));
		
		// KEY_年
		template.set(EZM0291B010CBSMsg.KEY_YEAR, seikyYm.substring(0, 4));
		
		// KEY_月
		template.set(EZM0291B010CBSMsg.KEY_MON, seikyYm.substring(4, 6));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 上りマッピング（業務パラメータ管理一意商会）
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

		// テンプレートID
		template.set(EZM0321A010CBSMsg.TEMPLATEID, JCHZuijiNkinAddConstCC.TEMPLATE_ID_EZM0321A010);

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

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

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

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

		// ＫＥＹ＿業務パラメータＩＤ
		template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, JACStrConst.WAKPARA_CH_BANK_CD_YUUCHO);

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

		return paramMap;
	}

	/**
	 * 上りマッピング（金融機関一覧照会）
	 * @param param リクエストパラメータ
	 * @param bankCd 金融機関コード
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0511B004(IRequestParameterReadWrite param, String bankCd) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		CAANMsg template = new CAANMsg(EKK0511B004CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0511B004CBSMsg.TEMPLATEID, JCHZuijiNkinAddConstCC.TEMPLATE_ID_EKK0511B004);

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

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

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

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

		// 検索結果最大件数
		template.set(EKK0511B004CBSMsg.MAX_SEARCH_NUM, String.valueOf(Integer.MAX_VALUE));

		// ＫＥＹ＿金融機関コード
		template.set(EKK0511B004CBSMsg.KEY_BANK_CD, bankCd);

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

		return paramMap;
	}

	/**
	 * 業務パラメータ管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param wkpara 業務パラメータ識別
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010_2(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

		// テンプレートID
		template.set(EZM0321A010CBSMsg.TEMPLATEID, JCHZuijiNkinAddConstCC.TEMPLATE_ID_EZM0321A010);

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

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

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

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

		// 業務パラメータID
		template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, JACStrConst.WKPARA_CH_HRKMSK_BANK_CD);

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

		return paramMap;
	}
	// ▲▲ サービスIF用メッセージ設定処理 ▲▲

	// ▼▼ サービスIF用メッセージ取得処理 ▼▼
	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsgEKK0491A010(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<String, Object> inMap = this.getMap(param);
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				// 随時入金登録マップ.契約請求方法コード ← 請求契約一意照会明細.請求方法コード
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_CD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KEI_SEIKY_WAY_CD, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_CD).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.次回請求方法コード ← 請求契約一意照会明細.次回請求方法コード
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.NEXT_SEIKY_WAY_DIV))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NEXT_SEIKY_WAY_DIV, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NEXT_SEIKY_WAY_DIV, childTemplate.getString(EKK0491A010CBSMsg1List.NEXT_SEIKY_WAY_DIV).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先法人格種別コード ← 請求契約一意照会明細.送付先法人格種別コード
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SHS_HOJIN_SBT_CD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_SBT_CD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_SBT_CD, childTemplate.getString(EKK0491A010CBSMsg1List.SHS_HOJIN_SBT_CD).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先法人格前後指定コード ← 請求契約一意照会明細.送付先法人格前後指定コード
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SHS_HOJIN_ZENGO_SHITEI_CD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_ZENGO_SHITEI_CD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_HOJIN_ZENGO_SHITEI_CD, childTemplate.getString(EKK0491A010CBSMsg1List.SHS_HOJIN_ZENGO_SHITEI_CD).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先カナ名 ← 請求契約一意照会明細.送付先カナ名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SHS_KANA))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_KANA, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SHS_KANA, childTemplate.getString(EKK0491A010CBSMsg1List.SHS_KANA));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_NM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先住所コード ← 請求契約一意照会明細.送付先住所コード
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_AD_CD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_CD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_CD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_AD_CD).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先郵便番号 ← 請求契約一意照会明細.送付先郵便番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_PCD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_PCD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_PCD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_PCD).trim());
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先都道府県名 ← 請求契約一意照会明細.送付先都道府県名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_STATE_NM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_STATE_NM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_STATE_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_STATE_NM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先市区町村名 ← 請求契約一意照会明細.送付先市区町村名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_CITY_NM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_CITY_NM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_CITY_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_CITY_NM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先大字通称名 ← 請求契約一意照会明細.送付先大字通称名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_OAZTSU_NM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_OAZTSU_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先字丁目名 ← 請求契約一意照会明細.送付先字丁目名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AZCHO_NM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AZCHO_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先住所補記・建物名 ← 請求契約一意照会明細.送付先住所補記・建物名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRTTM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRTTM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRTTM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRTTM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先住所補記・部屋番号 ← 請求契約一意照会明細.送付先住所補記・部屋番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRRM))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRRM, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_ADRRM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRRM));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先番地号 ← 請求契約一意照会明細.送付先番地号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_BNCHIGO, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_AD_BNCHIGO, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先電話番号 ← 請求契約一意照会明細.送付先電話番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_TELNO))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_TELNO, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_TELNO, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_TELNO));
				}

				// 随時入金登録マップ.請求契約一意照会明細.送付先メールアドレス ← 請求契約一意照会明細.送付先メールアドレス
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_MLAD))
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_MLAD, new String());
				}
				else
				{
					inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SOHUS_MLAD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_MLAD));
				}
			}
		}

		// エラー情報の設定
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0501A010(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<String, Object> inMap = this.getMap(param);
		ArrayList<HashMap<String, Object>> dataList = this.getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ECH0501A010CBSMsg1List);
		if (dataList == null)
		{
			dataList = new ArrayList<HashMap<String, Object>>();
		}
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size())
				{
					dataList.add(new HashMap<String, Object>());
				}
				HashMap<String, Object> childMap = dataList.get(i);
				
				// 随時入金登録マップ.請求年月 ← 料金スケジュール一意明細.請求年月
				if (childTemplate.isNull(ECH0501A010CBSMsg1List.SEIKY_YM))
				{
					childMap.put("seiky_ym", new String());
				}
				else
				{
					childMap.put("seiky_ym", childTemplate.getString(ECH0501A010CBSMsg1List.SEIKY_YM));
				}
			}
		}
		
		inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ECH0501A010CBSMsg1List, 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);
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0011D012(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<String, Object> inMap = this.getMap(param);
		// 払い出された債権番号を取得して設定する
		String saikenNoOut = parentTemplate.getString(ECH0011D012CBSMsg.SAIKEN_NO);
		inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO, saikenNoOut);

		// エラー情報の設定
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0051D010(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<String, Object> inMap = this.getMap(param);
		// 払い出された請求番号を取得して設定する
		String seikyNoOut = parentTemplate.getString(ECH0051D010CBSMsg.SEIKY_NO);
		inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_NO, seikyNoOut);

		// エラー情報の設定
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0051D011(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<String, Object> inMap = this.getMap(param);
		ArrayList<HashMap<String, Object>> dataList = this.getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ECH0051D011CBSMsg2List);
		if (dataList == null)
		{
			dataList = new ArrayList<HashMap<String, Object>>();
		}
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(ECH0051D011CBSMsg.ECH0051D011CBSMSG2LIST);
		// 機能コードが"2"の場合のみ、随時請求登録明細（表示用）をマッピング
		if (JPCModelConstant.FUNC_CD_2.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
		{
			if (templateArray != null)
			{
				for (int i = 0; i < templateArray.length; i++)
				{
					CAANMsg childTemplate = templateArray[i];
					if (i >= dataList.size())
					{
						dataList.add(new HashMap<String, Object>());
					}
					HashMap<String, Object> childMap = dataList.get(i);

					// 随時入金登録マップ.随時入金登録明細（表示用）.請求契約番号 ← 随時請求登録明細（表示用）.請求契約番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SEIKY_KEI_NO_OUT))
					{
						childMap.put("seiky_kei_no_out", new String());
					}
					else
					{
						childMap.put("seiky_kei_no_out", childTemplate.getString(ECH0051D011CBSMsg2List.SEIKY_KEI_NO_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.整理番号 ← 随時請求登録明細（表示用）.整理番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SEIRI_NO_OUT))
					{
						childMap.put("seiri_no_out", new String());
					}
					else
					{
						childMap.put("seiri_no_out", childTemplate.getString(ECH0051D011CBSMsg2List.SEIRI_NO_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.サービス契約番号 ← 随時請求登録明細（表示用）.サービス契約番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SVC_KEI_NO_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.SVC_KEI_NO_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金グループコード ← 随時請求登録明細（表示用）.料金グループコード
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PRC_GRP_CD_OUT))
					{
						childMap.put("prc_grp_cd_out", new String());
					}
					else
					{
						childMap.put("prc_grp_cd_out", childTemplate.getString(ECH0051D011CBSMsg2List.PRC_GRP_CD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金コースコード ← 随時請求登録明細（表示用）.料金コースコード
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PCRS_CD_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.PCRS_CD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金サービスコード ← 随時請求登録明細（表示用）.料金サービスコード
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PRC_SVC_CD_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.PRC_SVC_CD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金項目コード ← 随時請求登録明細（表示用）.料金項目コード
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PRC_KMK_CD_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.PRC_KMK_CD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.マンションＩＤ ← 随時請求登録明細（表示用）.マンションＩＤ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.MANSION_ID_OUT))
					{
						childMap.put("mansion_id_out", new String());
					}
					else
					{
						childMap.put("mansion_id_out", childTemplate.getString(ECH0051D011CBSMsg2List.MANSION_ID_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.回線場所住所補記＿部屋番号 ← 随時請求登録明細（表示用）.回線場所住所補記＿部屋番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.KAISEN_PLACE_ADRRM_OUT))
					{
						childMap.put("kaisen_place_adrrm_out", new String());
					}
					else
					{
						childMap.put("kaisen_place_adrrm_out", childTemplate.getString(ECH0051D011CBSMsg2List.KAISEN_PLACE_ADRRM_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.サービス詳細識別番号 ← 随時請求登録明細（表示用）.サービス詳細識別番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SVC_DTL_SKBT_NO_OUT))
					{
						childMap.put("svc_dtl_skbt_no_out", new String());
					}
					else
					{
						childMap.put("svc_dtl_skbt_no_out", childTemplate.getString(ECH0051D011CBSMsg2List.SVC_DTL_SKBT_NO_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.請求内訳番号 ← 随時請求登録明細（表示用）.請求内訳番号
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SEIKY_UCWK_NO_OUT))
					{
						childMap.put("seiky_ucwk_no_out", new String());
					}
					else
					{
						childMap.put("seiky_ucwk_no_out", childTemplate.getString(ECH0051D011CBSMsg2List.SEIKY_UCWK_NO_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.利用開始年月日 ← 随時請求登録明細（表示用）.利用開始年月日
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.USE_STAYMD_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_STAYMD_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.USE_STAYMD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.利用終了年月日 ← 随時請求登録明細（表示用）.利用終了年月日
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.USE_ENDYMD_OUT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_ENDYMD_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.USE_ENDYMD_OUT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.内訳額 ← 随時請求登録明細（表示用）.調整後金額
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.CYOSEI_AMNT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT_OUT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT_OUT, childTemplate.getString(ECH0051D011CBSMsg2List.CYOSEI_AMNT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金項目名称 ← 随時請求登録明細（表示用）.料金項目名称
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PRC_KMK_NM))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_NM, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_NM, childTemplate.getString(ECH0051D011CBSMsg2List.PRC_KMK_NM));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.埋込み項目コード ← 随時請求登録明細（表示用）.埋込み項目コード
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.UMKM_KMK_CD))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_UMKM_KMK_CD, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_UMKM_KMK_CD, childTemplate.getString(ECH0051D011CBSMsg2List.UMKM_KMK_CD));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.表示順 ← 随時請求登録明細（表示用）.表示順
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.DSP_JUN))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_DSP_JUN, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_DSP_JUN, childTemplate.getString(ECH0051D011CBSMsg2List.DSP_JUN));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.インデント数 ← 随時請求登録明細（表示用）.インデント数
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.INDENT_CNT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_INDENT_CNT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_INDENT_CNT, childTemplate.getString(ECH0051D011CBSMsg2List.INDENT_CNT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.請求書ＮＯ欄表示制御フラグ ← 随時請求登録明細（表示用）.請求書ＮＯ欄表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SKS_NO_RAN_DSP_CTRL_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SKS_NO_RAN_DSP_CTRL_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SKS_NO_RAN_DSP_CTRL_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.SKS_NO_RAN_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.サービス契約番号表示制御フラグ ← 随時請求登録明細（表示用）.サービス契約番号表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SVKEI_NO_DSP_CTRL_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SVKEI_NO_DSP_CTRL_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SVKEI_NO_DSP_CTRL_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.SVKEI_NO_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.請求契約番号表示制御フラグ ← 随時請求登録明細（表示用）.請求契約番号表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SEIKY_KEI_NO_DSP_CTRL_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO_DSP_CTRL_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO_DSP_CTRL_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.SEIKY_KEI_NO_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.整理番号表示制御フラグ ← 随時請求登録明細（表示用）.整理番号表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SEIRI_NO_DSP_CTRL_FLG))
					{
						childMap.put("seiri_no_dsp_ctrl_flg", new String());
					}
					else
					{
						childMap.put("seiri_no_dsp_ctrl_flg", childTemplate.getString(ECH0051D011CBSMsg2List.SEIRI_NO_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.マンションＩＤ表示制御フラグ ← 随時請求登録明細（表示用）.マンションＩＤ表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.MANS_ID_DSP_CTRL_FLG))
					{
						childMap.put("mans_id_dsp_ctrl_flg", new String());
					}
					else
					{
						childMap.put("mans_id_dsp_ctrl_flg", childTemplate.getString(ECH0051D011CBSMsg2List.MANS_ID_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.部屋番号表示制御フラグ ← 随時請求登録明細（表示用）.部屋番号表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.ADRRM_DSP_CTRL_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ADRRM_DSP_CTRL_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ADRRM_DSP_CTRL_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.ADRRM_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.利用期間表示制御フラグ ← 随時請求登録明細（表示用）.利用期間表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.USE_PRD_DSP_CTRL_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_PRD_DSP_CTRL_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_USE_PRD_DSP_CTRL_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.USE_PRD_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.金額表示カラム数 ← 随時請求登録明細（表示用）.金額表示カラム数
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.AMNT_DSP_COLUM_CNT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_AMNT_DSP_COLUM_CNT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_AMNT_DSP_COLUM_CNT, childTemplate.getString(ECH0051D011CBSMsg2List.AMNT_DSP_COLUM_CNT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.税区分表示フラグ ← 随時請求登録明細（表示用）.税区分表示フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.TAX_DIV_DSP_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_TAX_DIV_DSP_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_TAX_DIV_DSP_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.TAX_DIV_DSP_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.コメント表示フラグ ← 随時請求登録明細（表示用）.コメント表示フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.COMMENT_DSP_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_COMMENT_DSP_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_COMMENT_DSP_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.COMMENT_DSP_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.空行挿入フラグ ← 随時請求登録明細（表示用）.空行挿入フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.KUGYO_INS_FLG))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KUGYO_INS_FLG, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KUGYO_INS_FLG, childTemplate.getString(ECH0051D011CBSMsg2List.KUGYO_INS_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.注釈＿編集パターン ← 随時請求登録明細（表示用）.注釈＿編集パターン
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.COMMENT_HENSHU_PATTERN_CD))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_COMMENT_HENSHU_PATTERN_CD, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_COMMENT_HENSHU_PATTERN_CD, childTemplate.getString(ECH0051D011CBSMsg2List.COMMENT_HENSHU_PATTERN_CD));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.注釈＿コメント ← 随時請求登録明細（表示用）.注釈＿コメント
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SIKY_NYO_COMMENT))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SIKY_NYO_COMMENT, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SIKY_NYO_COMMENT, childTemplate.getString(ECH0051D011CBSMsg2List.SIKY_NYO_COMMENT));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.料金訂正可否 ← 随時請求登録明細（表示用）.料金訂正可否
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.PRC_TEISEI_KH))
					{
						childMap.put("prc_teisei_kh", new String());
					}
					else
					{
						childMap.put("prc_teisei_kh", childTemplate.getString(ECH0051D011CBSMsg2List.PRC_TEISEI_KH));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.訂正ボタン表示制御フラグ ← 随時請求登録明細（表示用）.訂正ボタン表示制御フラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.TEISEI_BTN_DSP_CTRL_FLG))
					{
						childMap.put("teisei_btn_dsp_ctrl_flg", new String());
					}
					else
					{
						childMap.put("teisei_btn_dsp_ctrl_flg", childTemplate.getString(ECH0051D011CBSMsg2List.TEISEI_BTN_DSP_CTRL_FLG));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.ご利用期間 ← 随時請求登録明細（表示用）.ご利用期間
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.USE_KIKAN))
					{
						childMap.put("use_kikan", new String());
					}
					else
					{
						childMap.put("use_kikan", childTemplate.getString(ECH0051D011CBSMsg2List.USE_KIKAN));
					}

					// 随時入金登録マップ.随時入金登録明細（表示用）.合計行判定区分 ← 随時請求登録明細（表示用）.合計行判定区分
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.SUM_LINE_JUDGE_DIV))
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SUM_LINE_JUDGE_DIV, new String());
					}
					else
					{
						childMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SUM_LINE_JUDGE_DIV, childTemplate.getString(ECH0051D011CBSMsg2List.SUM_LINE_JUDGE_DIV));
					}
//ANK-4543-00-00 ADD START
					// 随時請求登録マップ.随時請求登録明細.随時請求登録明細（表示用）.NTT卸契約エラーフラグ ← 随時請求登録明細（表示用）.NTT卸契約エラーフラグ
					if (childTemplate.isNull(ECH0051D011CBSMsg2List.NTT_ERR_FLG)) {
						childMap.put("ntt_err_flg", new String());
					} else {
						childMap.put("ntt_err_flg", childTemplate.getString(ECH0051D011CBSMsg2List.NTT_ERR_FLG));
					}
//ANK-4543-00-00 ADD END
				}
			}
			inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ECH0051D011CBSMsg2List, dataList);
			
			// 随時入金登録マップ.請求金額
			inMap.put("seiky_amnt", parentTemplate.getString(ECH0051D011CBSMsg.SEIKY_AMNT));
// OM-2014-0001880 DELETE START
//			// 随時入金登録マップ.消費税額
//			inMap.put("stax_amnt", parentTemplate.getString(ECH0051D011CBSMsg.STAX_AMNT));
// OM-2014-0001880 DELETE END
		}

// OM-2014-0001880 ADD START
		// 随時入金登録マップ.消費税額
		inMap.put("stax_amnt", parentTemplate.getString(ECH0051D011CBSMsg.STAX_AMNT));
// OM-2014-0001880 ADD END
		
		// エラー情報の設定
		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;
	}

	//REF
	/**
	 * 請求債権関連登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsgECH0041D010(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
	 */
	private IRequestParameterReadWrite editOutMsgECH0111D010(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<String, Object> inMap = this.getMap(param);

		// 払い出された入金番号を取得して充当債権リストに設定する
		String nkinNoOut = parentTemplate.getString(ECH0111D010CBSMsg.NYUKIN_NO);
		HashMap<String, Object> jutoSaikenMap = new HashMap<String, Object>();
		jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO, inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
		jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO, nkinNoOut);
		jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT, inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT));
		this.jutoSaikenList.add(jutoSaikenMap);

		// エラー情報の設定
		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 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(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		if (dataMap == null) {
			dataMap = new HashMap();
			param.setData(JCHZuijiNkinAddConstCC.MAP_CC_ID, dataMap);
		}
		// 電子ファイル管理登録マップ.電子ファイル管理番号 ← 電子ファイル管理番号
		if (parentTemplate.isNull(ECC0041D010CBSMsg.EFILE_KANRI_NO)) {
			dataMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_EFILE_KANRI_NO, new String());
		} else {
			dataMap.put(JCHZuijiNkinAddConstCC.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
	 */
	private IRequestParameterReadWrite editOutMsgECH0191D020_1(Map<?, ?> msgList, IRequestParameterReadWrite param)
			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);

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

		// 金庫移動登録の移動先金庫番号を取得して「充当債権リスト」を生成する
		templateArray = parentTemplate.getCAANMsgList(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST);
		if (templateArray != null)
		{
			CAANMsg childTemplate = templateArray[0];
			if (childTemplate.isNull(ECH0191D020CBSMsg1List.KNK_NO_AF) == false)
			{
				String knkNoAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_NO_AF);
				String knkAmntAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_AMNT_AF);
				String nyukinNo = parentTemplate.getString(ECH0191D020CBSMsg.NYUKIN_NO);

				// 充当債権リスト
				HashMap<String, Object> jutoSaikenMap = new HashMap<String, Object>();
				jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO, inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
				jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO, knkNoAf);
				jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT, knkAmntAf);
				jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO, nyukinNo);
				this.jutoSaikenList.add(jutoSaikenMap);
			}
		}

		// エラー情報の設定
		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 azukinMap 預り金明細１件のマップ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsgECH0191D020_2(Map<?, ?> msgList, IRequestParameterReadWrite param,
			HashMap<String, Object> azukinMap) 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);

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

		// 金庫移動登録の移動先金庫番号を取得して充当債権リスト」を生成する
		templateArray = parentTemplate.getCAANMsgList(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				if (childTemplate.isNull(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF) == false)
				{
					String knkNoAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_NO_AF);
					String ssnWayCdAf = childTemplate.getString(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF);
					String knkAmntAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_AMNT_AF);
					String knkPrcKmkCdAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF);
					String updDtm = parentTemplate.getString(ECH0191D020CBSMsg.UPD_DTM);
					String nyukinNo = parentTemplate.getString(ECH0191D020CBSMsg.NYUKIN_NO);

					if (knkPrcKmkCdAf.equals(JACStrConst.PRC_KMK_CD_ZUMI_AZUKIN_JUTO))
					{
						// 充当債権リスト
						HashMap<String, Object> jutoSaikenMap = new HashMap<String, Object>();
						jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO, inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SAIKEN_NO));
						jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO, knkNoAf);
						jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT, knkAmntAf);
						jutoSaikenMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_NO, nyukinNo);
						this.jutoSaikenList.add(jutoSaikenMap);
					}
					else if (knkPrcKmkCdAf.equals(JACStrConst.PRC_KMK_CD_AZUKIN))
					{
						// 預り金を上書き
						azukinMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_NO, knkNoAf);
						azukinMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_SSN_WAY_CD, ssnWayCdAf);
						azukinMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_AMNT, knkAmntAf);
						azukinMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_KNK_UPD_DTM, updDtm);
					}
				}
			}
		}

		// エラー情報の設定
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0201D010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

// OM-2014-0001880 ADD START
		CAANMsg parentTemplate = templates[0];
// OM-2014-0001880 ADD END
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

// OM-2014-0001880 ADD START
		// 払い出された充当番号を取得して充当番号リストに設定する
		String jutoNoOut = parentTemplate.getString(ECH0201D010CBSMsg.JUTO_NO);
		this.jutoNoList.add(jutoNoOut);
// OM-2014-0001880 ADD END

		// エラー情報の設定
		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
	 */
	private IRequestParameterReadWrite editOutMsgECH0311D010(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;
	}
	
	/**
	 * 下りマッピング（料金スケジュール一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0501A010_2(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoECH0501A010(param, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.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;
		}
		
		String seikyYm = null;
		
		CAANMsg[] msg1List = templates[0].getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		if(msg1List.length != 0)
		{
			seikyYm = msg1List[0].getString(ECH0501A010CBSMsg1List.SEIKY_YM);
		}
		
		return seikyYm;
	}
	
	/**
	 * 下りマッピング（料金スケジュール一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0501A010_3(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoECH0501A010(param, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.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;
		}
		
		String seikyYm = null;
		
		CAANMsg[] msg1List = templates[0].getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		if(msg1List.length != 0)
		{
			seikyYm = msg1List[0].getString(ECH0501A010CBSMsg1List.SEIKY_YM);
		}
		
		return seikyYm;
	}
	
	/**
	 * 下りマッピング（営業日管理一覧照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @return 最終営業日
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgEZM0291B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0291B010(param, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.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;
		}
		
		String endEigyDate = null;
		String busidayFlg = null;
		
		// 最終営業日を取得する
		CAANMsg[] msg1List = templates[0].getCAANMsgList(EZM0291B010CBSMsg.EZM0291B010CBSMSG1LIST);
		
		if(msg1List.length != 0)
		{
			for (int i = 0; i < msg1List.length; i++)
			{
				busidayFlg = msg1List[i].getString(EZM0291B010CBSMsg1List.BUSIDAY_FLG);
				if ("1".equals(busidayFlg))
				{
					endEigyDate = msg1List[i].getString(EZM0291B010CBSMsg1List.TRGT_YMD);
				}
			}
		}
		
		return endEigyDate;
	}
	
	/**
	 * 下りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010(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(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(JCHZuijiNkinAddConstCC.MAP_CC_ID, dataMap);
		}

		for (int i = 0; i < templates.length; i++)
		{
			CAANMsg parentTemplate = templates[i];
			// 検索系 共通部
			dataMap.put("total_search_num", parentTemplate.getString("total_search_num"));
			dataMap.put("total_page_num", parentTemplate.getString("total_page_num"));
			dataMap.put("search_err_flg", parentTemplate.getString("search_err_flg"));
	
			CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
			ArrayList<HashMap<String, Object>> dataList = (ArrayList)dataMap.get("EZM0321A010CBSMsg1List");
	
			if (dataList == null)
			{
				dataList = new ArrayList<HashMap<String, Object>>();
				dataMap.put("EZM0321A010CBSMsg1List", dataList);
			}
	
			if (templateArray != null)
			{
				for (int j = 0; j < templateArray.length; j++)
				{
					CAANMsg childTemplate = templateArray[j];
					if (i >= dataList.size())
					{
						dataList.add(new HashMap<String, Object>());
					}
					HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i);

					// 業務パラメータ管理情報取得マップ.業務パラメータ管理一意照会明細.業務パラメータID ← 業務パラメータ管理一意照会明細.業務パラメータID
					if (childTemplate.isNull(EZM0321A010CBSMsg1List.WORK_PARAM_ID))
					{
						childMap.put("work_param_id", "");
					}
					else
					{
						childMap.put("work_param_id", childTemplate.getString(EZM0321A010CBSMsg1List.WORK_PARAM_ID));
					}

					// 業務パラメータ管理情報取得マップ.業務パラメータ管理一意照会明細.業務パラメータ設定値 ← 業務パラメータ管理一意照会明細.業務パラメータ設定値
					if (childTemplate.isNull(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE))
					{
						childMap.put("work_param_sette_value", "");
					}
					else
					{
						childMap.put("work_param_sette_value", childTemplate.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
					}

				}
			}
		}

		// エラー情報の設定
		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;
	}

	/**
	 * 下りマッピング（金融機関一覧照会４）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @return 最終営業日
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0511B004(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(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(JCHZuijiNkinAddConstCC.MAP_CC_ID, dataMap);
		}

		for (int i = 0; i < templates.length; i++)
		{
			CAANMsg parentTemplate = templates[i];
			// 検索系 共通部
			dataMap.put("total_search_num", parentTemplate.getString("total_search_num"));
			dataMap.put("total_page_num", parentTemplate.getString("total_page_num"));
			dataMap.put("search_err_flg", parentTemplate.getString("search_err_flg"));
	
			CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EKK0511B004CBSMsg.EKK0511B004CBSMSG1LIST);
			ArrayList<HashMap<String, Object>> dataList = (ArrayList)dataMap.get("EKK0511B004CBSMsg1List");
	
			if (dataList == null)
			{
				dataList = new ArrayList<HashMap<String, Object>>();
				dataMap.put("EKK0511B004CBSMsg1List", dataList);
			}
	
			if (templateArray != null)
			{
				for (int j = 0; j < templateArray.length; j++)
				{
					CAANMsg childTemplate = templateArray[j];
					if (i >= dataList.size())
					{
						dataList.add(new HashMap<String, Object>());
					}
					HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i);

					// 金融機関一覧照会情報取得マップ.金融機関一覧照会明細.金融機関支店コード ← 金融機関一覧照会明細.金融機関支店コード
					if (childTemplate.isNull(EKK0511B004CBSMsg1List.BANK_SHITEN_CD))
					{
						childMap.put("bank_shiten_cd", "");
					}
					else
					{
						childMap.put("bank_shiten_cd", childTemplate.getString(EKK0511B004CBSMsg1List.BANK_SHITEN_CD));
					}

					// 金融機関一覧照会情報取得マップ.金融機関一覧照会明細.金融機関支店名 ← 金融機関一覧照会明細.金融機関支店名
					if (childTemplate.isNull(EKK0511B004CBSMsg1List.BANK_SHITEN_NM))
					{
						childMap.put("bank_shiten_nm", "");
					}
					else
					{
						childMap.put("bank_shiten_nm", childTemplate.getString(EKK0511B004CBSMsg1List.BANK_SHITEN_NM));
					}

				}
			}
		}

		// エラー情報の設定
		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;
	}

	/**
	 * 業務パラメータ管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param wkpara 業務パラメータ識別
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> editOutMsgEZM0321A010_2(Map<?, ?> msgList,
				IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0321A010(param, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.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;
		}

		// 払込先金融機関コード・払込先金融機関支店コード
		String[] hrkmBankCd = new String[]{};
		
		// 払込先金融機関コード・払込先金融機関支店コード格納マップ
		HashMap<String, String> hrkmBankCdMap = new HashMap<String, String>();
		
		// 業務パラメータ管理から取得した値を設定
		CAANMsg[] msg1List = templates[0].getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		if (msg1List != null && msg1List.length != 0)
		{
			hrkmBankCd = msg1List[0].getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE).split(JACStrConst.COMMA);
		}
		
		if(hrkmBankCd != null && hrkmBankCd.length != 0)
		{
			// 指定口座コードをkeyとして、払込先金融機関コード・払込先金融機関支店コードを格納する
			for(int i = 0; i < hrkmBankCd.length; i++)
			{
				String[] temp = hrkmBankCd[i].split(JACStrConst.COLON);
				hrkmBankCdMap.put(temp[0], temp[1]);
			}
		}
			
		return hrkmBankCdMap;
	}
	// ▲▲ サービスIF用メッセージ取得処理 ▲▲

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

		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = { template };
			if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_EKK0491A010.equals(templateId))
			{
				// 請求契約一意照会
				editErrorInfoEKK0491A010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0501A010.equals(templateId))
			{
				// 料金スケジュール定義一意照会
				editErrorInfoECH0501A010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0011D012.equals(templateId))
			{
				// 収納済債権登録
				editErrorInfoECH0011D012(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0051D010.equals(templateId))
			{
				// 請求登録
				editErrorInfoECH0051D010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0051D011.equals(templateId))
			{
				// 随時請求登録
				editErrorInfoECH0051D011(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0041D010.equals(templateId))
			{
				// 請求債権関連登録
				editErrorInfoECH0041D010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0111D010.equals(templateId))
			{
				// 入金登録
				editErrorInfoECH0111D010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0191D020.equals(templateId))
			{
				// 金庫移動登録
				editErrorInfoECH0191D020(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0201D010.equals(templateId))
			{
				// 充当登録
				editErrorInfoECH0201D010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECH0311D010.equals(templateId))
			{
				// 領収登録
				editErrorInfoECH0311D010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_EZM0321A010.equals(templateId))
			{
				// 業務パラメータ管理一意照会
				editErrorInfoEZM0321A010(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_EKK0511B004.equals(templateId))
			{
				// 金融機関一覧照会４
				editErrorInfoEKK0511B004(param, workTemplates, returnCode);
			}
			else if (JCHZuijiNkinAddConstCC.TEMPLATE_ID_ECC0041D010.equals(templateId))
			{
				// 電子ファイル管理登録
				editErrorInfoECC0041D010(param, workTemplates, returnCode);
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(EKK0491A010CBSMsg.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(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template.getString(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		// 請求契約一意照会明細 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST_ERR, template.getString(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST_ERR));
			}
		}

		return param;
	}

	/**
	 * 料金スケジュール定義一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	public 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));
			}
		}

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

		int templateStatus = template.getInt(ECH0011D012CBSMsg.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(ECH0011D012CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0011D012CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// サービス契約番号 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SVC_KEI_NO_ERR, template.getString(ECH0011D012CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		// 債権年月 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_YM_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_YM_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_YM_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_YM_ERR));
			}
		}
		// 請求方法コード のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SEIKY_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SEIKY_WAY_CD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SEIKY_WAY_CD_ERR, template.getString(ECH0011D012CBSMsg.SEIKY_WAY_CD_ERR));
			}
		}
		// 支払期限年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.PAY_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.PAY_KIGEN_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.PAY_KIGEN_YMD_ERR, template.getString(ECH0011D012CBSMsg.PAY_KIGEN_YMD_ERR));
			}
		}
		// 変更支払期限年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.CHG_PAY_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.CHG_PAY_KIGEN_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.CHG_PAY_KIGEN_YMD_ERR, template.getString(ECH0011D012CBSMsg.CHG_PAY_KIGEN_YMD_ERR));
			}
		}
		// 請求種別コード のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SEIKY_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SEIKY_SBT_CD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SEIKY_SBT_CD_ERR, template.getString(ECH0011D012CBSMsg.SEIKY_SBT_CD_ERR));
			}
		}
		// 債権取扱いコード のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_TORIATSU_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_TORIATSU_CD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_TORIATSU_CD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_TORIATSU_CD_ERR));
			}
		}
		// 債権確定年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_FIX_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_FIX_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_FIX_YMD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_FIX_YMD_ERR));
			}
		}
		// 債権充当年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_JUTO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_JUTO_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_JUTO_YMD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_JUTO_YMD_ERR));
			}
		}
		// 債権調整年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_CYOSEI_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_CYOSEI_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_CYOSEI_YMD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_CYOSEI_YMD_ERR));
			}
		}
		// 債権変更年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_HENKO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_HENKO_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_HENKO_YMD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_HENKO_YMD_ERR));
			}
		}
		// 充当完了年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.JUTO_FIN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.JUTO_FIN_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.JUTO_FIN_YMD_ERR, template.getString(ECH0011D012CBSMsg.JUTO_FIN_YMD_ERR));
			}
		}
		// 債権償却年月日 のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SAIKEN_SHOKYAKU_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SAIKEN_SHOKYAKU_YMD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SAIKEN_SHOKYAKU_YMD_ERR, template.getString(ECH0011D012CBSMsg.SAIKEN_SHOKYAKU_YMD_ERR));
			}
		}
		// 債権償却理由コード のエラー情報返却
		if (!template.isNull(ECH0011D012CBSMsg.SHOKYAKU_RSN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011D012CBSMsg.SHOKYAKU_RSN_CD_ERR))
			{
				inMap.put(ECH0011D012CBSMsg.SHOKYAKU_RSN_CD_ERR, template.getString(ECH0011D012CBSMsg.SHOKYAKU_RSN_CD_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0051D010CBSMsg.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(ECH0051D010CBSMsg.SEIKY_STAT_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_STAT_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_STAT_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_STAT_ERR));
			}
		}
		// 請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 督促番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.TOKUSOKU_NO_ERR, template.getString(ECH0051D010CBSMsg.TOKUSOKU_NO_ERR));
			}
		}
		// 請求年月 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_YM_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_YM_ERR));
			}
		}
		// 請求確定年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_FIX_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_FIX_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_FIX_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_FIX_YMD_ERR));
			}
		}
		// 請求種別コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_SBT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_SBT_CD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_SBT_CD_ERR));
			}
		}
		// 契約請求方法コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD_ERR, template.getString(ECH0051D010CBSMsg.KEI_SEIKY_WAY_CD_ERR));
			}
		}
		// 請求方法コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_WAY_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_WAY_CD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_WAY_CD_ERR));
			}
		}
		// 強制窓口フラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KYOSEI_MADOGUCHI_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KYOSEI_MADOGUCHI_FLG_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KYOSEI_MADOGUCHI_FLG_ERR, template.getString(ECH0051D010CBSMsg.KYOSEI_MADOGUCHI_FLG_ERR));
			}
		}
		// 請求依頼年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_IRAI_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_IRAI_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_IRAI_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_IRAI_YMD_ERR));
			}
		}
		// 同封コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.DOHU_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.DOHU_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.DOHU_CD_ERR, template.getString(ECH0051D010CBSMsg.DOHU_CD_ERR));
			}
		}
		// 請求書発行シーケンス のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SKS_HAKKO_SEQ_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SKS_HAKKO_SEQ_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SKS_HAKKO_SEQ_ERR, template.getString(ECH0051D010CBSMsg.SKS_HAKKO_SEQ_ERR));
			}
		}
		// カスタマーバーコード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CUSTOMER_BARCODE_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CUSTOMER_BARCODE_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CUSTOMER_BARCODE_ERR, template.getString(ECH0051D010CBSMsg.CUSTOMER_BARCODE_ERR));
			}
		}
		// インフォメーションパターンコード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.INFORMATION_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.INFORMATION_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.INFORMATION_CD_ERR, template.getString(ECH0051D010CBSMsg.INFORMATION_CD_ERR));
			}
		}
		// 請求同封物パターンコード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.DOHUBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.DOHUBT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.DOHUBT_CD_ERR, template.getString(ECH0051D010CBSMsg.DOHUBT_CD_ERR));
			}
		}
		// 送付先住所コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_AD_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_AD_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_AD_CD_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_AD_CD_ERR));
			}
		}
		// 送付先郵便番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_PCD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_PCD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_PCD_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_PCD_ERR));
			}
		}
		// 送付先都道府県名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_STATE_NM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_STATE_NM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_STATE_NM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_STATE_NM_ERR));
			}
		}
		// 送付先市区町村名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_CITY_NM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_CITY_NM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_CITY_NM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_CITY_NM_ERR));
			}
		}
		// 送付先大字通称名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_OAZTSU_NM_ERR));
			}
		}
		// 送付先字丁目名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_AZCHO_NM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_AZCHO_NM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_AZCHO_NM_ERR));
			}
		}
		// 送付先住所番地号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_AD_BNCHIGO_ERR));
			}
		}
		// 送付先住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_ADRTTM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_ADRTTM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_ADRTTM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_ADRTTM_ERR));
			}
		}
		// 送付先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_ADRRM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_ADRRM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_ADRRM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_ADRRM_ERR));
			}
		}
		// 送付先電話番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_TELNO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_TELNO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_TELNO_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_TELNO_ERR));
			}
		}
		// 送付先名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_NM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_NM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_NM_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_NM_ERR));
			}
		}
		// 送付先法人格種別コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD_ERR, template.getString(ECH0051D010CBSMsg.SHS_HOJIN_SBT_CD_ERR));
			}
		}
		// 送付先法人格前後指定コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD_ERR, template.getString(ECH0051D010CBSMsg.SHS_HOJIN_ZENGO_SHITEI_CD_ERR));
			}
		}
		// 送付先カナ名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SHS_KANA_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SHS_KANA_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SHS_KANA_ERR, template.getString(ECH0051D010CBSMsg.SHS_KANA_ERR));
			}
		}
		// 送付先メールアドレス のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SOHUS_MLAD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SOHUS_MLAD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SOHUS_MLAD_ERR, template.getString(ECH0051D010CBSMsg.SOHUS_MLAD_ERR));
			}
		}
		// 請求契約配下サービス契約状態コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SKHK_SVKEI_STAT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SKHK_SVKEI_STAT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SKHK_SVKEI_STAT_CD_ERR, template.getString(ECH0051D010CBSMsg.SKHK_SVKEI_STAT_CD_ERR));
			}
		}
		// 請求契約配下サービス契約解約理由識別コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SKHK_SVKEI_DLRE_SKBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SKHK_SVKEI_DLRE_SKBT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SKHK_SVKEI_DLRE_SKBT_CD_ERR, template.getString(ECH0051D010CBSMsg.SKHK_SVKEI_DLRE_SKBT_CD_ERR));
			}
		}
		// 請求書発行要否 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH_ERR, template.getString(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YH_ERR));
			}
		}
		// 次回請求方法コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV_ERR, template.getString(ECH0051D010CBSMsg.NEXT_SEIKY_WAY_DIV_ERR));
			}
		}
		// 領収額出力有無 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.RECEIPT_AMNT_OUTPUT_UM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.RECEIPT_AMNT_OUTPUT_UM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.RECEIPT_AMNT_OUTPUT_UM_ERR, template.getString(ECH0051D010CBSMsg.RECEIPT_AMNT_OUTPUT_UM_ERR));
			}
		}
		// 支払期限年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.PAY_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.PAY_KIGEN_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.PAY_KIGEN_YMD_ERR, template.getString(ECH0051D010CBSMsg.PAY_KIGEN_YMD_ERR));
			}
		}
		// 請求書引抜きフラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_HIKNK_FLG_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(ECH0051D010CBSMsg.SEIKY_HIKNK_FLG_ERR));
			}
		}
		// 請求書発行対象フラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_HAKKO_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_HAKKO_FLG_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_HAKKO_FLG_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_HAKKO_FLG_ERR));
			}
		}
		// 請求書発行年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKYUS_HAKKO_YMD_ERR));
			}
		}
		// 請求金額調整年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_CYOSEI_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_CYOSEI_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_CYOSEI_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_CYOSEI_YMD_ERR));
			}
		}
		// 請求金額変更年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_AMNT_CHGE_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_AMNT_CHGE_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_AMNT_CHGE_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_AMNT_CHGE_YMD_ERR));
			}
		}
		// 請求取消年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.SEIKY_CL_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.SEIKY_CL_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.SEIKY_CL_YMD_ERR, template.getString(ECH0051D010CBSMsg.SEIKY_CL_YMD_ERR));
			}
		}
		// 口座振替＿金融機関コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_BANK_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_BANK_CD_ERR, template.getString(ECH0051D010CBSMsg.KHRI_BANK_CD_ERR));
			}
		}
		// 口座振替＿金融機関支店コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR, template.getString(ECH0051D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR));
			}
		}
		// 口座振替＿口座種別コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_KOZA_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_KOZA_SBT_CD_ERR))
			{
				inMap.put("seiky_kei_no_err", template.getString(ECH0051D010CBSMsg.KHRI_KOZA_SBT_CD_ERR));
			}
		}
		// 口座振替＿口座番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_KOZA_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_KOZA_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_KOZA_NO_ERR, template.getString(ECH0051D010CBSMsg.KHRI_KOZA_NO_ERR));
			}
		}
		// 口座振替＿新規コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_NEW_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_NEW_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_NEW_CD_ERR, template.getString(ECH0051D010CBSMsg.KHRI_NEW_CD_ERR));
			}
		}
		// 口座振替＿通帳記号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_TSUCHO_SYMBOL_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_TSUCHO_SYMBOL_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_TSUCHO_SYMBOL_ERR, template.getString(ECH0051D010CBSMsg.KHRI_TSUCHO_SYMBOL_ERR));
			}
		}
		// 口座振替＿通帳番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_TSUCHO_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_TSUCHO_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_TSUCHO_NO_ERR, template.getString(ECH0051D010CBSMsg.KHRI_TSUCHO_NO_ERR));
			}
		}
		// 口座振替＿口座名義人カナ名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_KOZA_MEIGIN_KANA_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_KOZA_MEIGIN_KANA_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_KOZA_MEIGIN_KANA_ERR, template.getString(ECH0051D010CBSMsg.KHRI_KOZA_MEIGIN_KANA_ERR));
			}
		}
		// 口座振替＿口振結果返却年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_RTN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_RTN_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_RTN_YMD_ERR, template.getString(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_RTN_YMD_ERR));
			}
		}
		// 口座振替＿口振結果コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_CD_ERR, template.getString(ECH0051D010CBSMsg.KHRI_KOZA_RSLT_CD_ERR));
			}
		}
		// クレジット＿フロアリミット超過フラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_FLORLMT_ORVER_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_FLORLMT_ORVER_FLG_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_FLORLMT_ORVER_FLG_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_FLORLMT_ORVER_FLG_ERR));
			}
		}
		// クレジット＿クレジット会社コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_CRECARD_COMP_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_CRECARD_COMP_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_CRECARD_COMP_CD_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_CRECARD_COMP_CD_ERR));
			}
		}
		// クレジット＿クレジットカード名義人名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_KANA_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_KANA_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_KANA_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_KANA_ERR));
			}
		}
		// クレジット＿クレジットカード名義人英名 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_ROMAJI_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_ROMAJI_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_ROMAJI_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_CRECARD_NM_ROMAJI_ERR));
			}
		}
		// クレジット＿オーソリ結果フラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_AUTHORI_RESOLT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_AUTHORI_RESOLT_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_AUTHORI_RESOLT_CD_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_AUTHORI_RESOLT_CD_ERR));
			}
		}
		// クレジット＿加盟店番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_MEMBSTR_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_MEMBSTR_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_MEMBSTR_CD_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_MEMBSTR_CD_ERR));
			}
		}
		// クレジット＿クレジットカード番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_CRECARD_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_CRECARD_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_CRECARD_NO_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_CRECARD_NO_ERR));
			}
		}
		// クレジット＿クレジット交換コード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_CREDIT_KOKAN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_CREDIT_KOKAN_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_CREDIT_KOKAN_CD_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_CREDIT_KOKAN_CD_ERR));
			}
		}
		// クレジット＿取引年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_DEAL_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_DEAL_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_DEAL_YMD_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_DEAL_YMD_ERR));
			}
		}
		// クレジット＿売上オーソリ実施年月日時分秒 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_SALES_AUTHORI_JSSI_DTM_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_SALES_AUTHORI_JSSI_DTM_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_SALES_AUTHORI_JSSI_DTM_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_SALES_AUTHORI_JSSI_DTM_ERR));
			}
		}
		// クレジット＿オーソリ承認番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_AUTHORI_SHONIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_AUTHORI_SHONIN_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_AUTHORI_SHONIN_NO_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_AUTHORI_SHONIN_NO_ERR));
			}
		}
		// クレジット＿取引識別番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_DEAL_SKBT_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_DEAL_SKBT_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_DEAL_SKBT_NO_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_DEAL_SKBT_NO_ERR));
			}
		}
		// クレジット＿売上伝票番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.CREDIT_SALES_DENPYO_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.CREDIT_SALES_DENPYO_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.CREDIT_SALES_DENPYO_NO_ERR, template.getString(ECH0051D010CBSMsg.CREDIT_SALES_DENPYO_NO_ERR));
			}
		}
		// 窓口＿社内使用識別フラグ のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.MADOGUCHI_SHANAIUSE_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.MADOGUCHI_SHANAIUSE_FLG_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.MADOGUCHI_SHANAIUSE_FLG_ERR, template.getString(ECH0051D010CBSMsg.MADOGUCHI_SHANAIUSE_FLG_ERR));
			}
		}
		// 窓口＿ＥＡＮバーコード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_BARCODE_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.MADOGUCHI_EAN_BARCODE_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.MADOGUCHI_EAN_BARCODE_ERR, template.getString(ECH0051D010CBSMsg.MADOGUCHI_EAN_BARCODE_ERR));
			}
		}
		// 窓口＿ＥＡＮメーカーコード のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_MAKER_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.MADOGUCHI_EAN_MAKER_CD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.MADOGUCHI_EAN_MAKER_CD_ERR, template.getString(ECH0051D010CBSMsg.MADOGUCHI_EAN_MAKER_CD_ERR));
			}
		}
		// 窓口＿ＥＡＮ取扱期限年月日 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.MADOGUCHI_EAN_TORI_LIMIT_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.MADOGUCHI_EAN_TORI_LIMIT_YMD_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.MADOGUCHI_EAN_TORI_LIMIT_YMD_ERR, template.getString(ECH0051D010CBSMsg.MADOGUCHI_EAN_TORI_LIMIT_YMD_ERR));
			}
		}
		// 窓口＿ＯＣＲ番号 のエラー情報返却
		if (!template.isNull(ECH0051D010CBSMsg.MADOGUCHI_OCR_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D010CBSMsg.MADOGUCHI_OCR_NO_ERR))
			{
				inMap.put(ECH0051D010CBSMsg.MADOGUCHI_OCR_NO_ERR, template.getString(ECH0051D010CBSMsg.MADOGUCHI_OCR_NO_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0051D011CBSMsg.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(ECH0051D011CBSMsg.SEIKY_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.SEIKY_NO_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.SEIKY_NO_ERR, template.getString(ECH0051D011CBSMsg.SEIKY_NO_ERR));
			}
		}
		// 請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0051D011CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 債権番号 のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0051D011CBSMsg.SAIKEN_NO_ERR));
			}
		}
		// 請求年月 のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.SEIKY_YM_ERR, template.getString(ECH0051D011CBSMsg.SEIKY_YM_ERR));
			}
		}
		// 入金額 のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.NYUKIN_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.NYUKIN_AMNT_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.NYUKIN_AMNT_ERR, template.getString(ECH0051D011CBSMsg.NYUKIN_AMNT_ERR));
			}
		}
		// 随時入金登録マップ.預り金 → 預り金 のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.AZUKARI_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.AZUKARI_AMNT_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.AZUKARI_AMNT_ERR, template.getString(ECH0051D011CBSMsg.AZUKARI_AMNT_ERR));
			}
		}
		// 料金項目名称種別コード のエラー情報返却
		if (!template.isNull(ECH0051D011CBSMsg.PRC_KMK_NM_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051D011CBSMsg.PRC_KMK_NM_SBT_CD_ERR))
			{
				inMap.put(ECH0051D011CBSMsg.PRC_KMK_NM_SBT_CD_ERR, template.getString(ECH0051D011CBSMsg.PRC_KMK_NM_SBT_CD_ERR));
			}
		}
		ArrayList<HashMap<String, Object>> inList = this.getMapListItem(param, JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST);
		if (inList == null)
		{
			inList = new ArrayList<HashMap<String, Object>>();
			inMap.put(JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST, inList);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(ECH0051D011CBSMsg.ECH0051D011CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= inList.size())
				{
					inList.add(new HashMap<String, Object>());
				}

				HashMap<String, Object> childMap = inList.get(i);
				CAANMsg childTemplate = templateArray[i];

				// 随時請求登録明細.サービス契約番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.SVC_KEI_NO_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.SVC_KEI_NO_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.SVC_KEI_NO_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.SVC_KEI_NO_ERR));
					}
				}
				// 随時請求登録明細.料金コースコード のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.PCRS_CD_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.PCRS_CD_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.PCRS_CD_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.PCRS_CD_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.料金サービスコード → 随時請求登録明細.料金サービスコード のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.PRC_SVC_CD_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.PRC_SVC_CD_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.PRC_SVC_CD_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.PRC_SVC_CD_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.料金項目コード → 随時請求登録明細.料金項目コード のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.PRC_KMK_CD_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.PRC_KMK_CD_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.PRC_KMK_CD_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.PRC_KMK_CD_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.利用開始年月日 → 随時請求登録明細.利用開始年月日 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.USE_STAYMD_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.USE_STAYMD_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.USE_STAYMD_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.USE_STAYMD_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.利用終了年月日 → 随時請求登録明細.利用終了年月日 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.USE_ENDYMD_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.USE_ENDYMD_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.USE_ENDYMD_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.USE_ENDYMD_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号 → 随時請求登録明細.サービス詳細識別番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.サービス詳細識別番号区分 → 随時請求登録明細.サービス詳細識別番号区分 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.SVC_DTL_SKBT_NO_KBN_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.請求内訳番号 → 随時請求登録明細.請求内訳番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.SEIKY_UCWK_NO_ERR));
					}
				}
				// 随時入金登録マップ.随時入金明細リスト.調整後金額 → 随時請求登録明細.調整後金額 のエラー情報返却
				if (!childTemplate.isNull(ECH0051D011CBSMsg1List.AJST_AF_AMNT_ERR))
				{
					if (!childMap.containsKey(ECH0051D011CBSMsg1List.AJST_AF_AMNT_ERR))
					{
						childMap.put(ECH0051D011CBSMsg1List.AJST_AF_AMNT_ERR, childTemplate.getString(ECH0051D011CBSMsg1List.AJST_AF_AMNT_ERR));
					}
				}
			}
		}
		if (!template.isNull(ECH0051D011CBSMsg.ECH0051D011CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("zuiji_nkin_list_err"))
			{
				inMap.put("zuiji_nkin_list_err", template.getString(ECH0051D011CBSMsg.ECH0051D011CBSMSG1LIST_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0041D010CBSMsg.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 = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		CAANMsg[] templateArray = template.getCAANMsgList(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST);

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

				// 請求債権関連明細.引き継ぎ元請求番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO_ERR))
				{
					if (!inMap.containsKey(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO_ERR))
					{
						inMap.put(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO_ERR, childTemplate.getString(ECH0041D010CBSMsg1List.TRA_MT_SEIKY_NO_ERR));
					}
				}
				// 請求債権関連明細.引き継ぎ先請求番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0041D010CBSMsg1List.TRA_SK_SEIKY_NO_ERR))
				{
					if (!inMap.containsKey(ECH0041D010CBSMsg1List.TRA_SK_SEIKY_NO_ERR))
					{
						inMap.put(ECH0041D010CBSMsg1List.TRA_SK_SEIKY_NO_ERR, childTemplate.getString(ECH0041D010CBSMsg1List.TRA_SK_SEIKY_NO_ERR));
					}
				}
				// 請求債権関連明細.引き継ぎ元債権番号 のエラー情報返却
				if (!childTemplate.isNull(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO_ERR))
				{
					if (!inMap.containsKey(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO_ERR))
					{
						inMap.put(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO_ERR, childTemplate.getString(ECH0041D010CBSMsg1List.TRA_MT_SAIKEN_NO_ERR));
					}
				}
			}
		}
		if (!template.isNull(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST_ERR))
			{
				inMap.put(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST_ERR, template.getString(ECH0041D010CBSMsg.ECH0041D010CBSMSG1LIST_ERR));
			}
		}
		return param;
	}

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

		int templateStatus = template.getInt(ECH0111D010CBSMsg.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(ECH0111D010CBSMsg.NYUKIN_STAT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_STAT_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_STAT_CD_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_STAT_CD_ERR));
			}
		}
		// 入金登録.入金経路コードエラー → 入金経路コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD_ERR));
			}
		}
		// 入金登録.収納機関コードエラー → 収納機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.SHUNOKIKAN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SHUNOKIKAN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SHUNOKIKAN_CD_ERR, template.getString(ECH0111D010CBSMsg.SHUNOKIKAN_CD_ERR));
			}
		}
		// 入金登録.外部組織収納年月日エラー → 外部組織収納年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.SHUNO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SHUNO_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SHUNO_YMD_ERR, template.getString(ECH0111D010CBSMsg.SHUNO_YMD_ERR));
			}
		}
		// 入金登録.入金処理年月日エラー → 入金処理年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_TRN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_TRN_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_TRN_YMD_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_TRN_YMD_ERR));
			}
		}
		// 入金登録.入金処理時分秒エラー → 入金処理時分秒エラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_TRN_HMS_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_TRN_HMS_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_TRN_HMS_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_TRN_HMS_ERR));
			}
		}
		// 入金登録.領収年月日エラー → 領収年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.RECEIPT_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.RECEIPT_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.RECEIPT_YMD_ERR, template.getString(ECH0111D010CBSMsg.RECEIPT_YMD_ERR));
			}
		}
		// 入金登録.領収時分秒エラー → 領収時分秒エラー
		if (!template.isNull(ECH0111D010CBSMsg.RECEIPT_HMS_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.RECEIPT_HMS_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.RECEIPT_HMS_ERR, template.getString(ECH0111D010CBSMsg.RECEIPT_HMS_ERR));
			}
		}
		// 入金登録.入金額エラー → 入金額エラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_AMNT_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_AMNT_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_AMNT_ERR));
			}
		}
		// 入金登録.請求番号エラー → 請求番号エラー
		if (!template.isNull(ECH0111D010CBSMsg.SEIKY_NO_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SEIKY_NO_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SEIKY_NO_ERR, template.getString(ECH0111D010CBSMsg.SEIKY_NO_ERR));
			}
		}
		// 入金登録.請求契約番号エラー → 請求契約番号エラー
		if (!template.isNull(ECH0111D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0111D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 入金登録.入金経路コード → 入金登録方法コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_ADD_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_ADD_WAY_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_ADD_WAY_CD_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_ADD_WAY_CD_ERR));
			}
		}
		// 入金登録.入金処理済フラグ → 入金処理済フラグエラー
		if (!template.isNull(ECH0111D010CBSMsg.NYUKIN_SYRZM_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.NYUKIN_SYRZM_FLG_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.NYUKIN_SYRZM_FLG_ERR, template.getString(ECH0111D010CBSMsg.NYUKIN_SYRZM_FLG_ERR));
			}
		}
		// 入金登録.窓口金融機関コード → 窓口金融機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD_ERR, template.getString(ECH0111D010CBSMsg.MADOGUCHI_BANK_CD_ERR));
			}
		}
		// 入金登録.窓口金融機関支店コード → 窓口金融機関支店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD_ERR, template.getString(ECH0111D010CBSMsg.MADOGUCHI_BANK_SHITEN_CD_ERR));
			}
		}
		// 入金登録.口座振替金融機関コード → 口座振替金融機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.KHRI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.KHRI_BANK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.KHRI_BANK_CD_ERR, template.getString(ECH0111D010CBSMsg.KHRI_BANK_CD_ERR));
			}
		}
		// 入金登録.口座振替金融機関支店コード → 口座振替金融機関支店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR, template.getString(ECH0111D010CBSMsg.KHRI_BANK_SHITEN_CD_ERR));
			}
		}
		// 入金登録.クレジットカード会社コード → クレジットカード会社コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.CRECARD_COMP_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CRECARD_COMP_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CRECARD_COMP_CD_ERR, template.getString(ECH0111D010CBSMsg.CRECARD_COMP_CD_ERR));
			}
		}
		// 入金登録.債権回収委託会社コード → 債権回収委託会社コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.SKNKSITKCM_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SKNKSITKCM_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SKNKSITKCM_CD_ERR, template.getString(ECH0111D010CBSMsg.SKNKSITKCM_CD_ERR));
			}
		}
		// 入金登録.指定口座コード → 指定口座コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.SHITEIKOZA_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SHITEIKOZA_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SHITEIKOZA_CD_ERR, template.getString(ECH0111D010CBSMsg.SHITEIKOZA_CD_ERR));
			}
		}
		// 入金登録.払込先金融機関コード → 払込先金融機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD_ERR, template.getString(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD_ERR));
			}
		}
		// 入金登録.払込先金融機関支店コード → 払込先金融機関支店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD_ERR, template.getString(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD_ERR));
			}
		}
		// 入金登録.受取組織コード → 受取組織コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.UKETORI_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.UKETORI_ORG_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.UKETORI_ORG_CD_ERR, template.getString(ECH0111D010CBSMsg.UKETORI_ORG_CD_ERR));
			}
		}
		// 入金登録.社内使用分組織コード → 社内使用分組織コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD_ERR, template.getString(ECH0111D010CBSMsg.SYAYOBUN_ORG_CD_ERR));
			}
		}
		// 入金登録.コンビニエンスストアコード → コンビニエンスストアコードエラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_CD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ受付店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_UK_TEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_UK_TEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_UK_TEN_CD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_UK_TEN_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → ＥＡＮメーカーコードエラー
		if (!template.isNull(ECH0111D010CBSMsg.EAN_MAKER_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.EAN_MAKER_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.EAN_MAKER_CD_ERR, template.getString(ECH0111D010CBSMsg.EAN_MAKER_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニリアル業務コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_REAL_WORK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_REAL_WORK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_REAL_WORK_CD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_REAL_WORK_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニリアル速報通知年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_YMD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_YMD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニリアル速報通知時分秒エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_HMS_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_HMS_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_HMS_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_TCH_HMS_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニリアル速報処理済フラグエラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_ZUM_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_ZUM_FLG_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_ZUM_FLG_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_REAL_SOKHO_ZUM_FLG_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ速報通知年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_SOKHO_TCH_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_SOKHO_TCH_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_SOKHO_TCH_YMD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_SOKHO_TCH_YMD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ速報処理済フラグエラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_SOKHO_ZUM_FLG_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_SOKHO_ZUM_FLG_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_SOKHO_ZUM_FLG_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_SOKHO_ZUM_FLG_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ確報通知年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_KAKHO_TCH_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_KAKHO_TCH_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_KAKHO_TCH_YMD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_KAKHO_TCH_YMD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ支払予定年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD_ERR));
			}
		}
		// 入金登録.入金経路コード → コンビニ取消通知年月日エラー
		if (!template.isNull(ECH0111D010CBSMsg.CVSTORE_CL_TCH_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.CVSTORE_CL_TCH_YMD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.CVSTORE_CL_TCH_YMD_ERR, template.getString(ECH0111D010CBSMsg.CVSTORE_CL_TCH_YMD_ERR));
			}
		}
		// 入金登録.郵券受取組織コード → 郵券受取組織コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD_ERR, template.getString(ECH0111D010CBSMsg.YUKEN_UKETORI_ORG_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → 郵便自動振込金融機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.YJHRI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.YJHRI_BANK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.YJHRI_BANK_CD_ERR, template.getString(ECH0111D010CBSMsg.YJHRI_BANK_CD_ERR));
			}
		}
		// 入金登録.入金経路コード → 郵便自動振込金融機関支店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD_ERR, template.getString(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD_ERR));
			}
		}
		// 入金登録.郵便振込金融機関コード → 郵便振込金融機関コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD_ERR, template.getString(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD_ERR));
			}
		}
		// 入金登録.郵便振込金融機関支店コード → 郵便振込金融機関支店コードエラー
		if (!template.isNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD_ERR))
		{
			if (!inMap.containsKey(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD_ERR))
			{
				inMap.put(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD_ERR, template.getString(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0191D020CBSMsg.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 = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);

		// 金庫移動登録.金庫番号エラー → 金庫番号エラー
		if (!template.isNull(ECH0191D020CBSMsg.KNK_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.KNK_NO_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.KNK_NO_ERR, template.getString(ECH0191D020CBSMsg.KNK_NO_ERR));
			}
		}
		// 金庫移動登録.金庫料金項目コードエラー → 金庫料金項目コードエラー
		if (!template.isNull(ECH0191D020CBSMsg.KNK_PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.KNK_PRC_KMK_CD_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.KNK_PRC_KMK_CD_ERR, template.getString(ECH0191D020CBSMsg.KNK_PRC_KMK_CD_ERR));
			}
		}
		// 金庫移動登録.精算方法コードエラー → 精算方法コードエラー
		if (!template.isNull(ECH0191D020CBSMsg.SSN_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.SSN_WAY_CD_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.SSN_WAY_CD_ERR, template.getString(ECH0191D020CBSMsg.SSN_WAY_CD_ERR));
			}
		}
		// 金庫移動登録.金庫金額エラー → 金庫金額エラー
		if (!template.isNull(ECH0191D020CBSMsg.KNK_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.KNK_AMNT_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.KNK_AMNT_ERR, template.getString(ECH0191D020CBSMsg.KNK_AMNT_ERR));
			}
		}
		// 金庫移動登録.督促番号エラー → 督促番号エラー
		if (!template.isNull(ECH0191D020CBSMsg.TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.TOKUSOKU_NO_ERR, template.getString(ECH0191D020CBSMsg.TOKUSOKU_NO_ERR));
			}
		}
		// 金庫移動登録.移動元金庫更新年月日時分秒エラー → 移動元金庫更新年月日時分秒エラー
		if (!template.isNull(ECH0191D020CBSMsg.KNK_UPD_DTM_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.KNK_UPD_DTM_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.KNK_UPD_DTM_ERR, template.getString(ECH0191D020CBSMsg.KNK_UPD_DTM_ERR));
			}
		}
		// 金庫移動登録.金庫移動登録明細エラー → 金庫移動登録明細エラー
		if (!template.isNull(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST_ERR))
			{
				inMap.put(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST_ERR, template.getString(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST_ERR));
			}
		}
		// 金庫移動登録.請求契約番号エラー → 請求契約番号エラー
		if (!template.isNull(ECH0191D020CBSMsg1List.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg1List.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0191D020CBSMsg1List.SEIKY_KEI_NO_ERR, template.getString(ECH0191D020CBSMsg1List.SEIKY_KEI_NO_ERR));
			}
		}
		// 金庫移動登録.移動先金庫料金項目コードエラー → 移動先金庫料金項目コードエラー
		if (!template.isNull(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF_ERR))
			{
				inMap.put(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF_ERR, template.getString(ECH0191D020CBSMsg1List.KNK_PRC_KMK_CD_AF_ERR));
			}
		}
		// 金庫移動登録.移動先精算方法コードエラー → 移動先精算方法コードエラー
		if (!template.isNull(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF_ERR))
			{
				inMap.put(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF_ERR, template.getString(ECH0191D020CBSMsg1List.SSN_WAY_CD_AF_ERR));
			}
		}
		// 金庫移動登録.移動先金庫金額エラー → 移動先金庫金額エラー
		if (!template.isNull(ECH0191D020CBSMsg1List.KNK_AMNT_AF_ERR))
		{
			if (!inMap.containsKey(ECH0191D020CBSMsg1List.KNK_AMNT_AF_ERR))
			{
				inMap.put(ECH0191D020CBSMsg1List.KNK_AMNT_AF_ERR, template.getString(ECH0191D020CBSMsg1List.KNK_AMNT_AF_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0201D010CBSMsg.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(ECH0201D010CBSMsg.JUTO_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.JUTO_SBT_CD_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.JUTO_SBT_CD_ERR, template.getString(ECH0201D010CBSMsg.JUTO_SBT_CD_ERR));
			}
		}
		// 充当年月日 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.JUTO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.JUTO_YMD_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.JUTO_AMNT_ERR, template.getString(ECH0201D010CBSMsg.JUTO_YMD_ERR));
			}
		}
		// 充当額 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.JUTO_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.JUTO_AMNT_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.JUTO_AMNT_ERR, template.getString(ECH0201D010CBSMsg.JUTO_AMNT_ERR));
			}
		}
		// 入金番号 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.NYUKIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.NYUKIN_NO_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.NYUKIN_NO_ERR, template.getString(ECH0201D010CBSMsg.NYUKIN_NO_ERR));
			}
		}
		// 金庫番号 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.KNK_NO_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.KNK_NO_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.KNK_NO_ERR, template.getString(ECH0201D010CBSMsg.KNK_NO_ERR));
			}
		}
		// 債権番号 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0201D010CBSMsg.SAIKEN_NO_ERR));
			}
		}
		// 入金額 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.NYUKIN_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.NYUKIN_AMNT_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.NYUKIN_AMNT_ERR, template.getString(ECH0201D010CBSMsg.NYUKIN_AMNT_ERR));
			}
		}
		// 充当額合計 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.JUTO_AMNT_SUM_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.JUTO_AMNT_SUM_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.JUTO_AMNT_SUM_ERR, template.getString(ECH0201D010CBSMsg.JUTO_AMNT_SUM_ERR));
			}
		}
		// 金庫金額 のエラー情報返却
		if (!template.isNull(ECH0201D010CBSMsg.KNK_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0201D010CBSMsg.KNK_AMNT_ERR))
			{
				inMap.put(ECH0201D010CBSMsg.KNK_AMNT_ERR, template.getString(ECH0201D010CBSMsg.KNK_AMNT_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(ECH0311D010CBSMsg.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(ECH0311D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(ECH0311D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 入金番号 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.NYUKIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.NYUKIN_NO_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.NYUKIN_NO_ERR, template.getString(ECH0311D010CBSMsg.NYUKIN_NO_ERR));
			}
		}
		// 入金経路コード のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD_ERR, template.getString(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD_ERR));
			}
		}
		// 金庫処理年月日 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.NYUKIN_TRN_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.NYUKIN_TRN_YMD_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.NYUKIN_TRN_YMD_ERR, template.getString(ECH0311D010CBSMsg.NYUKIN_TRN_YMD_ERR));
			}
		}
		// 入金処理時分秒 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.NYUKIN_TRN_HMS_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.NYUKIN_TRN_HMS_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.NYUKIN_TRN_HMS_ERR, template.getString(ECH0311D010CBSMsg.NYUKIN_TRN_HMS_ERR));
			}
		}
		// 領収年月日 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.RECEIPT_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.RECEIPT_YMD_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.RECEIPT_YMD_ERR, template.getString(ECH0311D010CBSMsg.RECEIPT_YMD_ERR));
			}
		}
		// 領収時分秒 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.RECEIPT_HMS_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.RECEIPT_HMS_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.RECEIPT_HMS_ERR, template.getString(ECH0311D010CBSMsg.RECEIPT_HMS_ERR));
			}
		}
		// 債権年月 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.SAIKEN_YM_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.SAIKEN_YM_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.SAIKEN_YM_ERR, template.getString(ECH0311D010CBSMsg.SAIKEN_YM_ERR));
			}
		}
		// 請求方法コード のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.SEIKY_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.SEIKY_WAY_CD_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.SEIKY_WAY_CD_ERR, template.getString(ECH0311D010CBSMsg.SEIKY_WAY_CD_ERR));
			}
		}
		// 充当金額 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.JUTO_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.JUTO_AMNT_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.JUTO_AMNT_ERR, template.getString(ECH0311D010CBSMsg.JUTO_AMNT_ERR));
			}
		}
		// 充当金額うち消費税額 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX_ERR, template.getString(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX_ERR));
			}
		}
// OM-2014-0001880 ADD START
		// 債権番号 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0311D010CBSMsg.SAIKEN_NO_ERR));
			}
		}
		// 請求種別コード のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.SEIKY_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.SEIKY_SBT_CD_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.SEIKY_SBT_CD_ERR, template.getString(ECH0311D010CBSMsg.SEIKY_SBT_CD_ERR));
			}
		}
		// 充当番号 のエラー情報返却
		if (!template.isNull(ECH0311D010CBSMsg.JUTO_NO_ERR))
		{
			if (!inMap.containsKey(ECH0311D010CBSMsg.JUTO_NO_ERR))
			{
				inMap.put(ECH0311D010CBSMsg.JUTO_NO_ERR, template.getString(ECH0311D010CBSMsg.JUTO_NO_ERR));
			}
		}
// OM-2014-0001880 ADD END
		return param;
	}
	
	/**
	 * 営業日管理一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEZM0291B010(IRequestParameterReadWrite param, 
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EZM0291B010CBSMsg.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);
		
		// KEY_年エラー → 営業日管理一覧照会.KEY_年エラー
		if (!template.isNull(EZM0291B010CBSMsg.KEY_YEAR_ERR))
		{
			if (!inMap.containsKey(EZM0291B010CBSMsg.KEY_YEAR_ERR))
			{
				inMap.put(EZM0291B010CBSMsg.KEY_YEAR_ERR, template.getString(EZM0291B010CBSMsg.KEY_YEAR_ERR));
			}
		}
		
		// KEY_月エラー → 営業日管理一覧照会.KEY_月エラー
		if (!template.isNull(EZM0291B010CBSMsg.KEY_MON_ERR))
		{
			if (!inMap.containsKey(EZM0291B010CBSMsg.KEY_MON_ERR))
			{
				inMap.put(EZM0291B010CBSMsg.KEY_MON_ERR, template.getString(EZM0291B010CBSMsg.KEY_MON_ERR));
			}
		}
		
		return param;
	}

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

		int templateStatus = template.getInt(EZM0321A010CBSMsg.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(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
		{
			if (!inMap.containsKey(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
			{
				inMap.put(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR, template.getString(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(EKK0511B004CBSMsg.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(EKK0511B004CBSMsg.KEY_BANK_CD_ERR))
		{
			if (!inMap.containsKey(EKK0511B004CBSMsg.KEY_BANK_CD_ERR))
			{
				inMap.put(EKK0511B004CBSMsg.KEY_BANK_CD_ERR, template.getString(EKK0511B004CBSMsg.KEY_BANK_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * 電子ファイル管理登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	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;
	}
	// ▲▲ エラー情報マッピング処理 ▲▲

	// ▼▼ クラス内共通処理 ▼▼
	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。 マップには共通項目である電文ヘッダ、コントロールマップを設定します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param childMap 債権充当明細１件のマップ
	 * @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 テンプレート機能コードキー名
	 * @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(JCHZuijiNkinAddConstCC.MAP_CC_ID);
	}

	/**
	 * 随時入金登録マップから指定された項目名の値を取得します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param key 項目名
	 * @return マップ項目値
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private String getMapItem(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		return (String)inMap.get(key);
	}

	/**
	 * 随時入金登録マップに指定された項目名の値を設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param key 項目名
	 * @param value 値
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void setMapItem(IRequestParameterReadWrite param, String key, String value) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		inMap.put(key, value);
	}

	/**
	 * 随時入金登録マップから指定された項目名の値を削除します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param key 項目名
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void removeMapItem(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		if (inMap.containsKey(key))
		{
			inMap.remove(key);
		}
	}

	/**
	 * マップから指定されたリスト項目名の値を取得します。 <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(JCHZuijiNkinAddConstCC.MAP_CC_ID);
		return (ArrayList<HashMap<String, Object>>)inMap.get(key);
	}

	/**
	 * 指定された随時入金登録マップから債権に充当する合計額を算出します。 <br>
	 * 
	 * @param inMap 随時入金登録マップ
	 * @return 充当額合計
	 */
	@SuppressWarnings("unchecked")
	private BigDecimal sumUpJutoAmnt(HashMap<String, Object> inMap)
	{
		BigDecimal jutoAmntVal = BigDecimal.ZERO;

		// 随時入金明細リストより内訳額を合計し、債権充当額合計を算出
		ArrayList nkinList = (ArrayList)inMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_ZUIJI_NKIN_LIST);
		for (int i = 0; i < nkinList.size(); i++)
		{
			HashMap childMap = (HashMap)nkinList.get(i);

			String utwkAmnt = (String)childMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_UTWK_AMNT);
			if (utwkAmnt != null && "".equals(utwkAmnt) == false)
			{
				jutoAmntVal = jutoAmntVal.add(new BigDecimal(utwkAmnt));
			}
		}

		return jutoAmntVal;
	}

	/**
	 * オンライン運用年月取得.<br>
	 * <br>
	 * 
	 * @return オンライン運用年月
	 */
	private String getOpeYm()
	{
		String opeYm = JACStrConst.KARA_MOJI;

		String opeDate = JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH);
		if (opeDate != null && opeDate.length() == 8)
		{
			opeYm = opeDate.substring(0, 6);
		}

		return opeYm;
	}
	
	/**
	 * コンビニ支払予定年月日の取得を実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return コンビニ支払予定年月日
	 * @throws Exception 
	 */
	private String getCvsPayRsvYmd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 請求年月の取得（料金スケジュール定義一意照会の実行）
		String seikyYm = execECH0501A010_2(handle, param);

		// 請求年月の末日の取得
		String cvsPayRsvYmd = seikyYm + JPCDateUtil.getEndOfMonth(seikyYm);
		
		return cvsPayRsvYmd;
	}

	/**
	 * クレジット用の収納日の取得を実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 収納日
	 * @throws Exception 
	 */
	private String getCreShunoYmd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 請求年月の取得（料金スケジュール定義一意照会の実行）
		String seikyYm = execECH0501A010_3(handle, param);
		
		// 最終営業日の取得（営業日管理一覧照会の実行）
		String creShunoYmd = execEZM0291B010(handle, param, seikyYm);
		
		return creShunoYmd;
	}

	/**
	 * 電子ファイル登録内容生成処理<br>
	 * 
	 * @param String 入金経路コード
	 * @return byte[]
	 */
	private byte[] createEfile(String nyukinRouteCd)
	{
		try
		{
			byte[] fileByte = new byte[0];

			boolean bsetHeader = false;
			StringBuffer sb = new StringBuffer();
			for (CAANMsg caEfileInfo : efileInfoList)
			{
				if (!bsetHeader)
				{
					sb.append(caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO))                         // 請求契約番号
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM))                       // 請求年月
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO))                     // サービス契約番号
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_RECEIPT_YMD)))      // 入金情報.領収年月日
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_TRN_YMD)))   // 入金情報.入金処理年月日
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNO_YMD)))        // 入金情報.外部組織収納年月日
					  .append(CSV + nyukinRouteCd)                                                                        // 入金情報.入金経路コード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_GRP_CD))                     // 料金グループコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD))                        // 料金コースコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD))                     // 料金サービスコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD))                     // 料金項目コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SHUNOKIKAN_CD)))    // 入金情報.収納機関コード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_NYUKIN_AMNT))                    // 入金額
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_JUTO_AMNT))                      // 充当額
					  .append(CSV + ZERO)                                                                                 // 預り金
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_BANK_CD)))          // 入金情報.金融機関コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_BANK_SHITEN_CD)))   // 入金情報.金融機関支店コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CRECARD_COMP_CD)))  // 入金情報.クレジットカード会社コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_CVSTORE_CD)))       // 入金情報.コンビニエンスストアコード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_ORG_CD)))           // 入金情報.組織コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHZuijiNkinAddConstCC.MAP_KEY_SKNKSITKCM_CD)));   // 入金情報.債権回収委託会社コード

					bsetHeader = true;
				}
				else
				{
					sb.append(caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_KEI_NO))                         // 請求契約番号
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SEIKY_YM))                       // 請求年月
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_SVC_KEI_NO))                     // サービス契約番号
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金情報.領収年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金情報.入金処理年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金情報.外部組織収納年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金情報.入金経路コード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_GRP_CD))                     // 料金グループコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PCRS_CD))                        // 料金コースコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_SVC_CD))                     // 料金サービスコード
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.MAP_KEY_PRC_KMK_CD))                     // 料金項目コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金情報.収納機関コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                // 入金額
					  .append(CSV + caEfileInfo.getString(JCHZuijiNkinAddConstCC.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)                                                                // 入金情報.組織コード
					  .append(CSV + JACStrConst.KARA_MOJI);                                                               // 入金情報.債権回収委託会社コード
				}

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

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

			return fileByte;
		}
		catch (UnsupportedEncodingException e)
		{
			return null;
		}
	}
	
	/**
	 * NULLを空文字に変換する処理.<br>
	 * <br>
	 * 
	 * @param trgetStr 判定文字
	 * @return 判定結果 true:Null か 空文字
	 */
	public static String nullToEmpty(String trgetStr)
	{
		if (trgetStr == null)
		{
			return JACStrConst.KARA_MOJI;
		}

		return trgetStr;
	}
}