/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom  					 *
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatACTrgtSvcKeiMake
*	ソースファイル名	：JBSbatACTrgtSvcKeiMake.java
*	作成者				：富士通　
*	作成日				：2011年07月02日
*＜機能概要＞
*　課金対象サービス契約情報作成部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/07/02   富士通		新規作成
*	v3.00		2012/06/21   FJ)永田	【ANK-0024-04-00】
*	v4.00		2012/09/24   FJ)冨井	【ANK-0546-00-00】ファイル区分（課金対象割賦割引契約情報）追加対応
*	v4.01		2012/10/08   FJ)岡田	【ST3-2012-0000331】整理番号NULL対応
*	v4.02		2012/10/25   FJ)垣内	【TG1-2012-0000248】基本料金が出力される（利用不可期間中に解約場の場合）
*	v4.03		2013/01/18   FJ)早崎	【SEP-0041-00-00】  利用不可期間による減額仕様の誤り対応
*	v4.04		2013/02/06   FJ)早崎	【ST3-2013-0000347】課金開始日不正対応
*	v4.05		2013/03/29   FJ)後藤	【ST4-2013-0000263】性能改善
*	v4.06		2013/04/11   FJ)浜口	【TG1-2013-XXXXXXX】利用不可日数が利用日数を超す不具合修正
**	v4.06		2013/04/13   FJ)早崎	【TG1-2013-0000155】課金開始日最新レコード取得条件修正
*	v4.07		2013/06/07   FJ)前田	【内部管理番号-0001093】利用不可日数がマイナスのとき0と出力するように修正
*	v4.08		2013/06/15   FJ)後藤	【ANK-1535-00-00】回復時の利用不可日数算出方法変更対応
*	v5.00.00	2013/07/09   FJ)桑島	【TG1-2013-0000662】請求年月対応
*	v5.01		2013/09/09   FJ)伊藤	【OM-2013-0001854】休止状態が同月に複数回解除と開始されたケースに対応
*	v5.02		2013/10/24   FJ)小掠	【OM-2013-0003591】利用不可日数がマイナスの時、整理番号毎ではなく明細毎に０にするように修正
*	v6.00		2013/12/11   FJ)伊藤	【OM-2013-0005095】休止対象から、休止開始日が請求年月翌月以降のものは除外するように修正
*														   ただし、休止対象レコードが翌月以降のみのものしかない場合は、そちらを課金対象とする。
*	v6.01		2013/12/18   FJ)垣内	【OM-2013-0005081】休止時セット割適用外：割引契約に対する休止判定処理を追加
*	v7.00		2014/02/08   FJ)垣内	【OM-2014-0000520】サービス利用不可終了日が未設定の場合のソート順考慮漏れによる対応
*	v9.00.00	2014/04/16   FJ) 狭間	【ANK-2054-00-00】スマートリンク端末補償対応
*	v12.00.00	2014/09/24   FJ)岡田	【ANK-2249-00-00】マンション相対料金設定対応
*	v13.00.00	2015/03/26   FJ)阪口	【OM-2015-0000363】請求書発行手数料が課金されない
*	v15.00.00	2015/08/06   FJ)西面	【ANK-2163-00-00】利用不可減額
*	v20.00.00	2015/11/10   FJ)金	    【OM-2015-0002787】利用不可減額の日割要否の判定
*********************************************************************/
package eo.business.service;

import java.util.ArrayList;
import java.util.HashMap;

import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JACbatSchdlUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.util.file.JBSbatACIFI001;
import eo.business.util.file.JBSbatACIFI015;
import eo.business.util.file.JBSbatACIFM054;
import eo.business.util.table.JBSbatAC_M_MANS_TEGAKPRC;
import eo.business.util.table.JBSbatAC_M_PRC_COLLECT_JDG;
import eo.business.util.table.JBSbatAC_M_PRC_SVC_JOKEN;
import eo.business.util.table.JBSbatAC_M_PRC_SVC_KANRI;
import eo.business.util.table.JBSbatAC_M_TEGAK_PRC;
import eo.business.util.table.JBSbatAC_M_TEIZO_PRC;
import eo.business.util.table.JBSbatAC_M_WRIB_PRC;
import eo.common.constant.JACStrConst;
import eo.common.util.JPCUtilCommon;
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.JBSbatStringUtil;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatACTrgtSvcKeiMake extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(料金サービス条件)*/
	private static final String D_TBL_NAME_AC_M_PRC_SVC_JOKEN = "AC_M_PRC_SVC_JOKEN";

	/** テーブル(料金サービス管理)*/
	private static final String D_TBL_NAME_AC_M_PRC_SVC_KANRI = "AC_M_PRC_SVC_KANRI";

	/** テーブル(定額料金)*/
	private static final String D_TBL_NAME_AC_M_TEGAK_PRC = "AC_M_TEGAK_PRC";

	/** テーブル(割引料金)*/
	private static final String D_TBL_NAME_AC_M_WRIB_PRC = "AC_M_WRIB_PRC";

	/** テーブル(逓増料金)*/
	private static final String D_TBL_NAME_AC_M_TEIZO_PRC = "AC_M_TEIZO_PRC";

	/** テーブル(マンション定額料金)*/
	private static final String D_TBL_NAME_AC_M_MANS_TEGAKPRC = "AC_M_MANS_TEGAKPRC";

	/** テーブル(料金徴収判定)*/
	private static final String D_TBL_NAME_AC_M_PRC_COLLECT_JDG = "AC_M_PRC_COLLECT_JDG";

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

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

	/** SQL定義キー(AC_SELECT_001)*/
	private static final String AC_M_TEGAK_PRC_AC_SELECT_005 = "AC_SELECT_005";

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

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

	// ANK-2249-00-00 MOD START
	/** SQL定義キー(AC_SELECT_003)*/
	//private static final String AC_M_MANS_TEGAKPRC_AC_SELECT_003 = "AC_SELECT_003";
	/** SQL定義キー(AC_SELECT_005)*/
	private static final String AC_M_MANS_TEGAKPRC_AC_SELECT_005 = "AC_SELECT_005";
	// ANK-2249-00-00 MOD END

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

	/** テーブルアクセスクラス(料金サービス条件)*/
	private JBSbatSQLAccess db_AC_M_PRC_SVC_JOKEN = null;

	/** テーブルアクセスクラス(料金サービス管理)*/
	private JBSbatSQLAccess db_AC_M_PRC_SVC_KANRI = null;

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

	/** テーブルアクセスクラス(割引料金)*/
	private JBSbatSQLAccess db_AC_M_WRIB_PRC = null;

	/** テーブルアクセスクラス(逓増料金)*/
	private JBSbatSQLAccess db_AC_M_TEIZO_PRC = null;

	/** テーブルアクセスクラス(マンション定額料金)*/
	private JBSbatSQLAccess db_AC_M_MANS_TEGAKPRC = null;

	/** テーブルアクセスクラス(料金徴収判定)*/
	private JBSbatSQLAccess db_AC_M_PRC_COLLECT_JDG = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/**▼▼▼▼▼▼クラス変数追加 開始▼▼▼▼▼▼*/
	
	/** 料金グループコード桁数 */
	private static final int PRC_GRP_CD_LEN 			= 2;
	/** 料金コースコード桁数 */
	private static final int PCRS_CD_LEN 			= 3;
	/** 料金サービスコード桁数 */
	private static final int PRC_SVC_CD_LEN 			= 12;
	/** 請求契約番号（請求先番号）桁数 */
	private static final int SEIKY_KEI_NO_LEN 		= 10;
	/** 整理番号桁数 */
	private static final int SEIRI_NO_LEN 			= 14;
	/** サービス番号桁数 */
	private static final int SVC_NO_LEN 				= 20;
	/** 従属サービス番号桁数 */
	private static final int JYUZOKU_SVC_NO_LEN 		= 12;
	/** 割引サービス契約番号桁数 */
	private static final int WRIB_SVC_KEI_NO_LEN 	= 12;
	/** サービス開始日桁数 */
	private static final int SVC_STAYMD_LEN 			= 8;
	/** 初回課金開始日桁数 */
	private static final int FIRST_CHRG_STAYMD_LEN 	= 8;
	/** 課金開始日桁数 */
	private static final int CHRG_STAYMD_LEN 		= 8;
	/** 課金終了日桁数 */
	private static final int CHRG_ENDYMD_LEN 		= 8;
	/** サービス解約日桁数 */
	private static final int SVC_DSL_YMD_LEN 		= 8;
	/** サービス回復日桁数 */
	private static final int SVC_KAIHK_DAY_LEN 		= 8;
	/** サービスキャンセル日桁数 */
	private static final int SVC_CANCEL_DAY_LEN 		= 8;
	// ANK-2249-00-00 ADD START
	/** 料金グループコード「マンションオーナー」 */
	private static final String PRC_GRP_CD_MANS_OWNR 	= "99";
	// ANK-2249-00-00 ADD END
	
	/**
	 * 料金サービス条件保持用マップ<BR>
	 * 「請求書送付サービス」の判定用。
	 **/
	private HashMap<String, String> db_SkySvcJknMap		= null;

	/**
	 * 料金サービス条件保持用マップ<BR>
	 * 「通話明細送付サービス」の判定用。
	 **/
	private HashMap<String, String> db_TwMsiSvcJknMap		= null;
	
	/**
	 * 料金サービス条件保持用マップ<BR>
	 * 「割賦割引サービス」の判定用。
	 **/
	private HashMap<String, String> db_KapWriSvcJknMap		= null;
	
	/**
	 * 料金サービス条件保持用マップ<BR>
	 * 「スマートリンク端末系料金サービス」の判定用。
	 **/
	private HashMap<String, String> db_SmartLinkPrcSvcJknMap	= null;

	/**
	 * 料金サービス管理保持用マップ<BR>
	 * 出力ファイル、料金サービス識別コード用。
	 **/
	private HashMap<String, String> db_SvcKnrMap			= null;

	/** 請求年月 */
	private String wk_SkyuYM 	= null;

	/** 群月初日 */
	private String wk_GunStr 	= null;

	/** 群締め日 */
	private String wk_GunEnd 	= null;

// OM-2015-0000363 ADD START
	/** 前月末日(群月初日の前日) */
	private String wk_ZenEnd 	= null;
