/*******************************************************************************
* All Rights reserved,Copyright (c) K-Opticom
********************************************************************************
*＜プログラム内容＞
* システム名        ：eo顧客基幹システム
* モジュール名      ：JACPrcSimulation
* ソースファイル名  ：JACPrcSimulation.java
* 作成者            ：富士通
* 日付              ：2011年08月06日
*＜機能概要＞
* 料金シミュレーション共通コンポーネント部品
*＜修正履歴＞
* バージョン    修正日      修正者      修正内容
* v1.00.00
* v10.00.03		2014/10/10	FJ)古田    【OM-2014-0002369】リファクタリング（加減識別コード判別対応「減算」）
* v68.00.00		2023/11/30	FJ)張本    【ANK-4479-00-00】【eo】フロント料金シミュレーション機能の性能改善
* v67.00        2023/08/14  FJ)張本    【ANK-4467-00-00】FRONTIERのマンション導線巻き取りに伴うAPI変更
********************************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.fujitsu.futurity.bp.custom.constant.JACPrcSimulationMsg;
import com.fujitsu.futurity.bp.custom.constant.JACPrcSimulationMsg1List;
import com.fujitsu.futurity.bp.custom.constant.JACPrcSimulationMsg2List;
import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.model.base.CAANMsg;

import eo.common.constant.JACStrConst;
import eo.common.util.JACCommonUtil;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.EAC0231B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0231B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0251B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0251B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0271B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0271B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0281B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0281B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0441B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0441B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0471B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0471B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0401B020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0401B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg1List;

/**
 * 料金シミュレーション部品
 * @author   富士通)
 */
public class JACPrcSimulation
{
	
	/** 固定値　BigDecimal 「0」*/
	private static final BigDecimal	BIGDECIMAL_ZERO				= new BigDecimal("0");
	
	/** 金額初期値 */
	private static final String		PRC_ZERO				= "0";
	
	/** 機能コード1 */
	private static final String		FUNC_CODE_KEY_01		= "1";

	/** 機能コード2 */
	private static final String		FUNC_CODE_KEY_02		= "2";

	/** 機能コード3 */
	private static final String FUNC_CODE_KEY_03 = "3";

	/** 利用料金（料金コースコード） */
	private static final String		USE_PRC_PCRS_CD		= "PCRS_CD";

	/** 利用料金（料金サービスコード） */
	private static final String		USE_PRC_PRC_SVC_CD		= "PRC_SVC_CD";

	/** 利用料金（料金項目コード） */
	private static final String		USE_PRC_PRC_KMK_CD		= "PRC_KMK_CD";

	/** 利用料金（料金） */
	private static final String		USE_PRC_PRC		= "PRC";
	
	/** 利用料金（割引優先順位） */
	private static final String		USE_PRC_WRIB_YUSEN_JUN		= "WRIB_YUSEN_JUN";
	
	/** 利用料金（割引サービスコード） */
	private static final String		USE_WRIB_SVC_CD		= "WRIB_SVC_CD";

	/** 割引料金（割引料金サービスコード） */
	private static final String		WRIB_PRC_PRC_SVC_CD		= "PRC_SVC_CD";
	
	/** 割引料金（割引制御識別コード） */
	private static final String		WRIB_PRC_WRIB_CTRL_SKBT_CD		= "WRIB_CTRL_SKBT_CD";
	
	/** 割引料金（集計単位コード） */
	private static final String		WRIB_PRC_SHUK_TANI_CD		= "SHUK_TANI_CD";
	
	/** 割引料金（割引集計コード） */
	private static final String		WRIB_PRC_WRIB_SHUK_CD		= "WRIB_SHUK_CD";
	
	/** 割引料金（集計料金コースコード） */
	private static final String		WRIB_PRC_SHUK_PCRS_CD		= "SHUK_PCRS_CD";
	
	/** 割引料金（集計料金サービスコード） */
	private static final String		WRIB_PRC_SHUK_PRC_SVC_CD		= "SHUK_PRC_SVC_CD";
	
	/** 割引料金（集計料金項目コード） */
	private static final String		WRIB_PRC_SHUK_PRC_KMK_CD		= "SHUK_PRC_KMK_CD";
	
	/** 割引料金（割引優先順位） */
	private static final String		WRIB_PRC_WRIB_YUSEN_JUN		= "WRIB_YUSEN_JUN";
	
	/** 割引料金（料金） */
	private static final String		WRIB_PRC_PRC		= "PRC";

	/** 料金集計（料金コースコード） */
	private static final String		PRC_SHUK_PCRS_CD		= "PCRS_CD";

	/** 料金集計（料金サービスコード） */
	private static final String		PRC_SHUK_PRC_SVC_CD		= "PRC_SVC_CD";

	/** 料金集計（料金項目コード） */
	private static final String		PRC_SHUK_PRC_KMK_CD		= "PRC_KMK_CD";

	/** 料金集計（料金） */
	private static final String		PRC_SHUK_PRC		= "PRC";

	/** 料金集計（割引優先順位） */
	private static final String		PRC_SHUK_WRIB_YUSEN_JUN		= "WRIB_YUSEN_JUN";

	/** 料金集計（集計単位） */
	private static final String		PRC_SHUK_SHUK_TANI_CD		= "SHUK_TANI_CD";

	/** 料金集計（加減識別） */
	private static final String		PRC_SHUK_KAGEN_SKBT_CD		= "KAGEN_SKBT_CD";

	/** 料金集計（料金項目出力識別） */
	private static final String		PRC_SHUK_PRC_KMK_OPUT_SKBT_CD		= "PRC_KMK_OPUT_SKBT_CD";

	/** 料金集計（集計先0円時出力識別） */
	private static final String		PRC_SHUK_SHUK_SK_0_YEN_OPUT		= "SHUK_SK_0_YEN_OPUT_SKBT_CD";

	/** 料金集計（税計算識別） */
	private static final String		PRC_SHUK_TAX_CALC_SKBT_CD		= "TAX_CALC_SKBT_CD";

	/** 料金集計（集計方法） */
	private static final String		PRC_SHUK_SHUK_WAY_CD		= "SHUK_WAY_CD";

	/** 料金集計（集計限度額） */
	private static final String		PRC_SHUK_SHUK_GEND_AMNT		= "SHUK_GEND_AMNT";

	/** 料金集計（集計元料金項目コード） */
	private static final String		PRC_SHUK_SHUK_MT_PRC_KMK_CD		= "SHUK_MT_PRC_KMK_CD";
	
	/** 料金集計（集計先丸め方法コード） */
	private static final String		PRC_SHUK_SHUK_SK_ROUND_WAY_CD		= "SHUK_SK_ROUND_WAY_CD";

	/** 料金集計（集計先料金項目置換コード） */
	private static final String		PRC_SHUK_SHUK_SK_PRC_KMK_CKAN		= "SHUK_SK_PRC_KMK_CKAN_CD";

	/** 料金集計（相殺判断用） */
	private static final String		PRC_SHUK_SOSAI		= "SOSAI";
	
	/** 料金集計（相殺判断用　相殺あり） */
	private static final String		SOSAI_ARI		= "1";

	/** 利用料金リスト */
	private List<Map<String, String>> usePrcLst = null;

	/** 出力利用料金リスト */
	private List<Map<String, String>> outUsePrcLst = null;

	/** 税率リスト */
	private Map<String, CAANMsg> taxLst = null;
	
	/** システムコード */
	private String sysCd = null;
	
	/** 機能識別コード */
	private String kinoCd = null;
	
	/** セッションハンドラ */
	private SessionHandle sessionHandle = null;
	
	/** パラメータ */
	private IRequestParameterReadWrite parameter = null;

	/** シミュレーション依頼リスト（格納用） */
	private List<Map<String, String>> prcSimuMsgList = new ArrayList<Map<String, String>>();

	/** 定額料金リスト（格納用） */
	private List<CAANMsg> eac0280B010List = null;
	/** 料金シミュレーション集計リスト（格納用） */
	private List<CAANMsg> eac0471B010List = null;
	/** 料金集計用リスト（格納用） */
	private List<CAANMsg> ech0401B020List = null;

	private static final String AMPA = "&";

	/**
	 * <p>
	 * 料金シミュレーション処理、
	 * </p>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得I/F
	 * @throws Exception
	 */
	public IRequestParameterReadWrite getPrcSimulation(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		this.sessionHandle = handle;
		this.parameter = param;
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		// 機能コード
		String funcCode = (String) inMap.get(JCMConstants.FUNC_CODE_KEY);
		//入力条件のリスト
		List<Map<String, String>> child_JACPrcSimulationMsg1List = (List<Map<String, String>>)inMap.get(JACPrcSimulationMsg.JACPrcSimulationMSG1LIST);
		
		// 初期処理
		init(funcCode);
		
		// 定額料金計算
		teigakuKeisan(child_JACPrcSimulationMsg1List);
		
		// 割引料金計算
		waribikiKeisan(child_JACPrcSimulationMsg1List);
		
		List<Map<String, String>> outLst = new ArrayList<Map<String, String>>();
		
		if (FUNC_CODE_KEY_01.equals(funcCode))
		{
			// 料金集計
			ryokinShukei();
			
			// 名称・表示順編集
			outLst = meishoHyojijyun(outUsePrcLst);
		}
		else if (FUNC_CODE_KEY_02.equals(funcCode))
		{
			// 名称・表示順編集
			outLst = meishoHyojijyun(usePrcLst);
		}
		// 料金集計のみ
		else if (FUNC_CODE_KEY_03.equals(funcCode))
		{
			// 料金集計
			ryokinShukei();

			// 出力利用料金リスト 
			outLst = outUsePrcLst;
		}
		
		// シミュレーション結果リストをセット
		inMap.put(JACPrcSimulationMsg.JACPrcSimulationMSG2LIST, outLst);
		
		// 結果を返却する。
		return param;
	}
	
	/**
	 * <p>
	 * 初期化処理。
	 * </p>
	 * @param funcCode 機能コード
	 * @throws Exception 
	 */
	private void init(String funcCode) throws Exception
	{
		if (sysCd != null)
		{
			return;
		}

		sysCd = getSysParam(JACStrConst.SYSPARA_SYSTEM_CD, JACStrConst.SYSTEM_CD_PRC_SIMULATION);
		
		if(FUNC_CODE_KEY_01.equals(funcCode))
		{
			kinoCd = getSysParam(JACStrConst.SYSPARA_WORK_KINO_SKBT, JACStrConst.WORK_KINO_SKBT_SIMULATION1);
		}
		else if(FUNC_CODE_KEY_03.equals(funcCode))
		{
			kinoCd = getSysParam(JACStrConst.SYSPARA_WORK_KINO_SKBT, JACStrConst.WORK_KINO_SKBT_SIMULATION1);
		}
		else
		{
			kinoCd = getSysParam(JACStrConst.SYSPARA_WORK_KINO_SKBT, JACStrConst.WORK_KINO_SKBT_SIMULATION2);
		}
		
		//税率マスタ取得
		CAANMsg template = new CAANMsg(EAC0271B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0271B010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0271B010CBSMsg.EAC0271B010CBSMSG1LIST);
		if (outMsgLst != null)
		{
			taxLst = new HashMap<String, CAANMsg>();
			for (CAANMsg msg : outMsgLst) {
				taxLst.put(msg.getString(EAC0271B010CBSMsg1List.TAX_CALC_SKBT_CD), msg);
			}
		}
	}

