/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JCHTushinSvcPayShomesChohyoCC
*   ソースファイル名：JCHTushinSvcPayShomesChohyoCC.java
*   作成者          ：富士通
*   日付            ：2011年12月19日
*＜機能概要＞
*   通信サービス支払証明書帳票出力CC部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/12/19	富士通		新規作成
*	v8.00.00	2014/02/20	FJ) 小野   【ANK-1589-00-00】消費税に伴う料金施策（増税対応）【暫定対応】
 *	v9.00.00	2014/08/29	FJ) 古田   【OM-2014-0001880,IT2-2014-000167】支払証明書の消費税不正対応。
*	v67.00.00   2023/06/08  GDC)v.auditor   【ANK-4415-00-00】口振請求及びWeb申込システム移行 STEP1
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JCHTushinPayShomesConstCC;
import com.fujitsu.futurity.bp.custom.constant.JCHTushinSvcConstCC;
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.IRequestParameterReadOnly;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.AttachmentFileMapKeys;
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.JPCDateUtil;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.EAC0271B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0271B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECC0041D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0011B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0011B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0201B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0201B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0311B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0311B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EFU0011B501CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0171B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0171B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0261D010CBSMsg;

/**
 * 請求収納の各サービスより呼び出される通信サービス支払証明書帳票出力CC部品です。<p>
 * <BR>
 * @author 富士通
 */
public class JCHTushinSvcPayShomesChohyoCC extends AbstractCommonComponent {

	/** マップID */
	private static final String MAP_ID = "TUSHINSVCPAYSHOMESCHOHYOCC";
	
//	/** 帳票区分（支払証明書） */
//	private static final String LIST_KBN_PAY_SHOMES = "1";

	/** テンプレートID(税率一覧照会照会) */
	private static final String TEMPLATE_ID_EAC0271B010 = "EAC0271B010";

	/** テンプレートID(請求契約一意照会) */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";
	
	/** テンプレートID(領収一覧照会) */
	private static final String TEMPLATE_ID_ECH0311B010 = "ECH0311B010";	
	
	/** テンプレートID(帳票生成) */
	private static final String TEMPLATE_ID_ECC0041A110 = "ECC0041A110";
	
	/** テンプレートID(電子ファイル登録) */
	private static final String TEMPLATE_ID_ECC0041D010 = "ECC0041D010";
	
	/** テンプレートID(ダウンロード管理テーブル登録) */
	private static final String TEMPLATE_ID_EZM0261D010 = "EZM0261D010";
	
	/** テンプレートID(債権一覧照会) */
	private static final String TEMPLATE_ID_ECH0011B010 = "ECH0011B010";
	
	/** テンプレートID(コード名称管理一覧照会) */
	private static final String TEMPLATE_ID_EZM0171B010 = "EZM0171B010";
	
	/** テンプレートID(充当一覧照会) */
	private static final String TEMPLATE_ID_ECH0201B010 = "ECH0201B010";
	
	/** 帳票定義NO（通信サービス支払証明書リスト） */
	private static final String CHOHYO_TEIGI_NO = "PCHZ00000000005"; 

	/** 帳票定義NO（通信サービス支払証明書リスト（36明細）） */
	private static final String CHOHYO_TEIGI_NO_36 = "PCHZ00000000006"; 

	/** ダウンロード管理テーブル　処理管理番号 */
	private static final String NUM_000000000099 = "000000000099";

	/** ダウンロード管理テーブル ファイル名 */
	private static final String EXCEL_FILE_NAME = "支払証明書_";

	/** ダウンロード管理テーブル ファイル拡張子 */
	private static final String EXCEL_FILE_EXT = ".xlsx";

	/** 改行文字 */
	private static final String LINE_SEP = "line.separator";
	/**  カンマ区切り */
	public static final String CSV = ",";
	/** エスケープ文字 (")  */
	private static final String SINGLE_DBLQUOTE = "\"";	

	private static final DecimalFormat DF = new DecimalFormat("###0");

	private static final BigDecimal BD_HUNDRED = new BigDecimal("100");

	/** 帳票出力＿お客様名文字数 */
	private static final int CHOHYO_OUT_NAME_LENGTH = 15;

	/** 帳票出力＿うち消費税フォーマット */
	private static final String CHOHYO_OUT_UCHI_STAX_FORMAT = "(%s円)";

