/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatACJgshakSsnPrcItemShuk
*	ソースファイル名	：JBSbatACJgshakSsnPrcItemShuk.java
*	作成者				：富士通　
*	作成日				：2012年01月17日
*＜機能概要＞
*　事業者間精算料金項目集計部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2012/01/17   富士通		新規作成
*	v3.00		2012/08/03   FJ）冨井	【TAI-2012-0000094】税額計算部品修正（DBアクセスクラス見直し対応）
*********************************************************************/
package eo.business.service;

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

import eo.business.common.JACBatCommon;
import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCCBatCommon;
import eo.business.util.file.JBSbatACIFM107;
import eo.business.util.file.JBSbatACIFM116;
import eo.business.util.table.JBSbatAC_M_PRC_SHUK;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JPCEditString;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatACJgshakSsnPrcItemShuk extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	/** テーブル(料金集計)*/
	private static final String D_TBL_NAME_AC_M_PRC_SHUK 					= "AC_M_PRC_SHUK";

	/** SQL定義キー(AC_SELECT_002)*/
	private static final String AC_M_PRC_SHUK_AC_SELECT_002 				= "AC_SELECT_002";

	/** テーブルアクセスクラス(料金集計)*/
	private JBSbatSQLAccess db_AC_M_PRC_SHUK 								= null;
	/** Fullスペース項目(8桁スペース) */
	private static final String		ALL_SPACE_8			= JCCBatCommon.fillHalfSpace(" ", 8, true);
	/** 集計件数カウント */
	private BigDecimal 				summaryCounter		= BigDecimal.ONE;
	/** 業務共通クラスインスタンス */
	private JACbatRknBusinessUtil						rknBusinessUtil		= null;
	/** 料金項目集計マスタ検索結果 */
	private Map<String, List<JBSbatCommonDBInterface>> rknSyukeiDB			= null;	

	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][opeDate=" + super.opeDate + "]");
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][freeItem=" + super.freeItem + "]");
		// DBアクセスクラスを生成します
		db_AC_M_PRC_SHUK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_PRC_SHUK);
		
		this.rknBusinessUtil = new JACbatRknBusinessUtil(commonItem); 	// 料金業務共通クラス
		
		// 料金項目集計マスタの検索
		rknSyukeiDB = getRknSyukeiMst();
		
		// 料金集計マスタ　クローズ
		db_AC_M_PRC_SHUK.close();

		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");

	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param inMap　入力電文
	 * @param outputInItem 入力情報
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap, JBSbatOutputItem outputInItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute]");
		assert 	inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][inMap=" + inMap.getMap().toString() + "]") : true;
		// 初期化
		String inSKey 		= null; // ブレイクキー（入力．料金項目単位）
		String inTKey 		= null; // ブレイクキー（入力．タイミング単位）
		String inTTunitKey 	= null; // ブレイクキー（入力．タイミング単位・集計単位）
		String outSKey 		= null; // ブレイクキー（出力．料金項目単位）
		String outTKey 		= null; // ブレイクキー（出力．タイミング単位）
		String outTTunitKey = null; // ブレイクキー（出力．タイミング単位・集計単位）

		// 入力情報終了判定
		if (inMap == null)
		{
			// ２次集計処理（相殺・集計値作成処理）
			this.secondSummary(outputInItem);
			
			// 出力処理(退避.料金情報リスト)
			List<JBSbatServiceInterfaceMap> tmpList = outputInItem.getOutMapList();

			// 料金情報リストがなくなるまで、以下の処理を行なう。
			int idx = 0;
			while (idx < tmpList.size())
			{
				//出力内容確認
				if(!outPutCheck(tmpList.get(idx)))
				{
					// リストから削除し、再度、実行
					tmpList.remove(idx);
					idx = idx - 1;
				}
				idx++;
			}
			return outputInItem;
		}

		if (inMap.isInputErrorFlg())
		{
			//入力ファイルにエラーがあるときは処理中断
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0500CE);
		}

		// ブレイクキー（入力）の設定
		String[] keyAry = this.getKeyArray(inMap);
		inSKey 		= keyAry[0]; // ブレイクキー（入力．料金項目単位(退避．キー１)）
		inTKey 		= keyAry[1]; // ブレイクキー（入力．タイミング単位（退避．キー２））
		inTTunitKey = keyAry[2]; // ブレイクキー（入力．タイミング単位・集計単位）

		// ブレイクキー（出力）の設定
		// 引継ぎのブレイクキーが存在する
		if (outputInItem.isKeyList())
		{
			outSKey		 	= (String)outputInItem.getKeyList().get(0);
			outTKey 		= (String)outputInItem.getKeyList().get(1);
			outTTunitKey 	= (String)outputInItem.getKeyList().get(2);
		}
		
		// 退避情報初期設定
		// 退避．料金情報リストが存在しない場合（初回処理判定（入力1件目））
		if (!outputInItem.isOutMapList())
		{
			// 料金情報リスト追加処理
			outputInItem.addOutMapList(this.setRyokinInfo(inMap));
			
			// キー情報リストのクリア
			outputInItem.clearKeyList();

			// キー設定
			outputInItem.addKeyList(inSKey);
			outputInItem.addKeyList(inTKey);
			outputInItem.addKeyList(inTTunitKey);

			return outputInItem;
		}

		// キーブレイク判定（料金項目単位）
		// 入力キー．料金項目単位＝出力キー．料金項目単位の場合
		if (inSKey.equals(outSKey))
		{
			// １次集計処理	
			this.isFirstSummary(inMap, outputInItem, inSKey);
		}
		else
		{
			// 集計件数カウントを０にする
			this.summaryCounter = BigDecimal.ONE;

			// キー情報リストを格納
			List<String> keyList = outputInItem.getKeyList();

			// キーブレイク判定（タイミング単位）
			if (!inTKey.equals(outTKey))
			{
				// ２次集計処理（相殺・集計値作成処理）
				this.secondSummary(outputInItem);

				// 出力処理
				// 退避.料金情報リスト
				List<JBSbatServiceInterfaceMap> tmpList = outputInItem.getOutMapList();

				// 退避.料金情報リスト分、以下の処理を実行				
				int tmpIdx = 0;
				while (tmpIdx < tmpList.size())
				{
					JBSbatServiceInterfaceMap tmpMap = tmpList.get(tmpIdx); // 退避.料金情報
					// 退避.集計単位コード＝出力キー．タイミング単位・集計単位
					if (tmpMap.getString(JBSbatACIFM116.SHUK_TANI_CD).equals(outTTunitKey))
					{
						//出力内容確認
						if(!outPutCheck(tmpMap))
						{
							// リストから削除し、再度、実行
							tmpList.remove(tmpIdx);
							tmpIdx = tmpIdx - 1;
						}
					}
					tmpIdx++;
				}
				
				// ブレイクキー（出力．タイミング単位）の引継ぎ
				keyList.set(1, inTKey);
				keyList.set(2, inTTunitKey);
			}
			// １次集計処理
			boolean addResult = this.isFirstSummary(inMap, outputInItem, inSKey);

			// 料金情報が追加されなかった場合
			if (!addResult)
			{
				// 料金情報リスト追加処理
				outputInItem.addOutMapList(this.setRyokinInfo(inMap));
			}
			// ブレイクキー（出力．タイミング単位）の引継ぎ
			keyList.set(0, inSKey);
		}
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");

		return outputInItem;

	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");

	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * SQLKEY(AC_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	システムコード
	 *		 	バッチ運用日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAC_M_PRC_SHUK_AC_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

		// DBアクセスを実行します
		db_AC_M_PRC_SHUK.selectBySqlDefine(paramList, AC_M_PRC_SHUK_AC_SELECT_002);
	}

	/**
	 * １次集計処理を行います。
	 * <BR>
	 * @param inMap		入力情報（料金集計情報）
	 * @param outputInItem	出力情報（料金情報）
	 * @param inKey		ブレイクキー（入力.料金項目単位）
	 * @return boolean 料金情報追加結果　true:追加　false:非追加
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private boolean isFirstSummary(JBSbatServiceInterfaceMap inMap, JBSbatOutputItem outputInItem, String inKey) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isFirstSummary]");
		
		BigDecimal inRyokin 	= inMap.getBigDecimal(JBSbatACIFM116.PRC); // 入力．料金
		BigDecimal inGend 		= inMap.getBigDecimal(JBSbatACIFM116.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 = inMap.getString(JBSbatACIFM116.KAGEN_SKBT_CD);
		
		// 加減区分=「1：加算」の場合
		if (JACStrConst.KAGEN_SKBT_KASAN.equals(addsubKbn))
		{
			ryokin = ryokin.add(inRyokin);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]加減区分 1:加算 (" + ryokin + ")");
		}
		// 加減区分=「2：減算」の場合
		else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
		{
			ryokin = ryokin.subtract(inRyokin);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]加減区分 2:減算 (" + ryokin + ")");
		}

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

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

			keyBuf.append(tmpMap.getString(JBSbatACIFM116.SEIKY_YM)); 		// 請求年月
			keyBuf.append(tmpMap.getString(JBSbatACIFM116.SEIKY_KEI_NO));	// 請求先番号			
			keyBuf.append(tmpMap.getString(JBSbatACIFM116.SHUK_TANI_CD));	// 集計単位コード
			keyBuf.append(tmpMap.getString(JBSbatACIFM116.SVC_NO)); 		// サービス番号
			keyBuf.append(tmpMap.getString(JBSbatACIFM116.PCRS_CD));		// 料金コースコード
			keyBuf.append(tmpMap.getString(JBSbatACIFM116.PRC_KMK_CD));		// 料金項目コード
//			keyBuf.append(tmpMap.getString(JBSbatACIFM116.USE_STAYMD));		// 利用開始日
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]退避．料金情報[outMapList[idx(" + idx + ")]] 取得" +
					" 請求年月(" + tmpMap.getString(JBSbatACIFM116.SEIKY_YM) + ")" +
					" 請求契約番号(" + tmpMap.getString(JBSbatACIFM116.SEIKY_KEI_NO) + ")" +
					" 集計単位コード(" + tmpMap.getString(JBSbatACIFM116.SHUK_TANI_CD) + ")" +
					" サービス番号(" + tmpMap.getString(JBSbatACIFM116.SVC_NO) + ")" +
					" 料金コースコード(" + tmpMap.getString(JBSbatACIFM116.PCRS_CD) + ")" +
					" 料金項目コード(" + tmpMap.getString(JBSbatACIFM116.PRC_KMK_CD) + ")" +
					" 集計先処理タイミング制御(" + tmpMap.getString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD) + ")");
			String tmpKey = keyBuf.toString(); // ブレイクキー（入力.料金項目単位）
			
			// 料金情報リストの入力キーが一致する要素に料金を加減算する
			if (inKey.equals(tmpKey))
			{
				tmpRyokin = tmpMap.getBigDecimal(JBSbatACIFM116.PRC); // 退避．料金
				sumRyokin = tmpRyokin.add(ryokin);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]料金加算(" + sumRyokin + ") + (" + tmpRyokin + ")");
				break;
			}
		}

		// 退避.料金情報が存在しなかった場合
		if (idx >= outMapList.size())
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isFirstSummary]退避．料金情報が存在しない。");
			return false;
		}
		// 集計先０円時出力識別・集計先丸め方法コード・集計先料金項目置換コードが集計先に入っていない場合セットする
		if ("".equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD)))
		{
			tmpMap.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, inMap.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD));
		}
		if ("".equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD)))
		{
			tmpMap.setString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD, inMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD));
		}
		if ("".equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD)))
		{
			tmpMap.setString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD, inMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD));
		}

		// 相殺料金情報作成
		// 入力・料金情報・料金＜０ or 入力・料金情報・加減区分＝２（減算）の場合
		if (BigDecimal.ZERO.compareTo(ryokin) > 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
		{
			String totalWay = inMap.getString(JBSbatACIFM116.SHUK_WAY_CD); // 集計方法
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法(" + totalWay + ")");

			// 集計方法＝「1:全額集計」の場合
			if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(totalWay))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法 1全額集計 (" + sumRyokin + ")");

				// 退避．料金（サマリ値）
				tmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]退避．料金（サマリ値）(" + sumRyokin + ")");
			}
			// (集計方法＝「2:限度額まで集計」or「3:集計しない」) and 
			// サマリ料金が入力．集計限度額以上の場合
			else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay) || JACStrConst.SHUK_WAY_NOT_SHUK.equals(totalWay)) 
					&& sumRyokin.compareTo(inGend) >= 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法 （2:限度額まで集計 or 3:集計しない）かつ" +
						"サマリ料金(" + sumRyokin + ") が 集計限度額(" + inGend + ")以上");

				// 相殺額追加（入力．料金）
				outputInItem.addOutMapList(this.setRyokinInfoSosai(tmpMap, inMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, inRyokin));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]相殺額追加(" + inRyokin + ") 入力.料金");

				// 退避．料金（サマリ値）
				tmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]退避．料金（サマリ値）(" + sumRyokin + ")");
			} 
			// (集計方法＝「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)) 
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法" 
						+ "(" + totalWay + ")" +  " （2:限度額まで集計）かつ" + "退避．料金(" + tmpRyokin + ") が 集計限度額(" + inGend + ")未満 または");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法" 
						+ "(" + totalWay + ")" +  " （3:集計しない）かつ" + "サマリ料金(" + sumRyokin + ") が 集計限度額(" + inGend + ")未満 または");

				// 相殺額追加（０円）
				outputInItem.addOutMapList(this.setRyokinInfoSosai(tmpMap, inMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BigDecimal.ZERO));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]相殺額追加(0) 固定");

				// 相殺残追加（入力．料金）
				outputInItem.addOutMapList(this.setRyokinInfoSosai(tmpMap, inMap, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, inRyokin));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]相殺額追加(" + inRyokin + ") 入力.料金");
			}
			// 集計方法＝「2:限度額まで集計」   and
			// 退避．料金が入力．集計限度額以上 and
			// サマリ料金が入力．集計限度額未満
			else if (JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay)
					&& tmpRyokin.compareTo(inGend) >= 0 
					&& sumRyokin.compareTo(inGend) < 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]集計方法 2:限度額まで集計 かつ" +
						"退避料金(" + tmpRyokin + ") が 集計限度額(" + inGend + ")以上 かつ " +
						"サマリ料金(" + sumRyokin + ") が 集計限度額( " + inGend + ") 未満");

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

				// 入力．料金がマイナス値の場合
				if (BigDecimal.ZERO.compareTo(inRyokin) > 0)
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]入力．料金がマイナス値の場合(" + inRyokin + ")、" +
							"相殺額の符号反転(" + sosaigaku + ")→(" + sosaigaku.negate() + ")");
					sosaigaku = sosaigaku.negate();		// 相殺額の符号反転
				}
				else
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]入力．料金がプラス値の場合(" + inRyokin + ")、" +
							"相殺残の符号反転(" + sosaizan + ")→(" + sosaizan.negate() + ")");
					sosaizan = sosaizan.negate();		// 相殺残の符号反転
				}

				// 相殺額追加（退避．料金）
				outputInItem.addOutMapList(this.setRyokinInfoSosai(tmpMap, inMap, JACStrConst.PRC_KMK_CD_SBT_SOSAI, sosaigaku));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]相殺額追加（退避．料金）(" + sosaigaku + ")");

				// 相殺残追加（サマリ値）
				outputInItem.addOutMapList(this.setRyokinInfoSosai(tmpMap, inMap, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, sosaizan));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]相殺残追加（サマリ値）(" + sosaizan + ") ");

				// 退避．料金（入力．集計限度額）
				tmpMap.setBigDecimal(JBSbatACIFM116.PRC, inGend);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]退避．料金（入力．集計限度額）(" + inGend + ")");
			}
		}
		else
		{
			// 退避．料金（サマリ値）
			tmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isFirstSummary]退避．料金（サマリ値）(" + sumRyokin + ")");
		}
		// 精算項目件数を1件追加
		this.summaryCounter = this.summaryCounter.add(BigDecimal.ONE);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isFirstSummary]");
		
		return true;
	}

	/**
	 * ２次集計処理（相殺・集計値作成処理）を行います。 
	 * <BR>
	 * @param outputInItem 出力情報（料金情報）
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void secondSummary(JBSbatOutputItem outputInItem) throws Exception
	{
		
		// 検索先.料金情報リストの取得
		List<JBSbatServiceInterfaceMap> outMapList = outputInItem.getOutMapList();

		// 集計タイミング１〜９を順番に繰り返す
		for (int tmgCnt = 1; tmgCnt < 10; tmgCnt++)
		{
			// 前受相殺優先順位０〜９９を順番に繰り返す
			for (int maeukeCnt = 0; maeukeCnt < 100; maeukeCnt++) 
			{
				JBSbatServiceInterfaceMap tmTmpBean = null; // 検索元．料金情報
				// 現在の集計タイミングに一致する検索先.料金情報を検索
				for (int idx2 = 0; idx2 < outMapList.size(); idx2++)
				{
					tmTmpBean = (JBSbatServiceInterfaceMap)outMapList.get(idx2);
					secondSummaryDtl(outputInItem, outMapList, tmTmpBean, tmgCnt, maeukeCnt);
				}
			}
			
			// 税額設定処理
			for (int taxIdx = 0; taxIdx < outMapList.size(); taxIdx++)
			{
				JBSbatServiceInterfaceMap taxTmpBean = (JBSbatServiceInterfaceMap)outMapList.get(taxIdx);
				// 税計算区分が設定されている料金情報について処理を行う
				// 税計算区分≠スペース
				if (!JACStrConst.TAX_CALC_SKBT_CD_SP.equals(taxTmpBean.getString(JBSbatACIFM116.TAX_CALC_SKBT_CD)))
				{
					// 税額計算により消費税額を算出
					BigDecimal[] tax = this.rknBusinessUtil.calcTaxCharge(taxTmpBean.getString(JBSbatACIFM116.TAX_CALC_SKBT_CD)
																	, taxTmpBean.getBigDecimal(JBSbatACIFM116.PRC)
																	, super.opeDate);
					
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummary]料金（消費税額）(" + tax[0] + ") 税率(" + tax[1] + ")");
					
					taxTmpBean.setBigDecimal(JBSbatACIFM116.PRC, tax[0]); 	// 料金（消費税額）
					taxTmpBean.setString(JBSbatACIFM116.TAX_CALC_SKBT_CD, JACStrConst.TAX_CALC_SKBT_CD_SP); // 税計算区分（初期化）
				}
			}
		}
		
	}
	
	/**
	 * ２次集計処理（相殺・集計値作成処理）を行います。 
	 * <BR>
	 * @param outputInItem 出力情報（料金情報）
	 * @param outMapList 出力リスト
	 * @param tmTmpBean 料金集計結果
	 * @param tmgCnt 集計タイミング
	 * @param maeukeCnt 前受相殺優先順位
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void secondSummaryDtl(JBSbatOutputItem outputInItem, List<JBSbatServiceInterfaceMap> outMapList
									, JBSbatServiceInterfaceMap tmTmpBean, int tmgCnt, int maeukeCnt) throws Exception
	{

		// 同一検索元で相殺料金を複数追加しないためのフラグ
		boolean sosaiFlg = true;

		// 集計タイミングが一致した検索元.料金情報に対して処理を行う
		
		// 集計タイミングインデックス　＝検索先.集計タイミング             and
		// 前受相殺優先順位インデックス＝検索先.前受相殺優先順位           and
		// 検索元.集計単位             ＝出力キー.タイミング単位・集計単位
		if (String.valueOf(tmgCnt).equals(tmTmpBean.getString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD))
				&& maeukeCnt == Integer.parseInt(tmTmpBean.getString(JBSbatACIFM116.MAEUK_SOSAI_YUSE_JUN))
				&& tmTmpBean.getString(JBSbatACIFM116.SHUK_TANI_CD).equals((String)outputInItem.getKeyList().get(2)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][secondSummaryDtl]集計タイミング一致");

			// 料金集計マスタ情報取得（検索元.料金情報、入力.相対区分）
			List<JBSbatCommonDBInterface> rknSkiMstList = this.getRknSyukeiMst(tmTmpBean, true);

			// 相対区分="1"（相対契約なし）以外の場合
			if (rknSkiMstList == null && !JACStrConst.AITAIKBN_NON.equals(tmTmpBean.getString(JBSbatACIFM116.AIT_DIV)))
			{
				// 請求先番号で検索にトライして、結果がnullだった場合はスペースで検索を行う。
				rknSkiMstList = this.getRknSyukeiMst(tmTmpBean, false);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]料金集計マスタ情報取得(スペース検索)");
			}
			if (rknSkiMstList == null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]料金集計マスタ情報なし");
			}
			
			assert rknSkiMstList != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]料金集計マスタ情報あり") : true;
			
			// 検索結果がある時、検索結果分繰り返し
			for (int i = 0; (rknSkiMstList != null && i < rknSkiMstList.size()); i++)
			{
				JBSbatCommonDBInterface rknSkiMst = rknSkiMstList.get(i);
				
				// 現在処理対象としている「集計先処理タイミング制御コード＋１」以上の集計先処理タイミング制御コードを対象とする。
				int tmgCtrlCd = Integer.parseInt(tmTmpBean.getString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD)) + 1;
				if(rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_TRN_TMG_CTRL_CD).compareTo(String.valueOf(tmgCtrlCd)) < 0)
				{
					continue;
				}
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]rknSkiMst：" + rknSkiMst.getMap().toString());
				
				// 集計後相殺処理
				BigDecimal inRyokin = tmTmpBean.getBigDecimal(JBSbatACIFM116.PRC); 				// 検索元．料金
				BigDecimal inGend 	= rknSkiMst.getBigDecimal(JBSbatACIFM116.SHUK_GEND_AMNT); 	// 検索元．集計限度額
				BigDecimal srchTmpRyokin 	= BigDecimal.ZERO; 									// 検索先．料金
				BigDecimal ryokin 			= BigDecimal.ZERO; 									// 加減区分反映後料金
				BigDecimal sumRyokin 		= BigDecimal.ZERO; 									// サマリ料金

				// 検索元．料金 の設定
				String addsubKbn = rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.KAGEN_SKBT_CD);

				// 加減区分=「1：加算」の場合
				if (JACStrConst.KAGEN_SKBT_KASAN.equals(addsubKbn))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]加減区分=1:加算 料金(" + ryokin + ") + (" + inRyokin + ")");
					ryokin = ryokin.add(inRyokin);
					
				}
				// 加減区分=「2：減算」の場合
				else if (JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]加減区分=2:減算 料金(" + ryokin + ") - (" + inRyokin + ")");
					ryokin = ryokin.subtract(inRyokin);
				}

				String rknCode = rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_PRC_KMK_CD); 	// マスタ．集計先料金項目コード
				JBSbatServiceInterfaceMap srchTmpMap = null; // 検索先．料金情報

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

					srchTmpMap = (JBSbatServiceInterfaceMap)outMapList.get(srchIdx);

					// 料金情報リストの同料金項目コードの要素に料金を加減算する
					if (rknCode.equals(srchTmpMap.getString(JBSbatACIFM116.PRC_KMK_CD)))
					{
						srchTmpRyokin 	= srchTmpMap.getBigDecimal(JBSbatACIFM116.PRC); // 検索先．料金
						sumRyokin 		= srchTmpRyokin.add(ryokin);
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]合計料金(" 
																	+ sumRyokin + ") = (" + srchTmpRyokin + ") + (" + ryokin + ")");
						break;
					}
				}

				String totalWay = rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_WAY_CD); // マスタ．集計方法

				// 集計元適用フラグ（集計元を1円以上集計させた場合、集計先料金項目置換コードを置換させるために使用する。）
				boolean updateShkSkCkanCdFlg = false;

				// 検索先.料金情報が存在しなかった場合（初期設定）
				if (srchIdx >= outMapList.size())
				{
					JBSbatServiceInterfaceMap sakiMap = null;
					sumRyokin = ryokin;
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]検索先料金情報なし(初期設定) (" + sumRyokin + ")");
					// サマリ料金がマイナス値の場合
					if (BigDecimal.ZERO.compareTo(sumRyokin) > 0)
					{
						// 集計方法＝"1"(全額集計)
						if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(totalWay))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計方法＝1:全額集計 集計先追加(サマリ料金)(" + sumRyokin + ")");
							// 集計先追加（サマリ料金）
							sakiMap = this.setRyokinInfoSecondSosai(tmTmpBean, rknSkiMst, sumRyokin);
							outputInItem.addOutMapList(sakiMap);
							
							updateShkSkCkanCdFlg = true;
						}
						else
						{
							if (sosaiFlg)
							{
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ ON");

								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
										"[L][secondSummaryDtl]相殺額追加 0円、相殺残追加（検索元.料金）(" + inRyokin + ")円、集計先追加0円");
								// 相殺額追加（０円）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BigDecimal.ZERO));
								// 相殺残追加（検索元.料金）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, inRyokin));
								// 集計先追加（０円）
								sakiMap = this.setRyokinInfoSecondSosai(tmTmpBean, rknSkiMst, BigDecimal.ZERO);
								outputInItem.addOutMapList(sakiMap);

								sosaiFlg = false;
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ <- OFF");

								updateShkSkCkanCdFlg = false;
							}
						}
					}
					else
					{
						// 集計先追加（サマリ料金）
						sakiMap = this.setRyokinInfoSecondSosai(tmTmpBean, rknSkiMst, sumRyokin);
						outputInItem.addOutMapList(sakiMap);
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計先追加（サマリ料金）(" + sumRyokin + ")");
							
						updateShkSkCkanCdFlg = true;
					}
					
					// 集計先料金項目置換コード更新フラグがtrueの場合
					if(updateShkSkCkanCdFlg)
					{
						// 集計先料金項目置換コード更新
						this.updateShukSkPrcKmkCkanCd(sakiMap, rknSkiMst);
					}
				}
				else
				{
					// 集計先０円時出力識別・集計先丸め方法コードが集計先に入っていない場合セットする
					if ("".equals(srchTmpMap.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD)))
					{
						srchTmpMap.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, tmTmpBean.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD));
					}
					if ("".equals(srchTmpMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD)))
					{
						srchTmpMap.setString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD, tmTmpBean.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD));
					}
					// 相殺料金情報作成
					// 集計先への反映が減算要素の場合
					if (BigDecimal.ZERO.compareTo(ryokin) < 0 || JACStrConst.KAGEN_SKBT_GENSAN.equals(addsubKbn))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計先への反映が減算要素の場合");
						// 集計方法＝「1:全額集計」
						if (JACStrConst.SHUK_WAY_ZEN_SHUK.equals(totalWay))
						{
							// 検索先．料金（サマリ値）
							srchTmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]料金（サマリ値）(" + sumRyokin + ")");

							// 利用開始・終了日更新
							this.updateRiyoStEndDate(srchTmpMap, tmTmpBean);
							
							updateShkSkCkanCdFlg = true;
						}
						// 集計方法「2:限度額まで集計」or「3:集計しない」 かつ 
						// サマリ料金が集計限度額以上
						else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay) || JACStrConst.SHUK_WAY_NOT_SHUK.equals(totalWay))
								&& sumRyokin.compareTo(inGend) >= 0)
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計方法「2:限度額まで集計」or「3:集計しない」" +
									"サマリ料金(" + sumRyokin + ") が集計限度額(" + inGend + ")以上");
							if (sosaiFlg)
							{
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ ON");

								// 相殺額追加（検索元.料金）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAI, inRyokin));
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺額追加（検索元.料金）(" + inRyokin + ")");

								// 検索先．料金（サマリ値）
								srchTmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]検索先．料金（サマリ値）(" + sumRyokin + ")");

								// 利用開始・終了日更新
								this.updateRiyoStEndDate(srchTmpMap, tmTmpBean);
					
								sosaiFlg = false;
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ <- OFF");
							
								updateShkSkCkanCdFlg = true;
							}
						}
						// (集計方法＝「2:限度額まで集計」and 検索先．料金が集計限度額未満) or 
						// (集計方法＝「3:集計しない」    and   サマリ料金が集計限度額未満)
						else if ((JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay) 	&& srchTmpRyokin.compareTo(inGend) < 0) 
								|| (JACStrConst.SHUK_WAY_NOT_SHUK.equals(totalWay) && sumRyokin.compareTo(inGend) < 0))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計方法" 
									+ "(" + totalWay + ")" +  " （2:限度額まで集計）かつ" + "検索先．料金(" + srchTmpRyokin + ") が 集計限度額(" + inGend + ")未満 または");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計方法"
									+ "(" + totalWay + ")" +  " （3:集計しない）かつ" + "サマリ料金(" + sumRyokin + ") が 集計限度額(" + inGend + ")未満 または");

							if (sosaiFlg)
							{
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ ON");

								// 相殺額追加（０円）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAI, BigDecimal.ZERO));
								// 相殺残追加（検索元．料金）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, inRyokin));
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺額追加 0円、相殺残追加（検索元.料金）(" + inRyokin + ")");

								sosaiFlg = false;
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ <- OFF");
								
								updateShkSkCkanCdFlg = false;
							}
						}
						// 限度額まで集計               かつ 
						// 検索先．料金が集計限度額以上 かつ
						//   サマリ料金が集計限度額未満
						else if (JACStrConst.SHUK_WAY_GEND_SHUK.equals(totalWay)
								&& srchTmpRyokin.compareTo(inGend) >= 0
								&& sumRyokin.compareTo(inGend) < 0)
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計方法 2:限度額まで集計 かつ" +
									"検索先．料金(" + srchTmpRyokin + ") が 集計限度額(" + inGend + ")以上 かつ " +
									"サマリ料金(" + sumRyokin + ") が 集計限度額( " + inGend + ") 未満");
							if (sosaiFlg)
							{
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ ON");

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

								// 入力．料金がマイナス値の場合
								if (BigDecimal.ZERO.compareTo(inRyokin) < 0)
								{
									assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]入力．料金がマイナス値の場合(" + inRyokin + ")、" +
											"相殺額の符号反転(" + sosaigaku + ")→(" + sosaigaku.negate() + ")");
									sosaigaku = sosaigaku.negate();
								}
								else
								{
									assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]入力．料金がプラス値の場合(" + inRyokin + ")、" +
											"相殺残の符号反転(" + sosaizan + ")→(" + sosaizan.negate() + ")");
									sosaizan = sosaizan.negate();
								}

								// 相殺額追加（検索先．料金）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAI, sosaigaku));
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺額追加（検索先．料金）(" + sosaigaku + ")");

								// 相殺残追加（サマリ値）
								outputInItem.addOutMapList(this.setRyokinInfoSosai2(tmTmpBean, JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN, sosaizan));
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺残追加（サマリ値）(" + sosaizan + ")");

								// 検索先．料金（０円）
								srchTmpMap.setBigDecimal(JBSbatACIFM116.PRC, inGend);
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]料金(" + inGend + ")");

								sosaiFlg = false;
								assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]相殺済フラグ <- OFF");
							
								updateShkSkCkanCdFlg = true;
							}
						}
					}
					else
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]集計先への反映が減算要素 以外の場合");

						// 検索先．料金（サマリ値）
						srchTmpMap.setBigDecimal(JBSbatACIFM116.PRC, sumRyokin);
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][secondSummaryDtl]検索先．料金（サマリ値）(" + sumRyokin + ")");

						// 利用開始・終了日更新
						this.updateRiyoStEndDate(srchTmpMap, tmTmpBean);
							
						updateShkSkCkanCdFlg = true;
					}
					
					// 集計先料金項目置換コード更新フラグがtrueの場合
					if(updateShkSkCkanCdFlg)
					{
						// 集計先料金項目置換コード更新
						this.updateShukSkPrcKmkCkanCd(srchTmpMap, rknSkiMst);
					}
				}
			}
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][secondSummaryDtl]集計タイミング一致");
		}
	}
	
	/**
	 * 料金情報リスト編集処理（料金情報単純転送）を行います。 <BR>
	 * 
	 * @param inMap 料金情報
	 * @return JBSbatServiceInterfaceMap 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatServiceInterfaceMap setRyokinInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		// 料金情報電文
		JBSbatServiceInterfaceMap retunMap = new JBSbatServiceInterfaceMap();

		// 料金情報エリア
		retunMap.setString(JBSbatACIFM107.SEIKY_KEI_NO, 				inMap.getString(JBSbatACIFM116.SEIKY_KEI_NO));				// 請求先番号
		retunMap.setString(JBSbatACIFM107.SEIKY_YM, 					inMap.getString(JBSbatACIFM116.SEIKY_YM));					// 請求年月
		retunMap.setString(JBSbatACIFM107.SVC_NO, 						inMap.getString(JBSbatACIFM116.SVC_NO));					// サービス番号
		retunMap.setString(JBSbatACIFM107.SVC_SKBT_CD, 					inMap.getString(JBSbatACIFM116.SVC_SKBT_CD));				// サービス識別
		retunMap.setString(JBSbatACIFM107.PCRS_CD, 						inMap.getString(JBSbatACIFM116.PCRS_CD));					// 料金コースコード
		retunMap.setString(JBSbatACIFM107.PRC_SVC_CD, 					inMap.getString(JBSbatACIFM116.PRC_SVC_CD));				// 料金サービスコード
		retunMap.setString(JBSbatACIFM107.PRC_KMK_CD, 					inMap.getString(JBSbatACIFM116.PRC_KMK_CD));				// 料金項目コード
		retunMap.setBigDecimal(JBSbatACIFM107.PRC, 						inMap.getBigDecimal(JBSbatACIFM116.PRC));					// 料金(数量)
		retunMap.setString(JBSbatACIFM107.JIGYOSHA_CD, 					inMap.getString(JBSbatACIFM116.JIGYOSHA_CD));				// 事業者コード
		retunMap.setString(JBSbatACIFM107.JIGYOSHA_KEI_CD, 				inMap.getString(JBSbatACIFM116.JIGYOSHA_KEI_CD));			// 事業者契約コード
		retunMap.setBigDecimal(JBSbatACIFM107.SSN_CNT, 					this.summaryCounter);										// 精算項目件数
		retunMap.setString(JBSbatACIFM107.USE_STAYMD, 					inMap.getString(JBSbatACIFM116.USE_STAYMD)); 				// 利用開始日
		retunMap.setString(JBSbatACIFM107.USE_ENDYMD, 					inMap.getString(JBSbatACIFM116.USE_ENDYMD)); 				// 利用終了日
		retunMap.setString(JBSbatACIFM107.AIT_DIV, 						inMap.getString(JBSbatACIFM116.AIT_DIV)); 					// 相対区分
		retunMap.setString(JBSbatACIFM107.SIME_DAY, 					inMap.getString(JBSbatACIFM116.SIME_DAY)); 					// 締め日
		
		// 退避エリアとして、料金情報リスト内で保持する項目
		retunMap.setString(JBSbatACIFM116.MAEUK_SOSAI_YUSE_JUN, 		inMap.getString(JBSbatACIFM116.MAEUK_SOSAI_YUSE_JUN));		// 前受相殺優先順位
		retunMap.setString(JBSbatACIFM116.SHUK_TANI_CD, 				inMap.getString(JBSbatACIFM116.SHUK_TANI_CD)); 				// 集計単位コード
		retunMap.setString(JBSbatACIFM116.KAGEN_SKBT_CD, 				inMap.getString(JBSbatACIFM116.KAGEN_SKBT_CD)); 			// 加減区分
		retunMap.setString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD, 		inMap.getString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD)); 		// 料金項目出力区分
		retunMap.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, 	inMap.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD));// 集計先０円時出力識別
		retunMap.setString(JBSbatACIFM116.TAX_CALC_SKBT_CD, 			inMap.getString(JBSbatACIFM116.TAX_CALC_SKBT_CD)); 			// 税計算区分
		retunMap.setString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD, 		inMap.getString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD)); 	// 集計先処理タイミング制御
		retunMap.setString(JBSbatACIFM116.SHUK_WAY_CD, 					inMap.getString(JBSbatACIFM116.SHUK_WAY_CD)); 				// 集計方法		
		retunMap.setBigDecimal(JBSbatACIFM116.SHUK_GEND_AMNT, 			inMap.getBigDecimal(JBSbatACIFM116.SHUK_GEND_AMNT));		// 集計限度額
		retunMap.setString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD, 			inMap.getString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD)); 		// 集計元料金項目コード
		retunMap.setString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD, 		inMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD));		// 集計先丸め方法コード
		retunMap.setString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD, 		"");														// 集計先料金項目置換コード

		return retunMap;
	}

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

		map.setString(JBSbatACIFM107.PRC_KMK_CD,
					syukeiMap.getString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD).substring(0, 9) + rknCd_2byte); 		// 集計元料金項目コード（相殺額or相殺残）
		map.setBigDecimal(JBSbatACIFM107.PRC, ryokin);															// 料金
		
		// 退避エリアとして、料金情報リスト内で保持する項目
		map.setString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD, 			JACStrConst.PRC_KMK_OPUT_SKBT_OUT); 		// 料金項目出力区分（出力）		
		map.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, 	JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_OUT); 	// 集計先０円時出力識別（出力）		
		map.setString(JBSbatACIFM116.TAX_CALC_SKBT_CD, 				JACStrConst.TAX_CALC_SKBT_CD_SP); 	 		// 税計算区分
		map.setString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD, 			""); 	 									// 集計元料金項目コード

		return map;
	}

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

		// 料金情報（単純転送）の設定
		JBSbatServiceInterfaceMap map = this.setRyokinInfo(inMap);

		map.setString(JBSbatACIFM107.PRC_KMK_CD, 
				inMap.getString(JBSbatACIFM107.PRC_KMK_CD).substring(0, 9) + rknCd_2byte);			// 料金項目コード（相殺額or相殺残）
		map.setBigDecimal(JBSbatACIFM107.PRC, ryokin);												// 料金
		
		// 退避エリアとして、料金情報リスト内で保持する項目
		map.setString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD, 			JACStrConst.PRC_KMK_OPUT_SKBT_OUT); 			// 料金項目出力区分（出力）		
		map.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, 	JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_OUT); 		// 集計先０円時出力識別（出力）		
		map.setString(JBSbatACIFM116.TAX_CALC_SKBT_CD, 				JACStrConst.TAX_CALC_SKBT_CD_SP); 	 			// 税計算区分
		map.setString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD, 			""); 	 										// 集計元料金項目コード

		return map;
	}

	/**
	 * 料金情報リスト編集処理（集計先追加）を行います。
	 * <BR>
	 * @param inMap  料金情報
	 * @param mstMap 料金集計マスタ
	 * @param ryokin サマリ料金
	 * @return JBSbatServiceInterfaceMap 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatServiceInterfaceMap setRyokinInfoSecondSosai(JBSbatServiceInterfaceMap inMap,
											JBSbatCommonDBInterface mstMap, 
											BigDecimal ryokin) throws Exception
	{
		// 料金情報リスト編集処理（相殺額、相殺残）
		JBSbatServiceInterfaceMap outMap = this.setRyokinInfoSosai2(inMap, "", ryokin);
		String tunit_cd = mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_TANI_CD); // 集計単位	
		
		// サービス番号出力判定
		// 集計単位コード ＝ "1"（サービス番号)の場合
		if (JACStrConst.SHUK_TANI_CD_SVC_NO.equals(tunit_cd))
		{
			// 単純転送のため、処理なし			
		}
		// 集計単位コード ＝  "2"（請求先)の場合
		else if (JACStrConst.SHUK_TANI_CD_SEIKY.equals(tunit_cd))
		{
			outMap.setString(JBSbatACIFM107.SVC_NO,		JACStrConst.SVC_NO_SP); 	// サービス番号(空白埋め）
			outMap.setString(JBSbatACIFM107.PCRS_CD, 	JACStrConst.PCRS_CD_SP);	// 料金コースコード(空白埋め）
		}

		outMap.setString(JBSbatACIFM107.PRC_KMK_CD, 		mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_PRC_KMK_CD)); // 料金項目コード
		
		// 退避エリアとして、料金情報リスト内で保持する項目
		outMap.setString(JBSbatACIFM116.MAEUK_SOSAI_YUSE_JUN, 		mstMap.getString(JBSbatAC_M_PRC_SHUK.MAEUK_SOSAI_YUSEN_JUN));		// 前受相殺優先順位
		outMap.setString(JBSbatACIFM116.SHUK_TANI_CD, 				mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_TANI_CD)); 				// 集計単位コード
		outMap.setString(JBSbatACIFM116.KAGEN_SKBT_CD, 				mstMap.getString(JBSbatAC_M_PRC_SHUK.KAGEN_SKBT_CD)); 				// 加減区分
		outMap.setString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD, 		mstMap.getString(JBSbatAC_M_PRC_SHUK.PRC_KMK_OPUT_SKBT_CD));		// 料金項目出力区分
		outMap.setString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD, mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_0_YEN_OPUT_SKBT_CD));	// 集計先0円時出力識別
		outMap.setString(JBSbatACIFM116.TAX_CALC_SKBT_CD, 			mstMap.getString(JBSbatAC_M_PRC_SHUK.TAX_CALC_SKBT_CD)); 			// 税計算区分
		outMap.setString(JBSbatACIFM116.SHUK_SK_TRN_TMG_CTRL_CD, 	mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_TRN_TMG_CTRL_CD)); 	// 集計先処理タイミング制御
		outMap.setString(JBSbatACIFM116.SHUK_WAY_CD, 				mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_WAY_CD)); 				// 集計方法
		outMap.setBigDecimal(JBSbatACIFM116.SHUK_GEND_AMNT, 		mstMap.getBigDecimal(JBSbatAC_M_PRC_SHUK.SHUK_GEND_AMNT));			// 集計限度額
		outMap.setString(JBSbatACIFM116.SHUK_MT_PRC_KMK_CD, 		mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_MT_PRC_KMK_CD));			// 集計元料金項目コード
		outMap.setString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD, 		mstMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_ROUND_WAY_CD));		// 集計先丸め方法コード

		return outMap;
	}

	/**
	 * 利用開始・終了日更新を行います。
	 * 同ブレイクキー（料金項目単位）内で最新の利用開始・終了日を判定し、再設定します
	 * <BR>
	 * @param sakiMap 検索先.料金情報
	 * @param motoMap 検索元.料金情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void updateRiyoStEndDate(JBSbatServiceInterfaceMap sakiMap, JBSbatServiceInterfaceMap motoMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updateRiyoStEndDate]利用開始・終了日更新 の実施");
		
		String sakiRiyoStDate 	= sakiMap.getString(JBSbatACIFM116.USE_STAYMD); 	// 検索先.利用開始日
		String sakiRiyoEndDate 	= sakiMap.getString(JBSbatACIFM116.USE_ENDYMD); 	// 検索先.利用終了日
		String motoRiyoStDate 	= motoMap.getString(JBSbatACIFM116.USE_STAYMD); 	// 検索元.利用開始日
		String motoRiyoEndDate 	= motoMap.getString(JBSbatACIFM116.USE_ENDYMD); 	// 検索元.利用終了日

		// 利用開始日更新判定
		// 検索先.利用開始日＝スペースの場合
		if (ALL_SPACE_8.equals(sakiRiyoStDate))
		{
			sakiMap.setString(JBSbatACIFM116.USE_STAYMD, motoRiyoStDate);
		}
		// 検索元.利用開始日＝スペースの場合
		else if (ALL_SPACE_8.equals(motoRiyoStDate))
		{
			//何も行わない。
		}
		else
		{
			// 検索先.利用開始日（数値）
			int numSakiRiyoStDate = 0;
			if(!JACStrConst.KARA_MOJI.equals(sakiRiyoEndDate))
			{
				numSakiRiyoStDate = Integer.parseInt(sakiRiyoStDate);
			}
			
			// 検索元.利用開始日（数値）
			int numMotoRiyoStDate = 0;
			if(!JACStrConst.KARA_MOJI.equals(sakiRiyoEndDate))
			{
				numMotoRiyoStDate = Integer.parseInt(motoRiyoStDate);
			}
			
			// 検索先.利用開始日＞検索元.利用開始日の場合
			if (numSakiRiyoStDate > numMotoRiyoStDate)
			{
				sakiMap.setString(JBSbatACIFM116.USE_STAYMD, motoRiyoStDate);
			}
		}

		// 利用終了日更新判定
		// 検索先.利用終了日＝スペース
		if (ALL_SPACE_8.equals(sakiRiyoEndDate))
		{
			sakiMap.setString(JBSbatACIFM116.USE_ENDYMD, motoRiyoEndDate);
		}
		// 検索元.利用終了日＝スペース
		else if (ALL_SPACE_8.equals(motoRiyoEndDate))
		{
			// 何も行わない。
		}
		else
		{
			// 検索先.利用終了日（数値）
			int numSakiRiyoEndDate = 0;
			if(!JACStrConst.KARA_MOJI.equals(sakiRiyoEndDate))
			{
				numSakiRiyoEndDate = Integer.parseInt(sakiRiyoEndDate);
			}
			
			// 検索元.利用終了日（数値）
			int numMotoRiyoEndDate = 0;
			if(!JACStrConst.KARA_MOJI.equals(motoRiyoEndDate))
			{
				numMotoRiyoEndDate = Integer.parseInt(motoRiyoEndDate);
			}
			
			// 検索先.利用終了日＜検索元.利用終了日
			if (numSakiRiyoEndDate < numMotoRiyoEndDate)
			{
				sakiMap.setString(JBSbatACIFM116.USE_ENDYMD, motoRiyoEndDate);
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updateRiyoStEndDate]");
	}

	/**
	 * 集計先料金項目置換コード更新を行います。
	 * <BR>
	 * @param sakiMap    検索先.料金情報
	 * @param rknSkiMst  検索元.料金情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void updateShukSkPrcKmkCkanCd(JBSbatServiceInterfaceMap sakiMap, JBSbatCommonDBInterface rknSkiMst) throws Exception
	{
		if (JACBatCommon.isNull(sakiMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD)) 
				&& rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_PRC_KMK_CKAN_CD) != null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updateShukSkPrcKmkCkanCd]集計先料金項目置換コード更新 の実施　"
					+ "更新後料金項目コード (" + rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_PRC_KMK_CKAN_CD) + ")");

			sakiMap.setString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD, rknSkiMst.getString(JBSbatAC_M_PRC_SHUK.SHUK_SK_PRC_KMK_CKAN_CD));
		}
	}

	/**
	 * キー情報取得処理を行います。 
	 * <BR>
	 * @param inMap 料金集計情報
	 * @return String[] キー情報<BR>
	 * 			[0]：請求年月＋請求先番号＋集計単位コード＋サービス番号＋料金コースコード＋料金項目コード<BR>
	 * 			[1]：請求年月＋請求先番号＋集計単位コード＋（※　サービス番号＋料金コースコード）<BR>
	 * 				 ※集計単位コード＝1:回線（サービス番号）の場合）<BR>
	 * 			[2]：集計単位<BR>
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String[] getKeyArray(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		String[] returnStr = new String[3];

		// ブレイクキー（入力．料金項目単位(退避．キー１)）の設定
		StringBuffer sKeyBuf = new StringBuffer();
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.SEIKY_YM)); 		// 請求年月
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.SEIKY_KEI_NO)); 	// 請求先番号
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.SHUK_TANI_CD)); 	// 集計単位コード
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.SVC_NO)); 		// サービス番号
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.PCRS_CD)); 		// 料金コースコード
		sKeyBuf.append(inMap.getString(JBSbatACIFM116.PRC_KMK_CD)); 	// 料金項目コード
//		sKeyBuf.append(inMap.getString(JBSbatACIFM116.USE_STAYMD)); 	// 利用開始日
		returnStr[0] = sKeyBuf.toString(); 								// ブレイクキー（入力．集計単位）

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKeyArray]請求年月       (" + inMap.getString(JBSbatACIFM116.SEIKY_YM) + ")" +
																				"請求先番号      (" + inMap.getString(JBSbatACIFM116.SEIKY_KEI_NO) + ")" +
																				"集計単位コード  (" + inMap.getString(JBSbatACIFM116.SHUK_TANI_CD) + ")" +
																				"サービス番号    (" + inMap.getString(JBSbatACIFM116.SVC_NO) + ")" +
																				"料金コースコード(" + inMap.getString(JBSbatACIFM116.PCRS_CD) + ")" +
																				"料金項目コード  (" + inMap.getString(JBSbatACIFM116.PRC_KMK_CD) + ")");
		
		// ブレイクキー（入力．タイミング単位(退避．キー２)）の設定
		StringBuffer tKeyBuf = new StringBuffer();
		tKeyBuf.append(inMap.getString(JBSbatACIFM116.SEIKY_YM)); 			// 請求年月
		tKeyBuf.append(inMap.getString(JBSbatACIFM116.SEIKY_KEI_NO)); 		// 請求先番号
		tKeyBuf.append(inMap.getString(JBSbatACIFM116.SHUK_TANI_CD)); 		// 集計単位コード

		// サービス番号の設定判定
		// 集計単位コード＝1:回線（サービス番号）」の場合
		if (JACStrConst.SHUK_TANI_CD_SVC_NO.equals(inMap.getString(JBSbatACIFM116.SHUK_TANI_CD)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKeyArray]集計単位コード＝1:回線（サービス番号）の場合");
			tKeyBuf.append(inMap.getString(JBSbatACIFM116.SVC_NO));
			tKeyBuf.append(inMap.getString(JBSbatACIFM116.PCRS_CD));
		}

		returnStr[1] = tKeyBuf.toString(); 							// ブレイクキー（入力．タイミング単位）
		returnStr[2] = inMap.getString(JBSbatACIFM116.SHUK_TANI_CD); // ブレイクキー（入力．タイミング単位・集計単位）

		return returnStr;
	}

	/**
	 * 料金集計マスタ情報取得処理を行います。 <BR>
	 * 
	 * @return HashMap 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Map<String, List<JBSbatCommonDBInterface>> getRknSyukeiMst() throws Exception
	{

		// 対象キーの設定
		JBSbatCommonDBInterface dbSelectList = new JBSbatCommonDBInterface();
		// パラメタ設定
		dbSelectList.setValue(super.systemCode); 	// サブシステムコード
		dbSelectList.setValue(super.opeDate);		// 運用日

		// SELECT文発行
		executeAC_M_PRC_SHUK_AC_SELECT_002(dbSelectList.getList().toArray());

		// 結果を取得
		JBSbatCommonDBInterface dbMap = this.db_AC_M_PRC_SHUK.selectNext();
		
		// 検索結果をHashMapに設定
		Map<String, List<JBSbatCommonDBInterface>> rtnMap = new HashMap<String, List<JBSbatCommonDBInterface>>();
		
		// 検索結果がないときは、初期状態のHashMapを返却
		if(dbMap == null)
		{
			return rtnMap;
		}
		
		// キーの取得
		String tmpKey = getKeyByDBMap(dbMap);

		// 検索結果格納配列
		List<JBSbatCommonDBInterface> list = new ArrayList<JBSbatCommonDBInterface>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// キーの取得
			String inKey = getKeyByDBMap(dbMap);;
			
			// キーが同じ場合
			if (tmpKey.equals(inKey))
			{
				list.add(dbMap);
			}
			// キーブレイク時
			else
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRknSyukeiMst] キーブレイクinKey：" + inKey);
				
				rtnMap.put(tmpKey, list);	// HashMapへ設定
				tmpKey = inKey;				// 退避キーの置き換え

				list = new ArrayList<JBSbatCommonDBInterface>();		// listを初期化し、現在の検索結果を設定
				list.add(dbMap);
			}

			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRknSyukeiMst] dbMap：" + dbMap.getMap().toString());
			
			// 次レコード取得
			dbMap = this.db_AC_M_PRC_SHUK.selectNext();
		}

		// 最終のlistをMapに判定
		rtnMap.put(tmpKey, list);

		return rtnMap;
	}
	
	/**
	 * 料金集計マスタ検索処理を行います。 <BR>
	 * 初期処理で取得したHashMapより、inMapから組み立てたキーを用いて、検索します。
	 * 
	 * @param inMap 料金情報
	 * @param aitaiFlg 請求契約番号空白検索確定フラグ
	 * @return ArrayList 出力情報（JBSbatCommonDBInterfaceの配列）
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private List<JBSbatCommonDBInterface> getRknSyukeiMst(JBSbatServiceInterfaceMap inMap, boolean aitaiFlg) throws Exception
	{
		// キーの取得
		String inKey = getKeyByInMap(inMap, aitaiFlg);
		
		List<JBSbatCommonDBInterface> list = this.rknSyukeiDB.get(inKey);

		return list;
	}
	
	/**
	 * 料金集計情報のキーを取得します。 <BR>
	 * キー ： 相対番号 ＋ 料金項目コード
	 * 
	 * @param inMap 料金集計情報
	 * @param aitaiFlg 請求契約番号空白検索確定フラグ
	 * @return String キー
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String getKeyByInMap(JBSbatServiceInterfaceMap inMap, boolean aitaiFlg) throws Exception
	{
		// キーの取得
		StringBuffer inKeyBuf = new StringBuffer();
		
		// 相対区分="2"（請求先相対契約）の場合
		if (aitaiFlg && JACStrConst.AITAIKBN_SEIKYU.equals(inMap.getString(JBSbatACIFM116.AIT_DIV)))
		{
			inKeyBuf.append(inMap.getString(JBSbatACIFM116.SEIKY_KEI_NO));	// 請求先番号
		}
		// 相対区分="3"（サービス相対契約）の場合
		else if (aitaiFlg && JACStrConst.AITAIKBN_SVC.equals(inMap.getString(JBSbatACIFM116.AIT_DIV)))
		{
			inKeyBuf.append(inMap.getString(JBSbatACIFM116.SVC_NO).substring(0, JACStrConst.AITAI_NO_LENGTH));	// サービス番号
		}
		else
		{
			inKeyBuf.append(JACStrConst.AITAI_NO_SP);					// 相対番号（ALLスペース）
		}
		
		inKeyBuf.append(inMap.getString(JBSbatACIFM116.PRC_KMK_CD));		// 料金項目コード
		
		String rtnKey = inKeyBuf.toString();
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKeyByInMap]rtnKey(" + rtnKey +  ")");
		
		return rtnKey;
	}
	
	/**
	 * 料金集計マスタのキーを取得します。 <BR>
	 * キー ： 相対番号 ＋ 集計元料金項目コード
	 * 
	 * @param dbMap 料金集計マスタ
	 * @return String キー
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String getKeyByDBMap(JBSbatCommonDBInterface dbMap) throws Exception
	{
		// キーの取得
		StringBuffer inKeyBuf = new StringBuffer();
		inKeyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SHUK.AITAI_NO));	// 相対番号
		inKeyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SHUK.SHUK_MT_PRC_KMK_CD));	// 集計元料金項目コード
		
		String rtnKey = inKeyBuf.toString();
		
		return rtnKey;
	}
	
	/**
	 * 小数点第一位による丸め処理を行います。<BR>
	 * @param roundWay 丸め方法 1:四捨五入、2:切り上げ、3:切捨て、左記以外:丸めなし
	 * @param num 丸め処理前の数値
	 * @return BigDecimal 丸め処理後の数値
	 */
	private BigDecimal round(String roundWay, BigDecimal num)
	{
		
		// 四捨五入
		if (JACStrConst.ROUND_OFF.equals(roundWay))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][round]丸め処理 四捨五入(" + num + ")");
			return num.setScale(0, RoundingMode.HALF_UP);
		}
		// 切上げ
		else if (JACStrConst.ROUND_UP.equals(roundWay))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][round]丸め処理 切上げ(" + num + ")");
			return num.setScale(0, RoundingMode.UP);
		}
		// 切捨て
		else if (JACStrConst.ROUND_DOWN.equals(roundWay))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][round]丸め処理 切捨て(" + num + ")");
			return num.setScale(0, RoundingMode.DOWN);
		}
		// 丸めなし
		else
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][round]丸め処理 なし(" + num + ")");
			return num;
		}
	}
	
	/**
	 * 出力確認と出力前判断処理。<BR>
	 * @param tmpMap 出力ファイル
	 * @return Boolean 出力しないときはfalseを返す
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private Boolean outPutCheck(JBSbatServiceInterfaceMap tmpMap) throws Exception
	{

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][outPutCheck]tmpMap：" + tmpMap.getMap().toString());

		// 退避.料金項目出力識別＝「１:未出力」の場合
		if (JACStrConst.PRC_KMK_OPUT_SKBT_MI.equals(tmpMap.getString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][outPutCheck]退避.料金項目出力区分＝「１:未出力」の場合　出力しない");
			return false;
		}
		// 料金が0円の時で退避.料金項目出力識別    ＝「０:0円時未出力」または
		//                退避.集計先０円時出力識別＝「１:未出力」     の場合
		else if (BigDecimal.ZERO.compareTo(tmpMap.getBigDecimal(JBSbatACIFM116.PRC)) == 0
				&& (JACStrConst.PRC_KMK_OPUT_SKBT_0_YEN_MI.equals(tmpMap.getString(JBSbatACIFM116.PRC_KMK_OPUT_SKBT_CD))
				|| JACStrConst.SHUK_SK_0_YEN_OPUT_SKBT_MI.equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_0YENJI_OPUT_SKBT_CD))))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
					"[L][outPutCheck]料金が0円の時で退避.料金項目出力区分＝「０:0円時未出力」または退避.集計先０円時出力識別＝「１:未出力」の場合　　出力しない");
			return false;
		}
		else
		{
			//集計先料金項目置換コード が入っているときは料金項目コードを置き換える
			if(!"".equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD)))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
						"[L][outPutCheck]料金項目コード(" + tmpMap.getString(JBSbatACIFM107.PRC_KMK_CD) + ") <- (" +
						tmpMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD) + ")");
				tmpMap.setString(JBSbatACIFM107.PRC_KMK_CD, tmpMap.getString(JBSbatACIFM116.SHUK_SK_PRC_KMK_CKAN_CD));
			}
			
			if(!"".equals(tmpMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD)))
			{
				//丸め処理
				tmpMap.setBigDecimal(JBSbatACIFM107.PRC, round(tmpMap.getString(JBSbatACIFM116.SHUK_SK_ROUND_WAY_CD), tmpMap.getBigDecimal(JBSbatACIFM107.PRC)));
			}
			// 相殺額、相殺残額を作成する場合は、料金サービスコードを単純転送、それ以外の場合は空
			if(!JACStrConst.PRC_KMK_CD_SBT_SOSAI.equals(tmpMap.getString(JBSbatACIFM107.PRC_KMK_CD).substring(9, 11)) &&
				!JACStrConst.PRC_KMK_CD_SBT_SOSAIZAN.equals(tmpMap.getString(JBSbatACIFM107.PRC_KMK_CD).substring(9, 11)))
			{
				tmpMap.setString(JBSbatACIFM107.PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
			}
			
			// 「サービス番号」に対してトリム→10バイトパディングする処理を追加する。
			String svcNo = JPCEditString.Rtrim(tmpMap.getString(JBSbatACIFM107.SVC_NO));
			svcNo = JACbatRknBusinessUtil.fillHalfSpace(svcNo, JACStrConst.SVC_KEI_NO_LENGTH, true);
			tmpMap.setString(JBSbatACIFM107.SVC_NO, svcNo);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][outPutCheck]出力フラグを「true」にする。");
			
			// 出力フラグを「true」に
			tmpMap.setOutFlg(true);
		}
		return true;

	}
	
	/**▲▲▲▲▲▲メソッド追加 終了▲▲▲▲▲▲*/


	
}