/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *   システム名      ：eo顧客基幹システム
 *   モジュール名    ：JCHNkinAddSaikenJutoCC
 *   ソースファイル名：JCHNkinAddSaikenJutoCC.java
 *   作成者          ：富士通
 *   日付            ：2011年08月22日
 *＜機能概要＞
 *   入金登録債権充当CC部品です。
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00.00	2011/08/22	富士通		新規作成
 *	v5.00.00	2013/07/02	FJ)小野		【LT-2013-0000234】入金詳細照会で入金処理日時が表示されない。
 *	v5.00.01	2013/07/12	FJ)山口		【LT-2013-0000422】コンビニ支払予定年月日の取得・設定を追加。
 *  v5.00.02	2013/08/03  FJ)吉田		【IT1-2013-0001510】入金系画面強化対応
 *  v5.00.03	2013/08/13  FJ)吉田		【IT1-2013-0001583】入金経路がクレジットの場合、領収日付に請求年月末営業日を設定するよう修正。
 *  v5.00.04	2013/09/06  FJ)垣内		【OM-2013-0001613】現金・総合口座時の金融機関コード設定不備
 *	v5.00.05	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メーカーコードを設定する様に修正
 *	v10.00.00	2014/08/27  FJ)江森     【OM-2014-0001880,IT2-2014-000167】支払証明書の消費税不正対応。
 *	v32.00.00	2017/04/20	FJ)清原		【ANK-2996-00-00】ＳＭＳを利用した即時決済サービスの導入
*	v32.00.01	2017/04/20	FJ)西面		【ANK-2996-00-02】ＳＭＳを利用した即時決済サービスの導入
*	v52.00.00	2020/10/27	FJ)寺園     【ANK-3838-00-00】窓口払い手数料の顧客負担方式導入
*	v59.00.00	2022/04/18	FJ)吉田		【ANK-4160-00-00】SMBC即時決済入金会計システム化対応
 **********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.constant.JCHNkinAddSaikenJutoConstCC;
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.ECH0011C012CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0111D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0191D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0311D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg1List;
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 JCHNkinAddSaikenJutoCC extends AbstractCommonComponent
{

	/** 金庫充当債権リスト */
	private ArrayList<HashMap<String, Object>> knkJutoSaikenList = null;

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

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

	/** 電子ファイル管理登録情報 充当額合計 */
	private String jyutoAmntSum = null;
	
	/** 改行文字 */
	private static final String LINE_SEP = "line.separator";

	/**  カンマ区切り */
	private static final String CSV = ",";

	/**  ゼロ */
	private static final String ZERO = "0";

	/*
	 * ◇ダミー値 invokeCheck時には入金番号、金庫番号が採番されず、入金登録債権変更サービスIFに設定できないことに起因し、 
	 * 単関連チェックでエラーとなる事象を回避する目的でダミー値を設定する。
	 */
	/** 入金登録債権充当マップキー(ダミー：入金番号) */
	private static final String MAP_KEY_DUMMY_NYUKIN_NO = "dummy_nyukin_no";

	/** 入金登録債権充当マップキー(ダミー：金庫番号) */
	private static final String MAP_KEY_DUMMY_KNK_NO = "dummy_knk_no";

	/** ダミー値(入金番号／金庫番号) */
	private static final String DUMMY_NO = "000000000000";

	// ▲▲ マップキー(当クラス処理内おいて、新たに生成する項目、もしくはサービスIFに固定値を指定する項目) ▲▲

	// ▼▼ invokeCBSによる単項目チェック処理 ▼▼
	/**
	 * 入金登録債権充当チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws Exception 
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{

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

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

		/* 単項目・単関連チェックを通すためのダミー設定。 */
		this.setDummyNo(param);

		/* ◇入金経路判定 */
		String nyukinRouteCd = getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
		if (!nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_JUTO))
		{
			/* ◇入金経路が"金庫充当"以外である場合 */
			/* ◇業務パラメータ管理一意照会設定処理 */
			ArrayList<CAANMsg> templateEZM0321A010 = editInMsgEZM0321A010(param);
			for (CAANMsg msg : templateEZM0321A010)
			{
				templateList.add(msg);
			}

			// 入金登録サービスIF用メッセージ設定処理
			ArrayList<CAANMsg> templateECH0111D010 = editInMsgECH0111D010(param, null, null, null);
			for (CAANMsg msg : templateECH0111D010)
			{
				templateList.add(msg);
			}
		}

		// 入金登録債権変更サービスIF用メッセージ設定処理
		ArrayList<CAANMsg> templateECH0011C012 = editInMsgECH0011C012(param);
		for (CAANMsg msg : templateECH0011C012)
		{
			templateList.add(msg);
		}

		/* 単項目・単関連チェックを通すためのダミー設定解除 */
		this.removeDummyNo(param);

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

		return paramMap;
	}

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

	// ▼▼ 入金登録債権充当処理 ▼▼
	/**
	 * 入金登録債権充当マップに指定された入金情報、債権充当明細リストを基に入金登録債権充当を行います。 <br>
	 * 入金経路が金庫充当である場合は、金庫(預り金)から未収債権への充当を行います。 <br>
	 * 入金経路が金庫充当以外である場合は、入金登録と共に未収債権への充当を行い、 入金額に余剰金が発生した場合は、金庫に登録します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite addNkin(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{

		/* 単項目・単関連チェックを通すためのダミー設定。 */
		if (this.isFuncCodeCheckOnly(param))
		{
			this.setDummyNo(param);
		}
		
		/* 電子ファイル管理登録情報リスト設定 */
		setEfileInfoList(param);
		
		/* ◇入金経路判定 */
		String nyukinRouteCd = getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_JUTO))
		{
			/* ◇入金経路が"金庫充当"である場合は、金庫充当処理を実行 */
			this.execKnkJuto(handle, param);
		}
		else
		{
			/* ◇入金経路が"金庫充当"以外である場合は、入金登録債権充当処理を実行 */
			this.execNkinAddSaikenJuto(handle, param);
		}
		
		/* ◇電子ファイル管理登録処理 */
		execECC0041D010(handle, param);

		/* 単項目・単関連チェックを通すためのダミー設定解除 */
		this.removeDummyNo(param);

		return param;
	}

	/**
	 * 入金登録債権充当処理<br>
	 * 入金から未収債権への充当を行います。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execNkinAddSaikenJuto(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{

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

		/* ◇入金登録債権変更処理 */
		// 債権充当明細リスト分繰り返し
		// (Ｎ回の債権変更を１回のサービスIF呼出で行うと債権の排他チェックが検出されるためＮ回に分けて呼ぶ)
		ArrayList<HashMap<String, Object>> saikenJutoList = this.getMapListItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_LIST);

		// リストを逆順に読み、処理を実行
