/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatAKSeikyPtnuwsksei
*	ソースファイル名	：JBSbatAKSeikyPtnuwsksei.java
*	作成者				：富士通　
*	作成日				：2012年07月21日
*＜機能概要＞
*　請求パターン内訳情報作成部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2012/07/21   富士通		新規作成
*	v4.00.00	2013/03/06   FJ）高橋	長期継続割引制度対応
*	v4.00.01	2013/04/10   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応
*	v4.00.02	2013/04/20   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 違約金パターン判定条件変更漏れ対応
*	v4.00.03	2013/05/08   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 利用不可期間減額判定の条件変更対応
*	v5.00.00	2013/07/05   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 請求年月内に異動履歴が複数ある場合、継続分以外はスキップしないように変更
*	v5.00.01	2013/07/15   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 課金開始前解約時の想定料金0円化対応
*	v5.00.02	2013/07/23   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 月中利用日数依存パターン内訳作成抑止対応
*	v5.00.03	2013/07/29   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 割引適用対象契約の旧履歴読み飛ばし対応
*	v5.00.04	2013/08/14   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 定額料金パターン・利用不可期間減額の算出元を想定料金に修正
*	v5.00.05	2013/09/17   FJ) 前田	【OM-2013-0001968】課金開始前解約対応改善
*	v9.00.00	2014/05/15   FJ) 高橋	【ANK-2056-00-00】光電話セレクトオプションパック対応
*	v15.00.00	2015/08/20   FJ) 高橋	【ANK-2163-00-00】【ＮＯ．１５５７】課金終了日以降にも利用不可期間減額を適用
*********************************************************************/
package eo.business.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;