	/**
	 * <p>
	 * システムパラメータ取得。
	 * </p>
	 * @param bunruiId システムパラメータ分類コード
	 * @param paramId システムパラメータＩＤ
	 * @return システムパラメータ設定値
	 * @throws Exception 
	 */
	private String getSysParam(String bunruiId, String paramId) throws Exception
	{
		String ret = "";
		CAANMsg template = new CAANMsg(EZM0311A010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EZM0311A010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD, bunruiId);
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID, paramId);

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EZM0311A010CBSMsg.EZM0311A010CBSMSG1LIST);
		if (outMsgLst != null)
		{
			ret = outMsgLst[0].getString(EZM0311A010CBSMsg1List.SYS_PARAM_SETTE_VALUE_1);
		}
		
		return ret;
	}
	
	/**
	 * <p>
	 * 定額計算処理。
	 * </p>
	 * @param child_JACPrcSimulationMsg1List シミュレーション依頼リスト
	 * @throws Exception 
	 */
	private void teigakuKeisan(List<Map<String, String>> child_JACPrcSimulationMsg1List) throws Exception
	{
		usePrcLst = new ArrayList<Map<String, String>>();
		for (Map<String, String> msg : child_JACPrcSimulationMsg1List)
		{
			
			// 割引サービス単価番号が入っているときは次のデータ
			if (!nullOrEmpty(msg.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_TANKA_NO)))
			{
				continue;
			}
			if (!nullOrEmpty(msg.get(JACPrcSimulationMsg1List.KEY_TK_HOSHIKI_KEI_NO)))
			// 提供方式契約番号が入っているときはマンション定額料金マスタ
			{
				CAANMsg template = new CAANMsg(EAC0441B010CBSMsg.class.getName());
				
				// テンプレートID
				template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0441B010");
				template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
				
				template.set(EAC0441B010CBSMsg.KEY_SYS_CD, sysCd);
				template.set(EAC0441B010CBSMsg.KEY_TK_HOSHIKI_KEI_NO, msg.get(JACPrcSimulationMsg1List.KEY_TK_HOSHIKI_KEI_NO));
				template.set(EAC0441B010CBSMsg.KEY_PAY_KEI_SKBT_CD, msg.get(JACPrcSimulationMsg1List.KEY_PAY_KEI_SKBT_CD));

				/* SC呼出実行 */
				Map<?, ?> result = scCall(template);

				CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
				CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0441B010CBSMsg.EAC0441B010CBSMSG1LIST);
				for(CAANMsg outMsg : outMsgLst)
				{
					Map<String, String> usePrc = new HashMap<String, String>();
					usePrc.put(USE_PRC_PCRS_CD, outMsg.getString(EAC0441B010CBSMsg1List.PCRS_CD));
					usePrc.put(USE_PRC_PRC_SVC_CD, outMsg.getString(EAC0441B010CBSMsg1List.PRC_SVC_CD));
					usePrc.put(USE_PRC_PRC_KMK_CD, outMsg.getString(EAC0441B010CBSMsg1List.PRC_KMK_CD));
					usePrc.put(USE_PRC_PRC, outMsg.getString(EAC0441B010CBSMsg1List.PRC));
					usePrc.put(USE_PRC_WRIB_YUSEN_JUN, JACStrConst.WRIB_YUSEN_JUN_0);
					usePrc.put(USE_WRIB_SVC_CD, msg.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_CD));
					
					usePrcLst.add(usePrc);
				}
			}
			else
			// 提供方式契約番号が入っていないときは定額料金マスタ
			{
				CAANMsg[] outMsgLst = getEAC0281B010List(msg);
				if (outMsgLst != null && outMsgLst.length > 0)
				{
					CAANMsg outMsg = outMsgLst[0];
					Map<String, String> usePrc = new HashMap<String, String>();
					usePrc.put(USE_PRC_PCRS_CD, outMsg.getString(EAC0281B010CBSMsg1List.PCRS_CD));
					usePrc.put(USE_PRC_PRC_SVC_CD, outMsg.getString(EAC0281B010CBSMsg1List.PRC_SVC_CD));
					usePrc.put(USE_PRC_PRC_KMK_CD, outMsg.getString(EAC0281B010CBSMsg1List.PRC_KMK_CD));
					usePrc.put(USE_PRC_PRC, outMsg.getString(EAC0281B010CBSMsg1List.PRC));
					usePrc.put(USE_PRC_WRIB_YUSEN_JUN, JACStrConst.WRIB_YUSEN_JUN_0);
					usePrc.put(USE_WRIB_SVC_CD, msg.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_CD));
					
					usePrcLst.add(usePrc);
					printBpDebugLog(outMsg, new EAC0281B010CBSMsg1List().getContents()); 
				}
			}
		}
	}

	/**
	 * <p>
	 * 割引計算処理。
	 * </p>
	 * @param child_JACPrcSimulationMsg1List シミュレーション依頼リスト
	 * @throws Exception 
	 */
	private void waribikiKeisan(List<Map<String, String>> child_JACPrcSimulationMsg1List) throws Exception
	{
		List<Map<String, String>> waribikiLst = new ArrayList<Map<String, String>>();
		
		for (Map<String, String> msg : child_JACPrcSimulationMsg1List)
		{
			String inPcrsCd = msg.get(JACPrcSimulationMsg1List.KEY_PCRS_CD);
			String inWrbSvcTnkNo = msg.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_TANKA_NO);
			// 割引サービス単価番号が入ってないときはループを抜ける
			if (nullOrEmpty(inWrbSvcTnkNo))
			{
				continue;
			}
			CAANMsg template = new CAANMsg(EAC0231B010CBSMsg.class.getName());
			
			// テンプレートID
			template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0231B010");
			template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
			
			template.set(EAC0231B010CBSMsg.KEY_SYS_CD, sysCd);
			template.set(EAC0231B010CBSMsg.KEY_PRC_SVC_CD
					, JPCUtilCommon.fillHalfSpace(inWrbSvcTnkNo, JACStrConst.PRC_SVC_CD_LENGTH, true));

			/* SC呼出実行 */
			Map<?, ?> result = scCall(template);

			CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0231B010CBSMsg.EAC0231B010CBSMSG1LIST);

			for (CAANMsg outMsg : outMsgLst)
			{
				Map<String, String> waribiki = new HashMap<String, String>();
				waribiki.put(WRIB_PRC_PRC_SVC_CD, outMsg.getString(EAC0231B010CBSMsg1List.PRC_SVC_CD));
				waribiki.put(WRIB_PRC_WRIB_CTRL_SKBT_CD, outMsg.getString(EAC0231B010CBSMsg1List.WRIB_CTRL_SKBT_CD));
				waribiki.put(WRIB_PRC_SHUK_TANI_CD, outMsg.getString(EAC0231B010CBSMsg1List.SHUK_TANI_CD));
				waribiki.put(WRIB_PRC_WRIB_SHUK_CD, outMsg.getString(EAC0231B010CBSMsg1List.WRIB_SHUK_CD));
				waribiki.put(WRIB_PRC_SHUK_PCRS_CD, outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PCRS_CD));
				waribiki.put(WRIB_PRC_SHUK_PRC_SVC_CD, outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PRC_SVC_CD));
				waribiki.put(WRIB_PRC_SHUK_PRC_KMK_CD, outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PRC_KMK_CD));
				waribiki.put(WRIB_PRC_WRIB_YUSEN_JUN, outMsg.getString(EAC0231B010CBSMsg1List.WRIB_YUSEN_JUN));
				waribiki.put(WRIB_PRC_PRC, PRC_ZERO);
				waribiki.put(USE_WRIB_SVC_CD, msg.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_CD));
				waribiki.put(JACPrcSimulationMsg1List.KEY_PCRS_CD, inPcrsCd);
				waribiki.put(JACPrcSimulationMsg1List.KEY_WRIB_SVC_TANKA_NO, inWrbSvcTnkNo);
				for (Map<String, String> usePrc : usePrcLst) {
					if (outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PCRS_CD).equals(usePrc.get(USE_PRC_PCRS_CD)) &&
						outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PRC_SVC_CD).equals(usePrc.get(USE_PRC_PRC_SVC_CD)) &&
						outMsg.getString(EAC0231B010CBSMsg1List.SHUK_PRC_KMK_CD).equals(usePrc.get(USE_PRC_PRC_KMK_CD)))
					{
						waribiki.put(WRIB_PRC_PRC, usePrc.get(USE_PRC_PRC));
						break;
					}
				}
				waribikiLst.add(waribiki);
			}
		}
		// 割引対象情報集計
		Map<List<String>, Map<String, String>> shukeiMap = new HashMap<List<String>, Map<String, String>>();
		for (Map<String, String> waribiki : waribikiLst)
		{
			List<String> key = new ArrayList<String>();
			key.add(waribiki.get(WRIB_PRC_PRC_SVC_CD));
			key.add(waribiki.get(WRIB_PRC_WRIB_CTRL_SKBT_CD));
			key.add(waribiki.get(WRIB_PRC_WRIB_SHUK_CD));
			if (shukeiMap.containsKey(key))
			{
				BigDecimal shukeiPrc = new BigDecimal(shukeiMap.get(key).get(WRIB_PRC_PRC));
				BigDecimal waribikiPrc = new BigDecimal(waribiki.get(WRIB_PRC_PRC));
				BigDecimal plus = shukeiPrc.add(waribikiPrc);
				shukeiMap.get(key).put(WRIB_PRC_PRC, plus.toString());
			}
			else
			{
				shukeiMap.put(key, waribiki);
			}
		}
		// 割引計算
		Set<List<String>> keySet = shukeiMap.keySet();
		for (List<String> key : keySet)
		{
			Map<String, String> shukei =  shukeiMap.get(key);
			
			CAANMsg template = new CAANMsg(EAC0251B010CBSMsg.class.getName());
			
			// テンプレートID
			template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0251B010");
			template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
			
			template.set(EAC0251B010CBSMsg.KEY_SYS_CD, sysCd);
			template.set(EAC0251B010CBSMsg.KEY_PRC_SVC_CD, shukei.get(WRIB_PRC_PRC_SVC_CD));
			template.set(EAC0251B010CBSMsg.KEY_WRIB_SHUK_CD, shukei.get(WRIB_PRC_WRIB_SHUK_CD));

			/* SC呼出実行 */
			Map<?, ?> result = scCall(template);

			CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0251B010CBSMsg.EAC0251B010CBSMSG1LIST);

			BigDecimal wariPrc = BigDecimal.ZERO;
			
			if (outMsgLst != null && outMsgLst.length > 0)
			{
				CAANMsg outMsg = outMsgLst[0];
				BigDecimal wribValue = new BigDecimal(outMsg.getString(EAC0251B010CBSMsg1List.WRIB_VALUE));
				BigDecimal prc = new BigDecimal(shukei.get(WRIB_PRC_PRC));

				// 割引計算方法コード
				String wribCalcWayCd = outMsg.getString(EAC0251B010CBSMsg1List.WRIB_CALC_WAY_CD);
				if (JACStrConst.WRIB_CALC_WAY_CKAN_CKAN.equals(wribCalcWayCd)
						|| JACStrConst.WRIB_CALC_WAY_CKAN_NEBIKI.equals(wribCalcWayCd))
				{
					// 置換割引
					if (wribValue.compareTo(prc) < 0)
					{
						wariPrc = prc.subtract(wribValue);
						wariPrc = wariPrc.negate();
					}
				}
				else if (JACStrConst.WRIB_CALC_WAY_AMNT_CKAN.equals(wribCalcWayCd)
						|| JACStrConst.WRIB_CALC_WAY_AMNT_NEBIKI.equals(wribCalcWayCd))
				{
					// 金額割引
					if (wribValue.compareTo(prc) >= 0)
					{
						wariPrc = prc;
					}
					else
					{
						wariPrc = wribValue;
					}
				}
				else if (JACStrConst.WRIB_CALC_WAY_RT_CKAN.equals(wribCalcWayCd)
						|| JACStrConst.WRIB_CALC_WAY_RT_NEBIKI.equals(wribCalcWayCd))
				{
					// 率割引
					wariPrc = prc.multiply(wribValue).divide(new BigDecimal(100));
				}
				
				wariPrc = JACCommonUtil.round(JACStrConst.ROUND_DOWN, wariPrc, 0);
				Map<String, String> usePrc = new HashMap<String, String>();
				usePrc.put(USE_PRC_PCRS_CD, shukei.get(JACPrcSimulationMsg1List.KEY_PCRS_CD));
				usePrc.put(USE_PRC_PRC_SVC_CD, shukei.get(JACPrcSimulationMsg1List.KEY_WRIB_SVC_TANKA_NO));
				usePrc.put(USE_PRC_PRC_KMK_CD, outMsg.getString(EAC0251B010CBSMsg1List.WRIBPRC_KMK_CD));
				usePrc.put(USE_PRC_PRC, wariPrc.toString());
				usePrc.put(USE_PRC_WRIB_YUSEN_JUN, shukei.get(WRIB_PRC_WRIB_YUSEN_JUN));
				usePrc.put(USE_WRIB_SVC_CD, shukei.get(USE_WRIB_SVC_CD));
				usePrcLst.add(usePrc);
			}
		}
	}
	
	/**
	 * <p>
	 * 料金集計処理。
	 * </p>
	 * @throws Exception 
	 */
	private void ryokinShukei() throws Exception
	{
		if (usePrcLst == null || usePrcLst.size() == 0)
		{
			return;
		}
		// 利用料金ソート
		Collections.sort(usePrcLst, new Comparator<Map<String, String>>()
		{
			
			/**
			 * <p>
			 * ソート用。
			 * </p>
			 * @param o1 入力1
			 * @param o2 入力2
			 * @return int compareTo結果
			 */
			@Override public int compare(Map<String, String> o1, Map<String, String> o2)
			{
				return o1.get(USE_PRC_PRC_KMK_CD).compareTo(o2.get(USE_PRC_PRC_KMK_CD));
			
			}
		});
		
		List<Map<String, String>> prcShukLst = new ArrayList<Map<String, String>>();
		
		for (Map<String, String> usePrc : usePrcLst)
		{
			CAANMsg[] outMsgLst = getEAC0471B010List(usePrc);

			for (CAANMsg outMsg : outMsgLst)
			{
				//タイミング1だけを設定する
				if (!"1".equals(outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_TRN_TMG_CTRL_CD)))
				{
					continue;
				}
				Map<String, String> prcShuk = new HashMap<String, String>();
				if (JACStrConst.SHUK_TANI_CD_SVC_NO.equals(outMsg.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD))) 
				{
					prcShuk.put(PRC_SHUK_PCRS_CD, usePrc.get(USE_PRC_PCRS_CD));
					prcShuk.put(PRC_SHUK_PRC_SVC_CD, usePrc.get(USE_PRC_PRC_SVC_CD));
				}
				else
				{
					prcShuk.put(PRC_SHUK_PCRS_CD, JACStrConst.PCRS_CD_SP);
					prcShuk.put(PRC_SHUK_PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
				}
				prcShuk.put(PRC_SHUK_PRC_KMK_CD, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD));
				prcShuk.put(PRC_SHUK_PRC, usePrc.get(USE_PRC_PRC));
				prcShuk.put(PRC_SHUK_WRIB_YUSEN_JUN, usePrc.get(USE_PRC_WRIB_YUSEN_JUN));

				prcShuk.put(PRC_SHUK_SHUK_TANI_CD, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD));
				prcShuk.put(PRC_SHUK_KAGEN_SKBT_CD, outMsg.getString(EAC0471B010CBSMsg1List.KAGEN_SKBT_CD));
				prcShuk.put(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD, outMsg.getString(EAC0471B010CBSMsg1List.PRC_KMK_OPUT_SKBT_CD));
				prcShuk.put(PRC_SHUK_SHUK_SK_0_YEN_OPUT, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_0_YEN_OPUT_SKBT_CD));
				prcShuk.put(PRC_SHUK_TAX_CALC_SKBT_CD, outMsg.getString(EAC0471B010CBSMsg1List.TAX_CALC_SKBT_CD));
				prcShuk.put(PRC_SHUK_SHUK_WAY_CD, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_WAY_CD));
				prcShuk.put(PRC_SHUK_SHUK_GEND_AMNT, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_GEND_AMNT));
				prcShuk.put(PRC_SHUK_SHUK_MT_PRC_KMK_CD, usePrc.get(USE_PRC_PRC_KMK_CD));