//		int listSize = saikenJutoList.size();
//		for (int idx = listSize - 1; idx >= 0; idx--)
		for (int idx = 0; idx < saikenJutoList.size(); idx++)
		{
			// 入金登録で払い出された入金番号で入金登録債権変更処理を行う
			this.execSaikenJutoNkin(handle, param, saikenJutoList, idx);

// OM-2014-0001880 DELETE START
			// 入金登録で払い出された入金番号で領収登録処理を行う→入金登録債権変更処理で行うため削除
//			this.execRyoshuNkin(handle, param, saikenJutoList, idx);
// OM-2014-0001880 DELETE START
		}

		/* ◇金庫登録処理 */
		// 余剰となる入金額がある場合
		HashMap<String, Object> inMap = this.getMap(param);
		BigDecimal jutoAmntVal = this.sumUpSaikenJuto(inMap);
		BigDecimal nkinAmntVal = new BigDecimal((String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT));
		BigDecimal extraNkinVal = nkinAmntVal.subtract(jutoAmntVal);
		if (extraNkinVal.compareTo(BigDecimal.ZERO) > 0)
		{
			// 入金登録債権充当マップに余剰入金額を追加
			inMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EXTRA_NKIN_AMNT, String.valueOf(extraNkinVal));
			// 金庫登録
			this.execECH0191D010(handle, param);
		}

	}

	/**
	 * 入金による債権充当処理を行います。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param saikenJutoList 債権充当明細リスト
	 * @param idx 債権充当明細リストのインデックス
	 * @throws Exception 例外が発生した場合
	 */
	private void execSaikenJutoNkin(SessionHandle handle, IRequestParameterReadWrite param, ArrayList<HashMap<String, Object>> saikenJutoList, int idx) throws Exception
	{
		HashMap<String, Object> saikenJutoMap = saikenJutoList.get(idx);
		// 債権充当マップに入金番号を追加
		saikenJutoMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO, getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));

		// 上りマッピング
		HashMap<String, Object> paramMap = editInMsgECH0011C012(param, saikenJutoMap, saikenJutoMap);

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

		// 下りマッピング
		editOutMsgECH0011C012(result, param, saikenJutoList, idx);
	}
// OM-2014-0001880 DELETE START
	/**
	 * 入金による領収登録処理を行います。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param saikenJutoList 債権充当明細リスト
	 * @param idx 債権充当明細リストのインデックス
	 * @throws Exception 例外が発生した場合
	 */
//	private void execRyoshuNkin(SessionHandle handle, IRequestParameterReadWrite param, ArrayList<HashMap<String, Object>> saikenJutoList, int idx) throws Exception
//	{
//		HashMap<String, Object> saikenJutoMap = saikenJutoList.get(idx);
//
//		// 債権充当マップに入金番号を追加
//		saikenJutoMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO, getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));
//		
//		// 上りマッピング
//		HashMap<String, Object> paramMap = editInMsgECH0311D010(param, saikenJutoMap, saikenJutoMap);
//
//		// ＳＣ呼出実行
//		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//		Map<?, ?> result = scCall.run(paramMap, handle);
//
//		// 下りマッピング
//		editOutMsgECH0311D010(result, param);
//	}
// OM-2014-0001880 DELETE END
	// ▲▲ 入金登録債権充当処理 ▲▲

	// ▼▼ 金庫充当処理 ▼▼
	/**
	 * 金庫充当処理<br>
	 * 金庫(預り金)から未収債権への充当を行います。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execKnkJuto(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{

		// 債権充当明細リスト分繰り返し
		ArrayList<HashMap<String, Object>> saikenJutoList = getMapListItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_LIST);

		// リストを逆順に読み、処理を実行
//		int listSize = saikenJutoList.size();
//		for (int idx = listSize - 1; idx >= 0; idx--)
		for (int idx = 0; idx < saikenJutoList.size(); idx++)
		{
			// 金庫充当債権リストの初期化
			this.knkJutoSaikenList = new ArrayList<HashMap<String, Object>>();

			HashMap<String, Object> childMap = saikenJutoList.get(idx);

			// 債権充当明細リスト１件の金庫移動を行う
			this.execKnkIdoForOneSaiken(handle, param, childMap);

			// 金庫移動で生成された金庫充当債権リストに従って、入金登録債権変更処理を行う
			this.execSaikenJutoKnk(handle, param, childMap);
// OM-2014-0001880 DELETE START
			// 金庫移動で生成された金庫充当債権リストに従って、領収登録処理を行う→入金登録債権変更処理で行うため削除
//			this.execRyoshuKnk(handle, param, childMap);
// OM-2014-0001880 DELETE END
		}
	}

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

		// 充当額
		BigDecimal jutoAmntVal = new BigDecimal((String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));

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

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

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

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

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

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

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

		// 債権充当額がなくなるまで、預り金明細リストの金庫移動
		for (int idxAzukin = 0; idxAzukin < azukinList.size(); idxAzukin++)
		{
			HashMap<String, Object> azukinMap = azukinList.get(idxAzukin);
			// 債権充当額
			BigDecimal jutoAmnt = new BigDecimal((String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));
			// 実際の金庫移動額
			BigDecimal azukin = new BigDecimal((String)azukinMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_AMNT));

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

	/**
	 * 金庫移動による債権充当処理を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param saikenJutoMap 債権充当マップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execSaikenJutoKnk(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> saikenJutoMap) throws Exception
	{
		// 金庫充当債権リストの件数分、入金登録債権変更を行う
		for (int idx = 0; idx < knkJutoSaikenList.size(); idx++)
		{
			// 上りマッピング
			HashMap<String, Object> paramMap = editInMsgECH0011C012(param, knkJutoSaikenList.get(idx), saikenJutoMap);

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

			// 下りマッピング
			editOutMsgECH0011C012(result, param, knkJutoSaikenList, idx);
		}
	}

// OM-2014-0001880 DELETE START
	/**
	 * 金庫移動による領収登録処理を行う。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param saikenJutoMap 債権充当マップ
	 * @throws Exception 例外が発生した場合
	 */
//	private void execRyoshuKnk(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> saikenJutoMap) throws Exception
//	{
//		// 金庫充当債権リストの件数分、領収登録を行う
//		for (int idx = 0; idx < knkJutoSaikenList.size(); idx++)
//		{
//			// 上りマッピング
//			HashMap<String, Object> paramMap = editInMsgECH0311D010(param, knkJutoSaikenList.get(idx), saikenJutoMap);
//
//			// ＳＣ呼出実行
//			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//			Map<?, ?> result = scCall.run(paramMap, handle);
//	
//			// 下りマッピング
//			editOutMsgECH0311D010(result, param);
//		}
//	}
// OM-2014-0001880 DELETE END
	// ▲▲ 金庫充当処理 ▲▲

	// ▼▼ サービスIF呼び出し ▼▼
	/**
	 * 入金登録サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 払い出された入金番号
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0111D010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		String cvsPayRsvYmd = null;
		
		/* ◇業務パラメータ管理一意照会取得処理 */
		HashMap<String, String> hrkmBankCdMap = execEZM0321A010(handle, param);

		String nyukinRouteCd = getMapItem(param, JCHNkinAddSaikenJutoConstCC.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);
		}
		//v52.00.00 Add Start
		// v59.00.00 2022/04/18 ANK-4160-00-00 MOD START