	/**
	 * 通信サービス支払証明書帳票出力
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite outputTushinSvcPayShomesChohyo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText) throws Exception
	{

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

		if (inMap == null)
		{
			inMap = new HashMap<String, Object>();
			param.setData(MAP_ID, inMap);
		}

		// 機能コード ← 通信サービス支払証明書帳票マップ．機能コード
		String funcCd = (String) inMap.get(JCHTushinPayShomesConstCC.FUNC_CD);

		// 通信サービス支払証明書
		getInfoTushinSvcPayShomesSeiky(handle, param, fixedText, inMap);

		// CSV編集処理
		byte[] csvData = makeCSVDataTushinSvcPayShomesSeiky(param);

		// 帳票生成処理
		 createList(handle, param, csvData, funcCd);

		return param;
	}

	// ▼▼ 通信サービス支払証明書出力関連処理 ▼▼
	/**
	 * 通信サービス支払証明書帳票マップに指定されたキー情報を基に
	 * 【通信サービス支払証明書】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoTushinSvcPayShomesSeiky(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{

		/* ◇税率一覧照会サービスインターフェイス */
		execEAC0271B010(handle, param, chohyoReqMap);

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);

		/* ◇領収一覧照会サービスインターフェイス )*/
		execECH0311B010(handle, param, chohyoReqMap);

		return param;
	}
	
	
	
	/**
	 * 通信サービス支払証明書情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataTushinSvcPayShomesSeiky(IRequestParameterReadWrite param) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		ArrayList childList = (ArrayList)parentMapCC.get("ECH0311B010CBSMsg1List");
		StringBuffer sb = new StringBuffer();

		// フォーマット編集
		
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);
		
		// うち消費税
		String payAmntUchiStax = editUchiStax((String)parentMapCC.get(JCHTushinPayShomesConstCC.ECH0311B010_PAY_AMNT_UCHI_STAX));
		
		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);
			
			// フォーマット編集
			
			// 内訳うち消費税
			String jutoAmntUchiStax = editUchiStax((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT_UCHI_STAX));
			
			sb
			.append(getStringToDblQuote((String)sohusNmList.get(0)))																// 送付先名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))															// 送付先部署名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))															// 送付先担当者名
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinPayShomesConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))		// 請求契約番号
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinPayShomesConstCC.ECH0311B010_PAY_SMS_AMNT)))			// 支払証明書金額
			.append(CSV + getStringToDblQuote(payAmntUchiStax))																		// うち消費税
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_YEAR)))				// 内訳請求年月年
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_MON)))				// 内訳請求年月月
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_ZUIJI_DSP)))					// 随時表示
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT)))					// 内訳金額
			.append(CSV + getStringToDblQuote(jutoAmntUchiStax))																	// 内訳うち消費税
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_YEAR)))				// 内訳領収日年
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_MON)))				// 内訳領収日月
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_DAY)))				// 内訳領収日日
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD_NM)))			// 入金経路コード名称
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinPayShomesConstCC.ECH0311B010_HAKKO_YMD_YEAR)))		// 発行年月日年
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinPayShomesConstCC.ECH0311B010_HAKKO_YMD_MON)))		// 発行年月日月
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinPayShomesConstCC.ECH0311B010_HAKKO_YMD_DAY)))		// 発行年月日日
			.append(System.getProperty(LINE_SEP));
		}

		//UTF-8のバイト配列に変換して返す
		//TODO: JDKのアクセッサ使うようだが、JDKStirngToBytesが提供されていない？
//		return JDKStirngToBytes.toBytesSJIS(sb.toString());
		
//		CAANLog.println(CAANLog.LEVEL_MSG_DUMP, "支払証明書⇒["+sb.toString()+"]");

		return sb.toString().getBytes("UTF-8");
	}

	// ▼▼ クラス内共通処理 ▼▼
	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。
	 * マップには共通項目である電文ヘッダ、コントロールマップを設定します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @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, JPCModelConstant.FUNC_CD_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;
	}

	/**
	 * 文字列を「"」で囲みます。
	 * @param arg0 対象文字列
	 * @return "対象文字列"
	 */
	private String getStringToDblQuote(String arg0)
	{
		return SINGLE_DBLQUOTE + arg0 + SINGLE_DBLQUOTE;
		
	}
	// ▲▲ クラス内共通処理 ▲▲
	
	
	// ▼▼ サービスIF呼び出し ▼▼
	/**
	 * 税率一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEAC0271B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

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

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

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

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

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

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

	/**
	 * 領収一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0311B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

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

		// 下りマッピング
		editOutMsgECH0311B010(handle, result, param, chohyoReqMap);
	}
	// ▲▲ サービスIF呼び出し ▲▲
	
	
	// ▼▼ サービスIF用メッセージ設定処理 ▼▼
	/**
	 * 税率一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEAC0271B010(IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// オンライン運用日 → ＫＥＹ＿基準年月日
		template.set(EAC0271B010CBSMsg.KEY_STDARDYMD, JCCBPCommon.getOnlineOpeDate(null));

		// 税率.内税外税識別コード(内税) → ＫＥＹ＿内税外税識別コード
		template.set(EAC0271B010CBSMsg.KEY_UZEI_SZEI_SKBT_CD, JACStrConst.UZEI_SZEI_SKBT_UCHI);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0491A010(IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		String seikyKeiNo = (String) chohyoReqMap.get(JCHTushinPayShomesConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		if (chohyoReqMap == null || seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		} else {
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}

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

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

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 領収一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0311B010(IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

		/* ◇業務データの設定 */
		// 機能コード（債権年月降順）
		template.set(ECH0311B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		String seikyKeiNo = (String) chohyoReqMap.get(JCHTushinPayShomesConstCC.ECH0311B010_KEY_SEIKY_KEI_NO);
		if (chohyoReqMap == null || seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
		{
			template.setNull(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO);
		} else {
			template.set(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}
		
		// 帳票出力依頼リストマップ.ＫＥＹ＿債権年月（開始） → ＫＥＹ＿債権年月（開始）
		String saikenYmSta = (String) chohyoReqMap.get(JCHTushinPayShomesConstCC.ECH0311B010_KEY_SAIKEN_YM_STA);
		if (chohyoReqMap == null || saikenYmSta == null || JACStrConst.KARA_MOJI.equals(saikenYmSta))
		{
			template.setNull(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA);
		} else {
			template.set(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA, saikenYmSta);
		}
		
		// 帳票出力依頼リストマップ.ＫＥＹ＿債権年月（終了） → ＫＥＹ＿債権年月（終了）
		String saikenYmEnd = (String) chohyoReqMap.get(JCHTushinPayShomesConstCC.ECH0311B010_KEY_SAIKEN_YM_END);
		if (chohyoReqMap == null || saikenYmEnd == null || JACStrConst.KARA_MOJI.equals(saikenYmEnd))
		{
			template.setNull(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END);
		} else {
			template.set(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END, saikenYmEnd);
		}

		templateList.add(template);

		return templateList;
	}

	// ▲▲ サービスIF用メッセージ設定処理 ▲▲
	
	
	// ▼▼ サービスIF用メッセージ取得処理 ▼▼
	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0271B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

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

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

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

		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("EAC0271B010CBSMsg1List");

		if (dataList == null) {
			dataList = new ArrayList<HashMap<String, String>>();
		}

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

				// 通信サービス支払証明書マップ.税率適用開始年月日← 税率一覧照会明細.税率適用開始年月日
				if (childTemplate.isNull(EAC0271B010CBSMsg1List.TAX_RT_TSTAYMD)) {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT_TSTAYMD, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT_TSTAYMD, childTemplate.getString(EAC0271B010CBSMsg1List.TAX_RT_TSTAYMD));
				}

				// 通信サービス支払証明書マップ.税率← 税率一覧照会明細.税率
				if (childTemplate.isNull(EAC0271B010CBSMsg1List.TAX_RT)) {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT, childTemplate.getString(EAC0271B010CBSMsg1List.TAX_RT));
				}

				// 通信サービス支払証明書マップ.丸め方法コード ← 税率一覧照会明細.丸め方法コード
				if (childTemplate.isNull(EAC0271B010CBSMsg1List.ROUND_WAY_CD)) {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_ROUND_WAY_CD, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.EAC0271B010_ROUND_WAY_CD, childTemplate.getString(EAC0271B010CBSMsg1List.ROUND_WAY_CD));
				}
			}
		}

		dataMap.put("EAC0271B010CBSMsg1List", dataList);

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

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

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

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

		return param;
	}

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0491A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

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

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

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

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

				// 通信サービス支払証明書マップ.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM)) {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_NM, new String());
				} else {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}
				// 通信サービス支払証明書マップ.送付先部課名 ← 請求契約一意照会明細.送付先部課名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BKM)) {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_BKM, new String());
				} else {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_BKM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BKM));
				}
				// 通信サービス支払証明書マップ.送付先担当者名 ← 請求契約一意照会明細.送付先担当者名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM)) {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_TNTSHA_NM, new String());
				} else {
					dataMap.put(JCHTushinPayShomesConstCC.EKK0491A010_SOHUS_TNTSHA_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM));
				}
			}
		}

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

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

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

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

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

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

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

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

		BigDecimal paySmsAmnt = new BigDecimal("0");
		BigDecimal payAmntUchiStax = new BigDecimal("0");

		HashMap<String, HashMap<String, String>> taxMap = new HashMap<String, HashMap<String, String>>();

		ArrayList dataList = null;

		templateArray = parentTemplate.getCAANMsgList(ECH0311B010CBSMsg.ECH0311B010CBSMSG1LIST);

		dataList = (ArrayList)dataMap.get("ECH0311B010CBSMsg1List");
		
		String seikySbtCd = "";
		String saikenNo = "";
		String saikenYm = "";
		String printDtlAmnt = "";
		String shiharaiWayNm = "";
		BigDecimal printDtlUchiTax = null;
		String seikyKeiNo = (String) chohyoReqMap.get(JCHTushinPayShomesConstCC.ECH0311B010_KEY_SEIKY_KEI_NO);
		HashMap<String, Object> saikenMap = null;
		boolean payAmntUchiTaxMaskFlg = false;

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

		if (templateArray != null) {
			
			// 充当種別コードのコード名称取得
			execEZM0171B010(handle, param, JACStrConst.CD_SBT_CD_CD00182);
			// ANK-4415-00-00 ADD START
			// 入金経路コードのコード名称取得
			execEZM0171B010(handle, param, JACStrConst.CD_SBT_CD_CD00176);
			// ANK-4415-00-00 ADD END
			
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];
				if ( i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				seikySbtCd = getNullToStr(childTemplate.getString(ECH0311B010CBSMsg1List.SEIKY_SBT_CD));
				saikenNo = getNullToStr(childTemplate.getString(ECH0311B010CBSMsg1List.SAIKEN_NO));
				saikenYm = getNullToStr(childTemplate.getString(ECH0311B010CBSMsg1List.SAIKEN_YM));

				// 通信サービス支払証明書マップ.領収年月日年 ← 領収一覧明細.領収年月日年
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_YMD)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_YEAR, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_YEAR, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_YMD).substring(0, 4));
				}

				// 通信サービス支払証明書マップ.領収年月日月 ← 領収一覧明細.領収年月日月
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_YMD)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_MON, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_MON, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_YMD).substring(4, 6));
				}

				// 通信サービス支払証明書マップ.領収年月日日 ← 領収一覧明細.領収年月日日
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.RECEIPT_YMD)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_DAY, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_RECEIPT_YMD_DAY, childTemplate.getString(ECH0311B010CBSMsg1List.RECEIPT_YMD).substring(6, 8));
				}

				// 通信サービス支払証明書マップ.入金経路コード ← 領収一覧明細.入金経路コード
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD, new String());
				} else {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD));
				}
				
				// v9.00.00-UPD-start