//				//テーブルにないので未実装
//				prcShuk.put(PRC_SHUK_SHUK_SK_ROUND_WAY_CD, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_ROUND_WAY_CD));
				prcShuk.put(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CKAN_CD));
				prcShuk.put(USE_WRIB_SVC_CD, usePrc.get(USE_WRIB_SVC_CD));

				prcShukLst.add(prcShuk);
				printBpDebugLog(outMsg, new EAC0471B010CBSMsg1List().getContents());
			}
		}
		
		// 料金集計情報ソート
		Collections.sort(prcShukLst, new Comparator<Map<String, String>>()
		{
			
			/**
			 * <p>
			 * ソート用。
			 * </p>
			 * @param o1 入力1
			 * @param o2 入力2
			 * @return int compareTo結果
			 */
			@Override public int compare(Map<String, String> o1, Map<String, String> o2)
			{
				int ret = o1.get(PRC_SHUK_SHUK_TANI_CD).compareTo(o2.get(PRC_SHUK_SHUK_TANI_CD));
				if (ret != 0)
				{
					return ret;
				}
				ret = o1.get(PRC_SHUK_PCRS_CD).compareTo(o2.get(PRC_SHUK_PCRS_CD));
				if (ret != 0)
				{
					return ret;
				}
				ret = o1.get(PRC_SHUK_PRC_KMK_CD).compareTo(o2.get(PRC_SHUK_PRC_KMK_CD));
				if (ret != 0)
				{
					return ret;
				}
				Long l1 = Long.parseLong(o1.get(PRC_SHUK_WRIB_YUSEN_JUN));
				Long l2 = Long.parseLong(o2.get(PRC_SHUK_WRIB_YUSEN_JUN));
				ret = l1.compareTo(l2);
				if (ret != 0)
				{
					return ret;
				}
				ret = o1.get(PRC_SHUK_KAGEN_SKBT_CD).compareTo(o2.get(PRC_SHUK_KAGEN_SKBT_CD));
				if (ret != 0)
				{
					return ret;
				}
				Double d1 = Double.parseDouble(o1.get(PRC_SHUK_PRC));
				Double d2 = Double.parseDouble(o2.get(PRC_SHUK_PRC));
				return d2.compareTo(d1);
			}
		});
		
		String oldKey = null;
		String oldKey2 = null;
		
		// 料金集計
		outUsePrcLst = new ArrayList<Map<String, String>>();
		List<Map<String, String>> prcShukKekkaLst = new ArrayList<Map<String, String>>();
		for (Map<String, String> prcShuk : prcShukLst)
		{
			String newKey = prcShuk.get(PRC_SHUK_SHUK_TANI_CD) + prcShuk.get(PRC_SHUK_PCRS_CD) + prcShuk.get(PRC_SHUK_PRC_KMK_CD);
			// ブレイクキー（入力．タイミング単位(退避．キー２)）の設定
			StringBuffer tKeyBuf = new StringBuffer();
			tKeyBuf.append(prcShuk.get(PRC_SHUK_SHUK_TANI_CD)); 		// 集計単位コード
			// サービス番号の設定判定
			// 集計単位コード＝1:回線（サービス番号）」の場合
			if (JACStrConst.SHUK_TANI_CD_SVC_NO.equals(prcShuk.get(PRC_SHUK_SHUK_TANI_CD)))
			{
				tKeyBuf.append(prcShuk.get(PRC_SHUK_PCRS_CD));
			}
			String newKey2 = tKeyBuf.toString(); // ブレイクキー（入力．タイミング単位(退避．キー２)）
			boolean addResult = false;
			if (newKey.equals(oldKey))
			{
				addResult = isFirstSummary(prcShuk, prcShukKekkaLst, newKey);
			}
			else
			{
				// キーブレイク判定（タイミング単位）
				if (!nullOrEmpty(oldKey2) && !newKey2.equals(oldKey2))
				{
					secondSummary(prcShukKekkaLst);
					
					// 退避.料金情報リスト分、以下の処理を実行				
					int tmpIdx = 0;
					while (tmpIdx < prcShukKekkaLst.size())
					{
						Map<String, String> tmpMap = prcShukKekkaLst.get(tmpIdx); // 退避.料金情報
						// 退避.集計単位コード＝出力キー．タイミング単位・集計単位
						if (tmpMap.get(PRC_SHUK_SHUK_TANI_CD).equals(prcShuk.get(PRC_SHUK_SHUK_TANI_CD)))
						{
							outPutCheck(tmpMap);
							// リストから削除し、再度、実行
							prcShukKekkaLst.remove(tmpIdx);
							tmpIdx = tmpIdx - 1;
						}
						tmpIdx++;
					}
					oldKey2 = null;
				}
				else
				{
					oldKey2 = newKey2;
				}
				addResult = isFirstSummary(prcShuk, prcShukKekkaLst, newKey);
				oldKey = newKey;
			}
			// 料金情報が追加されなかった場合
			if (!addResult)
			{
				// 料金情報リスト追加処理
				prcShukKekkaLst.add(prcShuk);
			}

		}
		secondSummary(prcShukKekkaLst);
		for (Map<String, String> tmpMap : prcShukKekkaLst)
		{
			outPutCheck(tmpMap);
		}
	}

	/**
	 * <p>
	 * １次集計処理を行います。
	 * </p>
	 * @param prcShukTaihi 集計中の情報
	 * @param prcShuk 入力情報
	 * @param prcShukKekkaLst 集計リスト
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private boolean isFirstSummary(Map<String, String> prcShuk, List<Map<String, String>> prcShukKekkaLst, String inKey) throws Exception
	{
		
		if (prcShukKekkaLst == null)
		{
			return false;
		}
		BigDecimal inRyokin 	= new BigDecimal(prcShuk.get(PRC_SHUK_PRC)); // 入力．料金
		BigDecimal inGend 		= BIGDECIMAL_ZERO; // 入力．料金
		if(!nullOrEmpty(prcShuk.get(PRC_SHUK_SHUK_GEND_AMNT)))
		{
			inGend 		= new BigDecimal(prcShuk.get(PRC_SHUK_SHUK_GEND_AMNT)); // 入力．料金
		}
		BigDecimal tmpRyokin 	= BIGDECIMAL_ZERO; 		// 退避．料金
		BigDecimal ryokin 		= BIGDECIMAL_ZERO; 		// 加減区分反映後料金
		BigDecimal sumRyokin 	= BIGDECIMAL_ZERO; 		// サマリ料金
		BigDecimal sosaigaku 	= BIGDECIMAL_ZERO; 		// 退避．料金
		BigDecimal sosaizan  	= BIGDECIMAL_ZERO;		// サマリ値	
		
		// 入力．料金の設定
		String addsubKbn = prcShuk.get(PRC_SHUK_KAGEN_SKBT_CD);
		
		// 加減区分=「1：加算」の場合
		if (JACStrConst.KAGEN_SKBT_KASAN.equals(addsubKbn))
		{
			ryokin = ryokin.add(inRyokin);
		}
		// 加減区分=「2：減算」の場合
		/* ++++++++++ v10.00.00 変更開始 ++++++++++ */