//		else if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE_ETC))
		else if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_CVSTORE_ETC)
				|| nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_KESSAI_SMBC))
		// v59.00.00 2022/04/18 ANK-4160-00-00 MOD END
		{
			//外部収納年月日を取得する
			HashMap<String, Object> inMap = this.getMap(param);
			String shunoYmd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNO_YMD);
			
			//収納年月日の翌月15日を取得する
			cvsPayRsvYmd = JPCUtilCommon.addMonth(shunoYmd, 1);
			cvsPayRsvYmd = cvsPayRsvYmd.substring(0, 6) + "15";
		}
		//v52.00.00 Add End
		// 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(JCHNkinAddSaikenJutoConstCC.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);
		}

		/* ◇パラメータマップ生成 */
		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 execECH0191D010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

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

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

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

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 下りマッピング
		seikyYm = editOutMsgECH0501A010(result, param);
		
		return seikyYm;
	}
	
	/**
	 * 料金スケジュール定義一意照会サービスインタフェイスを実行します。 <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 リクエストパラメータ
	 * @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 HashMap<String, String> execEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

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

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

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

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

	// ▼▼ サービスIF用メッセージ設定処理 ▼▼
	/**
	 * 入金登録サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param cvsPayRsvYmd コンビニ支払予定年月日
	 * @param creShunoYmd クレジット用の収納日
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	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, JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD);
		}
		else
		{
			nyukinRouteCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
			template.set(ECH0111D010CBSMsg.NYUKIN_ROUTE_CD, nyukinRouteCd);
		}

		// 入金登録債権充当マップ.収納機関コード → 収納機関コード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNOKIKAN_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNOKIKAN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.SHUNOKIKAN_CD);
		}
		else
		{
			shunoKikanCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNO_YMD) == null || "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNO_YMD)))
		{
			template.setNull(ECH0111D010CBSMsg.SHUNO_YMD);
		}
		else
		{
			shunoYmd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNO_YMD);
			template.set(ECH0111D010CBSMsg.SHUNO_YMD, shunoYmd);
		}

		// オンライン運用日 → 入金処理年月日
		nyukinTrnYmd =  JCCBPCommon.getOpeDate(null);
		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(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD) == null || "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD)))
		{
			template.setNull(ECH0111D010CBSMsg.RECEIPT_YMD);
		}
		else
		{
			receiptYmd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD);
			template.set(ECH0111D010CBSMsg.RECEIPT_YMD, receiptYmd);
		}

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

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

		// 請求番号
		template.setNull(ECH0111D010CBSMsg.SEIKY_NO);

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

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

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

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

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

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

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

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

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

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

		// 入金経路コードが窓口（現金）の場合、業務パラメータから取得した値を設定する
		if(nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_GENKIN))
		{
			String shiteiKozaCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_CD) == null
					|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_CD)))
			{
				template.setNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD);
			}
			else
			{
				bankCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_CD);
				template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_CD, bankCd);
			}

			// 入金登録債権充当マップ.払込先金融機関支店コード → 払込先金融機関支店コード
			if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD) == null
					|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD)))
			{
				template.setNull(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD);
			}
			else
			{
				bankShitenCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_HRAKMISAKI_BANK_SHITEN_CD);
				template.set(ECH0111D010CBSMsg.HRAKMISAKI_BANK_SHITEN_CD, bankShitenCd);
			}
		}

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

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

		// 入金登録債権充当マップ.コンビニエンスストアコード → コンビニエンスストアコード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_CVSTORE_CD) == null || "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_CVSTORE_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.CVSTORE_CD);
		}
		else
		{
			cvstoreCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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);

		// パラメータ(コンビニ支払予定年月日) → コンビニ支払予定年月日
		if (cvsPayRsvYmd == null)
		{
			template.setNull(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD);
		}
		else
		{
			template.set(ECH0111D010CBSMsg.CVSTORE_PAY_RSV_YMD, cvsPayRsvYmd);
		}

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

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

		// 入金登録債権充当マップ.郵便自動振込金融機関コード → 郵便自動振込金融機関コード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.YJHRI_BANK_CD);
		}
		else
		{
			bankCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_CD);
			template.set(ECH0111D010CBSMsg.YJHRI_BANK_CD, bankCd);
		}

		// 入金登録債権充当マップ.郵便自動振込金融機関支店コード → 郵便自動振込金融機関支店コード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_SHITEN_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_SHITEN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD);
		}
		else
		{
			bankShitenCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YJHRI_BANK_SHITEN_CD);
			template.set(ECH0111D010CBSMsg.YJHRI_BANK_SHITEN_CD, bankShitenCd);
		}

		// 入金登録債権充当マップ.郵便振込金融機関コード → 郵便振込金融機関コード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD);
		}
		else
		{
			bankCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_CD);
			template.set(ECH0111D010CBSMsg.YHRIKOMI_BANK_CD, bankCd);
		}

		// 入金登録債権充当マップ.郵便振込金融機関支店コード → 郵便振込金融機関支店コード
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_SHITEN_CD) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_SHITEN_CD)))
		{
			template.setNull(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD);
		}
		else
		{
			bankShitenCd = (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_YHRIKOMI_BANK_SHITEN_CD);
			template.set(ECH0111D010CBSMsg.YHRIKOMI_BANK_SHITEN_CD, bankShitenCd);
		}

		templateList.add(template);

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

	/**
	 * 入金登録債権変更サービスインターフェイス用メッセージ設定処理<br>
	 * invokeCBSによる単項目チェック用にＮ件のテンプレートを生成します。
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0011C012(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		// 債権充当リスト
		ArrayList<HashMap<String, Object>> saikenJutoList = null;
		if (knkJutoSaikenList != null)
		{
			// 金庫充当である場合は、金庫充当債権リストにて入金登録債権充当を実施する
			saikenJutoList = knkJutoSaikenList;
		}
		else
		{
			saikenJutoList = this.getMapListItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_LIST);
		}

		for (int idx = 0; idx < saikenJutoList.size(); idx++)
		{
			CAANMsg template = new CAANMsg(ECH0011C012CBSMsg.class.getName());
			this.setTemplateCommonItem(param, template, ECH0011C012CBSMsg.TEMPLATEID, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0011C012, ECH0011C012CBSMsg.FUNC_CODE);

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

			HashMap<String, Object> saikenJutoMap = saikenJutoList.get(idx);
			// 債権番号
			template.set(ECH0011C012CBSMsg.SAIKEN_NO, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO));

			// 金庫番号
			if (inMap.containsKey(MAP_KEY_DUMMY_KNK_NO))
			{
				template.set(ECH0011C012CBSMsg.KNK_NO, (String)inMap.get(MAP_KEY_DUMMY_KNK_NO));
			}
			else if (saikenJutoMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO) && saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO) != null
					&& "".equals(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO)) == false)
			{
				template.set(ECH0011C012CBSMsg.KNK_NO, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO));
			}
			else
			{
				template.setNull(ECH0011C012CBSMsg.KNK_NO);
			}

			// 入金番号
			if (inMap.containsKey(MAP_KEY_DUMMY_NYUKIN_NO))
			{
				template.set(ECH0011C012CBSMsg.NYUKIN_NO, (String)inMap.get(MAP_KEY_DUMMY_NYUKIN_NO));
			}
			else if (saikenJutoMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO) && saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO) != null
					&& "".equals(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO)) == false)
			{
				template.set(ECH0011C012CBSMsg.NYUKIN_NO, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));
			}
			else
			{
				template.setNull(ECH0011C012CBSMsg.NYUKIN_NO);
			}

			// 入金経路コード
			template.set(ECH0011C012CBSMsg.NYUKIN_ROUTE_CD, getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD));

			// 債権充当年月日
			if (saikenJutoMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_YMD)
					&& saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_YMD) != null
					&& "".equals(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_YMD)) == false)
			{
				template.set(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_YMD));
			}
			else
			{
				// (オンライン運用日)
				template.set(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));
			}

			// 充当額
			template.set(ECH0011C012CBSMsg.JUTO_AMNT, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));

			// 未収額
			if (saikenJutoMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT) && saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT) != null
					&& "".equals(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT)) == false)
			{
				template.set(ECH0011C012CBSMsg.MISYU_AMNT, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT));
			}
			else
			{
				template.setNull(ECH0011C012CBSMsg.MISYU_AMNT);
			}

			// 預金
			template.set(ECH0011C012CBSMsg.AZUKIN, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_AZUKIN));

			// 債権ステータス
			template.set(ECH0011C012CBSMsg.SAIKEN_STAT_CD, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_STATE_CD));

			// 充当額合計
			template.set(ECH0011C012CBSMsg.JUTO_AMNT_SUM, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT_SUM));

			// 入金額
			template.set(ECH0011C012CBSMsg.NYUKIN_AMNT, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT));

			// 更新前債権更新年月日時分秒
			template.set(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF));

			templateList.add(template);
		}

		return templateList;
	}

	/**
	 * 入金登録債権変更サービスインターフェイス用メッセージ設定処理<br>
	 * 実際のトランザクション用に１件のテンプレートを設定したパラメータマップを生成します。
	 * 
	 * @param param リクエストパラメータ
	 * @param knkJutoSaikenMap 金庫充当債権リスト１件のマップ
	 * @param saikenJutoMap 債権充当リスト１件のマップ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECH0011C012(IRequestParameterReadWrite param, HashMap<String, Object> knkJutoSaikenMap, HashMap<String, Object> saikenJutoMap) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);

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

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

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

		// 債権番号
		template.set(ECH0011C012CBSMsg.SAIKEN_NO, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO));

		// 金庫番号
		if (inMap.containsKey(MAP_KEY_DUMMY_KNK_NO))
		{
			template.set(ECH0011C012CBSMsg.KNK_NO, (String)inMap.get(MAP_KEY_DUMMY_KNK_NO));
		}
		else if (knkJutoSaikenMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO))
		{
			template.set(ECH0011C012CBSMsg.KNK_NO, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO));
		}
		else
		{
			template.setNull(ECH0011C012CBSMsg.KNK_NO);
		}

		// 入金番号
		if (inMap.containsKey(MAP_KEY_DUMMY_NYUKIN_NO))
		{
			template.set(ECH0011C012CBSMsg.NYUKIN_NO, (String)inMap.get(MAP_KEY_DUMMY_NYUKIN_NO));
		}
		else if (knkJutoSaikenMap.containsKey(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO))
		{
			template.set(ECH0011C012CBSMsg.NYUKIN_NO, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));
		}
		else
		{
			template.setNull(ECH0011C012CBSMsg.NYUKIN_NO);
		}

		// 入金経路コード
		template.set(ECH0011C012CBSMsg.NYUKIN_ROUTE_CD, getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD));

		// 債権充当年月日(オンライン運用日)
		template.set(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD, JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		// 充当額
		template.set(ECH0011C012CBSMsg.JUTO_AMNT, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));

		// 未収額
		template.set(ECH0011C012CBSMsg.MISYU_AMNT, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT));

		// 預金
		template.set(ECH0011C012CBSMsg.AZUKIN, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_AZUKIN));

		// 債権ステータス
		template.set(ECH0011C012CBSMsg.SAIKEN_STAT_CD, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_STATE_CD));

		// 充当額合計
		template.set(ECH0011C012CBSMsg.JUTO_AMNT_SUM, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT_SUM));

		// 入金額
		template.set(ECH0011C012CBSMsg.NYUKIN_AMNT, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT));

		// 更新前債権更新年月日時分秒
		template.set(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF));

// OM-2014-0001880 ADD START
		// 請求契約番号
		if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO) == null
				|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0011C012CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0011C012CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO));
		}
		// 債権年月
		if (JCRUtilCommon.isNull(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_YM)))
		{
			template.setNull(ECH0011C012CBSMsg.SAIKEN_YM);
		}
		else
		{
			template.set(ECH0011C012CBSMsg.SAIKEN_YM, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_YM));
		}
// OM-2014-0001880 ADD END
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

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

		// 余剰入金額
		BigDecimal jutoAmntVal = this.sumUpSaikenJuto(inMap);
		BigDecimal nkinAmntVal = new BigDecimal((String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT));
		BigDecimal extraNkinVal = nkinAmntVal.subtract(jutoAmntVal);
		inMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EXTRA_NKIN_AMNT, String.valueOf(extraNkinVal));

		/* ◇ユーザデータ情報 */
		// 余剰入金額がある場合のみ金庫登録処理を行う
		if (extraNkinVal.compareTo(BigDecimal.ZERO) > 0)
		{
			CAANMsg template = new CAANMsg(ECH0191D010CBSMsg.class.getName());
			this.setTemplateCommonItem(param, template, ECH0191D010CBSMsg.TEMPLATEID, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0191D010, ECH0191D010CBSMsg.FUNC_CODE);

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

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

			// 入金登録債権充当マップ.請求契約番号 → 請求契約番号
			if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO) == null
					|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO)))
			{
				template.setNull(ECH0191D010CBSMsg.SEIKY_KEI_NO);
			}
			else
			{
				template.set(ECH0191D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO));
			}

			// オンライン運用日 → 金庫移動年月日
			template.set(ECH0191D010CBSMsg.KNK_IDO_YMD, JPCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

			// NULL固定 → 移動元金庫番号
			template.setNull(ECH0191D010CBSMsg.IDOMOTO_KNK_NO);

			// NULL固定 → 統合先金庫番号
			template.setNull(ECH0191D010CBSMsg.BNKT_KNK_NO);

			// 入金登録債権充当マップ.入金番号 → 入金番号
			if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO) == null || "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO)))
			{
				template.setNull(ECH0191D010CBSMsg.NYUKIN_NO);
			}
			else
			{
				template.set(ECH0191D010CBSMsg.NYUKIN_NO, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));
			}
			// 料金項目コード(固定：預り金) → 金庫料金項目コード
			template.set(ECH0191D010CBSMsg.KNK_PRC_KMK_CD, JACStrConst.PRC_KMK_CD_AZUKIN);

			// 入金登録債権充当マップ.余剰入金額 → 金庫金額
			if (inMap == null || inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EXTRA_NKIN_AMNT) == null
					|| "".equals(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EXTRA_NKIN_AMNT)))
			{
				template.setNull(ECH0191D010CBSMsg.KNK_AMNT);
			}
			else
			{
				template.set(ECH0191D010CBSMsg.KNK_AMNT, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EXTRA_NKIN_AMNT));
			}

			// NULL固定 → 精算方法コード
			template.setNull(ECH0191D010CBSMsg.SSN_WAY_CD);

			// 履歴データフラグ(固定：カレントデータ) → 履歴データフラグ
			template.set(ECH0191D010CBSMsg.RIREKI_DATA_FLG, JACStrConst.RIREKI_DATA_FLG_ON);

			templateList.add(template);
		}

		return templateList;
	}

	/**
	 * 金庫移動登録サービスインターフェイス用メッセージ設定処理［金庫金額の全額］<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param azukinMap 預り金明細１件のマップ
	 * @return HashMap<String, Object>
	 * @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, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0191D020, ECH0191D020CBSMsg.FUNC_CODE);

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

		// 金庫番号
		if (inMap.containsKey(MAP_KEY_DUMMY_KNK_NO))
		{
			template.set(ECH0191D020CBSMsg.KNK_NO, (String)inMap.get(MAP_KEY_DUMMY_KNK_NO));
		}
		else
		{
			template.set(ECH0191D020CBSMsg.KNK_NO, (String)azukinMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO));
		}

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

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

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

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

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

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

		// 移動元金庫更新年月日時分秒
		template.set(ECH0191D020CBSMsg.KNK_UPD_DTM, (String)azukinMap.get(JCHNkinAddSaikenJutoConstCC.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, JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_AMNT));

		childTemplateArray[0] = childTemplate;

		return template;
	}

	/**
	 * 金庫移動登録サービスインターフェイス用メッセージ設定処理［金庫金額の一部］<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param saikenJutoMap 債権充当明細１件のマップ
	 * @param azukinMap 預り金明細１件のマップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsgECH0191D020_2(IRequestParameterReadWrite param, HashMap<String, Object> saikenJutoMap, 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, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0191D020, ECH0191D020CBSMsg.FUNC_CODE);

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

		// 金庫番号
		if (inMap.containsKey(MAP_KEY_DUMMY_KNK_NO))
		{
			template.set(ECH0191D020CBSMsg.KNK_NO, (String)inMap.get(MAP_KEY_DUMMY_KNK_NO));
		}
		else
		{
			template.set(ECH0191D020CBSMsg.KNK_NO, (String)azukinMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO));
		}

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

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

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

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

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

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

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

		// 移動元金庫更新年月日時分秒
		template.set(ECH0191D020CBSMsg.KNK_UPD_DTM, (String)azukinMap.get(JCHNkinAddSaikenJutoConstCC.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, JCHNkinAddSaikenJutoConstCC.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)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));

		childTemplateArray[0] = childTemplate;

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

		// 請求契約番号
		childTemplate.set(ECH0191D020CBSMsg1List.SEIKY_KEI_NO, getMapItem(param, JCHNkinAddSaikenJutoConstCC.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;
	}

// OM-2014-0001880 DELETE START
	/**
	 * 領収登録用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @param knkJutoSaikenMap 金庫充当債権リスト１件のマップ
	 * @param saikenJutoMap 債権充当リスト１件のマップ
	 * @return HashMap<String, Object>
	 * @throws Exception 
	 */