// OM-2015-0000363 ADD END

	/** 請求年月の歴日付 */
	private int	wk_CalDay 	= -1;
	
	// twk_が付く変数は、同一キー単位での情報とする。
	// キーブレイクしたら、初期化すること。
	/**
	 * 当月イベント発生フラグ （true：当月イベントあり、false ：当月イベントなし（初期値））
	 */
	private boolean 	twk_flgIsEvntRslt 	= false;

	/** 入力レコード退避リスト */
	private ArrayList<JBSbatServiceInterfaceMap>	twk_tmpList = new ArrayList<JBSbatServiceInterfaceMap>();
	
	/** 通話明細送付サービスレコード退避リスト */
	private ArrayList<JBSbatServiceInterfaceMap>	twk_TwMsiShSVcMap = null;
	
	/** 通話明細送付サービスキー */
	private String thTwMsiShSvcKey = null;
	
	/** 有効範囲内チェック部品引数（3:文字列（年月日）） */
	private static final String RNG_CHCK_FLG_YMD = "3";

	/**  定額料金マップ */
	private HashMap<String, String> tegakMap = null;

	/**  割引料金マップ */
	private HashMap<String, String> wribMap = null;

	/**  逓増料金マップ */
	private HashMap<String, String> teizoMap = null;

	/**  マンション定額料金マップ */
	private HashMap<String, String> mansMap = null;

	/**  料金徴収判定マップ */
	private HashMap<String, String> colMap = null;
	
	/**  休止解除日空白フラグ */
	private boolean svcPauseRelEmpFlg = false;
	
	/**  未来休止開始日除外フラグ */
	private boolean furSvcPauseStrJgiFlg = false;
	
	/**▲▲▲▲▲▲クラス変数追加 終了▲▲▲▲▲▲*/
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_AC_M_PRC_SVC_JOKEN = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_PRC_SVC_JOKEN);
		db_AC_M_PRC_SVC_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_PRC_SVC_KANRI);
		db_AC_M_TEGAK_PRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_TEGAK_PRC);
		db_AC_M_WRIB_PRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_WRIB_PRC);
		db_AC_M_TEIZO_PRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_TEIZO_PRC);
		db_AC_M_MANS_TEGAKPRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_MANS_TEGAKPRC);
		db_AC_M_PRC_COLLECT_JDG = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_PRC_COLLECT_JDG);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		// 請求年月取得
		JACbatSchdlUtil schdUtil = new JACbatSchdlUtil(commonItem);
		
		try
		{
			// 料金スケジュール定義アクセス部品を使用する。
			this.wk_SkyuYM = schdUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_RYOKIN_KEISAN_YMD);
			
			// 群月初日、群締め日　←　JACbatSchdlUtil.getUseStrEnd(請求年月, イベントコード("01"（利用開始日））, イベントコード（"02"（利用終了日））)
			String[] rtn = schdUtil.getUseStrEnd(this.wk_SkyuYM, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
			
			this.wk_GunStr = rtn[0];
			this.wk_GunEnd = rtn[1];
		}
		finally
		{
			// クローズ
			schdUtil.close();
		}
		
// OM-2015-0000363 ADD START
		// 前月末日（群月初日の前日）の取得
		this.wk_ZenEnd = JPCUtilCommon.addDay(wk_GunStr, -1);