//				// 通信サービス支払証明書マップ.入金経路コード名称 ← 領収一覧明細.入金経路コード名称
//				if (childTemplate.isNull(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM)) {
//					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD_NM, new String());
//				} else {
//					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD_NM, childTemplate.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM));
//				}
				
				// 支払方法（入金経路コード名称）を取得します。
				shiharaiWayNm = getShiharaiWay(handle, param, seikyKeiNo, childTemplate);
				childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_NYUKIN_ROUTE_CD_NM, shiharaiWayNm);
				
				// 初期化します。
				dataMap.put("ECH0011B010CBSMsg1List", null);
				
				// 債権データの取得
				execECH0011B010(handle, param, seikyKeiNo, saikenYm, seikySbtCd);
				
				// 債権データ取得
				saikenMap = getSaikenData(param, saikenNo, seikySbtCd);

				//随時請求、随時入金時に表示する"*"の設定
				if(JCHTushinPayShomesConstCC.SEIKY_SBT_CD_ZUIJINYUKIN.equals(seikySbtCd)
					|| JCHTushinPayShomesConstCC.SEIKY_SBT_CD_ZUIJISEIKY.equals(seikySbtCd))
				{
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_ZUIJI_DSP, JCHTushinPayShomesConstCC.SEIKY_SBT_CD_ZUIJIDSP);
				}
				else
				{
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_ZUIJI_DSP, "");
				}
				
				// TODO 支払証明書の税額出力
				// 支払証明書に出力する税額は、
				// 領収テーブルの「充当金額うち消費税」をそのまま出力するように改修予定であるため
				// 以下の税率取得処理は、それまでの暫定処置である。
				// 上記対応が実施された場合、税率マスタを見る必要がなくなるため、この暫定処置は廃止すること。
				// --------------------------------------------------
				// 税率取得処理
				// --------------------------------------------------
				BigDecimal taxRate = null;
				BigDecimal taxRate2 = null;
				RoundingMode rdMode = null;

				// 通信サービス支払証明書マップ.請求年月年 ← 領収一覧明細.債権年月年
				// 通信サービス支払証明書マップ.請求年月月 ← 領収一覧明細.債権年月月
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.SAIKEN_YM)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_YEAR, new String());
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_MON, new String());
				} else {

					String seikyYm = childTemplate.getString(ECH0311B010CBSMsg1List.SAIKEN_YM);
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_YEAR, seikyYm.substring(0, 4));
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_SAIKEN_YM_MON, seikyYm.substring(4, 6));

					if (!taxMap.containsKey(seikyYm))
					{
						// 債権年月から取得した月末日
						String endDayOfMonth = seikyYm.concat(JPCDateUtil.getEndOfMonth(seikyYm));
						taxMap = getTaxInfo(param, taxMap, seikyYm, endDayOfMonth);
					}

					HashMap workMap = taxMap.get(seikyYm);

					taxRate = new BigDecimal((String)workMap.get(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT));
					taxRate2 = taxRate.add(BD_HUNDRED);
					String roundWayCd = (String)workMap.get(JCHTushinPayShomesConstCC.EAC0271B010_ROUND_WAY_CD);
					rdMode = this.getRoundingMode(roundWayCd);
				}

				// 通信サービス支払証明書マップ.金額 ← 領収一覧明細.充当金額
				// 通信サービス支払証明書マップ.うち消費税額 ← 領収一覧明細.充当金額うち消費税額
				if (childTemplate.isNull(ECH0311B010CBSMsg1List.JUTO_AMNT)) {
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT, new String());
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT_UCHI_STAX, new String());
				} else {
					
					
//					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT, childTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT));
//
//					// 税額（出力）の計算を行う(税額＝料金×税率÷(100+税率))
//					BigDecimal jutoAmnt = new BigDecimal(childTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT));
//					BigDecimal amntUchiTax = jutoAmnt.multiply(taxRate).divide(taxRate2, 0, rdMode);
//					// 丸め方法に従い、丸め処理を行う
//					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT_UCHI_STAX, DF.format(amntUchiTax));
//
//					paySmsAmnt = paySmsAmnt.add(jutoAmnt);
//					payAmntUchiStax = payAmntUchiStax.add(amntUchiTax);
					
					// 分納か判断するフラグ（true:分納 false:分納以外）
					boolean bunnouFlg = isBunnoHantei(handle, param, chohyoReqMap, childTemplate, saikenMap);
					
					// 金額の設定
					printDtlAmnt = getPrintDtlAmnt(childTemplate, saikenMap);
					childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT, printDtlAmnt);
					
					// 支払証明書金額
					paySmsAmnt = paySmsAmnt.add(new BigDecimal(printDtlAmnt));
					
					// うち消費税金額取得
					printDtlUchiTax = getPrintDtlAmntUchiTax(childTemplate, saikenMap, taxRate, taxRate2, rdMode);
					
					// 支払証明書金額
					payAmntUchiStax = payAmntUchiStax.add(printDtlUchiTax);
					
					// 分納の場合、消費税金額に"***"を設定
					if(bunnouFlg)
					{
						childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT_UCHI_STAX, JCHTushinPayShomesConstCC.JUTO_AMNT_UCHI_STAX_ITIBUSHUNO);
						
						payAmntUchiTaxMaskFlg = true;
					}
					else
					{
						childMap.put(JCHTushinPayShomesConstCC.ECH0311B010_JUTO_AMNT_UCHI_STAX, DF.format(printDtlUchiTax));
					}
					// v9.00.00-upd-end
				}
			}
		}
		dataMap.put("ECH0311B010CBSMsg1List", dataList);
		
		// 通信サービス支払証明書マップ.支払証明書金額 ← 領収一覧明細.金額
		dataMap.put(JCHTushinPayShomesConstCC.ECH0311B010_PAY_SMS_AMNT, DF.format(paySmsAmnt));
		
		// 明細行を１件でもマスク（分納）した場合、支払証明書うち消費税もマスクします。
		if(payAmntUchiTaxMaskFlg == true)
		{
			// 通信サービス支払証明書マップ.支払証明書うち消費税
			dataMap.put(JCHTushinPayShomesConstCC.ECH0311B010_PAY_AMNT_UCHI_STAX, JCHTushinPayShomesConstCC.JUTO_AMNT_UCHI_STAX_ITIBUSHUNO);
		}
		else
		{
			// 通信サービス支払証明書マップ.支払証明書うち消費税
			dataMap.put(JCHTushinPayShomesConstCC.ECH0311B010_PAY_AMNT_UCHI_STAX, DF.format(payAmntUchiStax));
		}
		
		// エラー情報の設定
		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;
	}
	// ▲▲ サービスIF用メッセージ取得処理 ▲▲
	
	
	
	// ▼▼ 帳票処理 ▼▼
	/**
	 * 帳票生成処理
	 * @param handle
	 * @param param
	 * @param csvData
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite createList(SessionHandle handle, 
			IRequestParameterReadWrite param, byte[] csvData, String funcCd) throws Exception
	{
		if(!JPCModelConstant.FUNC_CD_1.equals(funcCd))
		{
			return param;
		}

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

		// リクエストパラメータ作成
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		ArrayList childList = (ArrayList)parentMapCC.get("ECH0311B010CBSMsg1List");
		
		// 明細が１ヶ月分を超える場合は36明細用の帳票定義体を使用する
		String chohyoTeigiNo = CHOHYO_TEIGI_NO;
		if(childList.size() > 12)
		{
			chohyoTeigiNo = CHOHYO_TEIGI_NO_36;
		}
		
		// オペレータID
		String userId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID).toString();

		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO, chohyoTeigiNo);
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE, (byte[])csvData);
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_USER_ID, userId);
		// 帳票形成処理種別
		String oputSbtCd = parentMapCC.get("oput_sbt_cd").toString();
		String tranSbt = JACStrConst.KARA_MOJI;
		if(oputSbtCd.equals("01"))
		{
			// "1"（PDF形式）
			tranSbt = "1";
		}
		else if(oputSbtCd.equals("02"))
		{
			// "2"（EXCEL形式）
			tranSbt = "2";
		}
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT, tranSbt);

		/*
		 * 上りマッピング処理
		 */
		paramMap = editInMsg(param);

		/*
		 * ＳＣ呼出実行
		 */
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない。
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		/*
		 * 下りマッピング処理
		 */
		IRequestParameterReadWrite rtnParam = editOutMsg(result, param);
		byte[] excelFile = getExcel(result, param);

		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.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;
		}

		// EXCEL形式の場合、電子ファイル管理・ダウンロードファイル管理登録処理
		if(oputSbtCd.equals("02"))
		{
			// "2"（EXCEL形式）
			registEfile(handle, param, excelFile, funcCd);
		}

		return rtnParam;
	}

	/**
	 * 電子ファイル管理登録
	 * @param handle
	 * @param param
	 * @param csvData
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private void registEfile(SessionHandle handle, 
			IRequestParameterReadWrite param, byte[] csvData, String funcCd) throws Exception
	{
		if(!JPCModelConstant.FUNC_CD_1.equals(funcCd))
		{
			return ;
		}

		/* ◇上りマッピング処理（電子ファイル管理登録） */
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		paramMap = editInEfileMsg(param,csvData,funcCd);

		/* ◇ＳＣ呼出実行（電子ファイル管理登録） */
		Map<?, ?> result = callDoSc(paramMap, handle);

		/* ◇下りマッピング処理（電子ファイル管理登録） */
		HashMap<String, Object> cc0041d010_map = new HashMap<String, Object>();
		cc0041d010_map = editResultRpCc0041D010(result, param, MAP_ID);

		/* ◇上りマッピング処理（ダウンロードファイル管理登録） */
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		paramMap = editInMsgZm0261D010(param, cc0041d010_map, "1");

		/* ◇ＳＣ呼出実行（ダウンロードファイル管理登録） */
		result = callDoSc(paramMap, handle);

		/* ◇下りマッピング処理（ダウンロードファイル管理登録） */
		editResultRpZm0261D010(result, param, MAP_ID);
		
	}
	
	/**
	 * ＳＣ呼出実行処理<br>
	 * <br>
	 * @param paramMap
	 * @param handle
	 * @return Map<?, ?>
	 * @throws RequestParameterException 
	 */
	private Map<?, ?> callDoSc(HashMap<String, Object> paramMap, SessionHandle handle) throws Exception
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない。
		ServiceComponentRequestInvoker serviceIfCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = serviceIfCall.run(paramMap, handle);
		
		return result;
	}

	/**
	 * 帳票生成処理用メッセージ設定処理
	 * @param param
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		CAANMsg template = new CAANMsg(ECC0041A110CBSMsg.class.getName());
		// テンプレートID
		template.set(ECC0041A110CBSMsg.TEMPLATEID, TEMPLATE_ID_ECC0041A110);

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

		// 検索処理パターン
		template.setNull(ECC0041A110CBSMsg.SEARCH_TYPE);

		// 最大検索件数
		template.setNull(ECC0041A110CBSMsg.MAX_SEARCH_NUM);

		// 表示件数
		template.setNull(ECC0041A110CBSMsg.DISPLAY_NUM);

		// 表示ページ番号
		template.setNull(ECC0041A110CBSMsg.DISPLAY_PAGE_NUM);

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

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

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


		// ◇業務データの設定
		// 帳票定義体の電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO, inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO));
		}
		
		// データファイルの電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE_NO, inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE_NO));
		}
		
		// データファイル
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE, inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE));
		}

		// ユーザーID
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_USER_ID))) 
		{
			template.setNull(ECC0041A110CBSMsg.USER_ID);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.USER_ID, inMap.get(JCHTushinSvcConstCC.ECC0041A110_USER_ID));
		}
		
		// 処理種別
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT))) 
		{
			template.setNull(ECC0041A110CBSMsg.TRAN_SBT);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.TRAN_SBT, inMap.get(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT));
		}
		// 帳票出力環境識別コード
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD, inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD));
		}

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

		return paramMap;
	}

	/**
	 * 電子ファイル管理登録用メッセージ設定処理
	 * @param param
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInEfileMsg(IRequestParameterReadWrite param,byte[] csvData,String funcCd) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// テンプレートID
		template.set(ECC0041D010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECC0041D010);

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

		// システムコード
		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, "20991231");

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

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

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

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

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

		return paramMap;
	}

	/**
	 * 帳票生成処理用メッセージ取得処理
	 * @param msgList
	 * @param param
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

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

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

		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		// 検索系 共通部
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_TOTAL_SEARCH_NUM, parentTemplate.getString("total_search_num"));
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_TOTAL_PAGE_NUM, parentTemplate.getString("total_page_num"));
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_SEARCH_ERR_FLG, parentTemplate.getString("search_err_flg"));

		templateArray = parentTemplate.getCAANMsgList(ECC0041A110CBSMsg.ECC0041A110CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("ECC0041A110CBSMsg1List");

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

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

				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO)) 
				{
					childMap.put("output_chohyo", new byte[0]);
				} 
				else
				{
					//childMap.put("output_chohyo", (byte[])childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
					// byte配列の場合は添付ファイルエリアに格納する
					HashMap<Object, Object> map = new HashMap<Object, Object>();
					ArrayList<HashMap> list = new  ArrayList<HashMap>();
					map.put(AttachmentFileMapKeys.IDENTIFY_CD, MAP_ID);
					map.put(AttachmentFileMapKeys.LIST_NAME, "ECC0041A110CBSMsg1List");
					map.put(AttachmentFileMapKeys.ITEM_NAME, "output_chohyo");
					map.put(AttachmentFileMapKeys.INDEX, Integer.toString(i));
					map.put(AttachmentFileMapKeys.FILE, childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
					list.add(map);
					param.setControlMapData(SCControlMapKeys.ATTACHMENT_FILE_DOWN, list);
				}

				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, childTemplate.getString(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM));
				}
				
				if (childTemplate.isNull(ECC0041A110CBSMsg1List.SEND_RESULT_CD)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, childTemplate.getString(ECC0041A110CBSMsg1List.SEND_RESULT_CD));
				}
			}
		}
		dataMap.put("ECC0041A110CBSMsg1List", dataList);

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

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

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

		return rtnParam;
	}
	
	/**
	 * IRequestParameterReadWriteに必要なデータをマッピングします。<br>
	 * 電子ファイル管理登録（下り）<br>
	 * @param msgList (I) CAANMsgクラス
	 * @param param 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ定義文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception Exceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editResultRpCc0041D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText)
	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(fixedText);
		if (dataMap == null) 
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		// 電子ファイル管理登録マップ.電子ファイル管理番号 ← 電子ファイル管理番号
		if (parentTemplate.isNull(ECC0041D010CBSMsg.EFILE_KANRI_NO)) 
		{
			dataMap.put("efile_kanri_no", "");
		} 
		else 
		{
			dataMap.put("efile_kanri_no", parentTemplate.getString(ECC0041D010CBSMsg.EFILE_KANRI_NO));
		}
		// 電子ファイル管理登録マップ.ファイルサイズ ← ファイルサイズ
		if (parentTemplate.isNull(ECC0041D010CBSMsg.FILE_SIZE)) 
		{
			dataMap.put("file_size", "");
		} 
		else 
		{
			dataMap.put("file_size", parentTemplate.getString(ECC0041D010CBSMsg.FILE_SIZE));
		}
		// 電子ファイル管理登録マップ.登録年月日時分秒 ← 登録年月日時分秒
		if (parentTemplate.isNull(ECC0041D010CBSMsg.ADD_DTM)) 
		{
			dataMap.put("add_dtm", "");
		} 
		else 
		{
			dataMap.put("add_dtm", parentTemplate.getString(ECC0041D010CBSMsg.ADD_DTM));
		}
		
        // エラー情報の設定
		IRequestParameterReadWrite err_param = null;
		err_param = editErrorInfoCc0041D010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)err_param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		err_param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定*/
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);

		// 異常の場合、SCCallExceptionを生成してスローする
		if (!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		return dataMap;
	}

	
	/**
	 * IRequestParameterReadWriteにエラー情報をマッピングする。<br>
	 * 電子ファイル管理登録（エラー情報）<br>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception RequestParameterExceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCc0041D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws RequestParameterException
	{
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EFU0011B501CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null) 
		{
			bpStatus = -1;
		} 
		else 
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// システムコード のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.SYS_CD_ERR))
		{
			if (!inMap.containsKey("sys_cd_err"))
			{
				inMap.put("sys_cd_err", template.getString(ECC0041D010CBSMsg.SYS_CD_ERR));
			}
		}
		// 内部変数.電子ファイル → 電子ファイル のエラー情報返却
		if (!template.isNull(ECC0041D010CBSMsg.EFILE_ERR))
		{
			if (!inMap.containsKey("efile_err"))
			{
				inMap.put("efile_err", template.getString(ECC0041D010CBSMsg.EFILE_ERR));
			}
		}
		
		return param;
	}

	
	/**
	 * CAANMsgに必要なデータをマッピングします。<br>
	 * ダウンロードファイル管理登録（上り）<br>
	 * @param param (I) 業務データ取得用I/F
	 * @param inMap
	 * @param fu0011a010_map
	 * @param dataCnt
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterExceptionがスローされます。
	 */
	private HashMap<String, Object> editInMsgZm0261D010(IRequestParameterReadOnly param, 
			HashMap<String, Object> cc0041d010_map, String dataCnt) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// メッセージ共通部の設定
		setCommonParamMap(param, paramMap);

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

		// テンプレートID
		template.set(EZM0261D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0261D010);

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

		// サービスインターフェイス共通部の設定
		setCommonTemplate(param, template);
		
		// 処理管理番号
		template.set(EZM0261D010CBSMsg.SYORI_KANRI_NUM, NUM_000000000099);
		
		// 電子ファイル管理登録マップ.電子ファイル管理番号 → 電子ファイル管理番号
		if (cc0041d010_map == null || cc0041d010_map.get("efile_kanri_no") == null || "".equals(cc0041d010_map.get("efile_kanri_no")))
		{
			template.setNull(EZM0261D010CBSMsg.BUNSHO_KANRI_NO);
		}
		else
		{
			template.set(EZM0261D010CBSMsg.BUNSHO_KANRI_NO, cc0041d010_map.get("efile_kanri_no"));
		}
		
		// ファイル名
		StringBuffer fileName = new StringBuffer();
		fileName.append(EXCEL_FILE_NAME);
		fileName.append(JCCBPCommon.getOpeDateTime(JACStrConst.SYS_CD_CH));
		fileName.append(EXCEL_FILE_EXT);
		template.set(EZM0261D010CBSMsg.FILE_NM, fileName.toString());
		
		// 電子ファイル管理登録マップ.ファイルサイズ → ファイルサイズ
		if (cc0041d010_map == null || cc0041d010_map.get("file_size") == null || "".equals(cc0041d010_map.get("file_size")))
		{
			template.setNull(EZM0261D010CBSMsg.SIZE);
		}
		else
		{
			template.set(EZM0261D010CBSMsg.SIZE, cc0041d010_map.get("file_size"));
		}
		
		// 内部変数.データ件数 → データ件数
		if ("".equals(dataCnt))
		{
			template.setNull(EZM0261D010CBSMsg.DATA_CNT);
		}
		else
		{
			template.set(EZM0261D010CBSMsg.DATA_CNT, dataCnt);
		}
		
		// 電子ファイル管理登録マップ.登録年月日時分秒 → ファイル登録日時
		if (cc0041d010_map == null || cc0041d010_map.get("add_dtm") == null || "".equals(cc0041d010_map.get("add_dtm")))
		{
			template.setNull(EZM0261D010CBSMsg.FILE_ADD_DTM);
		}
		else
		{
			template.set(EZM0261D010CBSMsg.FILE_ADD_DTM, cc0041d010_map.get("add_dtm"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * IRequestParameterReadWriteに必要なデータをマッピングします。<br>
	 * 電子ファイル管理登録（下り）<br>
	 * @param msgList (I) CAANMsgクラス
	 * @param param 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ定義文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception Exceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editResultRpZm0261D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText)
	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(fixedText);
		if (dataMap == null) 
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
        // エラー情報の設定
		IRequestParameterReadWrite err_param = null;
		err_param = editErrorInfoZm0261D010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)err_param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		err_param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定*/
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);

		// 異常の場合、SCCallExceptionを生成してスローする
		if (!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		return dataMap;
	}

	/**
	 * IRequestParameterReadWriteにエラー情報をマッピングする。<br>
	 * ダウンロードファイル管理登録（エラー情報）<br>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception RequestParameterExceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoZm0261D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws RequestParameterException
	{
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EZM0261D010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null) 
		{
			bpStatus = -1;
		} 
		else 
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// 処理管理番号 のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.SYORI_KANRI_NUM_ERR))
		{
			if (!inMap.containsKey("syori_kanri_num_err"))
			{
				inMap.put("syori_kanri_num_err", template.getString(EZM0261D010CBSMsg.SYORI_KANRI_NUM_ERR));
			}
		}
		
		// 電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.BUNSHO_KANRI_NO_ERR))
		{
			if (!inMap.containsKey("bunsho_kanri_no_err"))
			{
				inMap.put("bunsho_kanri_no_err", template.getString(EZM0261D010CBSMsg.BUNSHO_KANRI_NO_ERR));
			}
		}
		
		// ファイル名 のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.FILE_NM_ERR))
		{
			if (!inMap.containsKey("file_nm_err"))
			{
				inMap.put("file_nm_err", template.getString(EZM0261D010CBSMsg.FILE_NM_ERR));
			}
		}
		
		// サイズ のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.SIZE_ERR))
		{
			if (!inMap.containsKey("size_err"))
			{
				inMap.put("size_err", template.getString(EZM0261D010CBSMsg.SIZE_ERR));
			}
		}
		
		// データ件数 のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.DATA_CNT_ERR))
		{
			if (!inMap.containsKey("data_cnt_err"))
			{
				inMap.put("data_cnt_err", template.getString(EZM0261D010CBSMsg.DATA_CNT_ERR));
			}
		}
		
		// ファイル登録日時 のエラー情報返却
		if (!template.isNull(EZM0261D010CBSMsg.FILE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("file_add_dtm_err"))
			{
				inMap.put("file_add_dtm_err", template.getString(EZM0261D010CBSMsg.FILE_ADD_DTM_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスインターフェイス共通部の設定。<br>
	 * <br>
	 * @param param (I) 業務データ取得用I/F
	 * @param template (O) サービスインターフェイス
	 * @exception RequestParameterExceptionがスローされます。
	 */
	private void setCommonTemplate(IRequestParameterReadOnly param, CAANMsg template)
	throws RequestParameterException
	{
		// オペレータ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);

	}

	
	/**
	 * メッセージ共通部の設定。<br>
	 * <br>
	 * @param param (I) 業務データ取得用I/F
	 * @param paramMap (O) メッセージ共通部
	 * @exception RequestParameterExceptionがスローされます。
	 */
	private void setCommonParamMap(IRequestParameterReadOnly param, HashMap<String, Object> paramMap)
	throws RequestParameterException
	{
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

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

	}

	/**
	 * エクセル取得処理
	 * @param msgList
	 * @param param
	 * @return byte[]
	 * @throws Exception
	 */
	private byte[] getExcel(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

		templateArray = parentTemplate.getCAANMsgList(ECC0041A110CBSMsg.ECC0041A110CBSMSG1LIST);

		if (templateArray != null) 
		{
			CAANMsg childTemplate = templateArray[0];

			if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO)) 
			{
				return  new byte[0];
			} 
			else
			{
				//childMap.put("output_chohyo", (byte[])childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
				return (byte[])childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO);
			}
		}

		return  new byte[0];
	}
	// ▲▲ 帳票処理 ▲▲


	// ▼▼ エラー情報マッピング処理 ▼▼
	/**
	 * サービス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 (TEMPLATE_ID_EKK0491A010.equals(templateId))
			{
				// 請求契約一意照会
				editErrorInfoEKK0491A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0311B010.equals(templateId))
			{
				// 領収一覧照会
				editErrorInfoECH0311B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECC0041A110.equals(templateId))
			{
				// 帳票生成
				editErrorInfoECC0041A110(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EAC0271B010.equals(templateId))
			{
				// 税率一覧照会
				editErrorInfoEAC0271B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0011B010.equals(templateId))
			{
				// 債権一覧照会
				editErrorInfoECH0011B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0201B010.equals(templateId))
			{
				// 充当一覧照会
				editErrorInfoECH0201B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EZM0171B010.equals(templateId))
			{
				// コード名称管理一意照会
				editErrorInfoEZM0171B010(param, workTemplates, returnCode);
			}
		}

		return param;
	}

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

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

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

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

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

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

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

		// 税率一覧照会マップ.ＫＥＹ＿基準年月日 → ＫＥＹ＿基準年月日 のエラー情報返却
		if (!template.isNull(EAC0271B010CBSMsg.KEY_STDARDYMD_ERR)) {
			if (!inMap.containsKey(EAC0271B010CBSMsg.KEY_STDARDYMD_ERR)) {
				inMap.put(EAC0271B010CBSMsg.KEY_STDARDYMD_ERR, template.getString(EAC0271B010CBSMsg.KEY_STDARDYMD_ERR));
			}
		}

		// 税率一覧照会マップ.ＫＥＹ＿内税外税識別コード → ＫＥＹ＿内税外税識別コード のエラー情報返却
		if (!template.isNull(EAC0271B010CBSMsg.KEY_UZEI_SZEI_SKBT_CD_ERR)) {
			if (!inMap.containsKey(EAC0271B010CBSMsg.KEY_UZEI_SZEI_SKBT_CD_ERR)) {
				inMap.put(EAC0271B010CBSMsg.KEY_UZEI_SZEI_SKBT_CD_ERR, template.getString(EAC0271B010CBSMsg.KEY_UZEI_SZEI_SKBT_CD_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

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

		// 請求契約一意照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) {
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) {
				inMap.put(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求契約一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) {
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) {
				inMap.put(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

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

		// 領収一覧照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) {
			if (!inMap.containsKey(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) {
				inMap.put(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0311B010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		// 領収一覧照会マップ.ＫＥＹ＿債権年月（開始） → ＫＥＹ＿債権年月（開始） のエラー情報返却
		if (!template.isNull(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA_ERR)) {
			if (!inMap.containsKey(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA_ERR)) {
				inMap.put(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA_ERR, template.getString(ECH0311B010CBSMsg.KEY_SAIKEN_YM_STA_ERR));
			}
		}

		// 領収一覧照会マップ.ＫＥＹ＿債権年月（終了） → ＫＥＹ＿債権年月（終了） のエラー情報返却
		if (!template.isNull(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END_ERR)) {
			if (!inMap.containsKey(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END_ERR)) {
				inMap.put(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END_ERR, template.getString(ECH0311B010CBSMsg.KEY_SAIKEN_YM_END_ERR));
			}
		}
		
		return param;
	}

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

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

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

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

		HashMap<String, Object> inMap = null;

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

		// 帳票生成.帳票定義体の電子ファイル管理番号→ 帳票定義体の電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR));
			}
		}
		// 帳票生成.データファイルの電子ファイル管理番号→ データファイルの電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_NO_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_NO_ERR));
			}
		}
		// 帳票生成.データファイル→ データファイル のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_ERR));
			}
		}
		// 帳票生成.ユーザーID→ ユーザーID のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.USER_ID_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.USER_ID_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.USER_ID_ERR, template.getString(ECC0041A110CBSMsg.USER_ID_ERR));
			}
		}
		// 帳票生成.処理種別→ 処理種別 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.TRAN_SBT_ERR, template.getString(ECC0041A110CBSMsg.TRAN_SBT_ERR));
			}
		}

		// 帳票生成.FAX送信先コード区分→ FAX送信先コード区分 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR));
			}
		}

		return param;
	}
	// ▲▲ エラー情報マッピング処理 ▲▲

	/**
     * 小数点第一位による丸め処理を行います。<BR>
     * 負の数の場合は絶対値を丸めた数に-1を乗算します。
     * <BR>
     * @param roundWay 丸め方法 1:四捨五入、2:切り上げ、3:切捨て、左記以外:丸めなし
     * @param num 丸め処理前の数値
     * @return double 丸め処理後の数値
     */
	private RoundingMode getRoundingMode(String roundWay)
	{
		// 丸め方法に従い、絶対値での丸め処理を行う
		// 四捨五入
		if (JACStrConst.ROUND_OFF.equals(roundWay))
		{
			return RoundingMode.HALF_UP;
		}
		// 切上げ
		else if (JACStrConst.ROUND_UP.equals(roundWay))
		{
			return RoundingMode.CEILING;
		}
		// 切捨て
		else if (JACStrConst.ROUND_DOWN.equals(roundWay))
		{
			return RoundingMode.FLOOR;
		}
		// 丸めなし
		else
		{
			return RoundingMode.HALF_UP;
		}
	}

	/**
	 * 編集したお客様名を返します。
	 * @param parentMapCC
	 * @return String
	 * @throws Exception
	 */
	private ArrayList<String> editSohusakiName(HashMap<String, Object> parentMapCC) throws Exception
	{
		ArrayList<String> nameList = new ArrayList<String>();
		String sohusNm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM);
		String sohusBkm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BKM);
		String sohusTntshaNm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_TNTSHA_NM);
		nameList.add(JACCommonUtil.editStrLength(sohusNm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusBkm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusTntshaNm, CHOHYO_OUT_NAME_LENGTH));
		ArrayList<String> resultNameList = JACCommonUtil.editNameList(nameList);

		return resultNameList;
	}
	
	/**
	 * 編集したうち消費税を返します。
	 * @param amnt 金額
	 * @return String うち消費税
	 * @throws Exception
	 */
	private String editUchiStax(String amnt) throws Exception
	{
		String uchiStax = JACStrConst.KARA_MOJI;
		
		try {
			
			if (JCHTushinPayShomesConstCC.JUTO_AMNT_UCHI_STAX_ITIBUSHUNO.equals(amnt))
			{
				return String.format(CHOHYO_OUT_UCHI_STAX_FORMAT, amnt);
			}
			else if (amnt != null && !JACStrConst.KARA_MOJI.equals(amnt))
			{
				uchiStax = String.format(CHOHYO_OUT_UCHI_STAX_FORMAT, String.format("%,d", Integer.valueOf(amnt)));
			}
			
		} catch (NumberFormatException e)
		{
			return uchiStax;
		}
		
		return uchiStax;
		
	}

	/**
	 * 税率マスタ情報を返します。
	 * @param endDayOfMonth 
	 * @param parentMapCC
	 * @return 税率マスタ情報
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, HashMap<String, String>> getTaxInfo(IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> taxMap, String saikenYm, String endDayOfMonth) throws Exception
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		List<HashMap<String, String>> taxList = (ArrayList<HashMap<String, String>>)inMap.get("EAC0271B010CBSMsg1List");
		
		for (HashMap<String, String> taxWork : taxList)
		{
			// 税率マスタ.税率適用開始年月日
			String mastYmd = (String)taxWork.get(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT_TSTAYMD);

			if (mastYmd.compareTo(endDayOfMonth) <= 0)
			{
				HashMap<String, String> workMap = new HashMap<String, String>();

				workMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT_TSTAYMD, (String)taxWork.get(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT_TSTAYMD));
				workMap.put(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT, (String)taxWork.get(JCHTushinPayShomesConstCC.EAC0271B010_TAX_RT));
				workMap.put(JCHTushinPayShomesConstCC.EAC0271B010_ROUND_WAY_CD, (String)taxWork.get(JCHTushinPayShomesConstCC.EAC0271B010_ROUND_WAY_CD));
				taxMap.put(saikenYm, workMap);

				return taxMap;
			}
		}

		return taxMap;
	}
	
	/**
	 * 債権一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0011B010(SessionHandle handle, IRequestParameterReadWrite param, 
									String seikyKeiNo, 
									String seikyYm,
									String seikySbtCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0011B010 = editInMsgECH0011B010(param, seikyKeiNo, seikyYm);
		for (CAANMsg msg : templateECH0011B010)
		{
			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);

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

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

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

		// 請求契約番号 → ＫＥＹ＿請求契約番号
		template.set(ECH0011B010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);

		// 請求年月 → ＫＥＹ＿請求年月
		template.set(ECH0011B010CBSMsg.KEY_SEIKY_YM, seikyYm);

		templateList.add(template);

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

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

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

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

		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("ECH0011B010CBSMsg1List");

		if (dataList == null) {
			dataList = new ArrayList<HashMap<String, String>>();
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0011B010CBSMsg.ECH0011B010CBSMSG1LIST);
		if (templateArray != null)
		{
			
			int j = 0;
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];
				String sSbtCd = childTemplate.getString(ECH0011B010CBSMsg1List.SEIKY_SBT_CD);
				
				//請求種別コードが同じものを処理。
				if(!seikySbtCd.equals(sSbtCd))
				{
					continue;
				}
				if ( j >= dataList.size()) {
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(j);

				// 充当額
				if (childTemplate.isNull(ECH0011B010CBSMsg1List.JYTO_AMNT)) {
					childMap.put(ECH0011B010CBSMsg1List.JYTO_AMNT, new String());
				} else {
					childMap.put(ECH0011B010CBSMsg1List.JYTO_AMNT, childTemplate.getString(ECH0011B010CBSMsg1List.JYTO_AMNT));
				}
				// うち消費税額
				if (childTemplate.isNull(ECH0011B010CBSMsg1List.SAIKEN_STAX)) {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_STAX, new String());
				} else {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_STAX, childTemplate.getString(ECH0011B010CBSMsg1List.SAIKEN_STAX));
				}
				// 債権ステータス
				if (childTemplate.isNull(ECH0011B010CBSMsg1List.SAIKEN_STAT)) {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_STAT, new String());
				} else {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_STAT, childTemplate.getString(ECH0011B010CBSMsg1List.SAIKEN_STAT));
				}
				// 債権番号
				if (childTemplate.isNull(ECH0011B010CBSMsg1List.SAIKEN_NO)) {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_NO, new String());
				} else {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_NO, childTemplate.getString(ECH0011B010CBSMsg1List.SAIKEN_NO));
				}
				// 債権額
				if (childTemplate.isNull(ECH0011B010CBSMsg1List.SAIKEN_AMNT)) {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_AMNT, new String());
				} else {
					childMap.put(ECH0011B010CBSMsg1List.SAIKEN_AMNT, childTemplate.getString(ECH0011B010CBSMsg1List.SAIKEN_AMNT));
				}
				
//				// 前受け充当額
//				if (childTemplate.isNull(ECH0011B010CBSMsg1List.MAEU_JYTO_AMNT)) {
//					childMap.put(ECH0011B010CBSMsg1List.MAEU_JYTO_AMNT, new String());
//				} else {
//					childMap.put(ECH0011B010CBSMsg1List.MAEU_JYTO_AMNT, childTemplate.getString(ECH0011B010CBSMsg1List.MAEU_JYTO_AMNT));
//				}
				
				j++;
			}
		}

		dataMap.put("ECH0011B010CBSMsg1List", dataList);

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

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

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

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

		return param;
	}

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

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

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

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

		HashMap<String, Object> inMap = null;

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

		// ＫＥＹ＿請求契約番号→ ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0011B010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0011B010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) 
			{
				inMap.put(ECH0011B010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0011B010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// ＫＥＹ＿請求年月→ ＫＥＹ＿請求年月のエラー情報返却
		if (!template.isNull(ECH0011B010CBSMsg.KEY_SEIKY_YM_ERR)) 
		{
			if (!inMap.containsKey(ECH0011B010CBSMsg.KEY_SEIKY_YM_ERR)) 
			{
				inMap.put(ECH0011B010CBSMsg.KEY_SEIKY_YM_ERR, template.getString(ECH0011B010CBSMsg.KEY_SEIKY_YM_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 債権データ取得メソッド
	 * 債権（ECH0011B010）より取得したデータより同一の債権番号のデータを取得する。
	 * （取得時、請求契約番号・債権年月・請求種別は領収データと一致している）
	 * @param param
	 * @param saikenNo
	 * @param seikySbtCd
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> getSaikenData(IRequestParameterReadWrite param, String saikenNo, String seikySbtCd) throws Exception
	{
		HashMap<String, Object> retMap = new HashMap<String, Object>();
		
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 債権データ
		List<HashMap<String, String>> ech0011b010List = (ArrayList<HashMap<String, String>>)dataMap.get("ECH0011B010CBSMsg1List");
		
		if(ech0011b010List != null && ech0011b010List.size() > 0)
		{
			BigDecimal saikenAmntSum = new BigDecimal("0");
			BigDecimal saikenStaxSum = new BigDecimal("0");
			HashMap<String, Object> childMap = null;
			String saikenNoEch0011 = "";
			
			for(int i=0;i<ech0011b010List.size();i++)
			{
				childMap = (HashMap)ech0011b010List.get(i);
				
				saikenNoEch0011 = getNullToStr(childMap.get(ECH0011B010CBSMsg1List.SAIKEN_NO));
				
				// 請求種別が随時請求・随時入金の場合、債権番号を条件に含め、定例請求の場合、債権番号は条件含めない。
				if(JCHTushinPayShomesConstCC.SEIKY_SBT_CD_ZUIJINYUKIN.equals(seikySbtCd)
						|| JCHTushinPayShomesConstCC.SEIKY_SBT_CD_ZUIJISEIKY.equals(seikySbtCd))
				{
				
					if(!"".equals(saikenNo) && saikenNoEch0011.equals(saikenNo))
					{
						saikenAmntSum = saikenAmntSum.add(getBigdecimal(childMap.get(ECH0011B010CBSMsg1List.SAIKEN_AMNT)));
						saikenStaxSum = saikenStaxSum.add(getBigdecimal(childMap.get(ECH0011B010CBSMsg1List.SAIKEN_STAX)));
					}
				}
				else
				{
					saikenAmntSum = saikenAmntSum.add(getBigdecimal(childMap.get(ECH0011B010CBSMsg1List.SAIKEN_AMNT)));
					saikenStaxSum = saikenStaxSum.add(getBigdecimal(childMap.get(ECH0011B010CBSMsg1List.SAIKEN_STAX)));
				}
			}
			
			retMap.put(ECH0011B010CBSMsg1List.SAIKEN_AMNT, saikenAmntSum.toString());
			retMap.put(ECH0011B010CBSMsg1List.SAIKEN_STAX, saikenStaxSum.toString());
		}
		
		return retMap;
	}
	
	/**
	 * 分納判定メソッド
	 * 領収の充当金額と債権内訳の債権額を比較し一致しない場合、分納と判断する
	 * @param handle
	 * @param param
	 * @param chohyoReqMap
	 * @return ryosyuTemplate
	 * @return saikenMap true:分納 false:分納ではない
	 * @throws Exception
	 */
	private boolean isBunnoHantei(SessionHandle handle, 
									IRequestParameterReadWrite param, 
									HashMap<String, Object> chohyoReqMap, 
									CAANMsg ryosyuTemplate,
									HashMap<String, Object> saikenMap) throws Exception
	{
		
		// 充当金額
		String ryosyuJutoAmnt = ryosyuTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT);
		
		// 債権データがない場合、分納の判断を行わない。
		if(saikenMap.isEmpty())
		{
			return false;
		}
		
		String saikenSaikenAmnt = getNullToStr(saikenMap.get(ECH0011B010CBSMsg1List.SAIKEN_AMNT));
		
		// 同じ場合、分納ではない
		if(ryosyuJutoAmnt.equals(saikenSaikenAmnt))
		{
			return false;
		}
		
		return true;
	}
	
	/**
	 * 印刷明細金額取得メソッド
	 * 領収.充当金額。
	 * @return ryosyuTemplate
	 * @return saikenMap
	 * @throws Exception
	 */
	private String getPrintDtlAmnt(CAANMsg ryosyuTemplate, HashMap<String, Object> saikenMap)
	{
		// 領収の充当金額
		String retStr = ryosyuTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT);
		