//	@SuppressWarnings("unchecked")
//	private HashMap<String, Object> editInMsgECH0311D010(IRequestParameterReadWrite param, HashMap<String, Object> knkJutoSaikenMap, HashMap<String, Object> saikenJutoMap) throws Exception
//	{
//		/* ◇パラメータマップ生成 */
//		HashMap<String, Object> paramMap = this.createNewParamMap(param);
//
//		/* ◇ユーザデータ情報 */
//		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(JCHNkinAddSaikenJutoConstCC.MAP_CC_ID);
//
//		CAANMsg template = new CAANMsg(ECH0311D010CBSMsg.class.getName());
//		this.setTemplateCommonItem(param, template, ECH0311D010CBSMsg.TEMPLATEID, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0311D010, ECH0311D010CBSMsg.FUNC_CODE);
//
//
//		/* ◇業務データの設定 */
//		// 機能コード
//		template.set(ECH0311D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
//
//		// 入金登録債権充当マップ.請求契約番号 → 請求契約番号
//		if (JCRUtilCommon.isNull(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO)))
//		{
//			template.setNull(ECH0311D010CBSMsg.SEIKY_KEI_NO);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO));
//		}
//
//		// 入金登録債権充当マップ.入金番号 → 入金番号
//		if (JCRUtilCommon.isNull(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO)))
//		{
//			template.setNull(ECH0311D010CBSMsg.NYUKIN_NO);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.NYUKIN_NO, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO));
//		}
//
//		// 入金登録債権充当マップ.入金経路コード → 入金経路コード
//		if (JCRUtilCommon.isNull(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD)))
//		{
//			template.setNull(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.NYUKIN_ROUTE_CD, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD));
//		}
//
//		// 入金処理年月日
//		template.set(ECH0311D010CBSMsg.NYUKIN_TRN_YMD, JCCBPCommon.getOpeDate(null));
//
//		// 入金処理時分秒
//		template.setNull(ECH0311D010CBSMsg.NYUKIN_TRN_HMS);
//
//		// 入金登録債権充当マップ.領収年月日 → 領収年月日
//		if (JCRUtilCommon.isNull(inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD)))
//		{
//			template.setNull(ECH0311D010CBSMsg.RECEIPT_YMD);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.RECEIPT_YMD, (String)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD));
//		}
//
//		// 領収時分秒
//		template.setNull(ECH0311D010CBSMsg.RECEIPT_HMS);
//
//		// 債権充当明細.請求年月 → 債権年月
//		if (JCRUtilCommon.isNull(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_YM)))
//		{
//			template.setNull(ECH0311D010CBSMsg.SAIKEN_YM);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.SAIKEN_YM, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_YM));
//		}
//
//		// 債権充当明細.請求方法コード → 請求方法コード
//		if (JCRUtilCommon.isNull(saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_WAY_CD)))
//		{
//			template.setNull(ECH0311D010CBSMsg.SEIKY_WAY_CD);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.SEIKY_WAY_CD, (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_SEIKY_WAY_CD));
//		}
//
//		// 債権充当明細.充当金額 → 充当金額
//		if (JCRUtilCommon.isNull(knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT)))
//		{
//			template.setNull(ECH0311D010CBSMsg.JUTO_AMNT);
//		}
//		else
//		{
//			template.set(ECH0311D010CBSMsg.JUTO_AMNT, (String)knkJutoSaikenMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT));
//		}
//
//		// 充当金額うち消費税
//		template.set(ECH0311D010CBSMsg.JUTO_AMNT_UCHI_STAX, "0");
//
//		CAANMsg[] templates = new CAANMsg[1];
//		templates[0] = template;
//		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
//
//		return paramMap;
//	}
// OM-2014-0001880 DELETE END	
	
	/**
	 * 上りマッピング（料金スケジュール定義一意照会）
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECH0501A010(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, JCHNkinAddSaikenJutoConstCC.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_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.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;
	}
	
	/**
	 * 業務パラメータ管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param wkpara 業務パラメータ識別
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0321A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

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

		templateList.add(template);

		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, JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECC0041D010, ECC0041D010CBSMsg.FUNC_CODE);

		// 電子ファイル登録内容生成処理
		byte[] binaryFile = createEfile(getMapItem(param, JCHNkinAddSaikenJutoConstCC.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;
	}
	// ▲▲ サービスIF用メッセージ設定処理 ▲▲

	// ▼▼ サービスIF用メッセージ取得処理 ▼▼
	/**
	 * 入金登録サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	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);
		inMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_NO, nkinNoOut);

		// 払い出された入金番号を料金対応記録MAPに設定する
		HashMap<String, Object> testMap = (HashMap<String, Object>)param.getData("PRCTAIOKIROKADDCC");
		ArrayList testList = (ArrayList)testMap.get("prc_taio_kirok_list");
		HashMap childMap = (HashMap)testList.get(0);
		// 入金番号 → 料金対応記録登録マップ.料金対応記録明細リスト.入金番号
		childMap.put("nyukin_no", nkinNoOut);

		// エラー情報の設定
		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)))
		{
			if (JPCModelConstant.FUNC_CD_1.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
			{
				throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
			}
			else
			{
				throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
			}
		}

		return param;
	}

	/**
	 * 入金登録債権変更サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param saikenJutoList 債権充当リスト(金庫充当債権リスト)
	 * @param idx 現在のインデックス
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0011C012(Map<?, ?> msgList, IRequestParameterReadWrite param, ArrayList<HashMap<String, Object>> saikenJutoList,
			int idx) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];

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

		// 入金登録債権変更マップ.債権ステータス ← 債権ステータス
		String saikenStat = "";
		if (!parentTemplate.isNull(ECH0011C012CBSMsg.SAIKEN_STAT))
		{
			saikenStat = parentTemplate.getString(ECH0011C012CBSMsg.SAIKEN_STAT);
		}

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

		// 業務データ設定
		if (saikenJutoList != null)
		{
			// 更新後の更新年月日時分秒を取得して、次の債権充当リスト(金庫充当債権リスト）の更新前債権更新年月日時分秒に設定する
			if (idx < saikenJutoList.size() - 1)
			{
				String curNo = (String)saikenJutoList.get(idx).get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO);
				String nextNo = (String)saikenJutoList.get(idx + 1).get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO);
				// 次の債権充当リストの債権番号が現在の債権番号と同じ場合のみ、更新年月日を上書き
				if (parentTemplate.isNull(ECH0011C012CBSMsg.UPD_DTM) == false && curNo.equals(nextNo))
				{
					String updDtm = parentTemplate.getString(ECH0011C012CBSMsg.UPD_DTM);
					saikenJutoList.get(idx + 1).put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF, updDtm);
				}
			}

			// 債権充当リストの債権ステータスを更新
			saikenJutoList.get(idx).put(JCHNkinAddSaikenJutoConstCC.MAP_SAIKEN_STATE, saikenStat);
		}

		// エラー情報の設定
		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)))
		{
			if (JPCModelConstant.FUNC_CD_1.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
			{
				throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
			}
			else
			{
				throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
			}
		}

		return param;
	}

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

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

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

		// 業務データ設定
		// OUT項目のマッピングは特になし

		// エラー情報の設定
		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)))
		{
			if (JPCModelConstant.FUNC_CD_1.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
			{
				throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
			}
			else
			{
				throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
			}
		}

		return param;
	}

	/**
	 * 金庫移動登録サービスインターフェイス用メッセージ取得処理［金庫金額の全額］<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param saikenJutoMap 債権充当明細１件のマップ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0191D020_1(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap<String, Object> saikenJutoMap)
			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);

		// 業務データ設定
		// 金庫移動登録の移動先金庫番号を取得して、「金庫充当債権リスト」を生成する
		templateArray = parentTemplate.getCAANMsgList(ECH0191D020CBSMsg.ECH0191D020CBSMSG1LIST);
		if (templateArray != null)
		{
			CAANMsg childTemplate = templateArray[0];
			if (childTemplate.isNull(ECH0191D020CBSMsg1List.KNK_NO_AF) == false)
			{
				// 現在の未収額
				BigDecimal misyuAmnt = new BigDecimal((String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT));

				String knkNoAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_NO_AF);
				String knkAmntAf = childTemplate.getString(ECH0191D020CBSMsg1List.KNK_AMNT_AF);
				// 金庫充当債権リスト
				HashMap<String, Object> knkJutoSaikenMap = new HashMap<String, Object>();
				knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO, saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO));
				knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO, knkNoAf);
				knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT, knkAmntAf);
				knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT, saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT));
				knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF, saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF));
				this.knkJutoSaikenList.add(knkJutoSaikenMap);
				BigDecimal bigknkAmntAF = new BigDecimal(knkAmntAf);
				// 次の金庫充当債権リストの未収額設定に向け、減額
				saikenJutoMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT, String.valueOf(misyuAmnt.subtract(bigknkAmntAF)));
			}
		}

		// エラー情報の設定
		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)))
		{
			if (JPCModelConstant.FUNC_CD_1.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
			{
				throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
			}
			else
			{
				throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
			}
		}

		return param;
	}

	/**
	 * 金庫移動登録サービスインターフェイス用メッセージ取得処理［金庫金額の一部］<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param saikenJutoMap 債権充当明細１件のマップ
	 * @param azukinMap 預り金明細１件のマップ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0191D020_2(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap<String, Object> saikenJutoMap,
			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);

		// 業務データ設定
		// 金庫移動登録の移動先金庫番号を取得して、「金庫充当債権リスト」を生成する
		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);
					if (knkPrcKmkCdAf.equals(JACStrConst.PRC_KMK_CD_ZUMI_AZUKIN_JUTO))
					{
						// 現在の未収額
						BigDecimal misyuAmnt = new BigDecimal((String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT));

						// 金庫充当債権リスト
						HashMap<String, Object> knkJutoSaikenMap = new HashMap<String, Object>();
						knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO, saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_NO));
						knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO, knkNoAf);
						knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT, knkAmntAf);
						knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT, String.valueOf(misyuAmnt));
						knkJutoSaikenMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF, saikenJutoMap
								.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_UPD_DTM_AF));
						this.knkJutoSaikenList.add(knkJutoSaikenMap);
						BigDecimal bigknkAmntAf = new BigDecimal(knkAmntAf);
						// 次の金庫充当債権リストの未収額設定に向け、減額
						saikenJutoMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_MISYU_AMNT, String.valueOf(misyuAmnt.subtract(bigknkAmntAf)));
					}
					else if (knkPrcKmkCdAf.equals(JACStrConst.PRC_KMK_CD_AZUKIN))
					{
						// 預り金を上書き
						azukinMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_NO, knkNoAf);
						azukinMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SSN_WAY_CD, ssnWayCdAf);
						azukinMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_KNK_AMNT, knkAmntAf);
						azukinMap.put(JCHNkinAddSaikenJutoConstCC.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)))
		{
			if (JPCModelConstant.FUNC_CD_1.equals(getMapItem(param, JCMConstants.FUNC_CODE_KEY)))
			{
				throw new CCException("INVALID_RETURN_MESSAGE", new Exception());
			}
			else
			{
				throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
			}
		}

		return param;
	}

// OM-2014-0001880 DELETE START
	/**
	 * 下りマッピング処理(領収登録)。<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
//	@SuppressWarnings("unchecked")
//	private IRequestParameterReadWrite editOutMsgECH0311D010(Map<?, ?> msgList,
//			IRequestParameterReadWrite param) throws Exception
//	{
//
//		// SCからの戻り値からCAANMsgを取得する。
//		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
//		CAANMsg parentTemplate = templates[0];
//
//		/* 業務データ設定 */
//		HashMap<String, Object> inMap = getMap(param);
//
//		// 領収リスト
//		ArrayList<HashMap<String, Object>> ryoshuList = (ArrayList<HashMap<String, Object>>)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RYOSHU_LIST);
//		if (ryoshuList == null)
//		{
//			ryoshuList = new ArrayList<HashMap<String, Object>>();
//			inMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RYOSHU_LIST, ryoshuList);
//		}
//
//		HashMap<String, Object> dataMap = new HashMap<String, Object>();
//
//		// 入金登録債権充当マップ.領収番号 ← 領収番号
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.RECEIPT_NO))
//		{
//			dataMap.put("receipt_no", "");
//		}
//		else
//		{
//			dataMap.put("receipt_no", parentTemplate.getString(ECH0311D010CBSMsg.RECEIPT_NO));
//		}
//
//		// 入金登録債権充当マップ.登録年月日時分秒 ← 登録年月日時分秒
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.ADD_DTM))
//		{
//			dataMap.put("add_dtm", "");
//		}
//		else
//		{
//			dataMap.put("add_dtm", parentTemplate.getString(ECH0311D010CBSMsg.ADD_DTM));
//		}
//
//		// 入金登録債権充当マップ.登録オペレータアカウント ← 登録オペレータアカウント
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.ADD_OPEACNT))
//		{
//			dataMap.put("add_opeacnt", "");
//		}
//		else
//		{
//			dataMap.put("add_opeacnt", parentTemplate.getString(ECH0311D010CBSMsg.ADD_OPEACNT));
//		}
//
//		// 入金登録債権充当マップ.更新年月日時分秒 ← 更新年月日時分秒
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.UPD_DTM))
//		{
//			dataMap.put("upd_dtm", "");
//		}
//		else
//		{
//			dataMap.put("upd_dtm", parentTemplate.getString(ECH0311D010CBSMsg.UPD_DTM));
//		}
//
//		// 入金登録債権充当マップ.更新オペレータアカウント ← 更新オペレータアカウント
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.UPD_OPEACNT))
//		{
//			dataMap.put("upd_opeacnt", "");
//		}
//		else
//		{
//			dataMap.put("upd_opeacnt", parentTemplate.getString(ECH0311D010CBSMsg.UPD_OPEACNT));
//		}
//
//		// 入金登録債権充当マップ.無効フラグ ← 無効フラグ
//		if (parentTemplate.isNull(ECH0311D010CBSMsg.MK_FLG))
//		{
//			dataMap.put("mk_flg", "");
//		}
//		else
//		{
//			dataMap.put("mk_flg", parentTemplate.getString(ECH0311D010CBSMsg.MK_FLG));
//		}
//
//		ryoshuList.add(dataMap);
//
//		// リターンコード取得
//		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);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
//
//		return param;
//
//	}
	