// OM-2015-0000363 ADD END
		
		// サービス条件マスタ検索処理 
		this.setSvcJokenMap();

		// サービス管理マスタ検索処理 
		this.setSvcKnrMap();
		
		// 請求月の暦日数を取得する（引数：群終了日、群開始日）
		this.wk_CalDay = JPCUtilCommon.subtractDay(wk_GunEnd, wk_GunStr) + 1;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
				"バッチ運用日：" + super.opeDate +
				"　群開始日："   + this.wk_GunStr +
				"　群開始日："   + this.wk_GunEnd +
				"　歴日付："     + this.wk_CalDay);
		
		// 各種料金マスタ処理 
		this.setHiwariJudgeMap();
	/** ▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲ */
	}

	/**
	 * 主処理
	 * @param inMap　入力電文
	 * @param outputInItem 入力情報
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap, JBSbatOutputItem outputInItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][mastMap=" + inMap.getMap().toString() + "]") : true;

		// ■最終レコード後はここで終了
		if(inMap == null)
		{
			// 出力
			// キーブレイク時の処理
			this.keyBreak(outputInItem);
			
			// 最終処理後
			// 通話明細送付サービスレコード退避リスト≠nullの場合
			if(this.twk_TwMsiShSVcMap != null)
			{
				outTwMsiShMap(this.twk_TwMsiShSVcMap, outputInItem);
			}
			// 処理終了
			return outputInItem;
		}
		
		// 主処理の先頭にて
		// サービスコードをフル桁にする
		inMap.setString(JBSbatACIFI001.TRGT_PRC_SVC_CD,
						JACbatRknBusinessUtil.fullPrcSvcCd(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)));

		String inKey 		= null;		// 入力．キー
		String tmpKey 		= null;		// 退避．キー

		// ブレイクキー（入力）の設定
		inKey = getKeyInfo(inMap);

		// ■1件目（初回）はここで終了
		//   退避．キー ＝ null の場合
		if (!outputInItem.isKeyList())
		{
			// ダミーレコードの設定
			// ※最終レコード後の主処理呼び出しのため
			outputInItem.addOutMapList(new JBSbatServiceInterfaceMap());

			// キー情報設定
			outputInItem.clearKeyList(); 		// キー情報のクリア
			outputInItem.addKeyList(inKey); 	// ブレイクキー（入力）

			// 対象判定処理
			this.checkRec(inMap);

			return outputInItem;
		}

		// ■2件目以降（退避キーが存在する場合）
		// 退避．キーの取得
		tmpKey = (String)outputInItem.getKeyList().get(0);

		// 出力情報設定
		// 入力．キー ＝　退避．キー
		if (inKey.equals(tmpKey))
		{
			// 対象判定処理
			this.checkRec(inMap);
		}
		// 入力．キー ≠　退避．キー
		else
		{
			this.keyBreak(outputInItem);
			
			// 退避クリア
			this.twk_flgIsEvntRslt = false;
			this.twk_tmpList       = new ArrayList<JBSbatServiceInterfaceMap>();

			// キー情報設定
			outputInItem.clearKeyList(); 		// キー情報のクリア
			outputInItem.addKeyList(inKey); 	// ブレイクキー（入力）

			// 対象判定処理
			this.checkRec(inMap);
		}
		assert inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]") : true;
		return outputInItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}
	
	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_AC_M_PRC_SVC_JOKEN.close();
		db_AC_M_PRC_SVC_KANRI.close();
		db_AC_M_TEGAK_PRC.close();
		db_AC_M_WRIB_PRC.close();
		db_AC_M_TEIZO_PRC.close();
		db_AC_M_MANS_TEGAKPRC.close();
		db_AC_M_PRC_COLLECT_JDG.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**
	 * SQLKEY(AC_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 executeAC_M_PRC_SVC_JOKEN_AC_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());

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

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

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

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

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

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

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

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

		// DBアクセスを実行します
		db_AC_M_TEIZO_PRC.selectBySqlDefine(paramList, AC_M_TEIZO_PRC_AC_SELECT_001);
	}
	// ANK-2249-00-00 MOD START
	/**
	 * SQLKEY(AC_SELECT_003)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	システムコード
	 *		 	マンション定額料金適用開始年月日
	 *		 	マンション定額料金適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
//	private void executeAC_M_MANS_TEGAKPRC_AC_SELECT_003(Object[] param) throws Exception
//	{
		// バイント変数のリストを生成します
//		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
//		paramList.setValue(param[0].toString());
//		paramList.setValue(param[1].toString());
//		paramList.setValue(param[2].toString());

		// DBアクセスを実行します
//		db_AC_M_MANS_TEGAKPRC.selectBySqlDefine(paramList, AC_M_MANS_TEGAKPRC_AC_SELECT_003);
//	}
	
	/**
	 * SQLKEY(AC_SELECT_005)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	システムコード
	 *		 	マンション定額料金適用開始年月日
	 *		 	マンション定額料金適用終了年月日
	 *		 	支払契約識別コード
	 *		 	支払契約識別コード
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAC_M_MANS_TEGAKPRC_AC_SELECT_005(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());
		paramList.setValue(param[4].toString());

		// DBアクセスを実行します
		db_AC_M_MANS_TEGAKPRC.selectBySqlDefine(paramList, AC_M_MANS_TEGAKPRC_AC_SELECT_005);
	}
	// ANK-2249-00-00 MOD END
	/**
	 * SQLKEY(AC_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 executeAC_M_PRC_COLLECT_JDG_AC_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

		// DBアクセスを実行します
		db_AC_M_PRC_COLLECT_JDG.selectBySqlDefine(paramList, AC_M_PRC_COLLECT_JDG_AC_SELECT_001);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	

	/**▼▼▼▼▼▼メソッド追加 開始▼▼▼▼▼▼*/	

	/**
	 * サービス条件マスタ検索処理 <br>
	 * @throws Exception
	 */
	private void setSvcJokenMap() throws Exception
	{
		// 請求書送付サービス判定マップ作成
		makeSkyShSvcMap();
		// 通話明細送付サービス判定マップ作成
		makeTwMsiShMap();
		// 割賦割引サービス判定マップ作成
		makeKapWriSvcMap();
		// スマートリンク端末系料金サービス判定マップ作成
		makeSmartLinkPrcSvcMap();
	}
	
	/**
	 * 請求書送付サービス判定マップ作成
	 * 検索結果は、HashMap（this.db_SkySvcJknMap）へ設定する。 <br>
	 *  キー：料金コースコード ＋ 料金サービスコード <br>
	 *  値  ：料金サービス条件コード <br>
	 * <br>
	 *  「請求書送付サービス」の判定にて使用する。 <br>
	 *   ※ 料金サービス条件コード = "1"（請求書送付サービス特定）
	 * @throws Exception
	 */
	private void makeSkyShSvcMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		dbList.setValue(super.systemCode);								// システムコード
		dbList.setValue(JACStrConst.REC_SKBT_CD_SKS_SOHU_SVC_JOKEN);	// レコード識別コード（"10"：請求書送付サービス条件）
		dbList.setValue(this.wk_GunEnd);								// 適用開始年月日,適用終了年月日
		
		// SELECT文発行
		executeAC_M_PRC_SVC_JOKEN_AC_SELECT_001(dbList.getList().toArray());
		
		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		
		db_SkySvcJknMap = new HashMap<String, String>();
		
		// 取得情報が存在する間繰り返す
		while (dbMap != null) 
		{
			StringBuffer keyBuf = new StringBuffer();
			
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PCRS_CD));		// 料金コースコード
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_CD)); 	// 料金サービスコード
			
			// Key  :料金コースコード＋料金サービスコード
			// value:料金サービス条件コード
			this.db_SkySvcJknMap.put(keyBuf.toString(), dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_JOKEN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		}
	}

	/**
	 * 通話明細送付サービス判定マップ作成
	 * 検索結果は、HashMap（this.db_TwMsiSvcJknMap）へ設定する。 <br>
	 *  キー：料金コースコード ＋ 料金サービスコード <br>
	 *  値  ：料金サービス条件コード <br>
	 * <br>
	 *  「通話明細送付サービス」の判定にて使用する。 <br>
	 *   ※ 料金サービス条件コード = "1"（通話明細送付サービス特定）
	 * @throws Exception
	 */
	private void makeTwMsiShMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		dbList.setValue(super.systemCode);								// システムコード
		dbList.setValue(JACStrConst.REC_SKBT_CD_TW_MSI_SOHU_SVC_JOKEN);	// レコード識別コード（"20"：通話明細送付サービス条件）
		dbList.setValue(this.wk_GunEnd);								// 適用開始年月日,適用終了年月日
		
		// SELECT文発行
		executeAC_M_PRC_SVC_JOKEN_AC_SELECT_001(dbList.getList().toArray());
		
		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		
		db_TwMsiSvcJknMap = new HashMap<String, String>();
		
		// 取得情報が存在する間繰り返す
		while (dbMap != null) 
		{
			StringBuffer keyBuf = new StringBuffer();
			
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PCRS_CD));		// 料金コースコード
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_CD)); 	// 料金サービスコード
			
			// Key  :料金コースコード＋料金サービスコード
			// value:料金サービス条件コード
			this.db_TwMsiSvcJknMap.put(keyBuf.toString(), dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_JOKEN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		}
	}

	/**
	 * 割賦割引サービス判定マップ作成
	 * 検索結果は、HashMap（this.db_KapWriSvcJknMap）へ設定する。 <br>
	 *  キー：料金コースコード ＋ 料金サービスコード <br>
	 *  値  ：料金サービス条件コード <br>
	 * <br>
	 *  「割賦割引サービス」の判定にて使用する。 <br>
	 *   ※ 料金サービス条件コード = "1"（割賦割引サービス特定）
	 * @throws Exception
	 */
	private void makeKapWriSvcMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		dbList.setValue(super.systemCode);								// システムコード
		dbList.setValue(JACStrConst.REC_SKBT_CD_KAP_WRI_SVC_JOKEN);		// レコード識別コード（"30"：割賦割引サービス条件）
		dbList.setValue(this.wk_GunEnd);								// 適用開始年月日,適用終了年月日
		
		// SELECT文発行
		executeAC_M_PRC_SVC_JOKEN_AC_SELECT_001(dbList.getList().toArray());
		
		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		
		db_KapWriSvcJknMap = new HashMap<String, String>();
		
		// 取得情報が存在する間繰り返す
		while (dbMap != null) 
		{
			StringBuffer keyBuf = new StringBuffer();
			
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PCRS_CD));		// 料金コースコード
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_CD)); 	// 料金サービスコード
			
			// Key  :料金コースコード＋料金サービスコード
			// value:料金サービス条件コード
			this.db_KapWriSvcJknMap.put(keyBuf.toString(), dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_JOKEN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		}
	}

	/**
	 * スマートリンク端末系料金サービス判定マップ作成
	 * 検索結果は、HashMap（this.db_SmartLinkPrcSvcJknMap）へ設定する。 <br>
	 *  キー：料金サービスコード <br>
	 *  値  ：料金サービス条件コード <br>
	 * <br>
	 *  「スマートリンク端末系料金サービス」の判定にて使用する。 <br>
	 *   ※ 料金サービス条件コード = "1"（スマートリンク端末系料金サービス特定）
	 * @throws Exception
	 */
	private void makeSmartLinkPrcSvcMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		dbList.setValue(super.systemCode);									// システムコード
		dbList.setValue(JACStrConst.REC_SKBT_CD_SMART_LINK_PRC_SVC_JOKEN);	// レコード識別コード（"40"：スマートリンク端末系料金サービス条件）
		dbList.setValue(this.wk_GunEnd);									// 適用開始年月日,適用終了年月日
		
		// SELECT文発行
		executeAC_M_PRC_SVC_JOKEN_AC_SELECT_001(dbList.getList().toArray());
		
		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		
		db_SmartLinkPrcSvcJknMap = new HashMap<String, String>();
		
		// 取得情報が存在する間繰り返す
		while (dbMap != null) 
		{
			StringBuffer keyBuf = new StringBuffer();
			
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_CD)); 	// 料金サービスコード
			
			// Key  :料金サービスコード
			// value:料金サービス条件コード
			this.db_SmartLinkPrcSvcJknMap.put(keyBuf.toString(), dbMap.getString(JBSbatAC_M_PRC_SVC_JOKEN.PRC_SVC_JOKEN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_PRC_SVC_JOKEN.selectNext();
		}
	}
	
	/**
	 * サービス管理マスタ検索処理 <br>
	 * 検索結果は、HashMap（this.db_SvcKnrMap）へ設定する。 <br>
	 * 　　キー：料金コースコード　＋ 料金サービスコード <br>
	 * 　　値　：料金サービス識別コード<br>
	 * <br>
	 * 出力ファイルの編集にて使用する。
	 * 
	 * @throws Exception
	 */
	private void setSvcKnrMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		dbList.setValue(super.systemCode);		// システムコード
		dbList.setValue(this.wk_GunEnd); 		// 適用開始年月日,適用終了年月日

		// SELECT文発行 サービス管理マスタ情報
		executeAC_M_PRC_SVC_KANRI_AC_SELECT_001(dbList.getList().toArray());

		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_SVC_KANRI.selectNext();
		
		db_SvcKnrMap = new HashMap<String, String>();

		// 取得情報が存在する間繰り返す
		while (dbMap != null)
		{
			StringBuffer keyBuf = new StringBuffer();

			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_KANRI.PCRS_CD)); 		// 料金コースコード
			keyBuf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_KANRI.PRC_SVC_CD));	// 料金サービスコード

			// キー :料金コースコード＋料金サービスコード
			// 値　 :料金サービス識別コード
			db_SvcKnrMap.put(keyBuf.toString(), dbMap.getString(JBSbatAC_M_PRC_SVC_KANRI.PRC_SVC_SKBT_CD));

			// 次レコード取得
			dbMap = db_AC_M_PRC_SVC_KANRI.selectNext();
		}
	}

	/**
	 * キー情報取得処理<BR>
	 * キー情報：料金グループコード　＋　料金コースコード　＋　料金サービスコード
	 *           ＋　請求契約番号（請求先番号）　＋　整理番号　＋　サービス番号
	 *           ＋　従属サービス番号　＋　割引サービス契約番号
	 *           ＋　サービス開始日　＋　初回課金開始日　＋　課金開始日　＋　課金終了日
	 *           ＋　サービス解約日　＋　サービス回復日　＋　サービスキャンセル日
	 * @param  inMap 入力情報
	 * @return String キー情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getKeyInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		StringBuffer keyBuf = new StringBuffer();
		
		// 料金グループコード
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.PRC_GRP_CD), 			PRC_GRP_CD_LEN, 		true));
		// 料金コースコード
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.PCRS_CD), 				PCRS_CD_LEN, 			true));
		// 料金サービスコード
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD), 		PRC_SVC_CD_LEN, 		true));
		// 請求契約番号（請求先番号）
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SEIKY_KEI_NO), 		SEIKY_KEI_NO_LEN, 		true));
		// 整理番号
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SEIRI_NO), 			SEIRI_NO_LEN, 			true));
		// サービス番号
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SVC_NO), 				SVC_NO_LEN, 			true));
		// 従属サービス番号
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.JYUZOKU_SVC_NO), 		JYUZOKU_SVC_NO_LEN, 	true));
		// 割引サービス契約番号
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.WRIB_SVC_KEI_NO), 		WRIB_SVC_KEI_NO_LEN, 	true));
		// サービス開始日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SVC_STAYMD), 			SVC_STAYMD_LEN, 		true));
		// 初回課金開始日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.FIRST_CHRG_STAYMD), 	FIRST_CHRG_STAYMD_LEN, 	true));
		// 課金開始日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.CHRG_STAYMD), 			CHRG_STAYMD_LEN, 		true));
		// 課金終了日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.CHRG_ENDYMD), 			CHRG_ENDYMD_LEN, 		true));
		// サービス解約日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SVC_DSL_YMD), 			SVC_DSL_YMD_LEN, 		true));
		// サービス回復日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SVC_KAIHK_DAY), 		SVC_KAIHK_DAY_LEN, 		true));
		// サービスキャンセル日
		keyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatACIFI001.SVC_CANCEL_DAY), 		SVC_CANCEL_DAY_LEN, 	true));
		return keyBuf.toString();
	}

	/**
	 * キーブレイク時の処理
	 * 1）退避リストに設定した情報から以下の情報を求める。
	 *    ・利用開始日
	 *    ・利用終了日
	 *    ・利用日数
	 *    ・利用不可日数
	 * 2）計算した結果を出力レコードへ設定する
	 * @param outputInItem 出力共通電文クラス
	 * @throws Exception
	 */
	public void keyBreak(JBSbatOutputItem outputInItem) throws Exception
	{
		//空白フラグを初期化
		this.svcPauseRelEmpFlg = false;
		
		//未来フラグを初期化
		this.furSvcPauseStrJgiFlg = false;
		
		// 退避なし
		if(this.twk_tmpList.size() == 0)
		{
			return;
		}
		ArrayList<JBSbatServiceInterfaceMap> fukaList 		= new ArrayList<JBSbatServiceInterfaceMap>();	// 	利用不可マージ用リスト
		ArrayList<JBSbatServiceInterfaceMap> kyushiList 	= new ArrayList<JBSbatServiceInterfaceMap>();	// 	休止オミット用リスト
		ArrayList<JBSbatServiceInterfaceMap> tmpList 		= null;
		
		// 通話明細判定用キー作成
		StringBuffer twJdgkeyBuf 	= new StringBuffer();
		// 料金コースコード
		twJdgkeyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(this.twk_tmpList.get(0).getString(JBSbatACIFI001.PCRS_CD), 			PCRS_CD_LEN, 		true));
		// 料金サービスコード
		twJdgkeyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(this.twk_tmpList.get(0).getString(JBSbatACIFI001.TRGT_PRC_SVC_CD), 	PRC_SVC_CD_LEN, 	true));
		
		// 通話明細集計キー作成
		StringBuffer twSumkeyBuf 	= new StringBuffer();
		// 請求契約番号
		twSumkeyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(this.twk_tmpList.get(0).getString(JBSbatACIFI001.SEIKY_KEI_NO), 	SEIKY_KEI_NO_LEN, 	true));
		// 整理番号
		twSumkeyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(this.twk_tmpList.get(0).getString(JBSbatACIFI001.SEIRI_NO), 		SEIRI_NO_LEN, 		true));
		// サービス番号
		twSumkeyBuf.append(JACbatRknBusinessUtil.fillHalfSpace(this.twk_tmpList.get(0).getString(JBSbatACIFI001.SVC_NO), 		SVC_NO_LEN, 		true));
		
		// 通話明細送付サービスレコード退避リスト≠nullの場合
		if(this.twk_TwMsiShSVcMap != null)
		{
			// 通話明細送付サービスキー≠通話明細集計キーの場合
			if(!this.thTwMsiShSvcKey.equals(twSumkeyBuf.toString()))
			{
				outTwMsiShMap(this.twk_TwMsiShSVcMap, outputInItem);
				// 退避マップクリア
				this.twk_TwMsiShSVcMap = null;
			}
		}
		
		// 以下４つ分けて処理を行う。
		// １）利用不可あり
		// ２）利用不可なし、休止あり
		// ３）その他
		// ４）通話明細送付サービス
		
		// ４）通話明細送付サービス
		// サービス条件 = "1"（通話明細送付サービス特定） 
		if(JACStrConst.PRC_SVC_JOKEN_CD_TW_MSI_SOHU_SVC.equals(this.db_TwMsiSvcJknMap.get(twJdgkeyBuf.toString())))
		{
			// 通話明細送付サービスキー＝null（初回起動時）
			if(this.thTwMsiShSvcKey == null)
			{
				// 退避マップ初期化
				this.twk_TwMsiShSVcMap = new ArrayList<JBSbatServiceInterfaceMap>();
				// 通話明細送付サービスキーに通話明細集計キーを退避
				this.thTwMsiShSvcKey = twSumkeyBuf.toString();
			}
			
			// 通話明細送付サービスキー＝通話明細集計キーの場合
			if(this.thTwMsiShSvcKey.equals(twSumkeyBuf.toString()))
			{
				// 退避リスト件数分処理継続
				for (int i = 0; i < this.twk_tmpList.size(); i++)
				{
					// 退避マップに格納する
					this.twk_TwMsiShSVcMap.add(this.twk_tmpList.get(i));
				}
			}
			// キーブレイク
			else
			{
				// 退避マップ初期化
				this.twk_TwMsiShSVcMap = new ArrayList<JBSbatServiceInterfaceMap>();
				// 退避リスト件数分処理継続
				for (int i = 0; i < this.twk_tmpList.size(); i++)
				{
					// 退避マップに格納する
					this.twk_TwMsiShSVcMap.add(this.twk_tmpList.get(i));
				}
				// キー退避
				this.thTwMsiShSvcKey = twSumkeyBuf.toString();
			}
		}
		else
		{
			for (int i = 0; i < this.twk_tmpList.size(); i++)
			{
					
				JBSbatServiceInterfaceMap tmpMap = this.twk_tmpList.get(i);
				
				// １）利用不可期間を1レコードとして出力するため
				// 　　利用不可開始日が設定されているレコードはfukaListへ退避し、for文の後でマージして出力する
				if(!tmpMap.getString(JBSbatACIFI001.SVC_USE_FAIL_STAYMD).equals(JACStrConst.KARA_MOJI))
				{
					fukaList.add(tmpMap);
				}
				// ２）休止レコードが複数あった場合、直近のみ出力するため分けて退避する
				else if(!tmpMap.getString(JBSbatACIFI001.SVC_PAUSE_DAY).equals(JACStrConst.KARA_MOJI))
				{
					String svcPauseStartYm = tmpMap.getString(JBSbatACIFI001.SVC_PAUSE_DAY).substring(0, 6);
					int kakinTg = svcPauseStartYm.compareTo(wk_SkyuYM);
					
					if(!furSvcPauseStrJgiFlg)
					{
						if(!svcPauseRelEmpFlg)
							kyushiList.add(tmpMap);
						if(kakinTg <= 0)
							furSvcPauseStrJgiFlg = true;
						if(tmpMap.getString(JBSbatACIFI001.SVC_PAUSE_RLS_YMD).equals(JACStrConst.KARA_MOJI))
							svcPauseRelEmpFlg = true;
					}
					else
					{
						if(kakinTg <= 0)
						{
							if(!svcPauseRelEmpFlg)
								kyushiList.add(tmpMap);
							if(tmpMap.getString(JBSbatACIFI001.SVC_PAUSE_RLS_YMD).equals(JACStrConst.KARA_MOJI))
								svcPauseRelEmpFlg = true;
						}
					}
					
				}
				// ３）その他
				else
				{
					// １件ずつ出力する
					tmpList = new ArrayList<JBSbatServiceInterfaceMap>();
					tmpList.add(this.twk_tmpList.get(i));
					this.outPutRec(tmpList, outputInItem, false);
				}
			}
			// １-２）利用不可マージ用のリストが存在するとき、利用不可日数の計算をして出力
			if(!fukaList.isEmpty())
			{
				this.outPutRec(fukaList, outputInItem, true);
			}
			
			// ２-２）休止オミット用リストが存在するとき、最後のリストのみを出力する
			if(!kyushiList.isEmpty())
			{
				ArrayList<JBSbatServiceInterfaceMap> kyushiOmtList = new ArrayList<JBSbatServiceInterfaceMap>();
				kyushiOmtList.add(kyushiList.get(kyushiList.size() - 1));
				this.outPutRec(kyushiOmtList, outputInItem, false);
			}
		}
		
	}
	
	/**
	 * 課金開始日最新レコード抽出
	 * @param   twMsiList その他リスト
	 * @param   outputInItem
	 * @throws  Exception
	 */
	private void outTwMsiShMap(ArrayList<JBSbatServiceInterfaceMap> twMsiList, JBSbatOutputItem outputInItem) throws Exception
	{
		// 課金開始日最新レコード
		ArrayList<JBSbatServiceInterfaceMap> twMsiMap = null;
		// 退避.課金開始日
		String thChgeStaYmd = JACStrConst.KARA_MOJI;

		// リスト件数分処理を継続
		for(int i = 0; i < twMsiList.size(); i++)
		{
			// 「解約されていない契約」または「当月課金終了となった契約」
			if((twMsiList.get(i).getString(JBSbatACIFI001.SVC_DSL_YMD) == null || twMsiList.get(i).getString(JBSbatACIFI001.SVC_DSL_YMD).equals(JACStrConst.KARA_MOJI)) ||
				((this.wk_GunStr.compareTo(twMsiList.get(i).getString(JBSbatACIFI001.CHRG_ENDYMD)) <= 0) && (this.wk_GunEnd.compareTo(twMsiList.get(i).getString(JBSbatACIFI001.CHRG_ENDYMD)) >= 0)) &&
				((twMsiList.get(i).getString(JBSbatACIFI001.CHRG_STAYMD)).compareTo(twMsiList.get(i).getString(JBSbatACIFI001.CHRG_ENDYMD)) <= 0))
			{
				// リスト.課金開始日≧退避.課金開始日の場合(最新のレコード一件のみが抽出対象となる)
				if(twMsiList.get(i).getString(JBSbatACIFI001.CHRG_STAYMD).compareTo(thChgeStaYmd) >= 0)
				{
					// 初期化
					twMsiMap = new ArrayList<JBSbatServiceInterfaceMap>();
					// 課金開始日最新レコードに退避
					twMsiMap.add(twMsiList.get(i));
					// 退避.課金開始日にリスト.課金開始日.課金開始日を退避
					thChgeStaYmd 	= twMsiList.get(i).getString(JBSbatACIFI001.CHRG_STAYMD);
				}
			}
		}
		
		// 該当レコードが存在する場合
		if(twMsiMap != null)
		{
			this.outPutRec(twMsiMap, outputInItem, true);
		}
	}

	/**
	 * 課金対象サービス契約情報レコードを出力する
	 * @param  tmpList 退避リスト
	 * @param  outputInItem 出力オブジェクト
	 * @param  tmpFlg 利用不可日数の計算実施フラグ
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void outPutRec(ArrayList<JBSbatServiceInterfaceMap> tmpList, JBSbatOutputItem outputInItem, boolean tmpFlg) throws Exception
	{
		String useStaYmd 			= null; // 利用開始日
		String useEndYmd 			= null; // 利用終了日
		String tmpFistChrgStaYmd 	= null; // 課金開始日
		String tmpLastChrgEndYmd 	= null; // 課金終了日
		
		int notUseStr 		= 0; // 未利用期間（開始）
		int nouUseEnd 		= 0; // 未利用期間（終了）
		int riyoDateCount 	= 0; // 利用日数
		int lastInd 		= 0; // 退避リスト最終件インデックス
		
		boolean riyoDateCntFlg = true; 	// 利用日数計算フラグ
		boolean flg = tmpFlg; 				// 利用不可日数の計算実施フラグ
		
		// サービスを利用していない期間の算出
		// 退避リスト[1件目]．課金開始日
		tmpFistChrgStaYmd 	= tmpList.get(0).getString(JBSbatACIFI001.CHRG_STAYMD);
		// 退避リスト[最終件]．課金終了日
		lastInd = tmpList.size() - 1;
		tmpLastChrgEndYmd 	= tmpList.get(lastInd).getString(JBSbatACIFI001.CHRG_ENDYMD);
		
		// 課金開始日が設定されていない場合
		if(tmpFistChrgStaYmd.equals(JACStrConst.KARA_MOJI))
		{
			riyoDateCount = 0;
			useStaYmd = JACStrConst.KARA_MOJI;
			useEndYmd = JACStrConst.KARA_MOJI;
		}
		else 
		{
			// 課金終了日が設定されていて
			// 課金開始＞課金終了（初月解約）の場合
			if(!tmpLastChrgEndYmd.equals(JACStrConst.KARA_MOJI) && tmpFistChrgStaYmd.compareTo(tmpLastChrgEndYmd) > 0)
			{
				riyoDateCntFlg = false;
			}
			
			// 前月で課金終了している場合
			else if(tmpLastChrgEndYmd.compareTo(this.wk_GunStr) < 0)
			{
				riyoDateCntFlg = false;
			}
			
			//////////////////////////////////
			// A.群月初日　から(当月)課金開始日
			//////////////////////////////////
			// 前月で課金開始している場合
			// 退避リスト[1件目]．課金開始日  < 群月初日
			if(tmpFistChrgStaYmd.compareTo(this.wk_GunStr) < 0)
			{
				// 前月以前で課金終了している場合
				if(tmpLastChrgEndYmd.compareTo(this.wk_GunStr) < 0)
				{
					// ◆利用開始日　←　課金開始日
					useStaYmd = tmpFistChrgStaYmd;
				}
				else
				{
					// ◆利用開始日　←　群月初日
					useStaYmd = this.wk_GunStr;
				}
				
				// 0日間
				notUseStr = 0;
			}
			// 群月初日より後に課金開始している場合	
			// 群月初日　≦　退避リスト[1件目]．課金開始日	
			else
			{
				// ◆利用開始日　←　課金開始日
				useStaYmd = tmpFistChrgStaYmd;

				// 退避リスト[1件目]．課金開始日　-　群月初日
				notUseStr = JPCUtilCommon.subtractDay(tmpFistChrgStaYmd, this.wk_GunStr);
			}

			//////////////////////////////////
			// B.課金終了日 から 群締め日
			//////////////////////////////////
			// 群締め日まで課金対象の場合
			// 　退避リスト[最終件]．課金終了日　＝　未設定　 または
			// 　退避リスト[最終件]．課金終了日　＞　群月末日
			if(tmpLastChrgEndYmd.isEmpty() 
				|| tmpLastChrgEndYmd.compareTo(this.wk_GunEnd) > 0)
			{
				// ◆利用終了　←　群締め日
				useEndYmd = this.wk_GunEnd;

				// 0日間
				nouUseEnd = 0;
			}
			// 翌郡月初日以前に課金終了した場合	
			// 　退避リスト[最終件]．課金終了日　≦　群月末日
			else
			{
				// ◆利用終了　←　課金終了日
				useEndYmd = tmpLastChrgEndYmd;

				// 群締め日　-　退避リスト[最終件]．課金終了日
				nouUseEnd = JPCUtilCommon.subtractDay(this.wk_GunEnd, useEndYmd);
			}
			
			// ◆利用期間
			if(riyoDateCntFlg)
			{
				// 　利用日数　←　歴日数 - サービスを利用していない期間（未利用期間（開始）＋（終了））
				riyoDateCount = this.wk_CalDay - (notUseStr + nouUseEnd);
			}
			else
			{
			    // 利用日数が0の場合は利用不可日数の算出を行わない
				riyoDateCount = 0;
				flg = false;
			}
		}

		// ◆利用不可日数
		int riyoFuka = 0;
		//   利用不可期間の算出
		if(flg)
		{
			String kaihkDay = tmpList.get(0).getString(JBSbatACIFI001.SVC_KAIHK_DAY);

			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][outPutRec][kaihkDay：" + kaihkDay + "]");
			
			if(this.wk_GunStr.compareTo(kaihkDay) <= 0
					&& kaihkDay.compareTo(this.wk_GunEnd) <= 0
					&& isHiwariUm(tmpList.get(0)))
			{
				riyoFuka = this.getnotUseDaysKaihk(tmpList);
			}
			// v15.00.00 2015/07/31 Add Start
			else if (isSeiYmChgEnd(tmpLastChrgEndYmd)
					&& isHiwariUm(tmpList.get(0))) {
				riyoFuka = this.getnotUseDaysKaihk(tmpList);

			}
			// v15.00.00 2015/07/31 Add End
			else
			{
				riyoFuka = this.getnotUseDays(tmpList);
			}
		}

		// マップより（退避リストの最終件目取得）
		JBSbatServiceInterfaceMap tmpList1 = tmpList.get(lastInd);

		// 料金サービス条件検索用キー
		StringBuffer mapKeyBuf = new StringBuffer();
		mapKeyBuf.append(tmpList1.getString(JBSbatACIFI001.PCRS_CD)); 			// 料金コースコード
		mapKeyBuf.append(tmpList1.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)); 	// 料金サービスコード
		
		String prcSvcSkbtCd = null; // 料金サービス識別コード
		
		// 該当データありの場合
		if (db_SvcKnrMap.containsKey(mapKeyBuf.toString()))
		{
			prcSvcSkbtCd = db_SvcKnrMap.get(mapKeyBuf.toString());
		}
		// 該当データなし
		else 
		{
			prcSvcSkbtCd = JACStrConst.KARA_MOJI;	// 空文字
		}
		
		// ファイル区分取得
		String filDiv = getFileDiv(tmpList1);
		// サービス解約日取得
		String svcDslYmd = tmpList1.getString(JBSbatACIFI001.SVC_DSL_YMD);
		// サービス解約理由取得
		String svcDlre = tmpList1.getString(JBSbatACIFI001.SVC_DLRE);
		// 課金開始日取得
		String chrgStaYmd = tmpList1.getString(JBSbatACIFI001.CHRG_STAYMD);
		// 課金終了日取得
		String chrgEndYmd = tmpList1.getString(JBSbatACIFI001.CHRG_ENDYMD);
// OM-2015-0000363 ADD START
		// サービス開始日取得
		String svcStaYmd = tmpList1.getString(JBSbatACIFI001.SVC_STAYMD);
// OM-2015-0000363 ADD START

		// 出力レコード情報設定
		JBSbatServiceInterfaceMap outRecMap = new JBSbatServiceInterfaceMap();

		// 出力情報設定
		outRecMap.setString(JBSbatACIFM054.FILE_DIV,					filDiv); 																		// ファイル区分
		// 整理番号が未設定である場合にはフル桁スペース埋めに変換する
		outRecMap.setString(JBSbatACIFM054.SEIRI_NO,					convertNull(tmpList1.getString(JBSbatACIFI001.SEIRI_NO), SEIRI_NO_LEN)); 		// 整理番号
		outRecMap.setString(JBSbatACIFM054.SVC_SKBT_CD,					prcSvcSkbtCd); 																	// 料金サービス識別コード
		outRecMap.setString(JBSbatACIFM054.PRC_GRP_CD,					convertNull(tmpList1.getString(JBSbatACIFI001.PRC_GRP_CD), PRC_GRP_CD_LEN)); 	// 料金グループコード
		outRecMap.setString(JBSbatACIFM054.PCRS_CD,						convertNull(tmpList1.getString(JBSbatACIFI001.PCRS_CD), PCRS_CD_LEN)); 			// 料金コースコード
		outRecMap.setString(JBSbatACIFM054.PRC_SVC_CD,					tmpList1.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)); 			// 料金サービスコード
		outRecMap.setString(JBSbatACIFM054.SVC_NO,						tmpList1.getString(JBSbatACIFI001.SVC_NO)); 					// サービス番号
		outRecMap.setString(JBSbatACIFM054.OP_SVKEI_NO,					tmpList1.getString(JBSbatACIFI001.JYUZOKU_SVC_NO)); 			// オプションサービス契約番号
		outRecMap.setString(JBSbatACIFM054.SEIKY_KEI_NO,				tmpList1.getString(JBSbatACIFI001.SEIKY_KEI_NO)); 				// 請求先番号
		outRecMap.setString(JBSbatACIFM054.SEIKY_YM,					this.wk_SkyuYM); 												// 請求年月
		outRecMap.setString(JBSbatACIFM054.WRIB_SVC_KEI_NO,				tmpList1.getString(JBSbatACIFI001.WRIB_SVC_KEI_NO)); 			// 割引サービス契約番号
		// 不要項目
	//	outRecMap.setString(JBSbatACIFM054.WRISVC_TRGT_KEI_NO,			tmpList1.getString(JBSbatACIFI001.WRISVC_TRGT_KEI_NO)); 		// 割引サービス対象契約番号
		outRecMap.setString(JBSbatACIFM054.SVC_STAYMD,					tmpList1.getString(JBSbatACIFI001.SVC_STAYMD)); 				// サービス開始日
		outRecMap.setString(JBSbatACIFM054.SVC_DSL_YMD,					svcDslYmd); 													// サービス解約日
		outRecMap.setString(JBSbatACIFM054.SVC_DLRE,					svcDlre); 														// サービス解約理由
		outRecMap.setString(JBSbatACIFM054.SVC_KAIHK_DAY,				tmpList1.getString(JBSbatACIFI001.SVC_KAIHK_DAY)); 				// サービス回復日
		outRecMap.setString(JBSbatACIFM054.SVC_CANCEL_DAY,				tmpList1.getString(JBSbatACIFI001.SVC_CANCEL_DAY)); 			// サービスキャンセル日
		outRecMap.setString(JBSbatACIFM054.SVC_PAUSE_DAY,				tmpList1.get(JBSbatACIFI001.SVC_PAUSE_DAY)); 					// サービス休止日
		outRecMap.setString(JBSbatACIFM054.SVC_PAUSE_RLS_YMD,			tmpList1.get(JBSbatACIFI001.SVC_PAUSE_RLS_YMD)); 				// サービス休止解除日
		outRecMap.setString(JBSbatACIFM054.USE_STAYMD,					useStaYmd); 													// 利用開始日
		outRecMap.setString(JBSbatACIFM054.USE_ENDYMD,					useEndYmd); 													// 利用終了日
		outRecMap.setBigDecimal(JBSbatACIFM054.USE_DAY_CNT,				riyoDateCount); 												// 利用日数
		outRecMap.setBigDecimal(JBSbatACIFM054.USE_FAIL_DAY_CNT,		riyoFuka); 														// 利用不可日数
		outRecMap.setString(JBSbatACIFM054.CHRG_STAYMD,					chrgStaYmd); 													// 課金開始日
		outRecMap.setString(JBSbatACIFM054.FIRST_CHRG_STAYMD,			tmpList1.getString(JBSbatACIFI001.FIRST_CHRG_STAYMD)); 			// 初回課金開始日
		outRecMap.setString(JBSbatACIFM054.CHRG_ENDYMD,					chrgEndYmd); 													// 課金終了日
		outRecMap.setBigDecimal(JBSbatACIFM054.SVC_KEIZOKU_MON_CNT,		tmpList1.getBigDecimal(JBSbatACIFI001.SVC_KEIZOKU_MON_CNT));	// サービス継続月数
		outRecMap.setBigDecimal(JBSbatACIFM054.SVC_KEIZOKU_DAY_CNT,		tmpList1.getBigDecimal(JBSbatACIFI001.SVC_KEIZOKU_DAY_CNT));	// サービス継続日数
		outRecMap.setBigDecimal(JBSbatACIFM054.CHRG_KEIZOKU_MON_CNT,	tmpList1.getBigDecimal(JBSbatACIFI001.CHRG_KEIZOKU_MON_CNT)); 	// 課金継続月数
		outRecMap.setBigDecimal(JBSbatACIFM054.CHRG_KEIZOKU_DAY_CNT,	tmpList1.getBigDecimal(JBSbatACIFI001.CHRG_KEIZOKU_DAY_CNT)); 	// 課金継続日数
		outRecMap.setBigDecimal(JBSbatACIFM054.KEI_CNT,					tmpList1.getBigDecimal(JBSbatACIFI001.KEI_CNT)); 				// 契約数
		outRecMap.setBigDecimal(JBSbatACIFM054.MON_CHU_MAX_KEI_CNT,		tmpList1.getBigDecimal(JBSbatACIFI001.MON_CHU_MAX_KEI_CNT)); 	// 月中最大契約数
		outRecMap.setString(JBSbatACIFM054.AIT_DIV,						JACStrConst.AITAI_NO_1); 										// 相対区分
		outRecMap.setString(JBSbatACIFM054.SIME_DAY,					tmpList1.getString(JBSbatACIFI001.SIME_DAY)); 					// 締め日
		outRecMap.setString(JBSbatACIFM054.MANSION_ID,					tmpList1.getString(JBSbatACIFI001.MANSION_ID)); 				// マンションＩＤ
		outRecMap.setString(JBSbatACIFM054.TK_HOSHIKI_KEI_NO,			tmpList1.getString(JBSbatACIFI001.TK_HOSHIKI_KEI_NO)); 			// 提供方式契約番号
		outRecMap.setString(JBSbatACIFM054.KANYU_KEI_PAY_HOSHIKI_CD,	tmpList1.getString(JBSbatACIFI001.KANYU_KEI_PAY_HOSHIKI_CD)); 	// 加入契約支払方式コード 
		outRecMap.setString(JBSbatACIFM054.TTL_KOSU,					tmpList1.getString(JBSbatACIFI001.TTL_KOSU)); 					// 総戸数
		outRecMap.setString(JBSbatACIFM054.SVC_DTL_SKBT_NO,				getSvcDtlSkbtNo(tmpList1));										// サービス詳細識別番号
		
		// ファイル区分が「請求書送付サービス判定」または「割賦割引サービス判定」の場合、
		// 以下の条件に該当する場合のみ出力する。（「課金対象サービス」「課金対象マンションサービス」については後続の「課金対象契約状態分割情報付加」ジョブにて精査している）
		if(!(JACStrConst.FILE_DIV_SKS_SOHU_SVC.equals(filDiv) || JACStrConst.FILE_DIV_KAP_WRI_KEI_INFO.equals(filDiv)))
		{
			outRecMap.setOutFlg(true);
			outputInItem.addOutMapList(outRecMap);
		}
// OM-2015-0000363 ADD START
		// ファイル区分が「請求書送付サービス判定」の場合
		else if (JACStrConst.FILE_DIV_SKS_SOHU_SVC.equals(filDiv))
		{
			// サービス開始日・課金開始日・課金終了日が設定されており
			// かつ　サービス開始日　≦　郡開始日の前日（前月末日）　≦　課金終了日
			// かつ　課金開始日　≦　課金終了日の場合
			if(!JACStrConst.KARA_MOJI.equals(svcStaYmd) && !JACStrConst.KARA_MOJI.equals(chrgStaYmd) && !JACStrConst.KARA_MOJI.equals(chrgEndYmd)
					&& wk_ZenEnd.compareTo(svcStaYmd) >= 0
					&& wk_ZenEnd.compareTo(chrgEndYmd) <= 0
					&& chrgStaYmd.compareTo(chrgEndYmd) <= 0)
			{
				outRecMap.setOutFlg(true);
				outputInItem.addOutMapList(outRecMap);
			}
		}
		// ファイル区分が「割賦割引サービス判定」の場合
// OM-2015-0000363 ADD END
		else 
		{
			// (サービス解約日　＝　""（空文字）　または(サービス解約理由　≠　""（空文字）　かつ　群開始日≦課金終了日≦群終了日))
			// かつ　課金開始日　≠　""（空文字）　かつ　課金終了日　≠　""（空文字）　かつ　課金開始日　≦　課金終了日の場合
			if((JACStrConst.KARA_MOJI.equals(svcDslYmd) 	|| (!JACStrConst.KARA_MOJI.equals(svcDlre) && JBSbatStringUtil.rangeCheck(wk_GunEnd, wk_GunStr, chrgEndYmd, RNG_CHCK_FLG_YMD)))
					&& !JACStrConst.KARA_MOJI.equals(chrgStaYmd) && !JACStrConst.KARA_MOJI.equals(chrgEndYmd) && chrgStaYmd.compareTo(chrgEndYmd) <= 0)
			{
				outRecMap.setOutFlg(true);
				outputInItem.addOutMapList(outRecMap);
			}
		}
	}

	/**
	 * ファイル区分取得処理
	 * 入力レコードを元に出力ファイルのファイル区分を編集する。
	 * @param map サービス契約情報（ＩＦ）
	 * @return String ファイル区分
	 * 1：
	 * 2：課金対象マンションサービス契約情報
	 * 3：課金対象サービス契約情報（請求書送付サービス）
	 * @throws Exception
	 */
	private String getFileDiv(JBSbatServiceInterfaceMap map) throws Exception
	{
		StringBuffer keyBuf = new StringBuffer();
		
		keyBuf.append(map.getString(JBSbatACIFI001.PCRS_CD));			// 料金コースコード
		keyBuf.append(map.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD));	// 料金サービスコード

		// １．請求書送付サービス判定
		//     サービス条件 = "1"（請求書送付サービス特定） 
		if(JACStrConst.PRC_SVC_JOKEN_CD_SKS_SOHU_SVC.equals(this.db_SkySvcJknMap.get(keyBuf.toString())))
		{
			// 請求書送付サービスとする。
			return JACStrConst.FILE_DIV_SKS_SOHU_SVC;
		}
		// ２．割賦割引サービス判定
		else if(JACStrConst.PRC_SVC_JOKEN_CD_KAP_WRI_SVC.equals(this.db_KapWriSvcJknMap.get(keyBuf.toString())))
		{
			// 課金対象割賦割引契約情報とする。
			return JACStrConst.FILE_DIV_KAP_WRI_KEI_INFO;
		}
		else
		{
			// ３．マンションサービス判定
			// 提供方式契約番号に値が設定されている場合
			if(!JACbatRknBusinessUtil.isNull(JPCUtilCommon.trim(map.getString(JBSbatACIFI001.TK_HOSHIKI_KEI_NO))))
			{
				// マンションとする。
				return JACStrConst.FILE_DIV_MANS;
			}
			// ３．その他
			else
			{
				// 戸建とする。
				return JACStrConst.FILE_DIV_KODATE;
			}
		}
	}

	/**
	 * サービス詳細識別番号取得処理
	 * 入力レコードを元に出力ファイルのサービス詳細識別番号を編集する。
	 * @param map サービス契約情報（ＩＦ）
	 * @return String サービス詳細識別番号
	 * @throws Exception
	 */
	private String getSvcDtlSkbtNo(JBSbatServiceInterfaceMap map) throws Exception
	{
		StringBuffer keyBuf = new StringBuffer();
		
		keyBuf.append(map.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD));	// 料金サービスコード

		// １．スマートリンク端末系料金サービス判定
		//     サービス条件 = "1"（スマートリンク端末系料金サービス特定） 
		if(JACStrConst.PRC_SVC_JOKEN_CD_SMART_LINK_PRC_SVC.equals(this.db_SmartLinkPrcSvcJknMap.get(keyBuf.toString())))
		{
			// 請求書送付サービスとする。
			return map.getString(JBSbatACIFI001.JYUZOKU_SVC_NO);
		}
		else
		{
			return JACStrConst.KARA_MOJI;
		}
	}

	/**
	 * 項目の設定／未設定を判定し、未設定である場合にはフル桁スペースを返却します。
	 * @param strValue 対象項目
	 * @param iLength 未設定の場合に返却するスペースの桁数
	 * @return 引数の項目またはフル桁スペース
	 */
	private String convertNull(String strValue, int iLength)
	{
		if (JACStrConst.KARA_MOJI.equals(strValue))
		{
			// 項目が未設定であった場合、フル桁スペースを返却する
			return JACbatRknBusinessUtil.fillHalfSpace(strValue, iLength, true);
		}
		else
		{
			// 上記以外は単純転送
			return strValue;
		}
	}
	
	/**
	 * 対象判定処理
	 * イベント日が当月かを判定し、対象の場合退避リストへ設定する。
	 * @param inMap 
	 * @throws Exception
	 */
	public void checkRec(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		String chrgStaYmd = inMap.getString(JBSbatACIFI001.CHRG_STAYMD); 	// 課金開始日
		String chrgEndYmd = inMap.getString(JBSbatACIFI001.CHRG_ENDYMD); 	// 課金終了日

		// ◆月初解約　または
		//   回復期間中に連携される解約情報かチェック
		//   ※課金開始と終了が反転してインターフェースされる。
		//       ⇒課金開始　＞　課金終了
		// 課金開始日と課金終了日が反転してインターフェイスされた場合trueとする。
		boolean firstDslFlg = false;

		// 課金終了日が設定されていて
		// 課金開始日　＞　課金終了日　の場合
		if(!chrgEndYmd.equals(JACStrConst.KARA_MOJI) && chrgStaYmd.compareTo(chrgEndYmd) > 0)
		{
			firstDslFlg = true;		// 初月解約とする
		}
		else
		{
			firstDslFlg = false;	// 初月解約としない
		}

		// 料金サービス条件検索用キー
		StringBuffer mapKeyBuf = new StringBuffer();
		mapKeyBuf.append(inMap.getString(JBSbatACIFI001.PCRS_CD)); 			// 料金コースコード
		mapKeyBuf.append(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)); 	// 料金サービスコード
		
		String prcSvcSkbtCd = null; // 料金サービス識別コード
		
		// 該当データありの場合
		if (db_SvcKnrMap.containsKey(mapKeyBuf.toString()))
		{
			prcSvcSkbtCd = db_SvcKnrMap.get(mapKeyBuf.toString());
		}
		
		// ◆課金開始日が翌月以降のサービス
		// 課金開始日が設定され　　 かつ
		// 初月解約以外　　　　　　 かつ
		// 群締め日　＜　課金開始日 の場合
		if(!chrgStaYmd.equals(JACStrConst.KARA_MOJI) && !firstDslFlg && this.wk_GunEnd.compareTo(chrgStaYmd) < 0)
		{
			// 対象外
			return;
		}
		else
		{
			// ◆割引休止判定（サービス識別コード＝"3"の場合のみ）
			if(prcSvcSkbtCd != null && prcSvcSkbtCd.equals(JACStrConst.SVC_SKBT_CD_WRIB))
			{
				// サービス休止日
				String svcPauseDay = inMap.getString(JBSbatACIFI001.SVC_PAUSE_DAY);
				// サービス休止解除日
				String svcPauseRlsYmd = inMap.getString(JBSbatACIFI001.SVC_PAUSE_RLS_YMD);
				
				// サービス休止日、サービス休止解除日ともに未設定の場合
				if(JACStrConst.KARA_MOJI.equals(svcPauseDay) && JACStrConst.KARA_MOJI.equals(svcPauseRlsYmd))
				{
					// 非休止
				}
				// サービス休止日のみ設定されている
				else if(!JACStrConst.KARA_MOJI.equals(svcPauseDay) && JACStrConst.KARA_MOJI.equals(svcPauseRlsYmd))
				{
					// サービス休止日が翌群月初日より前の場合
					if(svcPauseDay.compareTo(JPCUtilCommon.addMonth(this.wk_GunStr, 1)) < 0)
					{
						// 処理対象外
						return;
					}
				}
				// サービス休止日、サービス休止解除日ともに設定されている場合
				else if(!JACStrConst.KARA_MOJI.equals(svcPauseDay) && !JACStrConst.KARA_MOJI.equals(svcPauseRlsYmd))
				{
					// サービス休止日が翌群月初日より前、かつ
					// サービス休止解除日が翌群月初日以降の場合
					if(svcPauseDay.compareTo(JPCUtilCommon.addMonth(this.wk_GunStr, 1)) < 0 && 
							svcPauseRlsYmd.compareTo(JPCUtilCommon.addMonth(this.wk_GunStr, 1)) >= 0)
					{
						// 処理対象外
						return;
					}
				}
			}

			// 過去分の履歴が退避されている場合
			if(!this.twk_flgIsEvntRslt && !this.twk_tmpList.isEmpty())
			{
				// 過去分は直近のみ保持できていればよいので、削除する
				this.twk_tmpList.clear();
			}
			
			// 課金開始日が設定されていない場合
			if(chrgStaYmd.equals(JACStrConst.KARA_MOJI))
			{
				// 退避リストへ追加
				this.twk_tmpList.add(inMap);
				// 処理対象
				return;
			}
			
			// 当月のイベントレコードか、過去の履歴レコードかの判定を行う.

			// ◆判定方法
			// 　以下の項目のうちいずれかが、当月内のイベントだった場合
			// 　群月初日 ≦ ※ ≦ 群終了日
																							// 課金開始日
																							// 課金終了日
			String svcPauseDay 		= inMap.getString(JBSbatACIFI001.SVC_PAUSE_DAY); 		// サービス休止日
			String svcPauseRlsDay 	= inMap.getString(JBSbatACIFI001.SVC_PAUSE_RLS_YMD); 	// サービス休止解除日
			String svcUseFailStaymd = inMap.getString(JBSbatACIFI001.SVC_USE_FAIL_STAYMD);	// サービス利用不可開始日
			String svcUseFailEndymd = inMap.getString(JBSbatACIFI001.SVC_USE_FAIL_ENDYMD); 	// サービス利用不可終了日
			if (isTargetDate(chrgStaYmd) 
					|| isTargetDate(chrgEndYmd)
					|| isTargetDate(svcPauseDay)
					|| isTargetDate(svcPauseRlsDay)
					|| isTargetDate(svcUseFailStaymd)
					|| isTargetDate(svcUseFailEndymd))
			{
				this.twk_flgIsEvntRslt = true;
			}
			// 退避リストへ追加
			this.twk_tmpList.add(inMap);
			// 処理対象
			return;
		}
	}

	/**
	 * 当月のイベントがあるかどうかを判断する
	 * @param  inDate 対象日
	 * @return boolean true:イベントあり/false:イベントなし
	 */
	private boolean isTargetDate(String inDate)
	{
		// イベントなし（未設定）
		if(JACStrConst.KARA_MOJI.equals(inDate))
		{
			return false;
		}
		// 当月のイベントあり（群月初日　から　群締め日の間の場合）
		else if(this.wk_GunStr.compareTo(inDate) <= 0 && inDate.compareTo(this.wk_GunEnd) <= 0)
		{
			return true;
		}
		// 当月以外のイベントあり
		else
		{
			return false;
		}
	}

	/**
	 * 開始、終了日の調整をする
	 * 以下の場合、開始、終了日の調整をする。
	 * １．開始日　＜　群開始日　の場合
	 *   　群開始日とする。
	 * ２．未設定　または　群締め日＜終了日
	 *   　群締め日とする。
	 *   
	 * @param  tmpList 退避リスト
	 * @return int 利用不可期間
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private int getnotUseDays(ArrayList<JBSbatServiceInterfaceMap> tmpList) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDays]");
		// 利用不可リスト
		ArrayList<String[]> svcUseFailList = new ArrayList<String[]>();

		String useFailStaYmd  	= null; 	// サービス利用不可開始日
		String useFailEndYmd  	= null; 	// サービス利用不可終了日
		String chrgStaYmd 		= null; 	// 課金開始日
		String chrgEndYmd 		= null; 	// 課金終了日
		for(int i = 0; i < tmpList.size(); i++)
		{
			JBSbatServiceInterfaceMap tmpMap = tmpList.get(i);

			// サービス利用不可開始日を求める
			useFailStaYmd  = tmpMap.getString(JBSbatACIFI001.SVC_USE_FAIL_STAYMD);
			// サービス利用不可終了日を求める
			useFailEndYmd  = tmpMap.getString(JBSbatACIFI001.SVC_USE_FAIL_ENDYMD);
			
			// 開始日が空のデータ　または　開始日が未来のデータ（締め日＜開始日）は処理せず次のレコードへ
			if(!(useFailStaYmd.equals(JACStrConst.KARA_MOJI) || this.wk_GunEnd.compareTo(useFailStaYmd) < 0))
			{
				// サービス利用開始日≠""(空文字)　かつ　サービス利用終了日＝(空文字)の場合
				if(useFailEndYmd.equals(JACStrConst.KARA_MOJI)
					&& !useFailStaYmd.equals(JACStrConst.KARA_MOJI))
				{
					// 利用不可終了日に翌群月初を設定
					useFailEndYmd = JPCUtilCommon.addMonth(this.wk_GunStr, 1);
				}
				
				// サービス利用不可終了日　≧　群月初日の場合
				if(useFailEndYmd.compareTo(this.wk_GunStr) >= 0)
				{
					// サービス利用不可開始日　＜　群月初日の場合
					if(useFailStaYmd.compareTo(this.wk_GunStr) < 0)
					{
						// 群月初日
						useFailStaYmd = this.wk_GunStr;
					}
					// 課金開始日を設定する
					chrgStaYmd = tmpMap.getString(JBSbatACIFI001.CHRG_STAYMD); 
					// サービス利用不可開始日　＜　課金開始日の場合
					if(useFailStaYmd.compareTo(chrgStaYmd) < 0)
					{
						useFailStaYmd = chrgStaYmd;
					}
					
					// 課金終了日を設定する
					chrgEndYmd = tmpMap.getString(JBSbatACIFI001.CHRG_ENDYMD); 
					
					// 課金終了日に設定あり
					if(!JACbatRknBusinessUtil.isNull(chrgEndYmd))
					{
						// 課金終了日　＜　サービス利用不可終了日の場合
						if(chrgEndYmd.compareTo(useFailEndYmd) < 0)
						{
							// サービス利用不可終了日に課金終了日を設定する
							useFailEndYmd = chrgEndYmd;
						}
						// 課金終了日　≧　サービス利用不可終了日の場合
						else
						{
							// サービス利用不可終了日にサービス利用不可終了日の前日を設定する
							useFailEndYmd = JPCUtilCommon.addDay(useFailEndYmd, -1);
						}
					}
					this.setList(svcUseFailList, useFailStaYmd, useFailEndYmd, true);
				}
			}
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getnotUseDays]");
		// 利用不可期間の計算
		return this.keisan(svcUseFailList);
	}

	/**
	 * 開始、終了日の調整をする（回復時）
	 * 以下の場合、開始、終了日の調整をする。
	 * １．開始日　＜　群開始日　の場合
	 *   　群開始日とする。
	 * ２．未設定　または　群締め日＜終了日
	 *   　群締め日とする。
	 *   
	 * @param  tmpList 退避リスト
	 * @return int 利用不可期間
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private int getnotUseDaysKaihk(ArrayList<JBSbatServiceInterfaceMap> tmpList) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDaysKaihk]");
		// 利用不可リスト
		ArrayList<String[]> svcUseFailList = new ArrayList<String[]>();

		String useFailStaYmd  	= null; 	// サービス利用不可開始日
		String useFailEndYmd  	= null; 	// サービス利用不可終了日
		for(int i = 0; i < tmpList.size(); i++)
		{
			JBSbatServiceInterfaceMap tmpMap = tmpList.get(i);

			// サービス利用不可開始日を求める
			useFailStaYmd  = tmpMap.getString(JBSbatACIFI001.SVC_USE_FAIL_STAYMD);
			// サービス利用不可終了日を求める
			useFailEndYmd  = tmpMap.getString(JBSbatACIFI001.SVC_USE_FAIL_ENDYMD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getnotUseDaysKaihk][サービス利用不可開始日：" + useFailStaYmd + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getnotUseDaysKaihk][サービス利用不可終了日：" + useFailEndYmd + "]");
			
			// 開始日が空のデータ　または　開始日が未来のデータ（締め日＜開始日）は処理せず次のレコードへ
			if(!(useFailStaYmd.equals(JACStrConst.KARA_MOJI) || this.wk_GunEnd.compareTo(useFailStaYmd) < 0))
			{
				// サービス利用不可開始日≠""(空文字)　かつ　サービス利用不可終了日＝(空文字)の場合
				if(useFailEndYmd.equals(JACStrConst.KARA_MOJI)
					&& !useFailStaYmd.equals(JACStrConst.KARA_MOJI))
				{
					// 利用不可終了日に翌群月初を設定
					useFailEndYmd = JPCUtilCommon.addMonth(this.wk_GunStr, 1);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDaysKaihk][利用不可終了日に翌群月初を設定：" + useFailEndYmd + "]");
				}
				
				// サービス利用不可終了日　≧　群月初日の場合
				if(useFailEndYmd.compareTo(this.wk_GunStr) >= 0)
				{
					// サービス利用不可開始日　＜　群月初日の場合
					if(useFailStaYmd.compareTo(this.wk_GunStr) < 0)
					{
						// 群月初日
						useFailStaYmd = this.wk_GunStr;
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDaysKaihk][サービス利用不可開始日に群月初日を設定：" + useFailStaYmd + "]");
					}

					// 群月末日　＜　サービス利用不可終了日の場合
					if(wk_GunEnd.compareTo(useFailEndYmd) < 0)
					{
						// サービス利用不可終了日に群月末日を設定する
						useFailEndYmd = wk_GunEnd;
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDaysKaihk][サービス利用不可終了日に 群月末日を設定：" + useFailEndYmd + "]");
					}
					//  群月末日　≧　サービス利用不可終了日の場合
					else
					{
						// サービス利用不可終了日にサービス利用不可終了日の前日を設定する
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getnotUseDaysKaihk][サービス利用不可終了日にサービス利用不可終了日の前日を設定：" + useFailEndYmd + "]");
						useFailEndYmd = JPCUtilCommon.addDay(useFailEndYmd, -1);
					}
					
					
					this.setList(svcUseFailList, useFailStaYmd, useFailEndYmd, true);
				}
			}
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getnotUseDaysKaihk]");
		// 利用不可期間の計算
		return this.keisan(svcUseFailList);
	}

	/**
	 * 利用不可期間の計算処理を行う
	 *   
	 * @param  inList 利用不可リスト
	 * 
	 * @return rtn 利用不可期間
	 * 
	 */
	private int keisan(ArrayList<String[]> inList)
	{
		// 利用不可期間
		int rtn = 0;

		// 利用不可期間のリストが存在する場合計算する
		if (!inList.isEmpty())
		{
			// リスト分繰り返し
			for (int i = 0; i < inList.size(); i++)
			{
				String[] data = inList.get(i);

				String str = data[0];
				String end = data[1];
				
				// 2件目以降、
				// 前回と重複している場合、開始日を重複後からとする。
				if (i >= 1)
				{
					String[] bfDate = inList.get(i - 1);
					String bfEnd = bfDate[1];
					
					// 前回．終了日 >= 今回．開始日
					if (bfEnd.compareTo(str) >= 0)
					{
						// 今回開始日　←　前回終了日 + 1
						str = JPCUtilCommon.addDay(bfEnd, 1);
					}
				}

				// 終了日 - 開始日を足していく。
				// 利用不可日数がマイナスの場合、利用不可日数を0にする 
				if(JPCUtilCommon.subtractDay(end, str) + 1 < 0)
				{
					rtn = rtn + 0;
				}
				else
				{
					rtn = rtn + JPCUtilCommon.subtractDay(end, str) + 1;
				}
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "keisan: keisan=" + rtn + " 開始：str=" + str + "終了：end=" + end);

			}
		}

		return rtn;
	}

	/**
	 * 利用不可期間リスト設定処理を行います。
	 * 
	 * @param inList リスト
	 * @param str 開始日
	 * @param tmpEnd 終了日
	 * @param endFlg 利用不可期間に含むフラグ（true：含む、false：含まない（マイナス１日した日を設定する））
	 */
	private void setList(ArrayList<String[]> inList, String str, String tmpEnd, boolean endFlg)
	{
		
		String end = tmpEnd;
		
		// 終了日が利用不可期間に含まない場合 かつ
		// 群開始日から群開始日-1の場合　※群終了日の場合は処理対象外となるので、設定しない。
		if(!endFlg && !JACStrConst.KARA_MOJI.equals(end))
		{
			// 終了日-1
			end = JPCUtilCommon.addDay(end, -1);
		}
		
		// 終了日が当月以降　または　未設定の場合（群締め日　＜　終了日）
		if(this.wk_GunEnd.compareTo(end) < 0 || JACStrConst.KARA_MOJI.equals(end))
		{
			// 締め日とする
			end = this.wk_GunEnd;
		}
		
		String[] listData = null; 			// リスト内要素

		// 最後が同じ場合、同じ日付が存在するか確認する
		if(!inList.isEmpty())
		{
			listData = inList.get(inList.size() - 1);
		
			// リスト[最後]．開始日　＝　入力．開始日の場合
			if(listData[0].equals(str))
			{
				// 終了日が大きい場合のみ更新
				if(listData[1].compareTo(end) < 0)
				{
					// 要素を更新し、処理終了
					listData[1] = end;
				}
				return;
			}
		}
		
		String[] addData  = new String[2]; 	// 追加要素

		// 同じ開始日がない場合
		// 最後に追加する
		addData[0] = str;
		addData[1] = end;
		inList.add(addData);
	}
	
	/**
	 * 日割要否取得用の各種マップを作成します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void setHiwariJudgeMap() throws Exception
	{
		// 定額料金マップ作成
		this.getTegakPrc();
		// 割引料金マップ作成
		this.getWribPrc();
		// 逓増料金マップ作成
		this.getTeizoPrc();
		// マンション定額料金マップ作成
		this.getMansTegakPrc();
		// 料金徴収判定マップ作成
		this.getPrcCollect();
	}
	
	/**
	 * 定額料金データ取得を行います。
	 * tegakMap：定額料金マップに検索結果を格納する。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getTegakPrc() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// 定額料金 ＷＨＥＲＥ条件設定
		dbList.setValue(super.systemCode); 								// システムコード
		dbList.setValue(this.wk_GunEnd); 								// 群締め日

		// 定額料金データ取得
		executeAC_M_TEGAK_PRC_AC_SELECT_005(dbList.getList().toArray());

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_AC_M_TEGAK_PRC.selectNext();
		
		tegakMap = new HashMap<String, String>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// 請求先番号ごとハッシュマップにレコードを格納する
			String mapKey = dbMap.getString(JBSbatAC_M_TEGAK_PRC.AITAI_NO)
							.concat(dbMap.getString(JBSbatAC_M_TEGAK_PRC.PCRS_CD))
							.concat(dbMap.getString(JBSbatAC_M_TEGAK_PRC.PRC_SVC_CD));
			
			tegakMap.put(mapKey, dbMap.getString(JBSbatAC_M_TEGAK_PRC.COLLECT_PATTERN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_TEGAK_PRC.selectNext();
		}
	}
	
	/**
	 * 割引料金データ取得を行います。
	 * wribMap：割引料金マップに検索結果を格納する。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getWribPrc() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// 割引料金 ＷＨＥＲＥ条件設定
		dbList.setValue(super.systemCode); 								// システムコード
		dbList.setValue(this.wk_GunEnd); 								// 群締め日

		// 割引料金データ取得
		executeAC_M_WRIB_PRC_AC_SELECT_001(dbList.getList().toArray());

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_AC_M_WRIB_PRC.selectNext();
		
		wribMap = new HashMap<String, String>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// 請求先番号ごとハッシュマップにレコードを格納する
			String mapKey = dbMap.getString(JBSbatAC_M_WRIB_PRC.AITAI_NO)
							.concat(dbMap.getString(JBSbatAC_M_WRIB_PRC.PCRS_CD))
							.concat(dbMap.getString(JBSbatAC_M_WRIB_PRC.PRC_SVC_CD));
			
			wribMap.put(mapKey, dbMap.getString(JBSbatAC_M_WRIB_PRC.COLLECT_PATTERN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_WRIB_PRC.selectNext();
		}
	}

	/**
	 * 逓増料金データ取得を行います。
	 * teizoMap：逓増料金マップに検索結果を格納する。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getTeizoPrc() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// 逓増料金 ＷＨＥＲＥ条件設定
		dbList.setValue(super.systemCode); 					// システムコード
		dbList.setValue(JACStrConst.SYS_CD_AZ); 			// システムコード（AZ）
		dbList.setValue(this.wk_GunEnd); 					// 群締め日

		// 逓増料金データ取得
		executeAC_M_TEIZO_PRC_AC_SELECT_001(dbList.getList().toArray());

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_AC_M_TEIZO_PRC.selectNext();
		
		teizoMap = new HashMap<String, String>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// 請求先番号ごとハッシュマップにレコードを格納する
			String mapKey = dbMap.getString(JBSbatAC_M_TEIZO_PRC.AITAI_NO)
							.concat(dbMap.getString(JBSbatAC_M_TEIZO_PRC.PCRS_CD))
							.concat(dbMap.getString(JBSbatAC_M_TEIZO_PRC.PRC_SVC_CD));
			
			teizoMap.put(mapKey, dbMap.getString(JBSbatAC_M_TEIZO_PRC.COLLECT_PATTERN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_TEIZO_PRC.selectNext();
		}
	}
	
	/**
	 * マンション定額料金データ取得を行います。
	 * mansMap：マンション定額料金マップに検索結果を格納する。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getMansTegakPrc() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// マンション定額料金 ＷＨＥＲＥ条件設定
		dbList.setValue(super.systemCode); 								// システムコード
		dbList.setValue(this.wk_GunEnd); 								// 群締め日
		dbList.setValue(this.wk_GunEnd); 								// 群締め日
		// ANK-2249-00-00 ADD START
		dbList.setValue(JACStrConst.PAY_KEI_SKBT_CD_OWNR); 				// 支払契約識別コード（オーナー契約支払）
		dbList.setValue(JACStrConst.PAY_KEI_SKBT_CD_KNYSHA); 			// 支払契約識別コード（加入者契約支払）
		// ANK-2249-00-00 ADD END

		// マンション定額料金データ取得
		// ANK-2249-00-00 MOD START
		//executeAC_M_MANS_TEGAKPRC_AC_SELECT_003(dbList.getList().toArray());
		executeAC_M_MANS_TEGAKPRC_AC_SELECT_005(dbList.getList().toArray());
		// ANK-2249-00-00 MOD END

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_AC_M_MANS_TEGAKPRC.selectNext();
		
		mansMap = new HashMap<String, String>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// 請求先番号ごとハッシュマップにレコードを格納する
			// ANK-2249-00-00 MOD START
			//String mapKey = dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PCRS_CD)
			//				.concat(dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_SVC_CD));
			String mapKey = dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PCRS_CD)
							.concat(dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_SVC_CD))
							.concat(dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAY_KEI_SKBT_CD));
			// ANK-2249-00-00 MOD END
			
			mansMap.put(mapKey, dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));
			
			// 次レコード取得
			dbMap = db_AC_M_MANS_TEGAKPRC.selectNext();
		}
	}
	
	/**
	 * 料金徴収判定マスタテーブルより料金徴収判定情報を取得します。
	 * 
	 * @return 料金徴収判定情報
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getPrcCollect() throws Exception
	{
		// ＳＱＬキーを設定する
		JBSbatCommonDBInterface keyList = new JBSbatCommonDBInterface();

		// 対象キーの設定
		keyList.setValue(super.systemCode); 	// システムコード
		keyList.setValue(this.wk_GunEnd); 		// バッチ運用日
		
		// 料金徴収判定データ取得
		executeAC_M_PRC_COLLECT_JDG_AC_SELECT_001(keyList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_AC_M_PRC_COLLECT_JDG.selectNext();
		
		colMap = new HashMap<String, String>();

		// 検索結果がなくなるまで繰り返す
		while (dbMap != null)
		{
			// 請求先番号ごとハッシュマップにレコードを格納する
			String mapKey = dbMap.getString(JBSbatAC_M_PRC_COLLECT_JDG.COLLECT_PATTERN_CD)
							.concat(dbMap.getString(JBSbatAC_M_PRC_COLLECT_JDG.AITAI_NO));

			// 料金徴収判定マップにデータを格納
			colMap.put(mapKey, dbMap.getString(JBSbatAC_M_PRC_COLLECT_JDG.HIWARI_YH));

			// 次レコード取得
			dbMap = db_AC_M_PRC_COLLECT_JDG.selectNext();
		}
	}

	/**
	 * 以下参照スキーマのいずれかから取得された、「徴収パターンコード」を基に料金徴収判定マスタを検索し、
	 * 「日割要否」を取得する。
	 * 
	 * [参照スキーマ]
	 * 	↓参照順（徴収パターンコードを取得できた時点で終了）
	 * 	1	定額料金
	 * 	2	割引料金
	 * 	3	逓増料金
	 * 	4	マンション定額料金
	 * 
	 * @param inMap 入力情報
	 * @return 日割有無
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private boolean isHiwariUm(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		// 対象キー：相対番号の設定
		String aitNo = null;
		
		// 相対区分="2"（請求先番号）の場合
		if (JACStrConst.AITAIKBN_SEIKYU.equals(inMap.getString(JBSbatACIFI015.AIT_DIV)))
		{
			aitNo = inMap.getString(JBSbatACIFI015.SEIKY_KEI_NO); // 請求先番号
		}
		// 相対区分="3"（サービス番号）の場合
		else if(JACStrConst.AITAIKBN_SVC.equals(inMap.getString(JBSbatACIFI015.AIT_DIV)))
		{
			aitNo = inMap.getString(JBSbatACIFI015.SVC_NO); // サービス番号
		}
		else
		{
			aitNo = JACStrConst.AITAINO_SPACE; // 相対番号（ALLスペース）
		}
		
		// 料金徴収パターンコード取得
		String inKey = aitNo.concat(inMap.getString(JBSbatACIFI001.PCRS_CD)).concat(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD));
		
		String colCd = null;
		
		// 定額料金
		colCd = tegakMap.get(inKey);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isHiwariUm][定額料金：" + colCd + "]");
		
		// 定額料金から取得できなかった場合、割引料金から取得
		if(colCd == null)
		{
			colCd = wribMap.get(inKey);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isHiwariUm][割引料金：" + colCd + "]");
		}
		
		// 割引料金から取得できなかった場合、逓増料金から取得
		if(colCd == null)
		{
			colCd = teizoMap.get(inKey);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isHiwariUm][逓増料金：" + colCd + "]");
		}
		
		// 逓増料金から取得できなかった場合、マンション定額から取得
		if(colCd == null)
		{
			// マンション定額料金は相対番号がないため、料金コース＋料金サービス＋支払契約識別コードで取得する
			// ANK-2249-00-00 MOD START
			//String mansKey = inMap.getString(JBSbatACIFI001.PCRS_CD).concat(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD));
			String mansKey = "";
			// サービス契約情報.料金グループコードが「99：マンションオーナー」の場合、「1：オーナー契約支払」を設定します。
			if (PRC_GRP_CD_MANS_OWNR.equals(inMap.getString(JBSbatACIFI001.PRC_GRP_CD)))
			{
			
				mansKey = inMap.getString(JBSbatACIFI001.PCRS_CD)
							.concat(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)
							.concat(JACStrConst.PAY_KEI_SKBT_CD_OWNR));
			}
			// 上記以外の場合、「2：加入者契約支払」を設定します。
			else
			{
				mansKey = inMap.getString(JBSbatACIFI001.PCRS_CD)
							.concat(inMap.getString(JBSbatACIFI001.TRGT_PRC_SVC_CD)
							.concat(JACStrConst.PAY_KEI_SKBT_CD_KNYSHA));
			}
			// ANK-2249-00-00 MOD END
			
			colCd = mansMap.get(mansKey);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isHiwariUm][マンション定額料金：" + colCd + "]");
		}
		
		// 徴収パターンが所得できなかった場合、false
		if(colCd == null)
		{
			return false;
		}
		else
		{
			// ++++++ v20.00.00 MOD START +++++++++
//			String colKey = colCd.concat(aitNo);
			String colKey = colCd.concat(JACStrConst.AITAINO_SPACE);
			// ++++++ v20.00.00 MOD END +++++++++
			String hiwariYh = colMap.get(colKey);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isHiwariUm][日割要否：" + hiwariYh + "]");
			
			// 日割要否　＝　日割なしの場合、true
			if(JACStrConst.HIWARI_YH_NON.equals(hiwariYh))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
		// v15.00.00 2015/07/31 Add Start
	/**
	 * 課金終了年月日を取得し、請求月内で課金終了されている場合、trueを返却・されていない場合falseを返却
	 * 
	 * @param tmpLastChrgEndYmd
	 *            課金終了年月日
	 * @return true 請求月内課金終了 false 以外
	 * @throws Exception
	 */
	private boolean isSeiYmChgEnd(String tmpLastChrgEndYmd) throws Exception {

		// 入力チェック空白・nullチェック
		if (isNullBlank(this.wk_SkyuYM) || isNullBlank(tmpLastChrgEndYmd)) {

			// 空白orNullの場合falseを返却する
			return false;
		}
		
		//課金終了年月日より、課金終了年月を取得する
		String tmpLstChrgEndYm =tmpLastChrgEndYmd.substring(0, 6);

		// 請求年月と課金終了年月を比較し、一致すればtrue 一致しなければfalseを返却する
		if (this.wk_SkyuYM.equals(tmpLstChrgEndYm)) {

			return true;
		}

		return false;
	}

	/**
	 * null又は空文字の場合、trueを返却する
	 * 
	 * @param str
	 *            検査対象文字列
	 * @return true:null、又は空文字／false:左記以外
	 */
	public static boolean isNullBlank(String str) {
		if (str == null || "".equals(str)) {
			return true;
		}
		return false;
	}

	// v15.00.00 2015/07/31 Add End
	/**▲▲▲▲▲▲メソッド追加 終了▲▲▲▲▲▲*/
}