//		else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
		else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn) || JACStrConst.KAGEN_SKBT_GENSAN_GAMEN.equals(addsubKbn))
		/* ++++++++++ v10.00.00 変更完了 ++++++++++ */
		{
			ryokin = ryokin.subtract(inRyokin);
		}

		Map<String, String> tmpMap = null;
		// 料金集計リストがなくなるまで、以下の処理を行なう。
		int idx = 0;
		for (idx = 0; idx < prcShukKekkaLst.size(); idx++)
		{
			
			// 退避．料金情報を取得
			tmpMap = prcShukKekkaLst.get(idx);

			// ブレイクキー（入力.料金項目単位）の設定
			StringBuffer keyBuf = new StringBuffer();

			keyBuf.append(tmpMap.get(PRC_SHUK_SHUK_TANI_CD));	// 集計単位コード
			keyBuf.append(tmpMap.get(PRC_SHUK_PCRS_CD));		// 料金コースコード
			keyBuf.append(tmpMap.get(PRC_SHUK_PRC_KMK_CD));		// 料金項目コード
			String tmpKey = keyBuf.toString(); // ブレイクキー（入力.料金項目単位）
			
			// 料金情報リストの入力キーが一致する要素に料金を加減算する
			if (inKey.equals(tmpKey))
			{
				tmpRyokin = new BigDecimal(tmpMap.get(PRC_SHUK_PRC)); // 退避．料金
				sumRyokin = tmpRyokin.add(ryokin);
				break;
			}
		}

		// 退避.料金情報が存在しなかった場合
		if (idx >= prcShukKekkaLst.size())
		{
			return false;
		}
		// 集計先料金項目置換コードが入力情報に入っている場合に上書きする
		if (!nullOrEmpty(prcShuk.get(PRC_SHUK_SHUK_SK_0_YEN_OPUT)))
		{
			tmpMap.put(PRC_SHUK_SHUK_SK_0_YEN_OPUT, prcShuk.get(PRC_SHUK_SHUK_SK_0_YEN_OPUT));
		}
		// 集計先0円時出力識別コード"1"(未出力)が入力情報に入っている場合に上書きする
		if (JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_MI.equals(prcShuk.get(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN)))
		{
			tmpMap.put(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN, prcShuk.get(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN));
		}

		// 相殺料金情報作成
		// 入力・料金情報・料金＜０ or 入力・料金情報・加減区分＝２（減算）の場合
		/* ++++++++++ v10.00.00 変更開始 ++++++++++ */
//		if (ryokin.compareTo(BIGDECIMAL_ZERO) < 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
		if (ryokin.compareTo(BIGDECIMAL_ZERO) < 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn) || JACStrConst.KAGEN_SKBT_GENSAN_GAMEN.equals(addsubKbn))
		/* ++++++++++ v10.00.00 変更完了 ++++++++++ */
		{
			String totalWay = prcShuk.get(PRC_SHUK_SHUK_WAY_CD); // 集計方法

			// 集計方法＝「1:全額集計」の場合
			if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(totalWay))
			{

				// 退避．料金（サマリ値）
				tmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
			}
			// (集計方法＝「2:限度額まで集計」or「3:集計しない」) and 
			// サマリ料金が入力．集計限度額以上の場合
			else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay) || JACStrConst.SHUK_WAY_NOT_SHUK.equals(totalWay)) 
					&& sumRyokin.compareTo(inGend) >= 0)
			{
				// 相殺額追加（入力．料金）
				prcShukKekkaLst.add(this.setRyokinInfoSosai(tmpMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, inRyokin));
				// 退避．料金（サマリ値）
				tmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
			} 
			// (集計方法＝「2:限度額まで集計」and 退避．料金が入力．集計限度額未満) or 
			// (集計方法＝「3:集計しない」    and サマリ料金が入力．集計限度額未満)
			else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay) && tmpRyokin.compareTo(inGend) < 0) 
						|| (JACStrConst.SHUK_WAY_NOT_SHUK.equals(totalWay) && sumRyokin.compareTo(inGend) < 0)) 
			{

				// 相殺額追加（０円）
				prcShukKekkaLst.add(this.setRyokinInfoSosai(tmpMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BIGDECIMAL_ZERO));

				// 相殺残追加（入力．料金）
				prcShukKekkaLst.add(this.setRyokinInfoSosai(tmpMap, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, inRyokin));
			}
			// 集計方法＝「2:限度額まで集計」   and
			// 退避．料金が入力．集計限度額以上 and
			// サマリ料金が入力．集計限度額未満
			else if (JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay)
					&& tmpRyokin.compareTo(inGend) >= 0 
					&& sumRyokin.compareTo(inGend) < 0)
			{

				sosaigaku = tmpRyokin.subtract(inGend); // 退避．料金
				sosaizan  = sumRyokin.subtract(inGend); // サマリ値

				// 入力．料金がマイナス値の場合
				if (inRyokin.compareTo(BIGDECIMAL_ZERO) < 0 )
				{
					sosaigaku = sosaigaku.negate();		// 相殺額の符号反転
				}
				else
				{
					sosaizan = sosaizan.negate();		// 相殺残の符号反転
				}

				// 相殺額追加（退避．料金）
				prcShukKekkaLst.add(this.setRyokinInfoSosai(tmpMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, sosaigaku));

				// 相殺残追加（サマリ値）
				prcShukKekkaLst.add(this.setRyokinInfoSosai(tmpMap, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, sosaizan));

				// 退避．料金（入力．集計限度額）
				tmpMap.put(PRC_SHUK_PRC, inGend.toString());
			}
		}
		else
		{
			// 退避．料金（サマリ値）
			tmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
		}
		
		return true;

	}

	/**
	 * <p>
	 * ２次集計処理（相殺・集計値作成処理）を行います。
	 * </p>
	 * @param prcShukKekkaLst 料金集計結果リスト
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void secondSummary(List<Map<String, String>> prcShukKekkaLst) throws Exception
	{
		
		// 料金集計結果リストの丸め処理を行う
		for (Map<String, String> prcShukKekka : prcShukKekkaLst)
		{
			if(!nullOrEmpty(prcShukKekka.get(PRC_SHUK_SHUK_SK_ROUND_WAY_CD)))
			{
				//丸め処理
				prcShukKekka.put(PRC_SHUK_PRC, round(prcShukKekka.get(PRC_SHUK_SHUK_SK_ROUND_WAY_CD), prcShukKekka.get(PRC_SHUK_PRC)));
			}
		}

		// 集計タイミング２〜９を順番に繰り返す
		for (int tmgCnt = 2; tmgCnt < 10; tmgCnt++)
		{
			// 現在の集計タイミングに一致する検索先.料金情報を検索
			List<Map<String, String>> prcShukKekkaLstWk = new ArrayList<Map<String,String>>();
			prcShukKekkaLstWk.addAll(prcShukKekkaLst);
			List<Map<String, Object>> sortList = new ArrayList<Map<String, Object>>();
			for (Map<String, String> prcShukKekka : prcShukKekkaLstWk)
			{
				secondSummaryData(sortList, prcShukKekka, tmgCnt);
			}
			
			// 料金集計情報ソート
			Collections.sort(sortList, new Comparator<Map<String, Object>>()
			{
				
				/**
				 * <p>
				 * ソート用。
				 * </p>
				 * @param o1 入力1
				 * @param o2 入力2
				 * @return int compareTo結果
				 */
				@Override public int compare(Map<String, Object> o1, Map<String, Object> o2)
				{
					CAANMsg ca1 = (CAANMsg) o1.get("prcSimlShuk");
					CAANMsg ca2 = (CAANMsg) o2.get("prcSimlShuk");
					
					Map<String, String> ma1 = (Map<String, String>) o1.get("prcShukKekka");
					Map<String, String> ma2 = (Map<String, String>) o2.get("prcShukKekka");
					
					int ret = ca1.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD).compareTo(ca2.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD));
					if (ret != 0)
					{
						return ret;
					}
					ret = ma1.get(PRC_SHUK_PCRS_CD).compareTo(ma2.get(PRC_SHUK_PCRS_CD));
					if (ret != 0)
					{
						return ret;
					}
					ret = ca1.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD).compareTo(ca2.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD));
					if (ret != 0)
					{
						return ret;
					}
					Long l1 = Long.parseLong(ma1.get(PRC_SHUK_WRIB_YUSEN_JUN));
					Long l2 = Long.parseLong(ma2.get(PRC_SHUK_WRIB_YUSEN_JUN));
					ret = l1.compareTo(l2);
					if (ret != 0)
					{
						return ret;
					}
					ret = ca1.getString(EAC0471B010CBSMsg1List.KAGEN_SKBT_CD).compareTo(ca2.getString(EAC0471B010CBSMsg1List.KAGEN_SKBT_CD));
					if (ret != 0)
					{
						return ret;
					}
					Double d1 = Double.parseDouble(ma1.get(PRC_SHUK_PRC));
					Double d2 = Double.parseDouble(ma2.get(PRC_SHUK_PRC));
					return d2.compareTo(d1);
				}
			});
			
			secondSummaryDtl(sortList, prcShukKekkaLst, tmgCnt);

			// 税額設定処理
			for (Map<String, String> prcShukKekka : prcShukKekkaLst)
			{
				// 税計算区分が設定されている料金情報について処理を行う
				// 税計算区分≠スペース
				if (!JACStrConst.TAX_CALC_SKBT_CD_SP.equals(prcShukKekka.get(PRC_SHUK_TAX_CALC_SKBT_CD)))
				{
					
					// 税額計算により消費税額を算出
					double tax = calcTaxCharge(prcShukKekka.get(PRC_SHUK_TAX_CALC_SKBT_CD), Double.parseDouble(prcShukKekka.get(PRC_SHUK_PRC)));

					prcShukKekka.put(PRC_SHUK_PRC, String.valueOf(tax)); 	// 料金（消費税額）
					prcShukKekka.put(PRC_SHUK_TAX_CALC_SKBT_CD, JACStrConst.TAX_CALC_SKBT_CD_SP); 						 	// 税計算区分（初期化）
				}
			}
		}
	}

	/**
	 * <p>
	 * ２次集計処理詳細。
	 * </p>
	 * @param sortList 料金集計ソート用リスト
	 * @param prcShukKekka 料金集計結果
	 * @param tmgCnt 集計タイミング
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void secondSummaryData(List<Map<String, Object>> sortList, Map<String, String> prcShukKekka, int tmgCnt) throws Exception
	{

		if("1".equals(prcShukKekka.get("nashi")))
		{
			return;
		}
		CAANMsg[] outMsgLst = getEAC0471B010List2(prcShukKekka);

		boolean flg = false;
		for (CAANMsg prcSimlShuk : outMsgLst)
		{
			if (String.valueOf(tmgCnt).equals(prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_TRN_TMG_CTRL_CD)))
			{
				Map<String, Object> taihiMap = new HashMap<String, Object>();
				taihiMap.put("prcShukKekka",prcShukKekka);
				taihiMap.put("prcSimlShuk",prcSimlShuk);
				sortList.add(taihiMap);
			}
			if(tmgCnt < Integer.parseInt(prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_TRN_TMG_CTRL_CD)))
			{
				flg = true;
			}
			printBpDebugLog(prcSimlShuk, new EAC0471B010CBSMsg1List().getContents());
		}
		if(!flg)
		{
			//現在のタイミング以降の料金集計マスタがなければ見に行かないようにする。
			prcShukKekka.put("nashi", "1");
		}
		
	}

	/**
	 * <p>
	 * ２次集計処理詳細。
	 * </p>
	 * @param sortList 料金集計ソート用リスト
	 * @param prcShukKekka 料金集計結果
	 * @param tmgCnt 集計タイミング
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void secondSummaryDtl(List<Map<String, Object>> sortList, List<Map<String, String>> prcShukKekkaLst, int tmgCnt) throws Exception
	{
		// 同一検索元で相殺料金を複数追加しないためのフラグ
		boolean sosaiFlg = true;

			
		for (Map<String, Object> taihiMap : sortList)
		{
			
			Map<String, String> prcShukKekka = (Map<String, String>) taihiMap.get("prcShukKekka");
			CAANMsg prcSimlShuk = (CAANMsg) taihiMap.get("prcSimlShuk");
			// 集計後相殺処理
			BigDecimal inRyokin = new BigDecimal(prcShukKekka.get(PRC_SHUK_PRC)); // 検索元．料金
			BigDecimal srchTmpRyokin 	= BIGDECIMAL_ZERO; // 検索先．料金
			BigDecimal ryokin 			= BIGDECIMAL_ZERO; // 加減区分反映後料金
			BigDecimal sumRyokin 		= BIGDECIMAL_ZERO; // サマリ料金

			// 検索元．料金 の設定
			String kagenSkbt = prcSimlShuk.getString(EAC0471B010CBSMsg1List.KAGEN_SKBT_CD);

			// 加減区分=「1：加算」の場合
			if (JACStrConst.KAGEN_SKBT_KASAN.equals(kagenSkbt))
			{
				ryokin = ryokin.add(inRyokin);
			}
			// 加減区分=「2：減算」の場合
			/* ++++++++++ v10.00.00 変更開始 ++++++++++ */