// OM-2014-0001880 DELETE END
	/**
	 * 下りマッピング（料金スケジュール一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @return 請求年月
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String editOutMsgECH0501A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object 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_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 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;
	}
	
	/**
	 * 業務パラメータ管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param wkpara 業務パラメータ識別
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> editOutMsgEZM0321A010(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;
	}
	/**
	 * 電子ファイル管理登録サービスインターフェイス用メッセージ取得処理<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(JCHNkinAddSaikenJutoConstCC.MAP_CC_ID);
		if (dataMap == null) {
			dataMap = new HashMap();
			param.setData(JCHNkinAddSaikenJutoConstCC.MAP_CC_ID, dataMap);
		}
		// 電子ファイル管理登録マップ.電子ファイル管理番号 ← 電子ファイル管理番号
		if (parentTemplate.isNull(ECC0041D010CBSMsg.EFILE_KANRI_NO)) {
			dataMap.put(JCHNkinAddSaikenJutoConstCC.MAP_KEY_EFILE_KANRI_NO, new String());
		} else {
			dataMap.put(JCHNkinAddSaikenJutoConstCC.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;
	}
	// ▲▲ サービス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 (JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0111D010.equals(templateId))
			{
				// 入金登録
				editErrorInfoECH0111D010(param, workTemplates, returnCode);
			}
			else if (JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0011C012.equals(templateId))
			{
				// 入金登録債権変更
				editErrorInfoECH0011C012(param, workTemplates, returnCode);
			}
			else if (JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0191D010.equals(templateId))
			{
				// 金庫登録
				editErrorInfoECH0191D010(param, workTemplates, returnCode);
			}
			else if (JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0191D020.equals(templateId))
			{
				// 金庫異動登録
				editErrorInfoECH0191D020(param, workTemplates, returnCode);
			}
			else if (JCHNkinAddSaikenJutoConstCC.TEMPLATE_ID_ECH0311D010.equals(templateId))
			{
				// 領収登録
				editErrorInfoECH0311D010(param, workTemplates, returnCode);
			}
			else if (JCHNkinAddSaikenJutoConstCC.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 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
	 */
	private IRequestParameterReadWrite editErrorInfoECH0011C012(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 = this.getMap(param);

		// 入金登録債権変更.債権番号エラー → 債権番号エラー
		if (!template.isNull(ECH0011C012CBSMsg.SAIKEN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.SAIKEN_NO_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.SAIKEN_NO_ERR, template.getString(ECH0011C012CBSMsg.SAIKEN_NO_ERR));
			}
		}
		// 入金登録債権変更.金庫番号エラー → 金庫番号エラー
		if (!template.isNull(ECH0011C012CBSMsg.KNK_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.KNK_NO_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.KNK_NO_ERR, template.getString(ECH0011C012CBSMsg.KNK_NO_ERR));
			}
		}
		// 入金登録債権変更.入金番号エラー → 入金番号エラー
		if (!template.isNull(ECH0011C012CBSMsg.NYUKIN_NO_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.NYUKIN_NO_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.NYUKIN_NO_ERR, template.getString(ECH0011C012CBSMsg.NYUKIN_NO_ERR));
			}
		}
		// 入金登録債権変更.債権充当年月日エラー → 債権充当年月日エラー
		if (!template.isNull(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD_ERR, template.getString(ECH0011C012CBSMsg.SAIKEN_JUTO_YMD_ERR));
			}
		}
		// 入金登録債権変更.充当額エラー → 充当額エラー
		if (!template.isNull(ECH0011C012CBSMsg.JUTO_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.JUTO_AMNT_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.JUTO_AMNT_ERR, template.getString(ECH0011C012CBSMsg.JUTO_AMNT_ERR));
			}
		}
		// 入金登録債権変更.未収額エラー → 未収額エラー
		if (!template.isNull(ECH0011C012CBSMsg.MISYU_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.MISYU_AMNT_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.MISYU_AMNT_ERR, template.getString(ECH0011C012CBSMsg.MISYU_AMNT_ERR));
			}
		}
		// 入金登録債権変更.未収額エラー → 未収額エラー
		if (!template.isNull(ECH0011C012CBSMsg.MISYU_AMNT_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.MISYU_AMNT_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.MISYU_AMNT_ERR, template.getString(ECH0011C012CBSMsg.MISYU_AMNT_ERR));
			}
		}
		// 入金登録債権変更.債権ステータスコードエラー → 債権ステータスコードエラー
		if (!template.isNull(ECH0011C012CBSMsg.SAIKEN_STAT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.SAIKEN_STAT_CD_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.SAIKEN_STAT_CD_ERR, template.getString(ECH0011C012CBSMsg.SAIKEN_STAT_CD_ERR));
			}
		}
		// 入金登録債権変更.更新後更新年月日時分秒エラー → 更新後更新年月日時分秒エラー
		if (!template.isNull(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF_ERR))
		{
			if (!inMap.containsKey(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF_ERR))
			{
				inMap.put(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF_ERR, template.getString(ECH0011C012CBSMsg.SAIKEN_UPD_DTM_AF_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

		HashMap<String, Object> inMap = null;

		inMap = this.getMap(param);

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

		return param;
	}

	/**
	 * 金庫移動登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	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 = this.getMap(param);

		// 金庫移動登録.金庫番号エラー → 金庫番号エラー
		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.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));
			}
		}
		// 金庫移動登録.移動元金庫更新年月日時分秒エラー → 移動元金庫更新年月日時分秒エラー
		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));
			}
		}

		return param;
	}

	/**
	 * 領収登録サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	private 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 = null;

		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.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));
			}
		}

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

		int templateStatus = template.getInt(ECH0501A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

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

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

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

	/**
	 * 業務パラメータ管理一意照会サービスコンポーネント実行後に、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 = null;
		inMap = this.getMap(param);
		
		// 業務パラメータ管理情報取得マップ.ＫＥＹ＿業務パラメータIDエラー → ＫＥＹ＿業務パラメータIDエラー
		if (!template.isNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
		{
			if (!inMap.containsKey("key_work_param_id_err"))
			{
				inMap.put("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 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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.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(JCHNkinAddSaikenJutoConstCC.MAP_CC_ID);
		return (ArrayList<HashMap<String, Object>>)inMap.get(key);
	}

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

		// 債権充当明細リストより債権充当額(合計)を算出
		ArrayList saikenJutoList = (ArrayList)inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_LIST);
		for (int i = 0; i < saikenJutoList.size(); i++)
		{
			HashMap childMap = (HashMap)saikenJutoList.get(i);

			String jutoAmnt = (String)childMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT);
			if (jutoAmnt != null && "".equals(jutoAmnt) == false)
			{
				BigDecimal bigjutoAmnt = new BigDecimal(jutoAmnt);
				jutoAmntVal = jutoAmntVal.add(bigjutoAmnt);
			}
		}

		return jutoAmntVal;
	}

	/**
	 * チェックのみ機能コード判定.<br>
	 * <br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private boolean isFuncCodeCheckOnly(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isCheckOnly = false;

		HashMap<String, Object> inMap = this.getMap(param);
		if (JPCModelConstant.FUNC_CD_2.equals(inMap.get(JCMConstants.FUNC_CODE_KEY)))
		{
			isCheckOnly = true;
		}

		return isCheckOnly;
	}

	/**
	 * ダミー番号設定.<br>
	 * <br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private void setDummyNo(IRequestParameterReadWrite param) throws RequestParameterException
	{

		String nyukinRouteCd = getMapItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_ROUTE_CD);
		if (nyukinRouteCd.equals(JACStrConst.NYKNKEIRCD_JUTO))
		{
			setMapItem(param, MAP_KEY_DUMMY_KNK_NO, DUMMY_NO);
		}
		else
		{
			setMapItem(param, MAP_KEY_DUMMY_NYUKIN_NO, DUMMY_NO);
		}
	}

	/**
	 * ダミー番号設定解除.<br>
	 * <br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private void removeDummyNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		removeMapItem(param, MAP_KEY_DUMMY_NYUKIN_NO);
		removeMapItem(param, MAP_KEY_DUMMY_KNK_NO);
	}
	
	/**
	 * コンビニ支払予定年月日の取得を実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return コンビニ支払予定年月日
	 * @throws Exception 
	 */
	private String getCvsPayRsvYmd(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 請求年月の取得（料金スケジュール定義一意照会の実行）
		String seikyYm = execECH0501A010(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_2(handle, param);
		
		// 最終営業日の取得（営業日管理一覧照会の実行）
		String creShunoYmd = execEZM0291B010(handle, param, seikyYm);

		return creShunoYmd;
	}
	
	
	/**
	 * 電子ファイル管理登録情報リスト設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private void setEfileInfoList(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = this.getMap(param);

		// 電子ファイル管理登録情報リストの初期化
		this.efileInfoList = new ArrayList<CAANMsg>();

		// 充当額合計
		BigDecimal bdJyutoAmntSum = BigDecimal.ZERO;

		// 債権充当リスト
		ArrayList<HashMap<String, Object>> saikenJutoList = this.getMapListItem(param, JCHNkinAddSaikenJutoConstCC.MAP_KEY_SAIKEN_JUTO_LIST);

		for (int idx = 0; idx < saikenJutoList.size(); idx++)
		{
			HashMap<String, Object> saikenJutoMap = saikenJutoList.get(idx);

			String seikyKeiNo = (String) inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO);     // 請求契約番号
			String seikyYm = (String) saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_YM);    // 請求年月
			String nyukinAmnt = (String) inMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT);      // 入金額
			String jutoAmnt = (String)saikenJutoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT);   // 充当額

			// 電子ファイル管理登録情報リストに設定
			CAANMsg caEfileInfo = new CAANMsg();
			caEfileInfo.setPrivate(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO, seikyKeiNo);
			caEfileInfo.setPrivate(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_YM, seikyYm);
			caEfileInfo.setPrivate(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT, nyukinAmnt);
			caEfileInfo.setPrivate(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT, jutoAmnt);
			this.efileInfoList.add(caEfileInfo);
			
			// 充当額合計
			if (!JACStrConst.KARA_MOJI.equals(jutoAmnt.trim()))
			{
				bdJyutoAmntSum = bdJyutoAmntSum.add(new BigDecimal(jutoAmnt));
			}
		}

		jyutoAmntSum =  String.valueOf(bdJyutoAmntSum); // 充当額合計
	}
	
	/**
	 * 電子ファイル登録内容生成処理<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)
				{
					String nyukinAmnt = caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_AMNT);      // 入金額
					String azukariAmnt = ZERO;                                                                       // 預り金

					// 過剰充当の場合、余剰分を預り金に設定する
					if (nyukinAmnt.compareTo(jyutoAmntSum) > 0)
					{
						BigDecimal bdNyukinAmnt = new BigDecimal(nyukinAmnt);
						BigDecimal bdJyutoAmntSum = new BigDecimal(jyutoAmntSum);
						azukariAmnt = String.valueOf((bdNyukinAmnt.subtract(bdJyutoAmntSum)));
					}

					sb.append(caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO))                         // 請求契約番号
					  .append(CSV + caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_YM))                       // 請求年月
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // サービス契約番号
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_RECEIPT_YMD)))      // 入金情報.領収年月日
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_NYUKIN_TRN_YMD)))   // 入金情報.入金処理年月日
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNO_YMD)))        // 入金情報.外部組織収納年月日
					  .append(CSV + nyukinRouteCd)                                                                             // 入金情報.入金経路コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金グループコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金コースコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金サービスコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金項目コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SHUNOKIKAN_CD)))    // 入金情報.収納機関コード
					  .append(CSV + nyukinAmnt)                                                                                // 入金額
					  .append(CSV + caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_JUTO_AMNT))                      // 充当額
					  .append(CSV + azukariAmnt)                                                                               // 預り金
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_BANK_CD)))          // 入金情報.金融機関コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_BANK_SHITEN_CD)))   // 入金情報.金融機関支店コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_CRECARD_COMP_CD)))  // 入金情報.クレジットカード会社コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_CVSTORE_CD)))       // 入金情報.コンビニエンスストアコード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_ORG_CD)))           // 入金情報.組織コード
					  .append(CSV + nullToEmpty(efileNyukinInfoMap.get(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SKNKSITKCM_CD)));   // 入金情報.債権回収委託会社コード

					bsetHeader = true;
				}
				else
				{
					sb.append(caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_KEI_NO))                         // 請求契約番号
					  .append(CSV + caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.MAP_KEY_SEIKY_YM))                       // 請求年月
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // サービス契約番号
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金情報.領収年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金情報.入金処理年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金情報.外部組織収納年月日
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金情報.入金経路コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金グループコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金コースコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金サービスコード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 料金項目コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金情報.収納機関コード
					  .append(CSV + JACStrConst.KARA_MOJI)                                                                     // 入金額
					  .append(CSV + caEfileInfo.getString(JCHNkinAddSaikenJutoConstCC.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;
	}
	// ▲▲ クラス内共通処理 ▲▲
}