import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatParamUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JACbatSchdlUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCHbatSeikyKaknoBusinessUtil;
import eo.business.util.file.JBSbatAKIFM003;
import eo.business.util.file.JBSbatAKIFM004;
import eo.business.util.table.JBSbatAK_M_SEIKY_PTN_UW;
import eo.business.util.table.JBSbatAK_M_SOTEI_PRC;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_CS_CHGE;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.common.constant.JACStrConst;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatDateUtil;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatAKSeikyPtnuwsksei extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(請求パターン内訳)*/
	private static final String D_TBL_NAME_AK_M_SEIKY_PTN_UW = "AK_M_SEIKY_PTN_UW";

	/** テーブル(想定料金)*/
	private static final String D_TBL_NAME_AK_M_SOTEI_PRC = "AK_M_SOTEI_PRC";

	/** テーブル(サービス契約)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI = "KK_T_SVC_KEI";

	/** テーブル(料金項目抽出変換)*/
	private static final String D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE = "CH_M_PRC_KMK_CS_CHGE";

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

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

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

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

	/** テーブルアクセスクラス(請求パターン内訳)*/
	private JBSbatSQLAccess db_AK_M_SEIKY_PTN_UW = null;

	/** テーブルアクセスクラス(想定料金)*/
	private JBSbatSQLAccess db_AK_M_SOTEI_PRC = null;

	/** テーブルアクセスクラス(サービス契約)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI = null;

	/** テーブルアクセスクラス(料金項目抽出変換)*/
	private JBSbatSQLAccess db_CH_M_PRC_KMK_CS_CHGE = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/** 請求収納業務共通クラス */
	JCHbatSeikyKaknoBusinessUtil chUtil = null;
	
	/** 0（比較用） */
	private static final String ZERO = "0";
	
	/** 請求契約番号＿桁数 */
	private static final int SEIKY_KEI_NO_LENGTH 	= 10;

	/** サービス契約番号＿桁数 */
	private static final int SVC_KEI_NO_LENGTH 		= 10;

	/** サービス契約内訳番号＿桁数 */
	private static final int SVC_KEI_UCWK_NO_LENGTH 	= 12;

	/** オプションサービス契約番号＿桁数 */
	private static final int OP_SVC_KEI_NO_LENGTH 	= 12;

	/** サブオプションサービス契約番号＿桁数 */
	private static final int SBOP_SVC_KEI_NO_LENGTH 	= 12;

	/** 機器提供サービス契約番号＿桁数 */
	private static final int KKTK_SVC_KEI_NO_LENGTH 	= 12;

	/** 請求オプションサービス契約番号＿桁数 */
	private static final int SEIOPSVC_KEI_NO_LENGTH 	= 12;
	
	/** 割引サービス契約番号＿桁数 */
	private static final int WRIB_SVC_KEI_NO_LENGTH 	= 12;
	
	/** 予約適用年月日＿桁数 */
	private static final int RSV_APLY_YMD_LENGTH 	= 8;
	
	/** 世代登録年月日時分秒＿桁数 */
	private static final int GENE_ADD_DTM_LENGTH 	= 17;

	/** 利用不可期間減額用存在チェックレベルコード */
	private String rfkgySzchkLvCd = null;
	
	/** 利用不可期間減額用金額チェックレベルコード */
	private String rfkgyAmchkLvCd = null;
	
	/** 退避．請求年月 */
	private String tmpSeikyYm = null;
	
	/** 退避．月初日 */
	private String tmpMonStaDay = null;
	
	/** 退避．月末日 */
	private String tmpMonEndDay = null;
	
	/** 退避．料金計算日 */
	private String tmpEventYmd = null;
	
	/** 退避．請求年月の暦日数 */
	private BigDecimal tmpCalDay = BigDecimal.ZERO;
	
	/** 請求パターン内訳ＭＡＰ */
	private HashMap<String, ArrayList<JBSbatCommonDBInterface>> seikyPtnUwMap = null;
	
	/** 退避．想定料金マップ */
	private HashMap<String, ArrayList<JBSbatCommonDBInterface>> tmpSoteiPrcMap = null;
	
	/** 退避．料金コースコード */
	private String chrgStaBfDslPrcsCd = null;
	
	/** 退避．料金コースコード */
	private String chrgStaBfDslPrcSvcCd = null;
	
	/** 処理フラグ */
	private boolean tranFlg = true;
	
	/** 処理フラグ(割引用保存) */
	private boolean tranFlgWribSave = true;
	
	/** 契約状態履歴フラグ */
	private boolean keiStatRkFlg = true;
	
	/** 回復履歴フラグ */
	private boolean kaihkRkFlg = false;
	
	/** 課金開始前解約フラグ */
	private boolean chrgStaBfDslFlg = false;
	
	/** 固定値：日付差分フラグ（両日付を差に含める） */
	private static final String DIFF_NAI_FLG 		= "1";
	
	/** 退避キー */
	private String bkKey 		= null;
	
	/** 退避割引契約キー */
	private String bkWkeiKey 		= null;
	
	/** ワーク．出力フラグ */
	private int outFlg = 0;
	
	/** ワーク．利用不可想定金額 */
	private BigDecimal tmpUseFailSoteiAmnt = null;
	
	/** ワーク．利用不可料金項目コード */
	private String tmpWkUseFailPrcKmkCd = null;
	
	/** ワーク．利用不可出力フラグ */
	private boolean tmpWkUseFailOutFlg = false;
	
	/** ワーク．サービス課金終了月の月末日 */
	private String svcChrgEndMnEndYmd = null;

	/** ワーク．解約起算日 */
	private String svcDslKisanYmd = null;
	
	/** ワーク．対象期間の開始日 */
	private String trgtPrdStaYmd = null;
	
	/** ワーク．対象期間の終了日 */
	private String trgtPrdEndYmd = null;
	
	/** 固定値．サービス開始年月日（開始前解約用） */
	private static final String SVC_STA_YMD_STA_BF_DSL = "20010101";
	
	/** 固定値：1（編集用の値） */
	private static final int INT_ONE = 1;

	/** 固定値：1 */
	private static final BigDecimal ONE = new BigDecimal("1");
	
	/** 固定値：-1（編集用の値） */
	private static final int INT_MINUS_ONE = -1;

	/** 固定値：-1 */
	private static final BigDecimal MINUS_ONE = new BigDecimal("-1");
	
	/** 料金プランコード */
	private String pPlanCd = null;
	
	/** 業務機能識別コード */
	private String workKinoSkbtCd = null;
	
	/** 料金項目コード（請求書発行手数料） */
	private String outPrcKmkCd = null;
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_AK_M_SEIKY_PTN_UW = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AK_M_SEIKY_PTN_UW);
		db_AK_M_SOTEI_PRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AK_M_SOTEI_PRC);
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_CH_M_PRC_KMK_CS_CHGE = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		
		// 請求パターン内訳ＭＡＰ作成
		seikyPtnUwMapmake();
		
		// 想定料金ＭＡＰP作成
		this.makeSoteiPrcMap();
		
		// 請求年月・月初日・月末日・料金計算日・暦日数取得
		this.getSchdlInfo();
		
		// 業務パラメータ取得
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		this.rfkgySzchkLvCd = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_RFKGY_SZCHK_LV_CD); 	// 利用不可期間減額用存在チェックレベルコード
		this.rfkgyAmchkLvCd = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_RFKGY_AMCHK_LV_CD); 	// 利用不可期間減額用金額チェックレベルコード
		this.workKinoSkbtCd = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_WKS_MON_NM_SEIHK); 	// 請求書発行手数料
		paramUtil.close();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][利用不可期間減額用存在チェックレベルコード：" + rfkgySzchkLvCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][利用不可期間減額用金額チェックレベルコード：" + rfkgyAmchkLvCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][請求書発行手数料-業務機能識別コード：" + workKinoSkbtCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial]");
		
		// 料金項目抽出変換取得
		this.getPrcKmkCsChge();
		
		chUtil = new JCHbatSeikyKaknoBusinessUtil(commonItem);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param inMap　入力電文
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][inMap = " + inMap.getMap().toString() + "]") : true;
		
		JBSbatOutputItem outputItem = new JBSbatOutputItem();
		
		// キー設定・処理判定
		tranJudge(inMap);
		if(!tranFlg)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute][処理フラグ=FALSE のため、主処理を抜ける]");
			return null;
		}

		// 請求パターン内訳マスタ抽出
		ArrayList<JBSbatCommonDBInterface> seikyPtnUwList = seikyPtnUwMap.get(inMap.getString(JBSbatAKIFM003.SEIKY_PTN_CD));

		if(seikyPtnUwList != null)
		{		
			JBSbatCommonDBInterface dbMap = new JBSbatCommonDBInterface();
			for(JBSbatCommonDBInterface tmpMap : seikyPtnUwList)
			{
				outFlg = 1;
				tmpWkUseFailOutFlg = false;

				dbMap.getMap().putAll(tmpMap.getMap());
				
				// 請求パターン内訳情報作成
				seikyPtnUwInfoMake(inMap, dbMap);

				// 想定料金算出
				BigDecimal soteiPrc = soteiPrcCalc(inMap, dbMap);

				// ファイル出力
				if(outFlg != 0)
				{
					makeOutputInfo(inMap, dbMap, soteiPrc, outputItem);
				}
				// 利用不可情報出力
				if(tmpWkUseFailOutFlg)
				{
					makeOutputUseFailInfo(inMap, dbMap, outputItem);
				}
			}
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		return outputItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

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

	/**
	 * SQLKEY(AK_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 executeAK_M_SOTEI_PRC_AK_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

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

	/**
	 * SQLKEY(AK_SELECT_004)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	サービス契約番号
	 *		 	請求年月の月末日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SVC_KEI_AK_SELECT_004(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

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

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

		// DBアクセスを実行します
		db_CH_M_PRC_KMK_CS_CHGE.selectBySqlDefine(paramList, CH_M_PRC_KMK_CS_CHGE_AC_SELECT_008);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	
	/**
	 * 請求パターン内訳マスタを検索して、請求パターンコード毎に請求パターン内訳ＭＡＰを作成します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void seikyPtnUwMapmake() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][seikyPtnUwMapmake]");
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		
		paramList.setValue(super.opeDate);			// バッチ運用日
		paramList.setValue(super.opeDate);			// バッチ運用日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][seikyPtnUwMapmake][paramList=" + paramList.getList().toString() + "]");
		
		// 請求パターン内訳抽出
		executeAK_M_SEIKY_PTN_UW_AK_SELECT_001(paramList.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_AK_M_SEIKY_PTN_UW.selectNext();
		String ptnCd = null;
		String bkPtnCd = null;
		seikyPtnUwMap = new HashMap<String, ArrayList<JBSbatCommonDBInterface>>();
		
		ArrayList<JBSbatCommonDBInterface> seikyPtnUwList = null;
		while(dbMap != null)
		{
			ptnCd = dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SEIKY_PTN_CD);
			
			if(!ptnCd.equals(bkPtnCd))
			{
				if(bkPtnCd != null)
				{
					seikyPtnUwMap.put(bkPtnCd, seikyPtnUwList);
				}
				seikyPtnUwList = new ArrayList<JBSbatCommonDBInterface>();
				bkPtnCd = ptnCd;
			}
			
			seikyPtnUwList.add(dbMap);
			
			dbMap = db_AK_M_SEIKY_PTN_UW.selectNext();
		}
		
		seikyPtnUwMap.put(ptnCd, seikyPtnUwList);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][seikyPtnUwMapmake]");
		return;
	}
	
	/**
	 * 想定料金マスタを検索して、
	 * 料金コースコード・料金サービスコード・料金項目コード・支払契約識別コード・下限値・上限値毎に想定料金ＭＡＰを作成します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void makeSoteiPrcMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeSoteiPrcMap]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 想定料金適用開始年月日
		paramList.setValue(super.opeDate);
		// 想定料金適用終了年月日
		paramList.setValue(super.opeDate);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSoteiPrcMap][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeAK_M_SOTEI_PRC_AK_SELECT_002(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_AK_M_SOTEI_PRC.selectNext();
		
		this.tmpSoteiPrcMap = new HashMap<String, ArrayList<JBSbatCommonDBInterface>>();
		ArrayList<JBSbatCommonDBInterface> dbList = new ArrayList<JBSbatCommonDBInterface>();
		
		// 取得出来た場合
		if(dbMap != null)
		{
			// KEY：料金コースコード＋料金サービスコード＋料金項目コード＋ 加入契約支払方式コード＋支払契約識別コード
			String tihKey = makeStr(dbMap.getString(JBSbatAK_M_SOTEI_PRC.PCRS_CD),
					dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_SVC_CD), dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_KMK_CD),
					dbMap.getString(JBSbatAK_M_SOTEI_PRC.KANYU_KEI_PAY_HOSHIKI_CD), dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAY_KEI_SKBT_CD));
			// 取得件数分処理を繰り返す
			while(dbMap != null)
			{
				String key = makeStr(dbMap.getString(JBSbatAK_M_SOTEI_PRC.PCRS_CD), dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_SVC_CD),
					dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_KMK_CD), dbMap.getString(JBSbatAK_M_SOTEI_PRC.KANYU_KEI_PAY_HOSHIKI_CD),
					dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAY_KEI_SKBT_CD));
				// キーが同じ場合、リストに追加
				if(key.equals(tihKey))
				{
					dbList.add(dbMap);	// リストに追加
				}
				else
				{
					this.tmpSoteiPrcMap.put(tihKey, dbList);			// HashMapへ設定
					tihKey = key;										// 退避キーの置き換え
					dbList = new ArrayList<JBSbatCommonDBInterface>();	// 初期化
					dbList.add(dbMap);
				}
				// 次レコード取得
				dbMap = db_AK_M_SOTEI_PRC.selectNext(); 
			}
			this.tmpSoteiPrcMap.put(tihKey, dbList);	// HashMapへ設定
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeSoteiPrcMap]");
		return;
	}
	
	/**
	 * 料金スケジュール定義アクセス部品を使用してスケジュール情報を取得します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getSchdlInfo() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSchdlInfo]");
		
		JACbatSchdlUtil schdlUtil = new JACbatSchdlUtil(commonItem);
		try
		{
			// 請求年月
			this.tmpSeikyYm 		= schdlUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_PRC_CALC_DAY);
			// 月初日[0] 月末日[1]
			String[] ymd 		= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
			this.tmpMonStaDay 	= ymd[0];
			this.tmpMonEndDay 	= ymd[1];
			// 料金計算日
			this.tmpEventYmd 	= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_PRC_CALC_DAY)[1];
			// 請求年月の暦日数
			this.tmpCalDay 		= new BigDecimal(JBSbatDateUtil.dayDiff(this.tmpMonEndDay, this.tmpMonStaDay, DIFF_NAI_FLG));
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月=" + this.tmpSeikyYm + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月初日=" + this.tmpMonStaDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月末日=" + this.tmpMonEndDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][料金計算日=" + this.tmpEventYmd + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月の暦日数=" + this.tmpCalDay + "]");
		}
		finally
		{
			schdlUtil.close();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSchdlInfo]");
		return;
	}
	
	/**
	 * 料金項目抽出変換マスタを検索して料金項目コードを取得します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getPrcKmkCsChge() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPrcKmkCsChge]");
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		
		// 業務機能識別コードを算出する。
		// 業務パラメータ管理より取得した設定値　+　請求年月の月
		this.workKinoSkbtCd = this.workKinoSkbtCd.concat(this.tmpSeikyYm.substring(4, 6));
		
		// システムコード
		paramList.setValue(JACStrConst.SYS_CD_AK);
		// 業務機能識別コード
		paramList.setValue(this.workKinoSkbtCd);
		// 抽出変換コード
		paramList.setValue(JACStrConst.CHSHT_CHG_CD_1);
		// 運用日
		paramList.setValue(super.opeDate);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSoteiPrcMap][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeCH_M_PRC_KMK_CS_CHGE_AC_SELECT_008(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		while(dbMap != null)
		{
			// 料金項目コードを取得する。
			this.outPrcKmkCd = dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][請求書発行手数料の料金項目コード=" + this.outPrcKmkCd + "]");
			
			dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPrcKmkCsChge]");
	}
	
	/**
	 * 入力情報から、キー設定・処理判定を行います。
	 * 
	 * @param inMap 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void tranJudge(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][tranJudge]");
		
		// ワークキー
		String wkKey = this.makeKey(inMap);
		
		// ワーク割引契約キー
		String wkWkeiKey = this.makeWKeiKey(inMap);
		
		// 処理フラグ ← "処理続行"
		tranFlg = true;
		
		// 退避キーエリア　≠　ワークキー　の場合
		if(bkKey == null || !bkKey.equals(wkKey))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" + "退避キーエリア　≠　ワークキー]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][ 退避キーエリア（更新前）：" + bkKey + "]");
			// 退避キーエリア					← ワークキー
			// 課金開始前解約料金コースコード	← 入力．料金コースコード
			// 課金開始前解約料金サービスコース	← 入力．料金サービスコード
			// 契約状態履歴フラグ 				← "ＯＦＦ"
			// 回復履歴フラグ					← "ＯＦＦ"
			// 課金開始前解約フラグ				← "ＯＦＦ"
			bkKey 					= wkKey;
			chrgStaBfDslPrcsCd		= inMap.getString(JBSbatAKIFM003.PCRS_CD);
			chrgStaBfDslPrcSvcCd	= inMap.getString(JBSbatAKIFM003.PRC_SVC_CD);
			keiStatRkFlg	 		= false;
			kaihkRkFlg 				= false;
			chrgStaBfDslFlg			= false;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][ 退避キーエリア（更新後）：" + bkKey + "]");
			
		}
		
		// 入力．料金検証契約状態コードの取得
		String prcknsKeiStatCd = inMap.getString(JBSbatAKIFM003.PRCKNS_KEI_STAT_CD);
		
		// 入力．予約適用年月日　＜　月初日　かつ  契約状態履歴フラグ　＝　"ＯＮ"　かつ
		// 入力．料金検証契約状態コード　＝　"011"（継続月）の場合
		if(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD).compareTo(tmpMonStaDay) < 0 && keiStatRkFlg 
				&& (prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_KEIZK_MON)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" + "入力．予約適用年月日　＜　月初日　かつ " + 
					"契約状態履歴フラグ　＝　ＯＮ　かつ　入力．料金検証契約状態コード　＝　011（継続月）の場合]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][処理フラグ ← スキップ]");
			// 処理フラグ ← "スキップ"
			tranFlg = false;
		}
		
		// 入力．抽出契約識別コード　＝　"80"（割引適用対象契約）　かつ 
		// 契約状態履歴フラグ　＝　"ＯＮ" の場合
		if(inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD).equals(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI) && keiStatRkFlg)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" + "入力．抽出契約識別コード ＝ 割引適用対象契約 かつ" + 
					"契約状態履歴フラグ　＝　ＯＮ　の場合]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][処理フラグ ← スキップ]");
			// 処理フラグ ← "スキップ"
			tranFlg = false;
		}

		
		// 入力．料金検証契約状態コードの上１桁　＝　"0"　の場合
		if(prcknsKeiStatCd.substring(0 , 1).equals(ZERO))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" + "入力．料金検証契約状態コードの上１桁　＝　0]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][契約状態履歴フラグ　←　ＯＮ]");
			keiStatRkFlg = true;
		}
		
		// （入力．料金検証契約状態コード　＝　"091"（申出解約月）　　または
		//                                     "092"（強制解約月）　　または
		//                                     "093"（強制解約月翌月）または
		//                                     "094"（休止中解約月））かつ
		//  回復履歴フラグ                 ＝　"ＯＮ"                 の場合
		if((prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_MOSHIDE_DSL) || prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_KSI_DSL)
				|| prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_KSI_NEXT) || prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_PAUSE_DSL))
				&& kaihkRkFlg)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" + "（入力．料金検証契約状態コード　＝　091（申出解約月）" 
								+ "または 092（強制解約月）または 093（強制解約月翌月）または 094（休止中解約月））かつ　回復履歴フラグ　＝　ＯＮ]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][回復履歴フラグ　←　ＯＦＦ]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][処理フラグ　←　スキップ]");
			kaihkRkFlg 	= false;
			tranFlg 	= false;
		}
		
		// 入力．料金検証契約状態コード　＝　"095"（解約同月回復）　または
		//                                   "096"（解約翌月回復）　の場合
		if(prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_TOGTU_KAIHK) || prcknsKeiStatCd.equals(JACStrConst.PRCKNS_KEI_STAT_CD_NEXT_KAIHK))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][" 
					+ "入力．料金検証契約状態コード　＝　095（解約同月回復）　または 096（解約翌月回復）]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][回復履歴フラグ　←　ＯＮ]");
			kaihkRkFlg 	= true;
		}
		
		String chstKeiSkbCd = inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD);
		String prcsCd = inMap.getString(JBSbatAKIFM003.PCRS_CD);
		String prcSvcCd = inMap.getString(JBSbatAKIFM003.PRC_SVC_CD);
		
		// 課金開始前解約フラグ = "ＯＮ" の場合
		if(chrgStaBfDslFlg)
		{
			// 入力.抽出契約識別コード = "80"(割引適用対象契約) の場合
			if(chstKeiSkbCd.equals(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI))
			{
				inMap.setBigDecimal(JBSbatAKIFM003.USE_DAY_CNT, BigDecimal.ZERO);
			}
			else
			{
				// 課金開始前解約料金コースコード = 入力．料金コースコード かつ
				// 課金開始前解約料金サービスコード = 入力．料金サービスコード の場合
				if(chrgStaBfDslPrcsCd.equals(prcsCd) && chrgStaBfDslPrcSvcCd.equals(prcSvcCd))
				{
					inMap.setBigDecimal(JBSbatAKIFM003.USE_DAY_CNT, BigDecimal.ZERO);
				}
				else
				{
					// 課金開始前解約フラグ = "ＯＦＦ"
					chrgStaBfDslFlg = false;
				}
			}
		}
		
		// プラン課金開始年月日
		String planChrgStaYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);
		
		// プラン課金終了年月日
		String planChrgEndYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);
		
		// 入力．プラン課金開始年月日 > 入力．プラン課金終了年月日 の場合
		if(planChrgStaYmd.compareTo(planChrgEndYmd) > 0)
		{
			// 課金開始前フラグ ← "ＯＮ"
			// 課金開始前解約料金コースコード ← 入力．料金コースコード
			// 課金開始前解約料金サービスコード ← 入力．料金サービスコード
			chrgStaBfDslFlg = true;
			chrgStaBfDslPrcsCd = prcsCd;
			chrgStaBfDslPrcSvcCd = prcSvcCd;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][課金開始前解約："
							+  inMap.getString(JBSbatAKIFM003.SVC_KEI_NO) + "]");
		}
		
		// 入力．抽出契約識別コード　＝　"80"　かつ
		// 退避割引契約キーエリア　≠　ワーク割引契約キー　の場合
		if(chstKeiSkbCd.equals(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI) && (bkWkeiKey == null || !bkWkeiKey.equals(wkWkeiKey)))
		{
			//退避割引契約キーエリア　　←　ワーク割引契約キー
			bkWkeiKey = wkWkeiKey;
			//処理フラグ（割引用保存）　←　処理フラグ
			tranFlgWribSave = tranFlg;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][割引契約関連のキーを保存　退避割引契約キーエリア："
					+  bkWkeiKey + "、処理フラグ（割引用保存）：" + tranFlgWribSave + "]");
			
		}
		
		// 入力．抽出契約識別コード　＝　"80"　かつ
		// 退避割引契約キーエリア　＝　ワーク割引契約キー　の場合
		if(chstKeiSkbCd.equals(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI) && (bkWkeiKey != null && bkWkeiKey.equals(wkWkeiKey)))
		{
			//処理フラグ　←　処理フラグ（割引用保存）
			tranFlg = tranFlgWribSave;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tranJudge][処理フラグ（割引用保存）からの処理フラグ戻し処理を実行]");
		}
		
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][tranJudge]");
		return;
	}
	
	/**
	 * 請求パターン内訳情報を作成します。
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void seikyPtnUwInfoMake(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][seikyPtnUwInfoMake]");
		int dankaiKeteiMotoKmkDiv = Integer.parseInt(dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.DANKAI_KETEI_MOTO_KMK_DIV));
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][seikyPtnUwInfoMake][ 段階決定元項目区分：" + dankaiKeteiMotoKmkDiv + "]");
		
		// 請求パターン内訳の内訳料金サービスコードが空白だった場合
		if(JACStrConst.KARA_MOJI.equals(dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD).trim()))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
					"[L][seikyPtnUwInfoMake][請求パターン内訳の内訳料金サービスコードが空白のため、入力．料金サービスコードを使用");
			// 入力．料金サービスコードを設定
			dbMap.setValue(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD, inMap.getString(JBSbatAKIFM003.PRC_SVC_CD));
		}
		
		// 判定用段階決定元項目値を設定
		switch(dankaiKeteiMotoKmkDiv)
		{
		case 0:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.HANTEI_DANKAI_KMK_VALUE));
			break;
			
		case 1:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.SVC_KEIZOKU_MON_CNT));
			break;
			
		case 2:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.SVC_KEIZOKU_DAY_CNT));
			break;
			
		case 3:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.CHRG_KEIZOKU_MON_CNT));
			break;
			
		case 4:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.CHRG_KEIZOKU_DAY_CNT));
			break;
			
		case 5:
			dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, inMap.getBigDecimal(JBSbatAKIFM003.KEI_CNT));
			break;
			
		default:
			break;
		
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][seikyPtnUwInfoMake][ 判定用段階決定元項目値：" 
						+ dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE) + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][seikyPtnUwInfoMake]");
		return;
	}
	
	
	
	/**
	 * 想定料金を算出します。
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal soteiPrcCalc(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][soteiPrcCalc]");
		
		String ptnPrcUseFlg 		= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.PTN_PRC_USE_FLG);
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		String tkHoshikiKeiNo 		= inMap.getString(JBSbatAKIFM003.TK_HOSHIKI_KEI_NO);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][soteiPrcCalc][パターン料金使用フラグ：" + ptnPrcUseFlg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][soteiPrcCalc][想定金額算出方法コード：" + soteiAmntSnstWayCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][soteiPrcCalc][提供方式契約番号　　　：" + tkHoshikiKeiNo + "]");
		BigDecimal tmpWkSoteiAmnt = null;
		
		if(JACStrConst.PTN_PRC_USE_FLG_ON.equals(ptnPrcUseFlg))
		{
			// パターン料金使用
			tmpWkSoteiAmnt = ptnPrcUse(inMap, dbMap);
		}
		else if(JACStrConst.PTN_PRC_USE_FLG_OFF.equals(ptnPrcUseFlg))
		{
			if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_MANS.equals(soteiAmntSnstWayCd) && !tkHoshikiKeiNo.trim().equals(JACStrConst.KARA_MOJI))
			{
				// マンション定額
				tmpWkSoteiAmnt = BigDecimal.ZERO;
				outFlg = 2;
				
				// 月中利用日数なし時の出力抑止
				if((BigDecimal.ZERO.compareTo(inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT)) >= 0))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][soteiPrcCalc][月中利用日数:0以下のため出力しない]");
					//ワーク．出力フラグに"0(出力しない)"を設定
					outFlg = 0;
				}
			}
			else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_TEIZO.equals(soteiAmntSnstWayCd))
			{
				// 逓増料金パターン
				tmpWkSoteiAmnt = teizoPrcPtn(inMap, dbMap);
			}
			else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNLTY.equals(soteiAmntSnstWayCd)
					|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSM.equals(soteiAmntSnstWayCd)
					|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd)
					|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSD.equals(soteiAmntSnstWayCd))
			{
				// 違約金パターン
				tmpWkSoteiAmnt = pntlyPtn(inMap, dbMap);
			}
			else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_WRBK.equals(soteiAmntSnstWayCd))
			{
				// 割引料金パターン
				tmpWkSoteiAmnt = wrbkPrcPtn(inMap, dbMap);
			}
			else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_KAPWRI1.equals(soteiAmntSnstWayCd)
					|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_KAPWRI2.equals(soteiAmntSnstWayCd)
					|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_KAPWI.equals(soteiAmntSnstWayCd))
			{
				// 割賦割引料金
				tmpWkSoteiAmnt = BigDecimal.ZERO;
				outFlg = 2;
			}
			else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_KAP_PNL.equals(soteiAmntSnstWayCd))
			{
				// 割賦割引料金
				tmpWkSoteiAmnt = BigDecimal.ZERO;
				outFlg = 2;
			}
			else
			{
				// 定額料金パターン
				tmpWkSoteiAmnt = tegakPrcPtn(inMap, dbMap);
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][soteiPrcCalc]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * パターン料金使用
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal ptnPrcUse(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][ptnPrcUse]");
		
		BigDecimal tmpWkSoteiAmnt = null;
		
		String hiwariYh = dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.HIWARI_YH);		// 日割要否
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][日割要否：" + hiwariYh + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][日割前金額：" + dbMap.getBigDecimal(JBSbatAK_M_SEIKY_PTN_UW.PTN_PRC) + "]");
		// （ア）配列情報[]．日割要否 ＝ "1"（日割なし） の場合
		// 判定条件取得
		if(JACStrConst.HIWARI_YH_NON.equals(hiwariYh))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][日割なし]");
			// ワーク．想定金額　←　ワーク．想定料金（そのまま）
			tmpWkSoteiAmnt = dbMap.getBigDecimal(JBSbatAK_M_SEIKY_PTN_UW.PTN_PRC);
		}
		// （イ）上記（ア）以外（"2"（日割あり）） の場合
		else if(JACStrConst.HIWARI_YH_ARI.equals(hiwariYh))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][日割あり]");
			BigDecimal useDayCnt = inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT);		// 月中利用日数
			// ワーク．想定金額　　←　ワーク．請求パターン内訳[n]．パターン料金　×　入力．月中利用日数　÷　ワーク．暦日数　
			tmpWkSoteiAmnt = dbMap.getBigDecimal(JBSbatAK_M_SEIKY_PTN_UW.PTN_PRC).multiply(useDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][日割後金額：" + tmpWkSoteiAmnt + "]");
		}
		// （ウ）端数処理
		{
			String roundWayCd = dbMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][丸め方法コード：" + roundWayCd + "]");
			// （�@）配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
			// （�A）配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
			// （�B）配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
			// （�C）上記（�@）〜（�B）以外（"0"（丸めなし））     の場合
			// 小数点第三位で四捨五入を行う。
			tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(roundWayCd, tmpWkSoteiAmnt, 2);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][丸め処理後金額：" + tmpWkSoteiAmnt + "]");
		}
		// （エ）想定金額算出方法コード = "A1"（料金サービスコード編集）
		{
			String soteiAmntSnstWayCd = dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
			if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PRCSVC.equals(soteiAmntSnstWayCd))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][料金サービスコード編集]");
				// 請求月月末日に有効なサービス契約を取得する。
				getSvcKei(inMap);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][料金プランコード：" + this.pPlanCd + "]");
				// 料金サービスコードの編集を行う。
				if(this.pPlanCd != null)
				{
					dbMap.setValue(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD, this.pPlanCd);
				}
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][ptnPrcUse][想定料金：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][ptnPrcUse]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * サービス契約を取得する。
	 * 
	 * @param inMap 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getSvcKei(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKei]");
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		// サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO));
		// 請求月月末日
		paramList.setValue(this.tmpMonEndDay);
		
		executeKK_T_SVC_KEI_AK_SELECT_004(paramList.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbMap != null)
		{
			this.pPlanCd = padding(dbMap.getString(JBSbatKK_T_SVC_KEI.PPLAN_CD), 12);
			dbMap = db_KK_T_SVC_KEI.selectNext();
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSvcKei]");
	}
	
	/**
	 * 逓増料金パターン
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal teizoPrcPtn(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][teizoPrcPtn]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		
		// �@想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ ワーク退避．内訳料金項目コード
		//      ＋ ワーク退避． 加入契約支払方式コード ＋ 支払契約識別コード（マンション定額以外の場合の固定値）
		String serchKey = makeStr(inMap.getString(JBSbatAKIFM003.PCRS_CD), dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD)
							, dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD), JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO, JACStrConst.PAY_KEI_SKBT_CD_OTHER);
		// 判定条件取得
		BigDecimal hanteiDankaiKmkValue = dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][判定用段階決定元項目値：" + hanteiDankaiKmkValue + "]");
		
		BigDecimal wkTeizoPrc 	= BigDecimal.ZERO;
		BigDecimal wkDankaiUse 	= BigDecimal.ZERO;
		BigDecimal wkDankaiPrc 	= BigDecimal.ZERO;
		
		String hiwariYh = null;
		String roundWayCd = null;
		String useFailAplyWayCd = JACStrConst.KARA_MOJI; 
		String soteiPrcNaiyoCd = JACStrConst.KARA_MOJI;
		
		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);

			for(int i = 0; i <  dbList.size(); i++)
			{

				JBSbatCommonDBInterface soteiMap = dbList.get(i);
				
				if(i == 0)
				{
					hiwariYh = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.HIWARI_YH);
					roundWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
					useFailAplyWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD);
					soteiPrcNaiyoCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][日割要否：" + hiwariYh + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][丸め方法コード：" + roundWayCd + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][利用不可適用方法コード：" + useFailAplyWayCd + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][想定料金内容コード：" + soteiPrcNaiyoCd + "]");
				}
				
				// 判定条件取得
				BigDecimal lowlValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][下限値：" + lowlValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][上限値：" + upplValue + "]");
				
				BigDecimal wkAmount = BigDecimal.ZERO;
				// 段階利用数計算１
				if(upplValue.compareTo(hanteiDankaiKmkValue) <= 0)
				{
					wkAmount = upplValue.subtract(BigDecimal.ONE);
				}
				else if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					wkAmount = hanteiDankaiKmkValue;
				}
				
				// 段階利用数計算２
				if(lowlValue.equals(BigDecimal.ZERO))
				{
					wkDankaiUse = wkAmount;
				}
				else
				{
					wkDankaiUse = wkAmount.subtract(lowlValue).add(BigDecimal.ONE);
				}
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][数量：" + wkAmount + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][段階利用数：" + wkDankaiUse + "]");
				
				BigDecimal soteiPrcTani = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_TANI);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][想定料金単位：" + soteiPrcTani + "]");
				// 想定料金単位 ≠　0 の場合
				if(!BigDecimal.ZERO.equals(soteiPrcTani))
				{
					// ワーク．段階料金　←　（ワーク．段階利用数　÷　想定料金[i]．想定料金単位）(※)　×　想定料金[i]．想定料金
					// 小数点以下の端数は切り上げる。
					wkDankaiPrc = wkDankaiUse.divide(soteiPrcTani, 0,  BigDecimal.ROUND_UP).multiply(soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC));
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][段階料金：" + wkDankaiPrc + "]");
					wkTeizoPrc = wkTeizoPrc.add(wkDankaiPrc);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][逓増料金：" + wkTeizoPrc + "]");
				}
			}
			
			// 日割要否判定（日割計算）
			tmpWkSoteiAmnt = setSoteiAmntSnst(inMap, hiwariYh, roundWayCd, wkTeizoPrc);
			
			// 月中利用日数依存パターン内訳作成抑止処理
			if((BigDecimal.ZERO.compareTo(inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT)) >= 0)
					&& (JACStrConst.SOTEI_PRC_NAIYO_CD_TJPRC_UNISU.equals(soteiPrcNaiyoCd)))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][月中利用日数:0以下かつ、月中利用日数依存パターンのため出力しない]");
				//ワーク．出力フラグに"0(出力しない)"を設定
				outFlg = 0;
			}
			
			// 利用不可期間減額の算出
			// 2015/08/20 ANK-2163-00-00 MOD START
			//makeOutPutDtlUseFailInfo(inMap, dbMap, wkTeizoPrc, useFailAplyWayCd);
			makeOutPutDtlUseFailInfo(inMap, dbMap, wkTeizoPrc, useFailAplyWayCd, hiwariYh);
			// 2015/08/20 ANK-2163-00-00 MOD END
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][想定料金：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][teizoPrcPtn]");
		return tmpWkSoteiAmnt;
	}
	
	
	
	/**
	 * 違約金パターン
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal pntlyPtn(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][pntlyPtn]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		
		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		// サービス課金終了年月日を取得
		String svcChrgEndYmd = inMap.getString(JBSbatAKIFM003.SVC_CHRG_ENDYMD);
		if(JACStrConst.KARA_MOJI.equals(svcChrgEndYmd.trim()))
		{
			// サービス課金終了年月日に値が存在しない場合は、"0":出力しないを設定する。
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][サービス課金終了年月日が存在しないため算出不能]");
			outFlg = 0;
			return BigDecimal.ZERO;
		}
		
		// サービス開始年月日
		String svcStaYmd = null;
		
		// 想定金額算出方法コードが（違約金（サービス開始月基準））または（違約金（サービス開始日基準））の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNLTY.equals(soteiAmntSnstWayCd)
			|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd))
		{
			// サービス開始年月日を取得
			svcStaYmd = inMap.getString(JBSbatAKIFM003.SVC_STA_YMD);
			if(JACStrConst.KARA_MOJI.equals(svcStaYmd.trim()))
			{
				// サービス開始年月日に値が存在しない場合は、"0":出力しないを設定する。
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][サービス開始年月日が存在しないため算出不能]");
				outFlg = 0;
				return BigDecimal.ZERO;
			}
			
		}

		// サービス課金開始年月日
		String svcChrgStaYmd = null;
		
		// 想定金額算出方法コードが（違約金（課金開始月基準））または（違約金（課金開始日基準））の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSM.equals(soteiAmntSnstWayCd)
			|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSD.equals(soteiAmntSnstWayCd))
		{
			// サービス課金開始年月日を取得
			svcChrgStaYmd = inMap.getString(JBSbatAKIFM003.SVC_CHRG_STAYMD);
			if(JACStrConst.KARA_MOJI.equals(svcChrgStaYmd.trim()))
			{
				// サービス開始年月日に値が存在しない場合は、"0":出力しないを設定する。
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][サービス課金開始年月日が存在しないため算出不能]");
				outFlg = 0;
				return BigDecimal.ZERO;
			}			
		}
		
		// 違約金発生コード判定
		if(inMap.getString(JBSbatAKIFM003.PNLTY_HASSEI_CD).equals(JACStrConst.UM_NASHI))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][違約金発生コード：0（違約金なし）");
			outFlg = 0;
			return BigDecimal.ZERO;
		}
		
		// 想定金額算出方法コードが（違約金（サービス開始月基準））または（違約金（課金開始月基準））の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNLTY.equals(soteiAmntSnstWayCd)
			|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSM.equals(soteiAmntSnstWayCd))
		{
			
			// 違約金対象期間判定�T（月基準）
			tmpWkSoteiAmnt =  jdgPnltyTrgtPrd1(inMap, dbMap, svcStaYmd, svcChrgStaYmd, svcChrgEndYmd);
		}
		// 想定金額算出方法コードが（違約金（サービス開始日基準））または（違約金（課金開始日基準））の場合
		else if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd)
				|| JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSD.equals(soteiAmntSnstWayCd))
		{
			// 違約金対象期間判定�U（日基準）
			tmpWkSoteiAmnt =  jdgPnltyTrgtPrd2(inMap, dbMap, svcStaYmd, svcChrgStaYmd, svcChrgEndYmd);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][想定料金：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][pntlyPtn]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 割引料金パターン
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal wrbkPrcPtn(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][wrbkPrcPtn]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		
		// 想定料金マスタ検索
		// �@想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ ワーク退避．内訳料金項目コード
		//      ＋ ワーク退避． 加入契約支払方式コード ＋ 支払契約識別コード（マンション定額以外の場合の固定値）
		String serchKey = makeStr(inMap.getString(JBSbatAKIFM003.PCRS_CD), dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD),
							dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD), JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO, JACStrConst.PAY_KEI_SKBT_CD_OTHER);

		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
			// 判定条件取得
			BigDecimal hanteiDankaiKmkValue = dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);	// ワーク退避．判定用段階決定元項目値

			// 該当なしを設定する。
			boolean existFlg = false;

			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface soteiMap = dbList.get(i);
				// 配列情報[]．下限値 ≦ ワーク退避．判定用段階決定元項目値 
				// かつ 配列情報[]．上限値 ＞ ワーク退避．判定用段階決定元項目値
				// 判定条件取得
				BigDecimal lowlValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][下限値：" + lowlValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][上限値：" + upplValue + "]");
				
				if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					String hiwariYh = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.HIWARI_YH);
					String roundWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
					BigDecimal soteiPrc = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
					String useFailAplyWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD); 
					// 2015/08/20 ANK-2163-00-00 ADD START
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][日割要否：" + hiwariYh + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][丸め方法コード：" + roundWayCd + "]");
					// 2015/08/20 ANK-2163-00-00 ADD END
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][利用不可適用方法コード：" + useFailAplyWayCd + "]");
					// 想定料金算出
					// 日割要否判定（日割計算）
					tmpWkSoteiAmnt = setSoteiAmntSnst(inMap, hiwariYh, roundWayCd, soteiPrc);
					
					// 月中利用日数依存パターン内訳作成抑止対応
					if((BigDecimal.ZERO.compareTo(inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT)) >= 0)
							&& (JACStrConst.SOTEI_PRC_NAIYO_CD_WPRC_UNISU.equals(soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD))))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][月中利用日数:0以下かつ、月中利用日数依存パターンのため出力しない]");
						//ワーク．出力フラグに"0(出力しない)"を設定
						outFlg = 0;
					}
					
					// 利用不可期間減額の算出
					// 2015/08/20 ANK-2163-00-00 MOD START
					//makeOutPutDtlUseFailInfo(inMap, dbMap, soteiPrc, useFailAplyWayCd);
					makeOutPutDtlUseFailInfo(inMap, dbMap, soteiPrc, useFailAplyWayCd, hiwariYh);
					// 2015/08/20 ANK-2163-00-00 MOD END
					
					// 該当ありの場合、trueを設定する。
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][該当あり]");
					existFlg = true;
				}
			}
			
			// 該当あり、該当なしを判定し該当内の場合は出力フラグに"0":出力しないを設定する。
			if(!existFlg)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][該当なし]");
				outFlg = 0;
			}
		}
		else
		{
			// 想定料金マスタに存在しない場合は、"0":出力しないを設定する。
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][マスタに未存在]");
			outFlg = 0;
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][wrbkPrcPtn][想定料金：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][wrbkPrcPtn]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 定額料金パターン
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal tegakPrcPtn(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][tegakPrcPtn]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		BigDecimal tmpWkSoteiPrc = BigDecimal.ZERO;
		String tmpUseFailAplyWayCd = null;

		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		// 想定金額算出方法コードが（パック割引利用料内訳諸元）の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PWFUWSG.equals(soteiAmntSnstWayCd))
		{
			// サービス契約内訳番号
			String svcKeiUcwkNo 	= inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO);
			
			// サービス契約内訳番号がnull もしくは空文字の場合
			if((null == svcKeiUcwkNo)  || JACStrConst.KARA_MOJI.equals(svcKeiUcwkNo.trim()))
			{
				// 想定金額算出方法コードが（パック割引利用料内訳諸元）の場合は、"0":出力しないを設定する。
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
						"[L][tegakPrcPtn][想定金額算出方法コードが（パック割引利用料内訳諸元）の場合は出力しない。]");
				outFlg = 0;
				return BigDecimal.ZERO;
			}
		}
		
		// 想定料金マスタ検索
		// �@想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ ワーク退避．内訳料金項目コード
		//      ＋ ワーク退避． 加入契約支払方式コード ＋ 支払契約識別コード（マンション定額以外の場合の固定値）
		String serchKey = makeStr(inMap.getString(JBSbatAKIFM003.PCRS_CD), dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD)
							, dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD), JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO, JACStrConst.PAY_KEI_SKBT_CD_OTHER);

		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
			// 判定条件取得
			BigDecimal hanteiDankaiKmkValue = dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);	// ワーク退避．判定用段階決定元項目値
			
			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface soteiMap = dbList.get(i);
				// 配列情報[]．下限値 ≦ ワーク退避．判定用段階決定元項目値 
				// かつ 配列情報[]．上限値 ＞ ワーク退避．判定用段階決定元項目値
				// 判定条件取得
				BigDecimal lowlValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][下限値：" + lowlValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][上限値：" + upplValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][判定用段階決定元項目値：" + hanteiDankaiKmkValue + "]");
				
				if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					String hiwariYh = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.HIWARI_YH);
					String roundWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
					
					// 休止判定
					if(this.isSetPauseJdg(inMap, soteiMap))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][休止フラグ：true]");
						// ワーク．想定料金               ← 配列情報[]．想定休止料金
						// ワーク．利用不可適用方法コード ← 配列情報[]．休止利用不可適用方法コード
						// ワーク退避．内訳料金項目コード ← 配列情報[]．想定休止料金項目コード
						tmpWkSoteiPrc 			= soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC);		// 想定休止料金;
						tmpUseFailAplyWayCd 	= soteiMap.getString(JBSbatAK_M_SOTEI_PRC.PAUSE_USE_FAIL_APLY_WAY_CD);
						dbMap.setValue(JBSbatAKIFM004.UW_PRC_KMK_CD, soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC_KMK_CD));
					}
					else
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][休止フラグ：false]");
						tmpWkSoteiPrc 		= soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
						tmpUseFailAplyWayCd 	= soteiMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD);
					}
					// 2015/08/20 ANK-2163-00-00 ADD START
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][日割要否：" + hiwariYh + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][丸め方法コード：" + roundWayCd + "]");
					// 2015/08/20 ANK-2163-00-00 ADD END
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][想定料金[日割計算前]：" + tmpWkSoteiPrc + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][利用不可適用方法コード：" + tmpUseFailAplyWayCd + "]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][内訳料金項目コード："
																								+ dbMap.getValue(JBSbatAKIFM004.UW_PRC_KMK_CD) + "]");
					
					// 想定料金算出
					// 日割要否判定（日割計算）
					tmpWkSoteiAmnt = setSoteiAmntSnst(inMap, hiwariYh, roundWayCd, tmpWkSoteiPrc);
					
					// パケット通信料（無料通信分）端数処理
					// 想定料金ＭＡＰ．想定料金内容コード　＝　"4"（パケット通信料（無料通信分））　の場合
					if(JACStrConst.SOTEI_PRC_NAIYO_CD_PCTTSP_MRYO.equals(soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD)))
					{
						// 小数点第一位以下を切り捨て
						tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, tmpWkSoteiAmnt, 0);
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][パケット通信料（無料通信分）のため小数点第一位以下を切り捨て]");
					}
					
					// 月中利用日数依存パターン内訳作成抑止対応
					if((BigDecimal.ZERO.compareTo(inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT)) >= 0)
							&& (JACStrConst.SOTEI_PRC_NAIYO_CD_TJPRC_UNISU.equals(soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD))))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][teizoPrcPtn][月中利用日数:0以下かつ、月中利用日数依存パターンのため出力しない]");
						//ワーク．出力フラグに"0(出力しない)"を設定
						outFlg = 0;
					}
					
					// 利用不可期間減額の算出
					// 2015/08/20 ANK-2163-00-00 MOD START
					//makeOutPutDtlUseFailInfo(inMap, dbMap, tmpWkSoteiPrc, tmpUseFailAplyWayCd);
					makeOutPutDtlUseFailInfo(inMap, dbMap, tmpWkSoteiPrc, tmpUseFailAplyWayCd, hiwariYh);
					// 2015/08/20 ANK-2163-00-00 MOD END
					
				}
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][tegakPrcPtn][想定料金：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][tegakPrcPtn]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 配列情報[]．日割要否、丸め方法コードの設定に従い、ワーク．想定金額を算出します。
	 * 
	 * @param inMap 入力情報
	 * @param hiwariYh 日割要否
	 * @param roundWayCd 丸め方法コード
	 * @param tmpAmnt 編集前想定料金
	 * @return tmpWkSoteiAmnt 編集後想定料金
	 * @throws Exception
	 */
	private BigDecimal setSoteiAmntSnst(JBSbatServiceInterfaceMap inMap, String hiwariYh, String roundWayCd, BigDecimal tmpAmnt) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setSoteiAmntSnst]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][日割要否:" + hiwariYh + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][丸め方法コード:" + roundWayCd + "]");
		
		BigDecimal tmpWkSoteiAmnt = null;
		
		// （ア）配列情報[]．日割要否 ＝ "1"（日割なし） の場合
		// 判定条件取得
		if(JACStrConst.HIWARI_YH_NON.equals(hiwariYh))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][日割なし]");
			// ワーク．想定金額　←　ワーク．想定料金（そのまま）
			tmpWkSoteiAmnt = tmpAmnt;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][日割なし丸め処理前金額：" + tmpWkSoteiAmnt + "]");
		}
		// （イ）上記（ア）以外（"2"（日割あり）） の場合
		else if(JACStrConst.HIWARI_YH_ARI.equals(hiwariYh))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][日割あり]");
			BigDecimal useDayCnt = inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT);		// 月中利用日数
			// ワーク．想定金額 ← ワーク．想定料金 × ワーク退避．月中利用日数 ÷ ワーク．暦日数
			tmpWkSoteiAmnt = tmpAmnt.multiply(useDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][日割後金額：" + tmpWkSoteiAmnt + "]");

		}
		// （ウ）端数処理
		// （�@）配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
		// （�A）配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
		// （�B）配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
		// （�C）上記（�@）〜（�B）以外（"0"（丸めなし））     の場合
		// 小数点第三位で四捨五入を行う。
		tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(roundWayCd, tmpWkSoteiAmnt, 2);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setSoteiAmntSnst][丸め処理後金額：" + tmpWkSoteiAmnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setSoteiAmntSnst]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 利用不可期間減額を算出します。
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求パターン内訳マスタ
	 * @param wkTeizoPrc ワーク．逓増料金
	 * @param useFailAplyWayCd 利用不可適用方法コード
	 * @param hiwariYh 日割要否
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	// 2015/08/20 ANK-2163-00-00 MOD START
	//private void makeOutPutDtlUseFailInfo(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
	//											BigDecimal wkTeizoPrc, String useFailAplyWayCd) throws Exception
	private void makeOutPutDtlUseFailInfo(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
												BigDecimal wkTeizoPrc, String useFailAplyWayCd, String hiwariYh) throws Exception
	// 2015/08/20 ANK-2163-00-00 MOD END
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutDtlUseFailInfo]");
		
		BigDecimal useFailDayCnt = inMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT);			// 月中利用不可日数
		BigDecimal useDayCnt = inMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT);						// 月中利用日数
		// 2015/08/20 ANK-2163-00-00 ADD START
		BigDecimal useFailDayCntHiwariNon = inMap.getBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT_HIWARI_NON);	// 月中利用不可日数（日割なし）
		String planChrgEndYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);								// プラン課金終了年月日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用日数：" + useDayCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用不可日数：" + useFailDayCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用不可日数（日割なし）：" + useFailDayCntHiwariNon + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][プラン課金終了年月日：" + planChrgEndYmd + "]");
		// 2015/08/20 ANK-2163-00-00 ADD END
		
		// 2015/08/20 ANK-2163-00-00 MOD START
		//// （入力．月中利用不可日数 ≦ ゼロ ）の場合
		//if(useFailDayCnt.compareTo(BigDecimal.ZERO) <= 0)
		//{
		//	assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
		//			"[L][makeOutPutDtlUseFailInfo][月中利用不可日数が０以下のため、利用不可出力フラグ変更なし]");
		//	assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");
		//	return;
		//}
		// （入力．月中利用不可日数 ≦ ゼロ ）かつ（入力．月中利用不可日数（日割なし） ≦ ゼロ ）の場合
		if((useFailDayCnt.compareTo(BigDecimal.ZERO) <= 0) && (useFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) <= 0))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
					"[L][makeOutPutDtlUseFailInfo][月中利用不可日数が０以下かつ、月中利用不可日数（日割なし）が０以下のため、利用不可出力フラグ変更なし]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");
			return;
		}
		// 2015/08/20 ANK-2163-00-00 MOD END
		
		// （ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）の場合
		if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(useFailAplyWayCd))
		{
		
		// (a) 利用不可期間減額の算出
			// 2015/08/20 ANK-2163-00-00 MOD START
			// 想定金額算出方法コード　＝　割引料金パターン
			// 　ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 
			// 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切下げる（プラスが減る方向））
			// 想定金額算出方法コード　≠　割引料金パターン
			// 　ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 
//          // 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切下げる（マイナスが増える方向））
			//if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_WRBK.equals(dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD)))
			//{
			//	this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			//	this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
			//}
			//else
			//{
			//	this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			//	this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
			//}
			//assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][tmpWkUseFailSoteiAmnt：" + tmpUseFailSoteiAmnt + "]");
			// 想定金額算出方法コード　＝　割引料金パターン
			// 　(1) 請求年月　＝　プラン課金終了年月（入力．プラン課金終了年月日の上６桁）かつ、
			//       想定料金ＭＡＰ．日割要否 ＝ "1"（日割なし）かつ、
			//       入力．月中利用不可日数（日割なし）がゼロより大きい場合
			// 　     ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数（日割なし） 
			// 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切下げる（プラスが減る方向））
			// 　(2) 上記(1)以外かつ、入力．月中利用不可日数がゼロより大きい場合
			// 　     ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 
			// 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切下げる（プラスが減る方向））
			// 　(3) 上記(1)、(2)以外の場合
			// 　     入力．月中利用不可日数がゼロ以下の為、利用不可出力フラグ変更なし
			// 想定金額算出方法コード　≠　割引料金パターン
			// 　(1) 請求年月　＝　プラン課金終了年月（入力．プラン課金終了年月日の上６桁）かつ、
			//       想定料金ＭＡＰ．日割要否 ＝ "1"（日割なし）かつ、
			//       入力．月中利用不可日数（日割なし）がゼロより大きい場合
			// 　     ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 （日割なし）
			// 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切上げる（マイナスが増える方向））
			// 　(2) 上記(1)以外かつ、入力．月中利用不可日数がゼロより大きい場合
			// 　     ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 
			// 　                                  ÷ ワーク．暦日数 × -1（端数は小数点第三位で切上げる（マイナスが増える方向））
			// 　(3) 上記(1)、(2)以外の場合
			// 　     入力．月中利用不可日数がゼロ以下の為、利用不可出力フラグ変更なし
			if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_WRBK.equals(dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD)))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][想定金額算出方法コード＝割引料金パターン]");
				if(tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) && JACStrConst.HIWARI_YH_NON.equals(hiwariYh) 
					&& useFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0)
				{
					this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCntHiwariNon).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
					this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][利用不可想定金額（日割なし）算出]");
				}
				else if(useFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
				{
					this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
					this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][利用不可想定金額算出]");
				}
				else
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
							"[L][makeOutPutDtlUseFailInfo][月中利用不可日数が０以下のため、利用不可出力フラグ変更なし]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");
					return;
				}
			}
			else
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][想定金額算出方法コード≠割引料金パターン]");
				if(tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) && JACStrConst.HIWARI_YH_NON.equals(hiwariYh) 
					&& useFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0)
				{
					this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCntHiwariNon).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
					this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][利用不可想定金額（日割なし）算出]");
				}
				else if(useFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
				{
					this.tmpUseFailSoteiAmnt = wkTeizoPrc.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
					this.tmpUseFailSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, this.tmpUseFailSoteiAmnt, 2).multiply(MINUS_ONE);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][利用不可想定金額算出]");
				}
				else
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
							"[L][makeOutPutDtlUseFailInfo][月中利用不可日数が０以下のため、利用不可出力フラグ変更なし]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");
					return;
				}
			}
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][tmpWkUseFailSoteiAmnt：" + tmpUseFailSoteiAmnt + "]");
			// 2015/08/20 ANK-2163-00-00 MOD END

		// (b) 請求パターン内訳情報（マンション明細）編集・出力（利用不可期間減額）
			// ワーク退避（利用不可）．想定金額                 ← ワーク．想定金額
			// ワーク退避（利用不可）．内訳料金項目コード       ← ワーク退避（利用不可）．内訳料金項目コードの下3桁目を"7"（利用不可期間減額）に置換したコード
			// ワーク退避（利用不可）．存在チェックレベルコード ← ワーク．利用不可期間減額用存在チェックレベルコード（初期処理(5) にて取得済み）
			// ワーク退避（利用不可）．金額チェックレベルコード ← ワーク．利用不可期間減額用金額チェックレベルコード（初期処理(5) にて取得済み）
			String uwPrcKmkCd = dbMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][ワーク退避（利用不可）" +
																									"．内訳料金項目コード置換前：" + uwPrcKmkCd + "]");
			this.tmpWkUseFailPrcKmkCd = makeStr(uwPrcKmkCd.substring(0, uwPrcKmkCd.length() - 3), 
												JACStrConst.PRC_KMK_CD_RFKGY, uwPrcKmkCd.substring(uwPrcKmkCd.length() - 2));
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][ワーク退避（利用不可）．内訳料金項目コード置換後："
																										+ this.tmpWkUseFailPrcKmkCd + "]");
			tmpWkUseFailOutFlg = true;
		}
		// 2015/08/20 ANK-2163-00-00 MOD START
		// （ワーク．利用不可適用方法コード ＝ "2"（利用期間が前日利用不可時徴収なし）かつ
		// 入力．月中利用不可日数　≧　入力．月中利用日数　の場合
		//if(JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(useFailAplyWayCd)
		//		&& useFailDayCnt.compareTo(useDayCnt) >= 0)
		//{
		//	//ワーク．出力フラグに"0(出力しない)"を設定
		//	outFlg = 0;
		//}
		// （ワーク．利用不可適用方法コード ＝ "2"（利用期間が前日利用不可時徴収なし）の場合
		if(JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(useFailAplyWayCd))
		{
			// 　(1) 請求年月　＝　プラン課金終了年月（入力．プラン課金終了年月日の上６桁）かつ、
			//       想定料金ＭＡＰ．日割要否 ＝ "1"（日割なし）かつ、
			//       入力．月中利用不可日数（日割なし）がゼロより大きい場合
			if(tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) && JACStrConst.HIWARI_YH_NON.equals(hiwariYh) 
				&& useFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][請求年月＝プラン課金終了年月かつ月中利用不可日数（日割なし）＞0]");
				// 入力．月中利用不可日数（日割なし）　≧　入力．月中利用日数　の場合
				if(useFailDayCntHiwariNon.compareTo(useDayCnt) >= 0)
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用不可日数（日割なし）≧月中利用日数]");
					//ワーク．出力フラグに"0(出力しない)"を設定
					outFlg = 0;
				}
			}
			// 　(2) 上記(1)以外かつ、入力．月中利用不可日数がゼロより大きい場合
			else if(useFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用不可日数＞0]");
				// 入力．月中利用不可日数　≧　入力．月中利用日数　の場合
				if(useFailDayCnt.compareTo(useDayCnt) >= 0)
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][月中利用不可日数≧月中利用日数]");
						//ワーク．出力フラグに"0(出力しない)"を設定
					outFlg = 0;
				}
			}
		}
		// 2015/08/20 ANK-2163-00-00 MOD END
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][出力フラグ：" + outFlg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][利用不可出力フラグ：" + tmpWkUseFailOutFlg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");
		
		return;
	}
	
	/**
	 * ワークキーを生成します。
	 * 
	 * @param inMap 入力情報
	 * @return key ワークキー
	 * @throws Exception  業務サービス内で発生した例外全般。
	 */
	private String makeKey(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeKey]");
		StringBuffer tmpKey = new StringBuffer();
		
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.SEIKY_KEI_NO), SEIKY_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.SVC_KEI_NO), SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO), SVC_KEI_UCWK_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO), OP_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO), SBOP_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO), KKTK_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.SEIOPSVC_KEI_NO), SEIOPSVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
								inMap.getString(JBSbatAKIFM003.WRIB_SVC_KEI_NO), WRIB_SVC_KEI_NO_LENGTH, true));
		
		String key = tmpKey.toString();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeKey][key:" + key + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeKey]");
		return key;
	}
	
	/**
	 * 割引契約ワークキーを生成します。
	 * 
	 * @param inMap 入力情報
	 * @return key ワークキー
	 * @throws Exception  業務サービス内で発生した例外全般。
	 */
	private String makeWKeiKey(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeWKeiKey]");
		StringBuffer tmpKey = new StringBuffer();
		
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.SEIKY_KEI_NO), SEIKY_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.SVC_KEI_NO), SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO), SVC_KEI_UCWK_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO), OP_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO), SBOP_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO), KKTK_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.SEIOPSVC_KEI_NO), SEIOPSVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.WRIB_SVC_KEI_NO), WRIB_SVC_KEI_NO_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), RSV_APLY_YMD_LENGTH, true));
		tmpKey.append(chUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.HalfSpace, 
													inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM), GENE_ADD_DTM_LENGTH, true));
		
		String key = tmpKey.toString();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeWKeiKey][key:" + key + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeWKeiKey]");
		return key;
	}

	/**
	 * 休止判定を行います。
	 * 
	 * @param inMap 入力情報
	 * @param soteiMap  想定料金マップ.配列情報[]
	 * @return boolean 休止判定結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isSetPauseJdg(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface soteiMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isPauseJdg]");
		
		// （ア）（ ワーク退避．サービス休止課金開始年月日 ＝ （空） または ＝ 空白 ） の場合
		// 判定条件取得
		String svcPauseChrgStaYmd 	= inMap.getString(JBSbatAKIFM004.SVC_PAUSE_CHRG_STA_YMD);		// サービス休止課金開始年月日
		String svcPauseRlsYmd 		= inMap.getString(JBSbatAKIFM004.SVC_PAUSE_RLS_YMD);			// サービス休止解除年月日
		String pauseStpCd 			= inMap.getString(JBSbatAKIFM004.PAUSE_STP_CD);					// 休止中断コード
		BigDecimal soteiPausePrc 	= soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC);	// 想定休止料金
		
		if(JACStrConst.KARA_MOJI.equals(svcPauseChrgStaYmd.trim()))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
			return false;
		}
		
		// （イ）（ワーク退避．サービス休止課金開始年月日≠（空）かつ≠空白）
		// かつ（ワーク退避．サービス休止解除年月日＝（空）または＝空白）の場合
		else if(JACStrConst.KARA_MOJI.equals(svcPauseRlsYmd.trim()))
		{
			// （�@）（ワーク退避．サービス休止課金開始年月日 ≦ ワーク．月末日 ）
			//        かつ（ワーク退避．休止中断コード＝"00"（休止中(SOD未発行)）
			//        または ワーク退避．休止中断コード＝"01"（休止中(SOD発行済)））
			//        かつ（配列情報[]．想定休止料金≠（空） ）の場合
			if(svcPauseChrgStaYmd.compareTo(this.tmpMonEndDay) <= 0
					&& (JACStrConst.PAUSE_STP_CD_PAUSE_SOD_MI.equals(pauseStpCd)
						|| JACStrConst.PAUSE_STP_CD_PAUSE_SOD_ZUMI.equals(pauseStpCd))
					&& soteiPausePrc != null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
				return true;
			}
			//（�A）上記（�@）以外の場合
			else
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
				return false;
			}
		}
		// （ウ）（ワーク退避．サービス休止課金開始年月日 ≠ （空）かつ≠空白）
		//       かつ（ワーク退避．サービス休止解除年月日 ≠ （空）かつ≠空白）の場合
		else
		{
			
			//（�@）（ワーク退避．サービス休止課金開始年月日 ≦ ワーク．月末日
			//       かつ ワーク退避．サービス休止解除年月日 ＞ ワーク．月末日）
			//       かつ （ワーク退避．休止中断コード＝"00"（休止中(SOD未発行)） 
			//       または ワーク退避．休止中断コード＝"01"（休止中(SOD発行済)））
			//       かつ（配列情報[]．想定休止料金≠（空））の場合
			if((svcPauseChrgStaYmd.compareTo(this.tmpMonEndDay) <= 0
						&& svcPauseRlsYmd.compareTo(this.tmpMonEndDay) > 0)
					&& (JACStrConst.PAUSE_STP_CD_PAUSE_SOD_MI.equals(pauseStpCd)
							|| JACStrConst.PAUSE_STP_CD_PAUSE_SOD_ZUMI.equals(pauseStpCd))
					&& soteiPausePrc != null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
				return true;
			}
			// （�A）上記（�@）以外の場合
			else
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
				return false;
			}
		}
	}

	/**
	 * 請求パターン内訳情報を出力します。
	 * 
	 * @param wkMap ワーク退避レコード
	 * @param dbMap 請求内訳パターンマスタ
	 * @param soteiPrc 想定料金
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputInfo(JBSbatServiceInterfaceMap wkMap, JBSbatCommonDBInterface dbMap, 
									BigDecimal soteiPrc,  JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputInfo]");
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		// 入力電文コピー
		outMap.getMap().putAll(wkMap.getMap());
		
		outMap.setString(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, 	dbMap.getString(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE));
		outMap.setString(JBSbatAKIFM004.UW_PRC_SVC_CD, 				dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD));
		outMap.setString(JBSbatAKIFM004.UW_PRC_KMK_CD, 				dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD));
		outMap.setString(JBSbatAKIFM004.SONZAI_CHK_LV_CD,			dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SONZAI_CHK_LV_CD));
		outMap.setString(JBSbatAKIFM004.AMNT_CHK_LV_CD, 			dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.AMNT_CHK_LV_CD));
		outMap.setString(JBSbatAKIFM004.SOTEI_AMNT_SNST_WAY_CD, 	dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD));
		outMap.setString(JBSbatAKIFM004.DANKAI_KETEI_MOTO_KMK_DIV, 	dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.DANKAI_KETEI_MOTO_KMK_DIV));
		outMap.setString(JBSbatAKIFM004.SOTEI_AMNT, 				soteiPrc);
		
		// 想定金額算出方法が"18"（請求書発行手数料）
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_SHKH.equals(dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD)))
		{
			// 請求書発行手数料の月毎の料金項目コードを設定する
			outMap.setString(JBSbatAKIFM004.UW_PRC_KMK_CD, 			this.outPrcKmkCd);
		}
		
		// 出力フラグ設定
		outMap.setOutFlg(true);
		
		if(outFlg == 1)
		{
			outputInItem.addOutMapList(outMap);
		}
		else
		{
			outputInItem.addOutMapList_2(outMap);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutputInfo]");

		return;
	}
	
	/**
	 * 利用不可情報を出力します。
	 * 
	 * @param wkMap ワーク退避レコード
	 * @param dbMap 請求内訳パターンマスタ
	 * @param outputInItem  出力情報JBSbatAKPrckmkHanei
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputUseFailInfo(JBSbatServiceInterfaceMap wkMap, JBSbatCommonDBInterface dbMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputInfo]");
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		// 入力電文コピー
		outMap.getMap().putAll(wkMap.getMap());
		
		outMap.setString(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, 	dbMap.getString(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE));
		outMap.setString(JBSbatAKIFM004.UW_PRC_SVC_CD, 				dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD));
		outMap.setString(JBSbatAKIFM004.UW_PRC_KMK_CD, 				this.tmpWkUseFailPrcKmkCd);
		outMap.setString(JBSbatAKIFM004.SONZAI_CHK_LV_CD,			rfkgySzchkLvCd);
		outMap.setString(JBSbatAKIFM004.AMNT_CHK_LV_CD, 			rfkgyAmchkLvCd);
		outMap.setString(JBSbatAKIFM004.SOTEI_AMNT_SNST_WAY_CD, 	dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD));
		outMap.setString(JBSbatAKIFM004.DANKAI_KETEI_MOTO_KMK_DIV, 	dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.DANKAI_KETEI_MOTO_KMK_DIV));
		outMap.setString(JBSbatAKIFM004.SOTEI_AMNT, 				tmpUseFailSoteiAmnt);
		
		// 出力フラグ設定
		outMap.setOutFlg(true);

		outputInItem.addOutMapList(outMap);

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

		return;
	}
	
	/**
	 * 違約金対象期間判定�T（月基準）
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @param svcChrgEndYmd サービス課金終了年月日
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal jdgPnltyTrgtPrd1(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
											String svcStaYmd, String svcChrgStaYmd, String svcChrgEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgPnltyTrgtPrd1]");
		
		// 想定料金
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;

		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		// サービス課金終了月の月末日を算出
		this.svcChrgEndMnEndYmd = getEndOfMonthYmd(svcChrgEndYmd);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][サービス課金終了年月日の月末日" + this.svcChrgEndMnEndYmd + "]");
		
		// 解約起算日（サービス課金終了年月日の翌日）を算出
		this.svcDslKisanYmd = JBSbatDateUtil.adjustDate(svcChrgEndYmd, INT_ONE);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][解約起算日" + this.svcDslKisanYmd +  "]");
		
		

		// 想定金額算出方法コードが（違約金（サービス開始月基準））の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNLTY.equals(soteiAmntSnstWayCd))
		{
			// 判定用段階決定元項目値設定�@（サービス開始月基準）
			setHanteiDankaiKmkValue1(inMap, dbMap, svcStaYmd, svcChrgEndYmd);
		}
		else
		{
			// 上記以外　（想定金額算出方法コードが（違約金（課金開始月基準））の場合）
			// 判定用段階決定元項目値設定�A（課金開始月基準）
			setHanteiDankaiKmkValue2(inMap, dbMap, svcChrgStaYmd, svcChrgEndYmd);
		}
		
		// 想定料金マスタ検索�T（月基準）
		tmpWkSoteiAmnt = schSoteiPrcMst1(inMap, dbMap);
		

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

	/**
	 * 判定用段階決定元項目値１(サービス開始月基準)
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgEndYmd サービス課金終了年月日
	 * @return なし
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void setHanteiDankaiKmkValue1(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
															String svcStaYmd, String svcChrgEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setHanteiDankaiKmkValue1]");
		BigDecimal hanteiDankaiKmkValue = null;
		
		// サービス継続月数の取得
		BigDecimal svcKeizokuMonCnt = inMap.getBigDecimal(JBSbatAKIFM003.SVC_KEIZOKU_MON_CNT);
		// サービス課金終了年月日 = サービス課金終了年月の月末日 の場合 
		if(svcChrgEndYmd.equals(this.svcChrgEndMnEndYmd))
		{
			// 入力．サービス継続月数　＜　1かつ、解約起算日の年月≠サービス開始年月日の年月の場合
			if((svcKeizokuMonCnt.compareTo(ONE) < 0)
				&& !(this.svcDslKisanYmd.substring(0, 6)).equals(svcStaYmd.substring(0, 6)))
			{
				// 判定用段階決定元項目値にサービス継続月数（ゼロ）を設定
				hanteiDankaiKmkValue = svcKeizokuMonCnt;
			}
			else
			{
				// 判定用段階決定元項目値にサービス継続月数＋１（解約起算日までのため＋１補正）を設定
				hanteiDankaiKmkValue = svcKeizokuMonCnt.add(BigDecimal.ONE);
			}
		}
		else
		{
			// 判定用段階決定元項目値にサービス継続月数（月末日でないため補正なし）を設定
			hanteiDankaiKmkValue = svcKeizokuMonCnt;
		}
		
		// 判定用段階決定元項目値に算出値を設定
		dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, hanteiDankaiKmkValue);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setHanteiDankaiKmkValue1][判定用段階決定元項目値：" + hanteiDankaiKmkValue + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setHanteiDankaiKmkValue1]");
	
	}
		
	/**
	 * 判定用段階決定元項目値２(課金開始月基準)
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @param svcChrgEndYmd サービス課金終了年月日

	 * @return なし
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void setHanteiDankaiKmkValue2(JBSbatServiceInterfaceMap inMap,
					JBSbatCommonDBInterface dbMap, String svcChrgStaYmd, String svcChrgEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setHanteiDankaiKmkValue2]");
		BigDecimal hanteiDankaiKmkValue = null;

		BigDecimal chrgKeizokuMonCnt = inMap.getBigDecimal(JBSbatAKIFM003.CHRG_KEIZOKU_MON_CNT);
		// サービス課金終了年月日 = サービス課金終了年月の月末日 の場合 
		if(svcChrgEndYmd.equals(this.svcChrgEndMnEndYmd))
		{
			// 入力．課金継続月数　＜　1かつ、解約起算日の年月≠サービス課金開始年月日の年月の場合
			if((chrgKeizokuMonCnt.compareTo(ONE) < 0)
				&& 	!(this.svcDslKisanYmd.substring(0, 6)).equals(svcChrgStaYmd.substring(0, 6)))
			{
				// 判定用段階決定元項目値に課金継続月数（ゼロ）を設定
				hanteiDankaiKmkValue = chrgKeizokuMonCnt;
			}
			else
			{
				// 判定用段階決定元項目値に課金継続月数＋１（解約起算日までのため＋１補正）を設定
				hanteiDankaiKmkValue = chrgKeizokuMonCnt.add(BigDecimal.ONE);
			}
		}
		else
		{
			// 判定用段階決定元項目値に課金継続月数（月末日でないため補正なし）を設定
			hanteiDankaiKmkValue = chrgKeizokuMonCnt;
		}
		// 判定用段階決定元項目値に算出値を設定
		dbMap.setValue(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE, hanteiDankaiKmkValue);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setHanteiDankaiKmkValue2][判定用段階決定元項目値：" + hanteiDankaiKmkValue + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setHanteiDankaiKmkValue2]");
	}
	
	/**
	 * 想定料金マスタ検索�T（月基準）
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	
	private BigDecimal schSoteiPrcMst1(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][schSoteiPrcMst1]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;

		// �@想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ ワーク退避．内訳料金項目コード
		//      ＋ ワーク退避． 加入契約支払方式コード ＋ 支払契約識別コード（マンション定額以外の場合の固定値）
		String serchKey = makeStr(inMap.getString(JBSbatAKIFM003.PCRS_CD), dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD)
							, dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD), JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO, JACStrConst.PAY_KEI_SKBT_CD_OTHER);
		
		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
			// 判定条件取得
			BigDecimal hanteiDankaiKmkValue = dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);	// ワーク退避．判定用段階決定元項目値
		
			// 該当なしを設定する。
			boolean existFlg = false;
		
			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface soteiMap = dbList.get(i);
				// 配列情報[]．下限値 ≦ ワーク退避．判定用段階決定元項目値 
				// かつ 配列情報[]．上限値 ＞ ワーク退避．判定用段階決定元項目値
				// 判定条件取得
				BigDecimal lowlValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][下限値：" + lowlValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][上限値：" + upplValue + "]");
				
				if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					
					// 想定金額算出（違約金）�T（月基準）
					tmpWkSoteiAmnt = snstSoteiPrcIyak1(soteiMap, dbMap);
					

					// 該当ありの場合、trueを設定する。
		
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][該当あり]");
					existFlg = true;
				}
			}
			
			// 該当あり、該当なしを判定し該当なしの場合は出力フラグに"0":出力しないを設定する。
			if(!existFlg)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][該当なし]");
				outFlg = 0;
			}
		}
		else
		{
			// 想定料金マスタに存在しない場合は、"0":出力しないを設定する。
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][マスタに未存在]");
			outFlg = 0;
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][schSoteiPrcMst1]");
		return tmpWkSoteiAmnt;
	}
	

	/**
	 * 想定金額算出（違約金）�T（月基準）
	 * 
	 * @param soteiMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	
	private BigDecimal snstSoteiPrcIyak1(JBSbatCommonDBInterface soteiMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][snstSoteiPrcIyak1]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		
		// 想定料金内容コード　＝　B（違約金基準額）の場合
		if(JACStrConst.SOTEI_PRC_NAIYO_CD_BASE.equals(soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][想定料金内容コード：B]");
			
			// 判定用段階決定元項目値
			BigDecimal hanteiDankaiKmkValue = dbMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);
			
			// 残余日数算出(残された違約金対象期間の内、解約月を除く月の数)
			// ワーク．残余月数　　←　想定料金ＭＡＰ．上限値　−　ワーク．請求パターン内訳[n]．判定用段階決定元項目値　−　１
			BigDecimal zanYoNisu = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE).subtract(hanteiDankaiKmkValue).subtract(ONE);
			if(zanYoNisu.signum() == INT_MINUS_ONE)
			{
				zanYoNisu = BigDecimal.ZERO;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][残余日数がマイナスのため、ゼロに置き換え]");
			}
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][算出残余日数：" + zanYoNisu + "]");
			
			// 残余月割額算出
			//ワーク．残余月割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．残余月数
			BigDecimal zanYoGetuWriGak = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC).multiply(zanYoNisu);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][算出残余月割額：" + zanYoGetuWriGak + "]");
			
			// 終了月日割額
			// ワーク．終了月日割額　←　ゼロ
			BigDecimal endHiwariAmt = BigDecimal.ZERO;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][終了月日割額：" + endHiwariAmt + "]");
			
			BigDecimal dslMonHiwariAmt = BigDecimal.ZERO;
			
			// ワーク．請求パターン内訳[n]．判定用段階決定元項目値　≧　１　の場合 
			if(hanteiDankaiKmkValue.compareTo(ONE) >= INT_ONE)
			{
				String hiwariYh = dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.HIWARI_YH);		// 日割要否
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][日割要否：" + hiwariYh + "]");
				
				// 日割要否　＝　日割あり の場合
				if(JACStrConst.HIWARI_YH_ARI.equals(hiwariYh))
				{
					// 解約起算月の月末日を算出
					String svcDslKisanMnEndYmd = getEndOfMonthYmd(this.svcDslKisanYmd);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][解約起算月の月末日：" + svcDslKisanMnEndYmd + "]");
					
					// 解約月残日数
					// ワーク．解約月残日数　←　ワーク．解約起算月の月末日（dd）　−　ワーク．解約起算日（dd）　＋　１
					BigDecimal dslMonZanNisu = new BigDecimal(JBSbatDateUtil.dayDiff(svcDslKisanMnEndYmd, this.svcDslKisanYmd, DIFF_NAI_FLG));
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][解約月残日数：" + dslMonZanNisu + "]");
					
					// 解約月日割額
					// ワーク．解約月日割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．解約月残日数　÷　ワーク．解約起算月の月末日（dd）（＝解約起算月の暦日数）
					BigDecimal tmpDslMonHiwariAmt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC)
												.multiply(dslMonZanNisu).divide(new BigDecimal(svcDslKisanMnEndYmd.substring(6, 8)));
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][丸め処理前解約月日割額：" + tmpDslMonHiwariAmt + "]");
					
					// 丸め方法コード取得
					String roundWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
					// 端数処理
					// 配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
					// 配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
					// 配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
					// 上記以外（"0"（丸めなし））     の場合
					// 小数点第三位で四捨五入を行う。
					dslMonHiwariAmt = JACbatRknBusinessUtil.round(roundWayCd, tmpDslMonHiwariAmt, 2);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][丸め処理後解約月日割額：" + dslMonHiwariAmt + "]");
					
				}
				else
				{
					// 日割要否　＝　日割なし の場合
					// ワーク．解約月日割額　←　想定料金ＭＡＰ．想定料金
					dslMonHiwariAmt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
				}
			}
			else
			{
				// ワーク．請求パターン内訳[n]．判定用段階決定元項目値　＜　１　の場合 
				// ワーク．解約月日割額　←　０
				dslMonHiwariAmt = BigDecimal.ZERO;
			}
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][解約月日割額：" + dslMonHiwariAmt + "]");
			
			// 想定金額（違約金）算出
			// ワーク．想定金額　←　ワーク．残余月割額　＋　ワーク．解約月日割額　＋　ワーク．終了月日割額
			tmpWkSoteiAmnt = zanYoGetuWriGak.add(dslMonHiwariAmt).add(endHiwariAmt);
		}
		else
		{
			// 上記以外"A"（違約金（固定額））の場合
			// 想定金額違約金
			
			tmpWkSoteiAmnt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
			
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak1][想定金額（違約金）：" + tmpWkSoteiAmnt + "]");	
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][snstSoteiPrcIyak1]");
		return tmpWkSoteiAmnt;
	}

	/**
	 * 違約金対象期間判定�U（日基準）
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @param svcChrgEndYmd サービス課金終了年月日
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal jdgPnltyTrgtPrd2(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
									String svcStaYmd, String svcChrgStaYmd, String svcChrgEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgPnltyTrgtPrd2]");
		
		// 想定料金
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;

		// 解約起算日（サービス課金終了年月日の翌日）を算出
		this.svcDslKisanYmd = JBSbatDateUtil.adjustDate(svcChrgEndYmd, INT_ONE);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][解約起算日" + this.svcDslKisanYmd +  "]");
		
		// 想定料金マスタ検索�U（日基準）
		tmpWkSoteiAmnt = schSoteiPrcMst2(inMap, dbMap, svcStaYmd, svcChrgStaYmd);


		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][jdgPnltyTrgtPrd2]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 想定料金マスタ検索�U（日基準）
	 * 
	 * @param inMap 入力情報
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	
	private BigDecimal schSoteiPrcMst2(JBSbatServiceInterfaceMap inMap, JBSbatCommonDBInterface dbMap, 
																String svcStaYmd, String svcChrgStaYmd) throws Exception
	{
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][schSoteiPrcMst2]");
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
		
		String trgtPrdEndYmdYkJitu = null;

		
		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		// �@想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ ワーク退避．内訳料金項目コード
		//      ＋ ワーク退避． 加入契約支払方式コード ＋ 支払契約識別コード（マンション定額以外の場合の固定値）
		String serchKey = makeStr(inMap.getString(JBSbatAKIFM003.PCRS_CD), dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_SVC_CD)
							, dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.UW_PRC_KMK_CD), JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO, JACStrConst.PAY_KEI_SKBT_CD_OTHER);
		
		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
		
			// 該当なしを設定する。
			boolean existFlg = false;
		
			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface soteiMap = dbList.get(i);
				
				BigDecimal lowlValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][下限値：" + lowlValue + "]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][上限値：" + upplValue + "]");
				
				// 違約金対象期間導出
				// 想定金額算出方法コードが（違約金（サービス開始日基準））の場合
				if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd))
				{
					if(BigDecimal.ZERO.equals(lowlValue))
					{
						// 対象期間の開始日に開始前解約時のサービス開始年月日を設定
						this.trgtPrdStaYmd = SVC_STA_YMD_STA_BF_DSL;
					}
					else
					{
						// 対象期間の開始日
						this.trgtPrdStaYmd = JBSbatDateUtil.adjustMonth(svcStaYmd, lowlValue.intValue());
					}
					// 対象期間の終了日翌日
					trgtPrdEndYmdYkJitu = JBSbatDateUtil.adjustMonth(svcStaYmd, upplValue.intValue());
					// 対象期間の終了日
					this.trgtPrdEndYmd = JBSbatDateUtil.adjustDate(trgtPrdEndYmdYkJitu, INT_MINUS_ONE);
					
				}
				else
				{
					// 上記以外（想定金額算出方法コードが（違約金（課金開始日基準））の場合）
					if(BigDecimal.ZERO.equals(lowlValue))
					{
						// 対象期間の開始日に開始前解約時のサービス開始年月日を設定
						this.trgtPrdStaYmd = SVC_STA_YMD_STA_BF_DSL;
					}
					else
					{
						// 対象期間の開始日
						this.trgtPrdStaYmd = JBSbatDateUtil.adjustMonth(svcChrgStaYmd, lowlValue.intValue());
					}
					// 対象期間の終了日翌日
					trgtPrdEndYmdYkJitu = JBSbatDateUtil.adjustMonth(svcChrgStaYmd, upplValue.intValue());
					// 対象期間の終了日
					this.trgtPrdEndYmd = JBSbatDateUtil.adjustDate(trgtPrdEndYmdYkJitu, INT_MINUS_ONE);
				}
				
				// 対象期間の開始日　≦　解約起算日　かつ　解約起算日　≦　対象期間の終了日
				if((this.trgtPrdStaYmd.compareTo(this.svcDslKisanYmd) <= 0)
					&& (this.trgtPrdEndYmd.compareTo(this.svcDslKisanYmd) >= 0))
				{
					// 想定金額算出（違約金）�U（日基準）
					tmpWkSoteiAmnt = snstSoteiPrcIyak2(soteiMap, dbMap, svcStaYmd, svcChrgStaYmd);
					
					// 該当ありの場合、trueを設定する。
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][該当あり]");
					existFlg = true;
					
				}
				
			}
			
			// 該当あり、該当なしを判定し該当なしの場合は出力フラグに"0":出力しないを設定する。
			if(!existFlg)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][該当なし]");
				outFlg = 0;
			}
		}
		else
		{
			// 想定料金マスタに存在しない場合は、"0":出力しないを設定する。
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][マスタに未存在]");
			outFlg = 0;
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][schSoteiPrcMst2]");
		return tmpWkSoteiAmnt;
	}
	
	/**
	 * 想定金額算出（違約金）�U（日基準）
	 * 
	 * @param soteiMap 想定料金マスタ
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @return tmpWkSoteiAmnt 想定料金
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	
	private BigDecimal snstSoteiPrcIyak2(JBSbatCommonDBInterface soteiMap, JBSbatCommonDBInterface dbMap, 
															String svcStaYmd, String svcChrgStaYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][snstSoteiPrcIyak2]");
		
		BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO; // 想定料金
		
		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak2][上限値：" + upplValue + "]");

		
		// 想定料金内容コード　＝　B（違約（金基準額））の場合
		if(JACStrConst.SOTEI_PRC_NAIYO_CD_BASE.equals(soteiMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC_NAIYO_CD)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak2][想定料金内容コード：B]");
			
			// 残余月数算出
			BigDecimal zanYoTukiSu = snstZanYoTukiSuIyak2(soteiMap, dbMap, svcStaYmd, svcChrgStaYmd);
			
			// 残余月割額算出
			// ワーク．残余月割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．残余月数
			BigDecimal zanYoGetuWriGak = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC).multiply(zanYoTukiSu);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak2][算出残余月割額：" + zanYoGetuWriGak + "]");
			

			// 解約月日割額、終了月日割額産出
			BigDecimal[] tempHiwariAmt = new BigDecimal[2];
			tempHiwariAmt[0] = BigDecimal.ZERO; // 解約月日割額
			tempHiwariAmt[1] = BigDecimal.ZERO; // 終了月日割額
			
			// 解約月日割額、終了月日割額産出
			tempHiwariAmt = snstHiwariAmtIyak2(soteiMap, dbMap);
			

			// 想定金額算出
			// 想定金額算出方法コードが（違約金（サービス開始日基準））かつ、解約起算日 ≦ サービス開始年月日
			// 想定金額算出方法コードが（違約金（課金開始基準））かつ、解約起算日 ≦ サービス課金開始年月日 の場合
			if((JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd)) && (this.svcDslKisanYmd.compareTo(svcStaYmd) <=  0)  
				|| (JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_CSD.equals(soteiAmntSnstWayCd)) && (this.svcDslKisanYmd.compareTo(svcChrgStaYmd) <=  0))
			
			{
				tmpWkSoteiAmnt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC).multiply(upplValue);
			}
			else
			{
				// 想定金額（違約金）算出
				// ワーク．想定金額　←　ワーク．残余月割額　＋　ワーク．解約月日割額　＋　ワーク．終了月日割額
				tmpWkSoteiAmnt = zanYoGetuWriGak.add(tempHiwariAmt[0]).add(tempHiwariAmt[1]);
			}
		}
		else
		{
			// 上記以外"A"（違約金（固定額））の場合
			// 想定金額違約金
			
			tmpWkSoteiAmnt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstSoteiPrcIyak2][想定金額（違約金）：" + tmpWkSoteiAmnt + "]");
		return tmpWkSoteiAmnt;
		
	}
	

	/**
	 * 残余月数算出（違約金）�U（日基準）
	 * 
	 * @param soteiMap 想定料金マスタ
	 * @param dbMap 請求内訳パターンマスタ
	 * @param svcChrgStaYmd 
	 * @param svcStaYmd 
	 * @param svcStaYmd サービス開始年月日
	 * @param svcChrgStaYmd サービス課金開始年月日
	 * @return zanYoTukiSu 残余月数
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private BigDecimal snstZanYoTukiSuIyak2(JBSbatCommonDBInterface soteiMap, JBSbatCommonDBInterface dbMap,
																	String svcStaYmd, String svcChrgStaYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][snstZanYoTukiSuIyak2]");
		
		BigDecimal zanYoTukiSu = BigDecimal.ZERO;  // 残余月数（残された違約金対象期間の内、解約月を除く月の数）
		BigDecimal getuSa = BigDecimal.ZERO;       // 月差
		
		// 想定金額算出方法コード取得
		String soteiAmntSnstWayCd 	= dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.SOTEI_AMNT_SNST_WAY_CD);
		
		// 想定金額算出方法コードが（違約金（サービス開始日基準））の場合
		if(JACStrConst.SOTEI_AMNT_SNST_WAY_CD_PNL_SSD.equals(soteiAmntSnstWayCd))
		{
			// サービス開始年月日と解約起算日を基に月差を求める。
			getuSa =  new BigDecimal(JBSbatDateUtil.monthDiff(this.svcDslKisanYmd.substring(0, 6), svcStaYmd.substring(0, 6), DIFF_NAI_FLG)); 
		}
		else
		{
			//上記以外（ 想定金額算出方法コードが（違約金（課金開始日基準））の場合）
			// サービス課金開始年月日と解約起算日を基に月差を求める。
			getuSa =  new BigDecimal(JBSbatDateUtil.monthDiff(this.svcDslKisanYmd.substring(0, 6), svcChrgStaYmd.substring(0, 6), DIFF_NAI_FLG)); 
		}
		
		if(getuSa.signum() == INT_MINUS_ONE)
		{
			getuSa = BigDecimal.ZERO;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstZanYoTukiSuIyak2][月差がマイナスのため、ゼロに置き換え]");
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstZanYoTukiSuIyak2][算出月差：" + getuSa + "]");
		
		BigDecimal upplValue = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstZanYoTukiSuIyak2][上限値：" + upplValue + "]");

		// ワーク．残余月数　←　想定料金ＭＡＰ．上限値　−　ワーク．月差　−　１
		zanYoTukiSu = upplValue.subtract(getuSa).subtract(ONE);
		
		if(zanYoTukiSu.signum() == INT_MINUS_ONE)
		{
			zanYoTukiSu = BigDecimal.ZERO;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstZanYoTukiSuIyak2][残余月数がマイナスのため、ゼロに置き換え]");
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstZanYoTukiSuIyak2][算出残余月数：" + zanYoTukiSu + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][snstZanYoTukiSuIyak2]");
		return zanYoTukiSu;
		
	}

	/**
	 * 日割額算出（違約金）�U（日基準）
	 * 
	 * @param soteiMap 想定料金マスタ
	 * @param dbMap 請求内訳パターンマスタ
	 * @return BigDecimal[] 0:解約月日割額、1:終了月日割額
	 * @throws Exception
	 */
	private BigDecimal[] snstHiwariAmtIyak2(JBSbatCommonDBInterface soteiMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][snstHiwariAmtIyak2]");
		
		BigDecimal[] tempHiwariAmt = new BigDecimal[2];

		// 解約月日割額、終了月日割額算出
		BigDecimal dslMonHiwariAmt = BigDecimal.ZERO; // 解約月日割額
		BigDecimal endMonHiwariAmt = BigDecimal.ZERO; // 終了月日割額
		
		// 解約起算月の月末日を算出
		String svcDslKisanMnEndYmd = getEndOfMonthYmd(this.svcDslKisanYmd);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][解約起算月の月末日：" + svcDslKisanMnEndYmd + "]");
		
		String hiwariYh = dbMap.getString(JBSbatAK_M_SEIKY_PTN_UW.HIWARI_YH);		// 日割要否
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][日割要否：" + hiwariYh + "]");
		

		// 丸め方法コード取得
		String roundWayCd = soteiMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
		
		// 日割要否　＝　日割あり の場合
		if(JACStrConst.HIWARI_YH_ARI.equals(hiwariYh))
		{
			// 解約起算月（ワーク．解約起算日の上６桁）　＝　違約金対象期間の終了月（ワーク．対象期間の終了日の上６桁）の場合
			if(this.svcDslKisanYmd.substring(0, 6).equals(this.trgtPrdEndYmd.substring(0, 6)))
			{
				// ワーク．日割日数　　　←　ワーク．対象期間の終了日（dd）　−　ワーク．解約起算日（dd）　＋　１
				BigDecimal hiwariNisu = new BigDecimal(JBSbatDateUtil.dayDiff(this.trgtPrdEndYmd, this.svcDslKisanYmd, DIFF_NAI_FLG));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][日割日数：" + hiwariNisu + "]");

				// 解約月日割額
				// ワーク．解約月日割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．解約月残日数　÷　ワーク．解約起算月の月末日（dd）（＝解約起算月の暦日数）
				BigDecimal tmpDslMonHiwariAmt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC)
											.multiply(hiwariNisu).divide(new BigDecimal(svcDslKisanMnEndYmd.substring(6, 8)));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理前解約月日割額：" + tmpDslMonHiwariAmt + "]");
				
				
				// 端数処理
				// 配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
				// 配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
				// 配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
				// 上記以外（"0"（丸めなし））     の場合
				// 小数点第三位で四捨五入を行う。
				dslMonHiwariAmt = JACbatRknBusinessUtil.round(roundWayCd, tmpDslMonHiwariAmt, 2);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理後解約月日割額：" + dslMonHiwariAmt + "]");
				
				// 終了月日割額
				// ワーク．終了月日割額　←　ゼロ
				BigDecimal endHiwariAmt = BigDecimal.ZERO;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][終了月日割額：" + endHiwariAmt + "]");
				
			}
			else
			{
				// 対象期間終了月の月末日を算出
				String trgtPrdEndMnEndYmd = getEndOfMonthYmd(this.trgtPrdEndYmd);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][対象期間終了月の月末日：" + trgtPrdEndMnEndYmd + "]");
				
				// ワーク．解約月残日数　←　ワーク．解約起算月の月末日（dd）　−　ワーク．解約起算日（dd）　＋　１
				BigDecimal dslMnZanNisu = new BigDecimal(JBSbatDateUtil.dayDiff(svcDslKisanMnEndYmd, this.svcDslKisanYmd, DIFF_NAI_FLG));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][解約月残日数：" + dslMnZanNisu + "]");
				
				// ワーク．解約月日割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．解約月残日数　÷　ワーク．解約起算月の月末日（dd）（＝解約起算月の暦日数）
				BigDecimal tmpDslMonHiwariAmt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC)
										.multiply(dslMnZanNisu).divide(new BigDecimal(svcDslKisanMnEndYmd.substring(6, 8)));
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理前解約月日割額：" + tmpDslMonHiwariAmt + "]");
				
				// 端数処理
				// 配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
				// 配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
				// 配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
				// 上記以外（"0"（丸めなし））     の場合
				// 小数点第三位で四捨五入を行う。
				dslMonHiwariAmt = JACbatRknBusinessUtil.round(roundWayCd, tmpDslMonHiwariAmt, 2);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理後解約月日割額：" + dslMonHiwariAmt + "]");
				
				// 終了月残日数 ＝　対象期間の終了日（dd）
				BigDecimal endMnZnNisu = new BigDecimal(this.trgtPrdEndYmd.substring(6, 8));
				
				// ワーク．終了月日割額　←　想定料金ＭＡＰ．想定料金　×　ワーク．終了月残日数　÷　ワーク．対象期間終了月の月末日（dd）
				BigDecimal tmpEndMonHiwariAmt = soteiMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC)
								.multiply(endMnZnNisu).divide(new BigDecimal(svcDslKisanMnEndYmd.substring(6, 8)));
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理前終了月日割額：" + tmpEndMonHiwariAmt + "]");

				// 端数処理
				// 配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
				// 配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
				// 配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
				// 上記以外（"0"（丸めなし））     の場合
				// 小数点第三位で四捨五入を行う。
				endMonHiwariAmt = JACbatRknBusinessUtil.round(roundWayCd, tmpEndMonHiwariAmt, 2);
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][丸め処理後終了月日割額：" + endMonHiwariAmt + "]");
			}
		}
		else
		{
			dslMonHiwariAmt = BigDecimal.ZERO; // 解約月日割額
			endMonHiwariAmt = BigDecimal.ZERO; // 終了月日割額	
		}
		
		// 移送用のリストにコピー
		tempHiwariAmt[0] = dslMonHiwariAmt; // 解約月日割額
		tempHiwariAmt[1] = endMonHiwariAmt; // 終了月日割額

		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][解約月日割額：" + tempHiwariAmt[0] + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][snstHiwariAmtIyak2][終了月日割額：" + tempHiwariAmt[1] + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][snstHiwariAmtIyak2]");
		return tempHiwariAmt;
	}
	
	/**
	 * 月末日(年月日形式)を取得する
	 * @param inputYmd 入力年月日
	 * @return	入力年月日の月末日
	 * @throws Exception
	 */
	private String getEndOfMonthYmd(String inputYmd) throws Exception
	{
		String endYm = inputYmd.substring(0, 6);
		String endOfMonth = JBSbatDateUtil.getEndOfMonth(endYm);
		return endYm + endOfMonth;
	}
	
	/**
	 * 文字を連結します。
	 * 
	 * @param  string 文字
	 * @return strBuf 連結した文字列
	 */
	private String makeStr(String ...string)
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeStr]");
		
		StringBuffer strBuf = new StringBuffer();
		for(String str:string)
		{
			if(str == null)
			{
				strBuf.append(JACStrConst.KARA_MOJI);
			}
			else
			{
				strBuf.append(str);
			}
		}
		
		assert strBuf != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][strBuf][strBuf = " + strBuf.toString() + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeStr]");
		
		return strBuf.toString();
	}
	
	/**
	 * 指定文字列に対して指定桁数までのパディング処理を行い返却します。（指定桁数分半角スペース埋め）。
	 * 
	 * @param  s   指定文字列
	 * @param  digitno 指定桁数
	 * @return s   パディング処理した文字列
	 */
	private String padding(String s, int digitno)
	{
		String str = s;
		int cnt = digitno;
		
		cnt = cnt - str.length();
		
		for(int i = 0; i < cnt; i++)
		{
			str = str + JACStrConst.SPACE_1;
		}
		
		return str;
	}
}