//			else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(kagenSkbt))
			else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(kagenSkbt) || JACStrConst.KAGEN_SKBT_GENSAN_GAMEN.equals(kagenSkbt))
			/* ++++++++++ v10.00.00 変更完了 ++++++++++ */
			{
				ryokin = ryokin.subtract(inRyokin);
			}

			String rknCode = prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD); 	// マスタ．集計先料金項目コード

			Map<String, String> srchTmpMap = null; // 検索先．料金情報

			// 検索先.料金情報リスト分、以下の処理を行う。
			int srchIdx = 0;
			for (srchIdx = 0; srchIdx < prcShukKekkaLst.size(); srchIdx++)
			{

				srchTmpMap = prcShukKekkaLst.get(srchIdx);

				// 料金情報リストの同料金項目コードの要素に料金を加減算する
				if (rknCode.equals(srchTmpMap.get(PRC_SHUK_PRC_KMK_CD)))
				{
					srchTmpRyokin 	= new BigDecimal(srchTmpMap.get(PRC_SHUK_PRC)); // 検索先．料金
					sumRyokin 		= srchTmpRyokin.add(ryokin);
					break;
				}
			}

			String shukWay = prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_WAY_CD); // マスタ．集計方法

			// 検索先.料金情報が存在しなかった場合（初期設定）
			if (srchIdx >= prcShukKekkaLst.size())
			{
				sumRyokin = ryokin;

				// サマリ料金がマイナス値の場合
				if (sumRyokin.compareTo(BIGDECIMAL_ZERO) < 0)
				{
					// 集計方法＝"1"(全額集計)
					if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(shukWay))
					{
						// 集計先追加（サマリ料金）
						prcShukKekkaLst.add(this.setRyokinInfoSecondSosai(prcShukKekka, prcSimlShuk, sumRyokin));
					}
					else
					{
						if (sosaiFlg)
						{
							// 相殺額追加（０円）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BIGDECIMAL_ZERO));
							// 相殺残追加（検索元.料金）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, ryokin));
							// 集計先追加（０円）
							prcShukKekkaLst.add(this.setRyokinInfoSecondSosai(prcShukKekka, prcSimlShuk, BIGDECIMAL_ZERO));
							sosaiFlg = false;
						}
					}
				}
				else
				{
					// 集計先追加（サマリ料金）
					prcShukKekkaLst.add(this.setRyokinInfoSecondSosai(prcShukKekka, prcSimlShuk, sumRyokin));
				}
			}
			else
			{
				// 集計先料金項目置換コードが入力情報に入っている場合に上書きする
				if (!nullOrEmpty(prcSimlShuk.getString(PRC_SHUK_SHUK_SK_0_YEN_OPUT)))
				{
					srchTmpMap.put(PRC_SHUK_SHUK_SK_0_YEN_OPUT, prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_0_YEN_OPUT_SKBT_CD));
				}
				// 集計先0円時出力識別コード"1"(未出力)が入力情報に入っている場合に上書きする
				if (JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_MI.equals(prcSimlShuk.getString(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN)))
				{
					srchTmpMap.put(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN, prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CKAN_CD));
				}
				
				// 相殺料金情報作成
				// 集計先への反映が減算要素の場合
				/* ++++++++++ v10.00.00 変更開始 ++++++++++ */