//		// 領収の充当金額
//		BigDecimal ryosyuJuto = new BigDecimal(ryosyuTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT));
//		
//		// 債権の充当金額
//		BigDecimal saikenJuto = new BigDecimal(getNullToNum(saikenMap.get(ECH0011B010CBSMsg1List.JYTO_AMNT)));
//		
//		// 債権の前受け充当金額（データがない場合空白となる）
//		String saikenMaeJuto = getNullToStr(saikenMap.get(ECH0011B010CBSMsg1List.MAEU_JYTO_AMNT));
//		
//		if(ryosyuJuto.equals(saikenJuto) && !"".equals(saikenMaeJuto))
//		{
//			BigDecimal printDtlAmnt = saikenJuto.add(new BigDecimal(saikenMaeJuto));
//			
//			retStr = printDtlAmnt.toString();
//		}
		
		return retStr;
	}
	
	/**
	 * 印刷明細うち消費税取得メソッド
	 * 領収.債権額消費税
	 * @param ryosyuTemplate
	 * @param saikenMap
	 * @param taxRate
	 * @param taxRate2
	 * @param rdMode
	 * @return BigDecimal
	 * @throws Exception
	 */
	private BigDecimal getPrintDtlAmntUchiTax(CAANMsg ryosyuTemplate, HashMap<String, Object> saikenMap, BigDecimal taxRate, BigDecimal taxRate2, RoundingMode rdMode)
	{
		BigDecimal retBd = new BigDecimal("0");
		
		// 債権データが取得されなかった場合（領収より債権データが先に削除される）
		if(saikenMap.isEmpty())
		{
			// 税額（出力）の計算を行う(税額＝料金×税率÷(100+税率))
			BigDecimal jutoAmnt = new BigDecimal(ryosyuTemplate.getString(ECH0311B010CBSMsg1List.JUTO_AMNT));
			BigDecimal amntUchiTax = jutoAmnt.multiply(taxRate).divide(taxRate2, 0, rdMode);
			
			retBd = amntUchiTax;
		}
		else
		{
			retBd = new BigDecimal((String)saikenMap.get(ECH0011B010CBSMsg1List.SAIKEN_STAX));
		}

		
		return retBd;
	}
	
	/**
	 * 支払方法取得メソッド
	 * 領収.入金経路コードに対応するコード名称を取得する。
	 * ただし、入金経路コードが金庫充当("90")の場合、以下の充当種別コードに対応するコード名称を表示する。
	 * 領収.充当番号が設定ありの場合、充当番号より特定した充当の充当.充当種別コード(預り金充当("2")または前受金充当("3"))
	 * 領収.充当番号が設定なしの場合、充当種別コードの預り金充当("2")
	 * @param ryosyuTemplate
	 * @param saikenMap
	 * @param taxRate
	 * @param taxRate2
	 * @param rdMode
	 * @return BigDecimal
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String getShiharaiWay(SessionHandle handle, IRequestParameterReadWrite param, 
									String seikyKeiNo, CAANMsg ech0311Template) throws Exception
	{
		// 入金経路コード名称
		String retStr = getNullToStr(ech0311Template.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD_NM));
		
		// 入金経路コード
		String nyukinRoutCd = getNullToStr(ech0311Template.getString(ECH0311B010CBSMsg1List.NYUKIN_ROUTE_CD));
		
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 入金経路コードが金庫充当("90")の場合、充当種別に対応する名称を表示
		if(JACStrConst.NYKNKEIRCD_JUTO.equals(nyukinRoutCd))
		{
			// 領収の充当番号
			String ryosyuJutoNo = getNullToStr(ech0311Template.getString(ECH0311B010CBSMsg1List.JUTO_NO));
			
			// 空白の場合、預かり金充当を表示
			if("".equals(ryosyuJutoNo))
			{
				List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("EZM0171B010CBSMsg1List");
				
				String cdDiv = "";
				for(HashMap<String, String> cdNmkanriMap : dataList)
				{
					cdDiv = cdNmkanriMap.get(EZM0171B010CBSMsg1List.CD_DIV);
					// 預り金充当の名称を返却します
					if(JACStrConst.JUTO_SBT_AZKIN_JUTO.equals(cdDiv))
					{
						return getNullToStr(cdNmkanriMap.get(EZM0171B010CBSMsg1List.CD_DIV_NM));
					}
				}
			}
			else
			{
				// 充当テーブルに設定されている充当種別コードの名称を取得します。
				retStr = getJutoShiharaiWay(handle, param, ryosyuJutoNo);
			}
		}
		// ANK-4415-00-00 ADD START
		//・入金経路コードが口座振替（ＣＰ）("30")の場合、口座振替("31")のコード名称を表示
		else if(JACStrConst.NYKNKEIRCD_KOZA_CP.equals(nyukinRoutCd))
		{
			retStr = getNyukinShiharaiWay(handle, param, JACStrConst.NYKNKEIRCD_KOZA_SMBCFS);
		}
		//入金経路コードが郵便自動振込（ＣＰ）("35")の場合、郵便自動振込("36")のコード名称を表示
		else if(JACStrConst.NYKNKEIRCD_YUBIN_AUTO_CP.equals(nyukinRoutCd))
		{
			retStr = getNyukinShiharaiWay(handle, param, JACStrConst.NYKNKEIRCD_YUBIN_AUTO_SMBCFS);
		}
		//入金経路コードが決済代行（ＳＭＢＣ）("85")の場合、コンビニ等("82")のコード名称を表示
		else if(JACStrConst.NYKNKEIRCD_KESSAI_SMBC.equals(nyukinRoutCd))
		{
			retStr = getNyukinShiharaiWay(handle, param, JACStrConst.NYKNKEIRCD_CVSTORE_ETC);
		}
		//ANK-4415-00-00 ADD END
		
		return retStr;
	}
	
	/**
	 * 充当テーブル充当種別コード名称取得
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param ryosyuJutoNo
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private String getJutoShiharaiWay(SessionHandle handle
									, IRequestParameterReadWrite param
									, String ryosyuJutoNo) throws Exception
	{
		String retStr = "";
		
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		dataMap.put("ECH0201B010CBSMsg1List", null);
		
		execECH0201B010(handle, param, ryosyuJutoNo);
		
		ArrayList<HashMap<String, String>> ech0201B010List = (ArrayList<HashMap<String, String>>)dataMap.get("ECH0201B010CBSMsg1List");
		
		// 検索結果がある場合、充当番号が一致した充当データの充当種別コード名称を返却する。
		if(ech0201B010List != null && ech0201B010List.size() > 0)
		{
			// 充当番号で検索しているので１件のみ検索される
			for(HashMap<String, String> ech0201B010Map : ech0201B010List)
			{
				retStr = getNullToStr(ech0201B010Map.get(ECH0201B010CBSMsg1List.JUTO_SBT_CD_NM));
				break;
			}
		}
		
		return retStr;
	}
	
	/**
	 * 充当一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param ryosyuJutoNo 
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0201B010(SessionHandle handle
									, IRequestParameterReadWrite param
									, String ryosyuJutoNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

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

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

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

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

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

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

		// 充当番号
		template.set(ECH0201B010CBSMsg.KEY_JUTO_NO, ryosyuJutoNo);

		templateList.add(template);

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

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

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

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

		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("ECH0201B010CBSMsg1List");

		if (dataList == null) {
			dataList = new ArrayList<HashMap<String, String>>();
		}

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

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

		dataMap.put("ECH0201B010CBSMsg1List", dataList);

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

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

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

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

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

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

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

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

		HashMap<String, Object> inMap = null;

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

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

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

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

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0171B010 = editInMsgEZM0171B010(param, cdSbtcd);
		for (CAANMsg msg : templateEZM0171B010)
		{
			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);
		
		// ANK-4415-00-00 ADD START
		if(JACStrConst.CD_SBT_CD_CD00182.equals(cdSbtcd))
		{
		// ANK-4415-00-00 ADD END
			// 下りマッピング
			editOutMsgEZM0171B010(result, param);
		// ANK-4415-00-00 ADD START
		}
		else if(JACStrConst.CD_SBT_CD_CD00176.equals(cdSbtcd))
		{
			// 下りマッピング
			editOutMsgEZM0171B0102(result, param);
		}
		// ANK-4415-00-00 ADD END
	}
	
	/**
	 * コード名称管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0171B010(IRequestParameterReadWrite param, String cdSbtcd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

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

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

		// コード種別コード
		template.set(EZM0171B010CBSMsg.KEY_CD_SBT_CD, cdSbtcd);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * コード名称管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0171B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

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

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

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

		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("EZM0171B010CBSMsg1List");

		if (dataList == null) {
			dataList = new ArrayList<HashMap<String, String>>();
		}

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

				// コード区分
				if (childTemplate.isNull(EZM0171B010CBSMsg1List.CD_DIV)) {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV, new String());
				} else {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV, childTemplate.getString(EZM0171B010CBSMsg1List.CD_DIV));
				}
				// コード名称
				if (childTemplate.isNull(EZM0171B010CBSMsg1List.CD_DIV_NM)) {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV_NM, new String());
				} else {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV_NM, childTemplate.getString(EZM0171B010CBSMsg1List.CD_DIV_NM));
				}
			}
		}

		dataMap.put("EZM0171B010CBSMsg1List", dataList);

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

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

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

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

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

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

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

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

		HashMap<String, Object> inMap = null;

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

		// ＫＥＹ＿コード種別
		if (!template.isNull(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR)) 
		{
			if (!inMap.containsKey(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR)) 
			{
				inMap.put(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR, template.getString(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR));
			}
		}

		return param;
	}
	
	/**
	 * <p>
	 * BigDecimalに変換し返却します。
	 * </p>
	 * @param str 文字列
	 * @return str
	 */
	private BigDecimal getBigdecimal(Object str)
	{
		return new BigDecimal(getNullToNum(str));
	}
	
	
	/**
	 * <p>
	 * パラメタの後ろの空白削除
	 * Nullの場合空白を返却します。
	 * </p>
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToStr(Object str)
	{
		return JPCUtilCommon.Rtrim((String)str);
	}
	
	/**
	 * <p>
	 * パラメタの後ろの空白削除
	 * Nullの場合0を返却します。
	 * </p>
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToNum(Object str)
	{
		String retstr = JPCUtilCommon.Rtrim((String)str);
		
		if("".equals(retstr))
		{
			retstr = "0";
		}
		return retstr;
	}
	// ANK-4415-00-00 ADD START
	/**
	 * コード名称管理コード名称取得
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param nyukinRuteCd
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private String getNyukinShiharaiWay(SessionHandle handle
									, IRequestParameterReadWrite param
									, String nyukinRuteCd) throws Exception
	{
		String retStr = "";
		
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		ArrayList<HashMap<String, String>> ezm0171B010List = (ArrayList<HashMap<String, String>>)dataMap.get("EZM0171B010CBSMsg1List2");
		
		// 検索結果がある場合、入金経路コードが一致したコード名称管理のコード名称を返却する。
		if(ezm0171B010List != null && ezm0171B010List.size() > 0)
		{
			// 入金経路で検索しているので１件のみ検索される
			for(HashMap<String, String> ech0171B010Map : ezm0171B010List)
			{
				if (getNullToStr(ech0171B010Map.get(EZM0171B010CBSMsg1List.CD_DIV)).equals(nyukinRuteCd))
				{
					retStr = getNullToStr(ech0171B010Map.get(EZM0171B010CBSMsg1List.CD_DIV_NM));
					break;
				}
			}
		}
		
		return retStr;
	}
	/**
	 * コード名称管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0171B0102(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

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

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

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

		List<HashMap<String, String>> dataList = (ArrayList<HashMap<String, String>>)dataMap.get("EZM0171B010CBSMsg1List2");

		if (dataList == null) {
			dataList = new ArrayList<HashMap<String, String>>();
		}

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

				// コード区分
				if (childTemplate.isNull(EZM0171B010CBSMsg1List.CD_DIV)) {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV, new String());
				} else {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV, childTemplate.getString(EZM0171B010CBSMsg1List.CD_DIV));
				}
				// コード名称
				if (childTemplate.isNull(EZM0171B010CBSMsg1List.CD_DIV_NM)) {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV_NM, new String());
				} else {
					childMap.put(EZM0171B010CBSMsg1List.CD_DIV_NM, childTemplate.getString(EZM0171B010CBSMsg1List.CD_DIV_NM));
				}
			}
		}

		dataMap.put("EZM0171B010CBSMsg1List2", dataList);

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

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

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

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

		return param;
	}
	// ANK-4415-00-00 ADD END
}