//				if (ryokin.compareTo(BIGDECIMAL_ZERO) < 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(kagenSkbt))
				if (ryokin.compareTo(BIGDECIMAL_ZERO) < 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(kagenSkbt) || JACStrConst.KAGEN_SKBT_GENSAN_GAMEN.equals(kagenSkbt))
				/* ++++++++++ v10.00.00 変更完了 ++++++++++ */
				{
					BigDecimal inGend = null; // 集計限度額
					if (nullOrEmpty(prcShukKekka.get(PRC_SHUK_SHUK_GEND_AMNT)))
					{
						inGend = BIGDECIMAL_ZERO;
					}
					else
					{
						inGend = new BigDecimal(prcShukKekka.get(PRC_SHUK_SHUK_GEND_AMNT)); // 検索元．集計限度額
					}
					// 集計方法＝「0:全額集計」
					if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(shukWay))
					{
						// 検索先．料金（サマリ値）
						srchTmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
					}
					// 集計方法「2:限度額まで集計」or「3:集計しない」 かつ サマリ料金が集計限度額以上
					else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(shukWay) || JACStrConst.SHUK_WAY_NOT_SHUK.equals(shukWay))
							&& sumRyokin.compareTo(inGend) >= 0)
					{
						if (sosaiFlg)
						{
							// 相殺額追加（検索元.料金）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAI, ryokin));
							// 検索先．料金（サマリ値）
							srchTmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
							sosaiFlg = false;
						}
					}
					// 限度額まで集計 かつ 検索先．料金が集計限度額未満 or 「3:集計しない」かつ サマリ料金が集計限度額未満
					else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(shukWay) 	&& srchTmpRyokin.compareTo(inGend) < 0) 
							|| (JACStrConst.SHUK_WAY_NOT_SHUK.equals(shukWay) && sumRyokin.compareTo(inGend) < 0))
					{
						if (sosaiFlg)
						{
							// 相殺額追加（０円）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BIGDECIMAL_ZERO));
							// 相殺残追加（検索元．料金）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, ryokin));
							sosaiFlg = false;
						}
					}
					// 限度額まで集計 かつ 検索先．料金が集計限度額以上 サマリ料金が集計限度額未満
					else if (JACStrConst.SHUK_WAY_GEND_SHUK.equals(shukWay) && srchTmpRyokin.compareTo(inGend) >= 0
							&& sumRyokin.compareTo(inGend) < 0)
					{
						if (sosaiFlg)
						{
							BigDecimal sosaigaku = inGend.subtract(srchTmpRyokin); // 検索先．料金
							BigDecimal sosaizan  = sumRyokin.subtract(inGend); // サマリ値

							// 相殺額追加（検索先．料金）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAI, sosaigaku));
							// 相殺残追加（サマリ値）
							prcShukKekkaLst.add(this.setRyokinInfoSosai2(prcShukKekka, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, sosaizan));
							// 検索先．料金（０円）
							srchTmpMap.put(PRC_SHUK_PRC, inGend.toString());
							sosaiFlg = false;
						}
					}
				}
				else
				{
					// 検索先．料金（サマリ値）
					srchTmpMap.put(PRC_SHUK_PRC, sumRyokin.toString());
				}
			}
		}
		
	}
	
	/**
	 * 出力確認と出力前判断処理。<BR>
	 * @param tmpMap 出力ファイル
	 * @return Boolean 出力しないときはfalseを返す
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Boolean outPutCheck(Map<String, String> tmpMap) throws Exception
	{

		// 退避.料金項目出力識別＝「１:未出力」の場合
		if (JACStrConst.PRC_KMK_OPUT_SKBT_MI.equals(tmpMap.get(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD)))
		{
			return false;
		}
		// 料金が0円の時で退避.料金項目出力識別    ＝「０:0円時未出力」または
		//                退避.集計先０円時出力識別＝「１:未出力」     の場合
		else if (new BigDecimal(tmpMap.get(PRC_SHUK_PRC)).compareTo(BIGDECIMAL_ZERO) == 0
				&& (JACStrConst.PRC_KMK_OPUT_SKBT_0_YEN_MI.equals(tmpMap.get(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD))
				|| JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_MI.equals(tmpMap.get(PRC_SHUK_SHUK_SK_0_YEN_OPUT))))
		{
			return false;
		}
		else
		{
			//集計先料金項目置換コード が入っているときは料金項目コードを置き換える
			if(!nullOrEmpty(tmpMap.get(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN)))
			{
				tmpMap.put(PRC_SHUK_PRC_KMK_CD, tmpMap.get(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN));
			}
		}
		outUsePrcLst.add(tmpMap);
		return true;
	}

	/**
	 * <p>
	 * 名称・表示順編集。
	 * </p>
	 * @param UsePrcList 利用料金リスト
	 * @return List<CAANMsg> 出力情報
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private List<Map<String, String>> meishoHyojijyun(List<Map<String, String>> UsePrcList) throws Exception
	{
		
		List<Map<String, String>> retList = new ArrayList<Map<String, String>>();
		if (UsePrcList != null && UsePrcList.size() > 0)
		{
			for (Map<String, String> usePrc : UsePrcList)
			{
				
				CAANMsg[] outMsgLst = getECH0401B020List(usePrc);
				if (outMsgLst != null && outMsgLst.length > 0)
				{
					CAANMsg outMsg = outMsgLst[0];
					Map<String, String> ret = new HashMap<String, String>();
					ret.put(JACPrcSimulationMsg2List.DSP_JUN, outMsg.getString(ECH0401B020CBSMsg1List.DSP_JUN));
					ret.put(JACPrcSimulationMsg2List.PCRS_CD, usePrc.get(USE_PRC_PCRS_CD));
					ret.put(JACPrcSimulationMsg2List.PRC_SVC_CD, usePrc.get(USE_PRC_PRC_SVC_CD));
					ret.put(JACPrcSimulationMsg2List.PRC_KMK_CD, usePrc.get(USE_PRC_PRC_KMK_CD));
					ret.put(JACPrcSimulationMsg2List.PRC_KMK_NM, outMsg.getString(ECH0401B020CBSMsg1List.PRC_KMK_NM));
					ret.put(JACPrcSimulationMsg2List.SEIKY_AMNT, usePrc.get(USE_PRC_PRC));
					ret.put(JACPrcSimulationMsg2List.WRIB_SVC_CD, usePrc.get(USE_WRIB_SVC_CD));
					retList.add(ret);
					printBpDebugLog(outMsg, new ECH0401B020CBSMsg1List().getContents());
				}
			}
		}
		
		// 料金項目出力ソート
		Collections.sort(retList, new Comparator<Map<String, String>>()
		{
			
			/**
			 * <p>
			 * ソート用。
			 * </p>
			 * @param o1 入力1
			 * @param o2 入力2
			 * @return int compareTo結果
			 */
			@Override public int compare(Map<String, String> o1, Map<String, String> o2)
			{
				Long l1 = Long.parseLong(o1.get(JACPrcSimulationMsg2List.DSP_JUN));
				Long l2 = Long.parseLong(o2.get(JACPrcSimulationMsg2List.DSP_JUN));
				
				return l1.compareTo(l2);
			
			}
		});
		
		return retList;
		
	}

	/**
	 * 料金集計編集処理（料金集計情報単純転送）を行います。 <BR>
	 * 
	 * @param prcShuk 料金集計
	 * @return Map<String, String> 料金集計
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Map<String, String> setPrcShuk(Map<String, String> prcShuk) throws Exception
	{
		// 料金集計情報単純転送
		Map<String, String> retMap = new HashMap<String, String>();

		retMap.putAll(prcShuk);
		return retMap;
	}
	
	/**
	 * 料金情報リスト編集処理２次（相殺額、相殺残）を行います。
	 * <BR>
	 * @param prcShukKekka			料金情報
	 * @param rknCd_2byte	料金項目コード下２桁
	 * @param ryokin 		サマリ料金
	 * @return Map<String, String> 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Map<String, String> setRyokinInfoSosai2(Map<String, String> prcShukKekka, String rknCd_2byte, BigDecimal ryokin) throws Exception
	{

		// 料金集計（単純転送）の設定
		Map<String, String> retMap = this.setPrcShuk(prcShukKekka);

		retMap.put(PRC_SHUK_PRC_KMK_CD, prcShukKekka.get(PRC_SHUK_PRC_KMK_CD).substring(0, 9) + rknCd_2byte);	// 料金項目コード（相殺額or相殺残）
		retMap.put(PRC_SHUK_PRC,	ryokin.toString());	// 料金
		
		// 退避エリアとして、料金集計リスト内で保持する項目
		retMap.put(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD, 	JACStrConst.PRC_KMK_OPUT_SKBT_OUT); 	// 料金項目出力区分（出力）
		retMap.put(PRC_SHUK_SHUK_SK_0_YEN_OPUT, JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_OUT);
		retMap.put(PRC_SHUK_TAX_CALC_SKBT_CD, JACStrConst.TAX_CALC_SKBT_CD_SP);
		retMap.put(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN, "");
		retMap.put(PRC_SHUK_SOSAI, SOSAI_ARI);

		return retMap;
	}
	
	/**
	 * 料金集計リスト編集処理（集計先追加）を行います。
	 * <BR>
	 * @param prcShukKekka            料金集計
	 * @param prcSimlShuk  料金集計マスタ
	 * @param ryokin           サマリ料金
	 * @return Map<String, String> 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Map<String, String> setRyokinInfoSecondSosai(Map<String, String> prcShukKekka, CAANMsg prcSimlShuk, BigDecimal ryokin)
			throws Exception
	{
		// 料金集計リスト編集処理（相殺額、相殺残）
		Map<String, String> retMap = this.setRyokinInfoSosai2(prcShukKekka, "", ryokin);
		
		retMap.put(PRC_SHUK_PRC_KMK_CD, 		prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD)); // 料金項目コード
		
		// 退避エリアとして、料金集計リスト内で保持する項目
		retMap.put(PRC_SHUK_SHUK_TANI_CD, 			prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD)); 		// 集計単位コード
		retMap.put(PRC_SHUK_KAGEN_SKBT_CD, 			prcSimlShuk.getString(EAC0471B010CBSMsg1List.KAGEN_SKBT_CD)); 		// 加減区分
		retMap.put(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD, 	prcSimlShuk.getString(EAC0471B010CBSMsg1List.PRC_KMK_OPUT_SKBT_CD)); 	// 料金項目出力区分
		retMap.put(PRC_SHUK_TAX_CALC_SKBT_CD, 		prcSimlShuk.getString(EAC0471B010CBSMsg1List.TAX_CALC_SKBT_CD)); 		// 税計算区分
		retMap.put(PRC_SHUK_SHUK_WAY_CD, 			prcSimlShuk.getString(EAC0471B010CBSMsg1List.SHUK_WAY_CD)); 		// 集計方法

		return retMap;
	}

	/**
	 * 料金情報リスト編集処理１次（相殺額、相殺残）を行います。
	 * <BR>
	 * @param prcShuk        料金情報
	 * @param rknCd_2byte	料金項目コード下２桁
	 * @param ryokin		料金
	 * @return Map<String, String> 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般 
	 */
	private Map<String, String> setRyokinInfoSosai(Map<String, String> prcShuk, String rknCd_2byte, BigDecimal ryokin) throws Exception
	{
		// 料金集計（単純転送）の設定
		Map<String, String> retMap = this.setPrcShuk(prcShuk);

		retMap.put(PRC_SHUK_PRC, ryokin.toString());
		retMap.put(PRC_SHUK_PRC_KMK_OPUT_SKBT_CD, JACStrConst.PRC_KMK_OPUT_SKBT_OUT);
		retMap.put(PRC_SHUK_SHUK_SK_0_YEN_OPUT, JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_OUT);
		retMap.put(PRC_SHUK_TAX_CALC_SKBT_CD, JACStrConst.TAX_CALC_SKBT_CD_SP);
		retMap.put(PRC_SHUK_SHUK_SK_PRC_KMK_CKAN, "");
		retMap.put(PRC_SHUK_SOSAI, SOSAI_ARI);
		return retMap;
	}

	/**
	 * SC呼出
	 * <br>
	 * @param template テンプレート
	 * @return Map<?, ?> ＳＣ呼出結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Map<?, ?> scCall(CAANMsg template) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, parameter.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, parameter.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, parameter.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, parameter.getCallType());
		
		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, parameter.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, parameter.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, parameter.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, parameter.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		CAANMsg[] templates = new CAANMsg[1];

		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, parameter.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY,  parameter.getControlMapData(SCControlMapKeys.OPE_TIME));

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

		return result;
		
	}

	/**
	 * 文字の空白チェック。<BR>
	 * @param val 検査文字
	 * @return boolean 空白またはNullのときtrue
	 */
	private boolean nullOrEmpty(String val)
	{
		if (val == null)
		{
			return true;
		}
		return "".equals(val);
	}
	
	/**
	 * 税額計算処理を行います。<BR>
	 * ※コンストラクタJBSbatRknBusinessUtil(commonItem, opeDate)を呼び出してから実行しないと、税率マスタの内容を使用出来ません。<BR>
	 * 
	 * @param tax_kbn 税計算区分
	 * @param ryokin 料金
	 * @return double[] 0:税額、1:税率
	 * @throws Exception
	 */
	private double calcTaxCharge(String tax_kbn, double ryokin)
			throws Exception
	{
		// 返却情報を生成する
		double taxCharge = 0.0; // 税額（出力）
		
		// 税率マスタが存在する場合
		if (taxLst != null && taxLst.containsKey(tax_kbn))
		{
			CAANMsg taxMsg = taxLst.get(tax_kbn);
			// 税率（マスタ）を取得する
			double mstTaxRate = Double.parseDouble(taxMsg.getString(EAC0271B010CBSMsg1List.TAX_RT));

			// 内税外税区分の取得
			String uchiSotoKbn = taxMsg.getString(EAC0271B010CBSMsg1List.UZEI_SZEI_SKBT_CD);
			// 外税の場合
			if (uchiSotoKbn.equals(JACStrConst.UZEI_SZEI_SKBT_SOTO))
			{
				// 税額（出力）の計算を行う(税額＝料金×税率÷100)
				taxCharge = ryokin * mstTaxRate / 100;
			}
			// 内税の場合
			else if (uchiSotoKbn.equals(JACStrConst.UZEI_SZEI_SKBT_UCHI))
			{
				// 税額（出力）の計算を行う(税額＝料金×税率÷(100+税率))
				taxCharge = ryokin * mstTaxRate / (100 + mstTaxRate);
			}
			
			// 丸め方法に従い、丸め処理を行う
			taxCharge = round(taxMsg.getString(EAC0271B010CBSMsg1List.ROUND_WAY_CD), taxCharge);
		} 
		// 税率マスタが存在しない場合
		else
		{ 
			// 税額、税率ともに初期値(0)のまま
		}
		return taxCharge;
	}
	
	/**
     * 小数点第一位による丸め処理を行います。<BR>
     * 負の数の場合は絶対値を丸めた数に-1を乗算します。
     * <BR>
     * @param roundWay 丸め方法 1:四捨五入、2:切り上げ、3:切捨て、左記以外:丸めなし
     * @param num 丸め処理前の数値
     * @return double 丸め処理後の数値
     */
	private double round(String roundWay, double num)
	{
		double retNum = 0.0;
		// 符号を設定する
		double sign = 1.0;
		if (num < 0)
		{
			sign = -1.0;
		}
		
		// 絶対値を取得する
		double absNum = Math.abs(num);

		// 丸め方法に従い、絶対値での丸め処理を行う
		// 四捨五入
		if (JACStrConst.ROUND_OFF.equals(roundWay))
		{
			retNum = Math.round(absNum);
		}
		// 切上げ
		else if (JACStrConst.ROUND_UP.equals(roundWay))
		{
			retNum = Math.ceil(absNum);
		}
		// 切捨て
		else if (JACStrConst.ROUND_DOWN.equals(roundWay))
		{
			retNum = Math.floor(absNum);
		}
		// 丸めなし
		else
		{
			retNum = absNum;
		}

		// 符号を元に戻す
		retNum = retNum * sign;

		return retNum;
	}

	/**
     * 小数点第一位による丸め処理を行います。<BR>
     * 負の数の場合は絶対値を丸めた数に-1を乗算します。
     * <BR>
     * @param roundWay 丸め方法 1:四捨五入、2:切り上げ、3:切捨て、左記以外:丸めなし
     * @param num 丸め処理前の数値
     * @return double 丸め処理後の数値
     */
	private String round(String roundWay, String num)
	{
		
		double retNum = round(roundWay, Double.parseDouble(num));

		return String.valueOf(retNum);
	}

	/**
	 * <p>
	 * 定額料金リスト呼び出しを行います。
	 * </p>
	 * @param msg
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0281B010List(Map<String, String> msg)
			throws Exception {

		if (eac0280B010List != null)
		{
			return getEAC0281B010List(msg, eac0280B010List);
		}

		CAANMsg template = new CAANMsg(EAC0281B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0281B010");
		if (nullOrEmpty(msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD)))
		{
			template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
			template.setNull(EAC0281B010CBSMsg.KEY_PRC_KMK_CD);
		}
		else
		{
			template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_02);
			template.set(EAC0281B010CBSMsg.KEY_PRC_KMK_CD, msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD));
		}
		template.set(EAC0281B010CBSMsg.KEY_SYS_CD, sysCd);
		template.set(EAC0281B010CBSMsg.KEY_PRC_SVC_CD
				, JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PRC_PLAN_CD), JACStrConst.PRC_SVC_CD_LENGTH, true));
		template.set(EAC0281B010CBSMsg.KEY_PCRS_CD
				, JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PCRS_CD), JACStrConst.PCRS_CD_LENGTH, true));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0281B010CBSMsg.EAC0281B010CBSMSG1LIST);
		return outMsgLst;
	}

	/**
	 * <p>
	 * 料金シミュレーション集計リスト呼び出しを行います。
	 * </p>
	 * @param usePrc
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0471B010List(Map<String, String> usePrc)
			throws Exception {

		if (eac0471B010List != null)
		{
			return getEAC0471B010List(usePrc, eac0471B010List);
		}

		// 利用シミュレーション集計呼び出し
		CAANMsg template = new CAANMsg(EAC0471B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0471B010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_02);
		
		template.set(EAC0471B010CBSMsg.KEY_SYS_CD, sysCd);
		template.set(EAC0471B010CBSMsg.KEY_SHUK_MT_PRC_KMK_CD, usePrc.get(USE_PRC_PRC_KMK_CD));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0471B010CBSMsg.EAC0471B010CBSMSG1LIST);
		return outMsgLst;
	}

	/**
	 * <p>
	 * 料金シミュレーション集計リスト(２次集計)呼び出しを行います。
	 * </p>
	 * @param prcShukKekka
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0471B010List2(Map<String, String> prcShukKekka)
			throws Exception {

		if (eac0471B010List != null)
		{
			return getEAC0471B010List2(prcShukKekka, eac0471B010List);
		}

		CAANMsg template = new CAANMsg(EAC0471B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0471B010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
		
		template.set(EAC0471B010CBSMsg.KEY_SYS_CD, sysCd);
		template.set(EAC0471B010CBSMsg.KEY_SHUK_MT_PRC_KMK_CD, prcShukKekka.get(PRC_SHUK_PRC_KMK_CD));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0471B010CBSMsg.EAC0471B010CBSMSG1LIST);
		return outMsgLst;
	}

	/**
	 * <p>
	 * 料金集計用リスト呼び出しを行います。
	 * </p>
	 * @param usePrc
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getECH0401B020List(Map<String, String> usePrc)
			throws Exception {

		if (ech0401B020List != null)
		{
			return getECH0401B020List(usePrc, ech0401B020List);
		}

		CAANMsg template = new CAANMsg(ECH0401B020CBSMsg.class.getName());
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "ECH0401B020");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_01);
		
		template.set(ECH0401B020CBSMsg.KEY_SYS_CD, sysCd);
		template.set(ECH0401B020CBSMsg.KEY_APL_KINO_CD, kinoCd);
		template.set(ECH0401B020CBSMsg.KEY_PCRS_CD, usePrc.get(USE_PRC_PCRS_CD));
		template.set(ECH0401B020CBSMsg.KEY_PRC_SVC_CD, usePrc.get(USE_PRC_PRC_SVC_CD));
		template.set(ECH0401B020CBSMsg.KEY_PRC_KMK_CD, usePrc.get(USE_PRC_PRC_KMK_CD));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(ECH0401B020CBSMsg.ECH0401B020CBSMSG1LIST);
		return outMsgLst;
	}

	/**
	 * <p>
	 * シミュレーション依頼リストを格納する
	 * <br>※リストに格納する料金コースは全て同じ値にすること。
	 * </p>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得I/F
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public void setPrcSimuMsgList(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		// 入力条件のリスト
		List<Map<String, String>> child_JACPrcSimulationMsg1List = (List<Map<String, String>>)inMap.get(JACPrcSimulationMsg.JACPrcSimulationMSG1LIST);

		// 入力条件のリストを保持
		prcSimuMsgList.addAll(child_JACPrcSimulationMsg1List);

	}

	/**
	 * <p>
	 * シミュレーション依頼リストを取得する
	 * </p>
	 * @throws Exception
	 */
	protected void readPrcSimuList(SessionHandle handle, IRequestParameterReadWrite param) throws Exception {

		if (prcSimuMsgList.size() < 1)
		{
			return;
		}

		this.sessionHandle = handle;
		this.parameter = param;

		init(FUNC_CODE_KEY_01);

		// 利用料金リスト
		List<Map<String, String>> usePrcLst = new ArrayList<Map<String, String>>();
		// 料金集計リスト
		List<Map<String, String>> prcShukLst = new ArrayList<Map<String, String>>();

		// 定額料金リストを取得
		readEAC0281B010List(prcSimuMsgList);

		for(Map<String, String> msg: prcSimuMsgList)
		{
			CAANMsg[] outMsgLst = getEAC0281B010List(msg, eac0280B010List);
			if (outMsgLst != null && outMsgLst.length > 0)
			{
				CAANMsg outMsg = outMsgLst[0];
				Map<String, String> usePrc = new HashMap<String, String>();
				usePrc.put(USE_PRC_PCRS_CD, outMsg.getString(EAC0281B010CBSMsg1List.PCRS_CD));
				usePrc.put(USE_PRC_PRC_SVC_CD, outMsg.getString(EAC0281B010CBSMsg1List.PRC_SVC_CD));
				usePrc.put(USE_PRC_PRC_KMK_CD, outMsg.getString(EAC0281B010CBSMsg1List.PRC_KMK_CD));

				usePrcLst.add(usePrc);
			}
		}

		// 料金シミュレーション集計一覧リストを取得
		readEAC0471B010List(usePrcLst);

		for (Map<String, String> usePrc : usePrcLst)
		{
			CAANMsg[] outMsgLst = getEAC0471B010List2(usePrc, eac0471B010List);

			for (CAANMsg outMsg : outMsgLst)
			{
				Map<String, String> prcShuk = new HashMap<String, String>();
				if (JACStrConst.SHUK_TANI_CD_SVC_NO.equals(outMsg.getString(EAC0471B010CBSMsg1List.SHUK_TANI_CD))) 
				{
					prcShuk.put(PRC_SHUK_PCRS_CD, usePrc.get(USE_PRC_PCRS_CD));
					prcShuk.put(PRC_SHUK_PRC_SVC_CD, usePrc.get(USE_PRC_PRC_SVC_CD));
				}
				else
				{
					prcShuk.put(PRC_SHUK_PCRS_CD, JACStrConst.PCRS_CD_SP);
					prcShuk.put(PRC_SHUK_PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
				}
				prcShuk.put(PRC_SHUK_PRC_KMK_CD, outMsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_PRC_KMK_CD));

				prcShukLst.add(prcShuk);
			}
		}

		// 料金項目抽出変換リストを取得
		readECH0401B020List(prcShukLst);

		// シミュレーション依頼リストクリア
		prcSimuMsgList = new ArrayList<Map<String, String>>();
	}

	/**
	 * <p>
	 * 定額料金リスト呼び出しを行います。
	 * </p>
	 * @param msgList
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void readEAC0281B010List(List<Map<String, String>> msgList)
			throws Exception {

		eac0280B010List = new ArrayList<CAANMsg>();

		ArrayList<String> aryPcrsCd = new ArrayList<String>();
		ArrayList<String> aryPrcSvcCd = new ArrayList<String>();
		for (Map<String, String> msg : msgList)
		{
			// リストに存在する場合は除外する
			if (getEAC0281B010List(msg, eac0280B010List).length > 0)
			{
				continue;
			}
			// 料金コースコード
			addKeyList(aryPcrsCd, JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PCRS_CD), JACStrConst.PCRS_CD_LENGTH, true));

			// ＫＥＹ＿料金サービスコード
			String appendKey = JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PRC_PLAN_CD), JACStrConst.PRC_SVC_CD_LENGTH, true) + AMPA;
			// ＫＥＹ＿料金項目コード
			if(!nullOrEmpty(msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD)))
			{
				appendKey = appendKey + msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD);
			}
			addKeyList(aryPrcSvcCd, appendKey);
		}

		// 対象がない場合は実行しない
		if (aryPrcSvcCd.size() < 1)
		{
			return;
		}

		CAANMsg template = new CAANMsg(EAC0281B010CBSMsg.class.getName());
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0281B010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_03);
		template.set(EAC0281B010CBSMsg.KEY_SYS_CD, sysCd);
		template.set(EAC0281B010CBSMsg.KEY_PCRS_CD, JPCUtilCommon.convListToString(aryPcrsCd));
		template.set(EAC0281B010CBSMsg.KEY_PRC_SVC_CD, JPCUtilCommon.convListToString(aryPrcSvcCd));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0281B010CBSMsg.EAC0281B010CBSMSG1LIST);

		eac0280B010List.addAll(Arrays.asList(outMsgLst));
	}

	/**
	 * <p>
	 * 利用シミュレーション集計リスト呼び出しを行います。
	 * </p>
	 * @param prcList
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void readEAC0471B010List(List<Map<String, String>> prcList)
			throws Exception {

		eac0471B010List = new ArrayList<CAANMsg>();

		// ＫＥＹ＿集計元料金項目コード
		ArrayList<String> aryPrcKmkCd = new ArrayList<String>();
		for (Map<String, String> usePrc : prcList)
		{
			// リストに存在する場合は除外する
			if (getEAC0471B010List2(usePrc, eac0471B010List).length > 0)
			{
				continue;
			}
			addKeyList(aryPrcKmkCd, usePrc.get(USE_PRC_PRC_KMK_CD));
		}

		// 対象がない場合は実行しない
		if (aryPrcKmkCd.size() < 1)
		{
			return;
		}

		// 利用シミュレーション集計呼び出し
		CAANMsg template = new CAANMsg(EAC0471B010CBSMsg.class.getName());
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "EAC0471B010");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_03);
		template.set(EAC0471B010CBSMsg.KEY_SYS_CD, sysCd);
		template.set(EAC0471B010CBSMsg.KEY_SHUK_MT_PRC_KMK_CD, JPCUtilCommon.convListToString(aryPrcKmkCd));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EAC0471B010CBSMsg.EAC0471B010CBSMSG1LIST);

		eac0471B010List.addAll(Arrays.asList(outMsgLst));
	}

	/**
	 * <p>
	 * 料金集計用リスト呼び出しを行います。
	 * </p>
	 * @param prcShukLst
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void readECH0401B020List(List<Map<String, String>> prcShukLst)
			throws Exception {

		ech0401B020List = new ArrayList<CAANMsg>();

		// ＫＥＹ＿料金コース
		ArrayList<String> aryPcrsCd = getKeyList(prcShukLst, new String[]{PRC_SHUK_PCRS_CD});
		// ＫＥＹ＿料金サービスコード
		ArrayList<String> aryPrcSvcCd = getKeyList(prcShukLst, new String[]{PRC_SHUK_PRC_SVC_CD, PRC_SHUK_PRC_KMK_CD});

		CAANMsg template = new CAANMsg(ECH0401B020CBSMsg.class.getName());
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, "ECH0401B020");
		template.set(JCMConstants.FUNC_CODE_KEY, FUNC_CODE_KEY_02);
		template.set(ECH0401B020CBSMsg.KEY_SYS_CD, sysCd);
		template.set(ECH0401B020CBSMsg.KEY_APL_KINO_CD, kinoCd);
		template.set(ECH0401B020CBSMsg.KEY_PCRS_CD, JPCUtilCommon.convListToString(aryPcrsCd));
		template.set(ECH0401B020CBSMsg.KEY_PRC_SVC_CD, JPCUtilCommon.convListToString(aryPrcSvcCd));

		/* SC呼出実行 */
		Map<?, ?> result = scCall(template);

		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(ECH0401B020CBSMsg.ECH0401B020CBSMSG1LIST);

		ech0401B020List.addAll(Arrays.asList(outMsgLst));
	}

	/**
	 * <p>
	 * 定額料金リスト呼び出しを行います。
	 * </p>
	 * @param msg
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0281B010List(Map<String, String> msg, List<CAANMsg> caanMsgList)
			throws Exception {

		ArrayList<CAANMsg> outMsgLst = new ArrayList<CAANMsg>();
		for (CAANMsg outmsg : caanMsgList)
		{
			if (!nullOrEmpty(msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD))
					&& !msg.get(JACPrcSimulationMsg1List.KEY_PRC_KMK_CD).equals(outmsg.getString(EAC0281B010CBSMsg1List.PRC_KMK_CD)))
			{
				continue;
			}
			if (!JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PRC_PLAN_CD), JACStrConst.PRC_SVC_CD_LENGTH, true)
					.equals(outmsg.getString(EAC0281B010CBSMsg1List.PRC_SVC_CD)))
			{
				continue;
			}
			if (!JPCUtilCommon.fillHalfSpace(msg.get(JACPrcSimulationMsg1List.KEY_PCRS_CD), JACStrConst.PCRS_CD_LENGTH, true)
					.equals(outmsg.getString(EAC0281B010CBSMsg1List.PCRS_CD)))
			{
				continue;
			}
			outMsgLst.add(outmsg);
		}

		return (CAANMsg[])outMsgLst.toArray(new CAANMsg[outMsgLst.size()]);
	}

	/**
	 * <p>
	 * 料金シミュレーション集計リスト呼び出しを行います。
	 * </p>
	 * @param usePrc
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0471B010List(Map<String, String> usePrc, List<CAANMsg> caanMsgList)
			throws Exception {

		ArrayList<CAANMsg> outMsgLst = new ArrayList<CAANMsg>();
		for (CAANMsg outmsg : caanMsgList)
		{
			if (!usePrc.get(USE_PRC_PRC_KMK_CD).equals(outmsg.getString(EAC0471B010CBSMsg1List.SHUK_MT_PRC_KMK_CD)))
			{
				continue;
			}
			if (!"1".equals(outmsg.getString(EAC0471B010CBSMsg1List.SHUK_SK_TRN_TMG_CTRL_CD)))
			{
				continue;
			}
			outMsgLst.add(outmsg);
		}

		return (CAANMsg[])outMsgLst.toArray(new CAANMsg[outMsgLst.size()]);
	}

	/**
	 * <p>
	 * 料金シミュレーション集計リスト(２次集計)呼び出しを行います。
	 * </p>
	 * @param prcShukKekka
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getEAC0471B010List2(Map<String, String> prcShukKekka, List<CAANMsg> caanMsgList)
			throws Exception {

		ArrayList<CAANMsg> outMsgLst = new ArrayList<CAANMsg>();
		for (CAANMsg outmsg : caanMsgList)
		{
			if (!prcShukKekka.get(PRC_SHUK_PRC_KMK_CD).equals(outmsg.getString(EAC0471B010CBSMsg1List.SHUK_MT_PRC_KMK_CD)))
			{
				continue;
			}
			outMsgLst.add(outmsg);
		}

		return (CAANMsg[])outMsgLst.toArray(new CAANMsg[outMsgLst.size()]);
	}

	/**
	 * <p>
	 * 料金集計用リスト呼び出しを行います。
	 * </p>
	 * @param usePrc
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	CAANMsg[] getECH0401B020List(Map<String, String> usePrc, List<CAANMsg> caanMsgList)
			throws Exception {

		ArrayList<CAANMsg> outMsgLst = new ArrayList<CAANMsg>();
		for (CAANMsg outmsg : caanMsgList)
		{
			if (!usePrc.get(USE_PRC_PCRS_CD).equals(outmsg.getString(ECH0401B020CBSMsg1List.PCRS_CD)))
			{
				continue;
			}
			if (!usePrc.get(USE_PRC_PRC_SVC_CD).equals(outmsg.getString(ECH0401B020CBSMsg1List.PRC_SVC_CD)))
			{
				continue;
			}
			if (!usePrc.get(USE_PRC_PRC_KMK_CD).equals(outmsg.getString(ECH0401B020CBSMsg1List.PRC_KMK_CD)))
			{
				continue;
			}
			outMsgLst.add(outmsg);
		}

		return (CAANMsg[])outMsgLst.toArray(new CAANMsg[outMsgLst.size()]);
	}

	/**
	 * <p>
	 * キー値のリストを取得します。
	 * </p>
	 * @param msgList
	 * @param keys
	 */
	private ArrayList<String> getKeyList(List<Map<String, String>> msgList, String[] keys) {

		ArrayList<String> keyList = new ArrayList<String>();
		for (Map<String, String> msg : msgList)
		{
			String key = "";
			for(int i=0; i<keys.length; i++)
			{
				key += AMPA + JFUBPCommon.nvl(msg.get(keys[i]));
			}
			addKeyList(keyList, key.substring(1));
		}

		return keyList;
	}

	/**
	 * <p>
	 * リストに値を追加します。（重複キーは除外）
	 * </p>
	 * @param keyList
	 * @param val
	 */
	private void addKeyList(ArrayList<String> keyList, String val)
	{
		if (!keyList.contains(val))
		{
			keyList.add(val);
		}
	}

	/**
	 * デバッグログを出力します。
	 * @param outMsg メッセージ
	 * @param contents 項目の配列
	 */
	private void printBpDebugLog(CAANMsg outMsg, Object[][] contents)
	{
		String msg = "	@@@@@ " + outMsg.getSchemaName() + ":";
		for(Object[] con :contents){
			msg = msg + con[0] + "=" + outMsg.getString((String)con[0]) + ",";
		}
		JFUBPCommon.printBpDebugLog(this.getClass(), msg.substring(0, msg.length()-1));
	}
}