/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatAKSeikyPtnhuka
*	ソースファイル名	：JBSbatAKSeikyPtnhuka.java
*	作成者				：富士通　
*	作成日				：2012年07月21日
*＜機能概要＞
*　請求パターン付加部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v3.00.00	2012/07/21  FJ）今井	新規作成
*	v4.00.00	2013/03/12  FJ）垣内	【ST2-2013-0001421】
*	v4.00.01	2013/04/27  FJ）高橋	料金検証障害対応【No6】利用不可減額不具合対応
*	v5.00.00	2013/06/26  FJ）黒木	【ANK-1464-00-00】料金検証障害対応
*	v5.01.00	2013/07/04  FJ）黒木	【ANK-1464-00-00】料金検証障害対応
*	v7.00.00	2013/12/16  FJ) 前田	【ANK-1578-00-00】多機能ルータ対応
*	v7.00.01	2013/12/19  FJ) 高橋	【ANK-1578-00-00】多機能ルータ対応（割引適用対象契約の利用不可期間抽出処理を修正）
*	v9.00.00	2014/04/25  FJ) 前田	【ANK-2054-00-00】スマートリンク端末保障対応
*	v15.00.00	2015/08/18  FJ) 高橋	【ANK-2163-00-00】【ＮＯ．１５５７】課金終了日以降にも利用不可期間減額を適用
*********************************************************************/
package eo.business.service;

import java.util.HashMap;

import eo.business.common.JACBatCommon;
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.util.file.JBSbatAKIFM003;
import eo.business.util.file.JBSbatAKIFM061;
import eo.business.util.table.JBSbatAK_M_SEIKY_PTN_KETEI;
import eo.business.util.table.JBSbatKK_T_KAISEN_USE_KEI;
import eo.business.util.table.JBSbatKK_T_TK_HOSHIKI_KEI;
import eo.business.util.table.JBSbatKK_T_USE_STP_PRD;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
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.JBSbatDateUtil;

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

	/** テーブル(利用停止期間)*/
	private static final String D_TBL_NAME_KK_T_USE_STP_PRD = "KK_T_USE_STP_PRD";

	/** テーブル(提供方式契約)*/
	private static final String D_TBL_NAME_KK_T_TK_HOSHIKI_KEI = "KK_T_TK_HOSHIKI_KEI";

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

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

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

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

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

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

	/** SQL定義キー(AK_SELECT_007)*/
	private static final String KK_T_USE_STP_PRD_AK_SELECT_007 = "AK_SELECT_007";
	
	/** SQL定義キー(AK_SELECT_001)*/
	private static final String KK_T_TK_HOSHIKI_KEI_AK_SELECT_001 = "AK_SELECT_001";
	
	/** テーブルアクセスクラス(請求パターン決定)*/
	private JBSbatSQLAccess db_AK_M_SEIKY_PTN_KETEI = null;

	/** テーブルアクセスクラス(利用停止期間)*/
	private JBSbatSQLAccess db_KK_T_USE_STP_PRD = null;

	/** テーブルアクセスクラス(提供方式契約)*/
	private JBSbatSQLAccess db_KK_T_TK_HOSHIKI_KEI = null;
	
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/** 請求パターン決定ＭＡＰ */
	private HashMap<String, String> map_SeikyPtnFix = null;
	
	/** 料金グループコード（テレビ契約用） */
	private String[] strList_TvKei = null;
	
	/** 料金グループコード（マンションオーナー用） */
	private String[] strList_ManOwnr = null;
	
	/** 退避キー */
	private String tmpKey = null;
	
	/** 退避キー２ */
	private String tmpKey_Sec = null;
	
	/** 請求パターンコード */
	private String tmpSeikyPtnCd = null;
	
	/** 群月初日 */
	private String wk_GunStr 	= null;

	/** 群締め日 */
	private String wk_GunEnd 	= null;
	
	// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 ADD START
	/** 利用停止開始日 */
	private static final String USE_STP_STA_YMD 	= "USE_STP_STA_YMD";

	/** 利用停止終了日 */
	private static final String USE_STP_END_YMD 	= "USE_STP_END_YMD";
	
	/** 利用停止開始日 */
	private String wkUseStpStaDay 	= null;

	/** 利用停止終了日 */
	private String wkUseStpEndDay 	= null;
	
	// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 ADD END
	
	// 2015/08/18 ANK-2163-00-00 ADD START
	
	/** 利用停止開始日（日割なし） */
	private String wkUseStpStaDayHN 	= null;

	/** 利用停止終了日（日割なし） */
	private String wkUseStpEndDayHN 	= null;
	
	// 2015/08/18 ANK-2163-00-00 ADD END
	
	/** 請求パターン付加検証対象契約情報（オーナーダミー）出力フラグ */
	private boolean skyPtnOwnrDummyOutFlg = false;
	
	/** 請求パターン付加検証対象契約情報出力フラグ */
	private boolean skyPtnOutFlg = false;
	
	/** 固定値：-1（編集用の値） */
	private static final int INT_MINUS_ONE = -1;

	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_AK_M_SEIKY_PTN_KETEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AK_M_SEIKY_PTN_KETEI);
		db_KK_T_USE_STP_PRD = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_USE_STP_PRD);
		db_KK_T_TK_HOSHIKI_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_TK_HOSHIKI_KEI);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		// 請求パターン決定ＭＡＰの設定
		this.setMap_SeikyPtnFix();
		
		// パラメータ取得クラス生成
		JACbatParamUtil paramUtil 	= new JACbatParamUtil(commonItem);
		
		// テレビ契約用料金グループコード
		this.strList_TvKei		= paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_TV_KEI_PRC_GRP_CD).split(JACStrConst.SEMI_COLON);
		
		// オーナー用料金グループコード
		this.strList_ManOwnr	= paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_OWNR_PRC_GRP_CD).split(JACStrConst.SEMI_COLON);
		
		paramUtil.close();

		// 料金スケジュール定義アクセス部品初期処理
		JACbatSchdlUtil schdlUtil 	= new JACbatSchdlUtil(commonItem);

		// 請求年月を取得する
		String seikyYm = schdlUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_RYOKIN_KEISAN_YMD);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "バッチ運用日" + super.opeDate + "から取得した請求年月：" + seikyYm);

		// 群月初日、群締め日を取得する
		String[] gunStartEndDate = schdlUtil.getUseStrEnd(seikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
		this.wk_GunStr = gunStartEndDate[0];
		this.wk_GunEnd = gunStartEndDate[1];
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "群月初日：" + gunStartEndDate[0]);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "群締め日：" + gunStartEndDate[1]);

		// 料金スケジュール定義アクセス部品クローズ
		schdlUtil.close();

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

	/**
	 * 主処理
	 * @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 = null;
		
		// ブレイクキー（入力）
		String inKey = this.getBreakKey(inMap);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][inKey = " + inKey + "]");
		
		// キーブレイク時
		if (!inKey.equals(this.tmpKey))
		{
			this.tmpKey = inKey;
			
			this.getMap_SeikyPtnFix(inMap);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][請求パターンコード = " + this.tmpSeikyPtnCd + "]");
			
			if (null == this.tmpSeikyPtnCd)
			{
				// 処理終了（オミット）
				return null;
			}
			
			outputItem = new JBSbatOutputItem();
			
			this.setUseFailDayCnt(inMap);
			this.setMansKeiInfo(inMap);
			
			inMap.setString(JBSbatAKIFM003.SEIKY_PTN_CD, this.tmpSeikyPtnCd);
			
			inMap.setOutFlg(true);
			
			// 出力判定
			this.judgeOutFile(inMap);
			
			// 請求パターン付加検証対象契約情報（オーナーダミー）出力判定
			if(this.skyPtnOwnrDummyOutFlg)
			{
				outputItem.addOutMapList_2(inMap);
			}
			
			// 請求パターン付加検証対象契約情報出力判定
			if(this.skyPtnOutFlg)
			{
				outputItem.addOutMapList(inMap);
			}
		}
		// キーが同じ時
		else
		{
			// 処理終了（オミット）
			return null;
		}
		
		// フラグリセット
		skyPtnOwnrDummyOutFlg = false;
		skyPtnOutFlg = false;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		return outputItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_AK_M_SEIKY_PTN_KETEI.close();
		db_KK_T_USE_STP_PRD.close();
		db_KK_T_TK_HOSHIKI_KEI.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

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

		// DBアクセスを実行します
		db_KK_T_USE_STP_PRD.selectBySqlDefine(paramList, KK_T_USE_STP_PRD_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 executeKK_T_USE_STP_PRD_AK_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

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

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

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

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

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

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

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

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

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

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

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

	/**
	 * 請求パターン決定ＭＡＰの設定処理 <br>
	 * 検索結果は、HashMap（this.map_SeikyPtnFix）へ設定する。 <br>
	 * 　　キー：料金コースコード ＋ 料金サービスコード ＋ 料金検証契約状態コード<br>
	 * 　　値　：請求パターンコード<br>
	 * <br>
	 * 出力ファイルの編集にて使用する。
	 * 
	 * @throws Exception
	 */
	private void setMap_SeikyPtnFix() throws Exception
	{
		// 初期化
		this.map_SeikyPtnFix = new HashMap<String, String>();
		
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		dbList.setValue(super.opeDate);		// バッチ運用日
		dbList.setValue(super.opeDate); 	// バッチ運用日

		// SELECT文発行 請求パターン決定
		this.executeAK_M_SEIKY_PTN_KETEI_AK_SELECT_001(dbList.getList().toArray());

		// 料金項目コードの設定
		JBSbatCommonDBInterface dbMap = db_AK_M_SEIKY_PTN_KETEI.selectNext();

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

			keyBuf.append(dbMap.getString(JBSbatAK_M_SEIKY_PTN_KETEI.PCRS_CD)); 			// 料金コースコード
			keyBuf.append(dbMap.getString(JBSbatAK_M_SEIKY_PTN_KETEI.PRC_SVC_CD));			// 料金サービスコード
			keyBuf.append(dbMap.getString(JBSbatAK_M_SEIKY_PTN_KETEI.PRCKNS_KEI_STAT_CD));	// 料金検証契約状態コード

			this.map_SeikyPtnFix.put(keyBuf.toString(), dbMap.getString(JBSbatAK_M_SEIKY_PTN_KETEI.SEIKY_PTN_CD));

			// 次レコード取得
			dbMap = db_AK_M_SEIKY_PTN_KETEI.selectNext();
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint,
				"[L][setMap_SeikyPtnFix][請求パターン決定ＭＡＰ：this.map_SeikyPtnFix]" + this.map_SeikyPtnFix.toString());
	}
	
	/**
	 * 請求パターン決定ＭＡＰの値取得処理 <br>
	 * 入力ファイルよりキーを作成し、HashMap（this.map_SeikyPtnFix）より請求パターンコードを取得する。 <br>
	 * 　　キー：料金コースコード ＋ 料金サービスコード ＋ 料金検証契約状態コード<br>
	 * 
	 * @param inMap 入力ファイル（AKIFM003_検証対象契約情報）
	 * @throws Exception
	 */
	private void getMap_SeikyPtnFix(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		StringBuffer key = new StringBuffer();
		
		key.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PCRS_CD),				3,	true));	// 料金コースコード
		key.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PRC_SVC_CD),			12,	true));	// 料金サービスコード
		key.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PRCKNS_KEI_STAT_CD),	3,	true));	// 料金検証契約状態コード
		
		if(!key.toString().equals(this.tmpKey_Sec))
		{
			// キー退避
			this.tmpKey_Sec = key.toString();
			
			// 請求パターンコード取得
			this.tmpSeikyPtnCd = this.map_SeikyPtnFix.get(key.toString());
			
		}
		
		return;
	}
	
	/**
	 * キー取得処理 <br>
	 * inMapより、ブレイクキーを取得する。<br>
	 * 　　ブレイクキー： 料金コースコード<br>
	 * 　　　　　　　　　 料金サービスコード<br>
	 * 　　　　　　　　　 料金検証契約状態コード<br>
	 * 　　　　　　　　　 請求契約番号<br>
	 * 　　　　　　　　　 サービス契約番号<br>
	 * 　　　　　　　　　 サービス契約内訳番号<br>
	 * 　　　　　　　　　 オプションサービス契約番号<br>
	 * 　　　　　　　　　 サブオプションサービス契約番号<br>
	 * 　　　　　　　　　 機器提供サービス契約番号<br>
	 * 　　　　　　　　　 請求オプションサービス契約番号<br>
	 * 　　　　　　　　　 割引サービス契約番号<br>
	 * 　　　　　　　　　 機器オプションサービス契約番号<br>
	 * ファイル出力時に同一キーは出力しないようにするために使用する。
	 * @param inMap 入力ファイル（AKIFM003_検証対象契約情報）
	 * @return String キー
	 * @throws Exception
	 */
	private String getBreakKey(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		StringBuffer strBuff = new StringBuffer();
		
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PCRS_CD),				3,	true));	// 料金コースコード
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PRC_SVC_CD),			12,	true));	// 料金サービスコード
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.PRCKNS_KEI_STAT_CD),	3,	true));	// 料金検証契約状態コード
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.SEIKY_KEI_NO),		10,	true));	// 請求契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO),			10,	true));	// サービス契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO),		12,	true));	// サービス契約内訳番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO),		12,	true));	// オプションサービス契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO),		12,	true));	// サブオプションサービス契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO),		12,	true));	// 機器提供サービス契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.SEIOPSVC_KEI_NO),		12,	true));	// 請求オプションサービス契約番号
		strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM003.WRIB_SVC_KEI_NO),		12,	true));	// 割引サービス契約番号
		
		// 機器オプションサービス契約または、割引適用対象契約なら機器オプションサービス契約に追加
		if(JACStrConst.CHST_KEI_SKB_CD_KKOP_SVC_KEI.equals(inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD))
						|| JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI.equals(inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD)))
		{
			strBuff.append(JACbatRknBusinessUtil.fillHalfSpace(inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO),		12,	true));	// 機器オプションサービス契約番号	
		}
		
		return strBuff.toString();
	}
	
	/**
	 * 月中利用不可日数の算出処理 <br>
	 * 請求年月の月初日と月末日、
	 * 入力のプラン課金開始年月日と
	 * 　　　プラン課金終了年月日、
	 * 　　　利用停止期間スキーマより取得する
	 * 利用停止開始年月日時分秒と
	 * 利用停止終了年月日時分秒により
	 * 月中利用不可日数を算出する。
	 * @param inMap 入力ファイル（AKIFM003_検証対象契約情報）
	 * @throws Exception
	 */
	private void setUseFailDayCnt(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setUseFailDayCnt]");
		// 戻り値：月中利用不可日数（初期値：0日）
		int rtnCnt = 0;
		
		// 2015/08/18 ANK-2163-00-00 ADD START
		// 戻り値：月中利用不可日数（日割なし）（初期値：0日）
		int rtnCntHN = 0;
		// 2015/08/18 ANK-2163-00-00 ADD END
		
		// 課金開始前の判定
		// プラン課金開始年月日　＝　（空）　または	
		// 月末日　＜　プラン課金開始年月日　の場合	

		String planChrgStaYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);
		// 2015/08/18 ANK-2163-00-00 ADD START
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][プラン課金開始年月日 = " + planChrgStaYmd + "]");
		// 2015/08/18 ANK-2163-00-00 ADD END

		if(JACStrConst.KARA_MOJI.equals(planChrgStaYmd)
				|| this.wk_GunEnd.compareTo(planChrgStaYmd) < 0)
		{
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT, rtnCnt);
			// 2015/08/18 ANK-2163-00-00 ADD START
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT_HIWARI_NON, rtnCntHN);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
					"[L][setUseFailDayCnt][プラン課金開始年月日が空または月末日＜プラン課金開始年月日]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setUseFailDayCnt]");
			// 2015/08/18 ANK-2163-00-00 ADD END
			return;
		}
		
		
		// 課金終了後の判定
		// プラン課金終了年月日　≠　（空、空白）　かつ	
		// プラン課金終了年月日　＜　月初日　　　　の場合	

		String planChrgEndYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);
		// 2015/08/18 ANK-2163-00-00 ADD START
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][プラン課金終了年月日 = " + planChrgEndYmd + "]");
		// 2015/08/18 ANK-2163-00-00 ADD END

		// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 MOD START
		if(!JACStrConst.KARA_MOJI.equals(planChrgEndYmd.trim())
				&& planChrgEndYmd.compareTo(this.wk_GunStr) < 0)
		// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 MOD END
		{
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT, rtnCnt);
			// 2015/08/18 ANK-2163-00-00 ADD START
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT_HIWARI_NON, rtnCntHN);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
					"[L][setUseFailDayCnt][プラン課金終了年月日が空、空白またはプラン課金終了年月日＜月初日]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setUseFailDayCnt]");
			// 2015/08/18 ANK-2163-00-00 ADD END
			return;
		}
		
		// 利用停止期間スキーマ検索
		// 入力．抽出契約識別コードに応じた検索キーで、利用停止期間スキーマを検索する。

		String chstKeiSkbCd = inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD);
		
		// ＤＢアクセス用のパラメータ定義
		// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 MOD START
		Object[] dbPram = { null };
		// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 MOD END

		if(JACStrConst.CHST_KEI_SKB_CD_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.SVC_KEI_NO);			// サービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_001(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_SVC_KEI_UCWK.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO);	// サービス契約内訳番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_002(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_OP_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO);		// オプションサービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_003(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_SBOP_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO);	// サブオプションサービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_004(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_KKTK_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO);	// 機器提供サービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_005(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_SEIOPSVC_KEI.equals(chstKeiSkbCd))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ 請求オプションサービス契約については、SQL実施せず上位に返却]");
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT, rtnCnt);
			return;
			// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 MOD END
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_WRIB_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM003.SVC_KEI_NO);			// サービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_001(dbPram);
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI.equals(chstKeiSkbCd))
		{
			// �@ サブオプションサービス契約番号　≠　空、空白
			if(inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO).trim()))
			{
				dbPram[0] = inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO);	// サブオプションサービス契約番号
				
				this.executeKK_T_USE_STP_PRD_AK_SELECT_004(dbPram);
			}
			// �A オプションサービス契約番号　≠　空、空白
			else if(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO).trim()))
			{
				dbPram[0] = inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO);		// オプションサービス契約番号
				
				this.executeKK_T_USE_STP_PRD_AK_SELECT_003(dbPram);
			}
			// �B 機器オプションサービス契約番号  ≠  空、空白
			else if(inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO).trim()))
			{
			
				dbPram[0] = inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO);	// 機器オプションサービス契約番号
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][機器オプションサービス契約番号に紐づく利用不可期間を取得]");
				this.executeKK_T_USE_STP_PRD_AK_SELECT_007(dbPram);
				
			}
			// �C 機器提供サービス契約内訳番号　≠　空、空白
			else if(inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO).trim()))
			{
				dbPram[0] = inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO);	// 機器提供サービス契約番号
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][機器提供サービス契約番号に紐づく利用不可期間を取得]");
				this.executeKK_T_USE_STP_PRD_AK_SELECT_005(dbPram);
				
			}
			
			// �D サービス契約内訳番号　≠　空、空白
			else if(inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO).trim()))
			{
				dbPram[0] = inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO);	// サービス契約内訳番号
				
				this.executeKK_T_USE_STP_PRD_AK_SELECT_002(dbPram);
			}
			// �E サービス契約番号　≠　空、空白
			else if(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO) != null
					&& !JACStrConst.KARA_MOJI.equals(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO).trim()))
			{
				dbPram[0] = inMap.getString(JBSbatAKIFM003.SVC_KEI_NO);			// サービス契約番号
				
				this.executeKK_T_USE_STP_PRD_AK_SELECT_001(dbPram);
			}
			else
			{
				inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT, rtnCnt);
				// 2015/08/18 ANK-2163-00-00 ADD START
				inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT_HIWARI_NON, rtnCntHN);
				// 2015/08/18 ANK-2163-00-00 ADD END
				return;
			}
		}
		else if(JACStrConst.CHST_KEI_SKB_CD_KKOP_SVC_KEI.equals(chstKeiSkbCd))
		{
			dbPram[0] = inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO);			// 機器オプションサービス契約番号
			
			this.executeKK_T_USE_STP_PRD_AK_SELECT_007(dbPram);
		}
		
		JBSbatCommonDBInterface dbMap = db_KK_T_USE_STP_PRD.selectNext();
		
		// 検索結果
		while(null != dbMap)
		{
			
			// 値受渡し用の領域
			HashMap<String, String>workMap = new HashMap<String, String>();
			
			// 処理対象データの判定
			if(!chkUseStpPrdData(dbMap, workMap))
			{
				dbMap = db_KK_T_USE_STP_PRD.selectNext();
				continue;				
			}
			
			// 利用停止開始年月日、利用停止終了年月日の取得
			String useStpStaYmd = workMap.get(USE_STP_STA_YMD);
			String useStpEndYmd = workMap.get(USE_STP_END_YMD);
			
			// �@利用停止期間１件目の処理
			// 利用停止開始年月日、利用停止終了年月日の初期値設定
			this.setWkUseStpStaEndYmd(planChrgStaYmd, planChrgEndYmd, useStpStaYmd, useStpEndYmd);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][利用停止期間1件目の処理終了]");

			// 2015/08/18 ANK-2163-00-00 ADD START
			// 利用停止開始年月日、利用停止終了年月日の初期値設定（日割なし）
			this.setWkUseStpStaEndYmdHiwariNon(useStpStaYmd, useStpEndYmd);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][利用停止期間（日割なし）1件目の処理終了]");
			// 2015/08/18 ANK-2163-00-00 ADD END

			
			// 次データを検索
			dbMap = db_KK_T_USE_STP_PRD.selectNext();
			
			// 次データありの場合はなくなるまで繰り返す。
			while(null != dbMap)
			{
				// 処理対象データの判定
				if(!chkUseStpPrdData(dbMap, workMap))
				{
					dbMap = db_KK_T_USE_STP_PRD.selectNext();
					continue;				
				}
				// 利用停止開始年月日、利用停止終了年月日の取得
				useStpStaYmd = workMap.get(USE_STP_STA_YMD);
				useStpEndYmd = workMap.get(USE_STP_END_YMD);
				
				// ワーク．利用停止終了日　＜　利用停止開始年月日　の場合　※取得済のデータと利用開始日が離れていた場合
				if(this.wkUseStpEndDay.compareTo(useStpStaYmd) < 0)
				{
					// ワーク．利用停止日数の算出
					int wkCnt = JPCUtilCommon.subtractDay(this.wkUseStpEndDay, this.wkUseStpStaDay) + 1;
					
					// ワーク．月中利用不可日数　←　ワーク．月中利用不可日数　＋　ワーク．利用停止日数
					rtnCnt = rtnCnt + wkCnt;
					
					//利用停止開始日の設定
					this.wkUseStpStaDay = useStpStaYmd;
				}
				
				// 利用停止終了年月日 ≠ （空、空白）            かつ
				// ワーク.利用停止終了日 ≧ 利用停止終了年月日の場合
				if (!(JACBatCommon.isNull(JPCUtilCommon.trim(useStpEndYmd))) && 
				this.wkUseStpEndDay.compareTo(useStpEndYmd) >= 0)
				{
					// 2015/08/18 ANK-2163-00-00 MOD START
					// 後続の月中利用不可日数（日割なし）算出処理追加に伴いスキップ処理を削除
					// 利用停止終了日を更新する必要がないためスキップ
					//dbMap = db_KK_T_USE_STP_PRD.selectNext();
					//continue;				
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][利用停止終了日を更新する必要がないためスキップ]");
					// 2015/08/18 ANK-2163-00-00 MOD END
				}
				// 2015/08/18 ANK-2163-00-00 MOD START
				// ワーク．利用停止終了日の初期設定（最高が、月末日以降が最高のために更新）
				//this.wkUseStpEndDay = this.wk_GunEnd;
				//
				// プラン課金終了年月日 ≠ （空、空白）            かつ
				// プラン課金終了年月日 ＜ ワーク．利用停止終了日  の場合
				//if (!(JACBatCommon.isNull(JPCUtilCommon.trim(planChrgEndYmd))) && 
				//		planChrgEndYmd.compareTo(this.wkUseStpEndDay) < 0)
				//{
				//	this.wkUseStpEndDay = planChrgEndYmd;
				//}
				//
				// 利用停止終了年月日 ≠ （空、空白）            かつ
				// 利用停止終了年月日 ＜ ワーク．利用停止終了日  の場合
				//if (!(JACBatCommon.isNull(JPCUtilCommon.trim(useStpEndYmd))) && 
				//		useStpEndYmd.compareTo(this.wkUseStpEndDay) < 0)
				//{
				//	this.wkUseStpEndDay = useStpEndYmd;
				//}
				else
				{
					// ワーク．利用停止終了日の初期設定（月末日以降も利停が継続する場合があるため月末日を設定）
					this.wkUseStpEndDay = this.wk_GunEnd;
					
					// プラン課金終了年月日 ≠ （空、空白）            かつ
					// プラン課金終了年月日 ＜ ワーク．利用停止終了日  の場合
					if (!(JACBatCommon.isNull(JPCUtilCommon.trim(planChrgEndYmd))) && 
							planChrgEndYmd.compareTo(this.wkUseStpEndDay) < 0)
					{
						this.wkUseStpEndDay = planChrgEndYmd;
					}
					
					// 利用停止終了年月日 ≠ （空、空白）            かつ
					// 利用停止終了年月日 ＜ ワーク．利用停止終了日  の場合
					if (!(JACBatCommon.isNull(JPCUtilCommon.trim(useStpEndYmd))) && 
							useStpEndYmd.compareTo(this.wkUseStpEndDay) < 0)
					{
						this.wkUseStpEndDay = useStpEndYmd;
					}
				}
				// 2015/08/18 ANK-2163-00-00 MOD END
				// 2015/08/18 ANK-2163-00-00 ADD START
				// ワーク．利用停止終了日（日割なし）　＜　利用停止開始年月日　の場合　※取得済のデータと利用開始日が離れていた場合
				if(this.wkUseStpEndDayHN.compareTo(useStpStaYmd) < 0)
				{
					// ワーク．利用停止日数（日割なし）の算出
					int wkCntHN = JPCUtilCommon.subtractDay(this.wkUseStpEndDayHN, this.wkUseStpStaDayHN) + 1;
					
					// ワーク．月中利用不可日数（日割なし）　←　ワーク．月中利用不可日数（日割なし）　＋　ワーク．利用停止日数（日割なし）
					rtnCntHN = rtnCntHN + wkCntHN;
					
					//利用停止開始日（日割なし）の設定
					this.wkUseStpStaDayHN = useStpStaYmd;
				}
				
				// 利用停止終了年月日 ≠ （空、空白）            かつ
				// ワーク.利用停止終了日（日割なし） ≧ 利用停止終了年月日の場合
				if (!(JACBatCommon.isNull(JPCUtilCommon.trim(useStpEndYmd))) && 
				this.wkUseStpEndDayHN.compareTo(useStpEndYmd) >= 0)
				{
					// 利用停止終了日を更新する必要がないためスキップ
					dbMap = db_KK_T_USE_STP_PRD.selectNext();
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][利用停止終了日（日割なし）を更新する必要がないためスキップ]");
					continue;
				}
				
				// ワーク．利用停止終了日（日割なし）の初期設定（月末日以降も利停が継続する場合があるため月末日を設定）
				this.wkUseStpEndDayHN = this.wk_GunEnd;
				
				// 利用停止終了年月日 ≠ （空、空白）            かつ
				// 利用停止終了年月日 ＜ ワーク．利用停止終了日（日割なし）  の場合
				if (!(JACBatCommon.isNull(JPCUtilCommon.trim(useStpEndYmd))) && 
						useStpEndYmd.compareTo(this.wkUseStpEndDayHN) < 0)
				{
					this.wkUseStpEndDayHN = useStpEndYmd;
				}
				// 2015/08/18 ANK-2163-00-00 ADD END
				
				// 次データを検索
				dbMap = db_KK_T_USE_STP_PRD.selectNext();
				
			}
			
			// 次データなしの場合
			// ワーク．利用停止日数の算出
			int wkCnt = JPCUtilCommon.subtractDay(this.wkUseStpEndDay, this.wkUseStpStaDay) + 1;
			
			// ワーク．月中利用不可日数　←　ワーク．月中利用不可日数　＋　ワーク．利用停止日数
			rtnCnt = rtnCnt + wkCnt;
			
			//月中利用不可日数を設定
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT, rtnCnt);
			
			// 2015/08/18 ANK-2163-00-00 ADD START
			// ワーク．利用停止日数（日割なし）の算出
			int wkCntHN = JPCUtilCommon.subtractDay(this.wkUseStpEndDayHN, this.wkUseStpStaDayHN) + 1;
			
			// ワーク．月中利用不可日数（日割なし）　←　ワーク．月中利用不可日数（日割なし）　＋　ワーク．利用停止日数（日割なし）
			rtnCntHN = rtnCntHN + wkCntHN;
			
			//月中利用不可日数（日割なし）を設定
			inMap.setBigDecimal(JBSbatAKIFM003.USE_FAIL_DAY_CNT_HIWARI_NON, rtnCntHN);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．利用停止開始日 = " + this.wkUseStpStaDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．利用停止終了日 = " + this.wkUseStpEndDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．利用停止開始日（日割なし） = " + this.wkUseStpStaDayHN + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．利用停止終了日（日割なし） = " + this.wkUseStpEndDayHN + "]");
			
			// 2015/08/18 ANK-2163-00-00 ADD END
			
		// 2013/04/27 料金検証障害対応【No6】利用不可減額不具合対応 ADD END
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．月中利用不可日数 = " + rtnCnt + "]");
		// 2015/08/18 ANK-2163-00-00 ADD START
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setUseFailDayCnt][ワーク．月中利用不可日数（日割なし） = " + rtnCntHN + "]");
		// 2015/08/18 ANK-2163-00-00 ADD END
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setUseFailDayCnt]");
		return;
	}

	/**
	 * 利用停止期間レコードが処理対象外かどうかをチェックする。 <br>
	 * @param dbMap 入力スキーマ情報（利用停止期間スキーマの処理対象レコード）
	 * @param workMap 値受渡し用の領域　（利用停止開始年月日、利用停止終了年月日）
	 * @return boolean（true：1．処理対象データ、false：2．処理対象外データ）
	 * @throws Exception
	 */
	private boolean chkUseStpPrdData(JBSbatCommonDBInterface dbMap, HashMap<String, String> workMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][chkSkipUseStpPrdData]");
		
		// 利用停止開始年月日に対するチェック
		String useStpStaDtm = dbMap.getString(JBSbatKK_T_USE_STP_PRD.USE_STP_STA_DTM);	// 利用停止開始年月日時分秒
		
		if(null == useStpStaDtm || JACStrConst.KARA_MOJI.equals(useStpStaDtm.trim()))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkSkipUseStpPrdData][利用停止開始年月日が空、空白のためスキップ]");
			return false;
		}
		// 利用停止開始年月日の初期値設定
		String useStpStaYmd = useStpStaDtm.substring(0, 8);
		
		// 利用停止開始年月日　＞　月末日
		if(useStpStaYmd.compareTo(this.wk_GunEnd) > 0)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkSkipUseStpPrdData][利用停止開始年月日が月末日より未来のためスキップ]");
			return false;
		}
		
		// 利用停止終了年月日に対するチェック
		String useStpEndDtm = dbMap.getString(JBSbatKK_T_USE_STP_PRD.USE_STP_END_DTM);	// 利用停止終了年月日時分秒
		String useStpEndYmd = null;
		
		if(null != useStpEndDtm && !JACStrConst.KARA_MOJI.equals(useStpEndDtm.trim()))
		{
			// 利用停止終了年月日を取得
			useStpEndYmd = useStpEndDtm.substring(0, 8);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][利用停止終了年月日" + useStpEndYmd +  "]");
			
			// 利用停止終了年月日の前日を算出
			useStpEndYmd = JBSbatDateUtil.adjustDate(useStpEndYmd, INT_MINUS_ONE);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][pntlyPtn][利用停止終了年月日の前日" + useStpEndYmd +  "]");
		}
		
		// 利用停止終了年月日　＜　月初日
		if(null != useStpEndYmd && (useStpEndYmd.compareTo(this.wk_GunStr) < 0))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkSkipUseStpPrdData][利用停止終了年月日が月初日より過去のためスキップ]");
			return false;
		}
		
		// 利用停止開始年月日　＞　利用停止終了年月日
		if(null != useStpEndYmd && (useStpStaYmd.compareTo(useStpEndYmd) > 0))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkSkipUseStpPrdData][利用停止開始日＞利用停止終了日データのためスキップ]");
			return false;
		}

		workMap.put(USE_STP_STA_YMD, useStpStaYmd);
		workMap.put(USE_STP_END_YMD, useStpEndYmd);
		
		return true;
	}

	/**
	 * 利用停止開始年月日、利用停止終了年月日の初期値設定 <br>
	 * @param planChrgStaYmd プラン課金開始年月日
	 * @param planChrgEndYmd プラン課金開始年月日
	 * @param useStpStaYmd 利用停止開始年月日
	 * @param useStpEndYmd 利用停止終了年月日
	 * @throws Exception
	 */
	private void setWkUseStpStaEndYmd(String planChrgStaYmd, String planChrgEndYmd, String useStpStaYmd, String useStpEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setWkUseStpStaEndYmd]");
		
		// 利用停止開始日の初期設定
		// 初期値：月初日
		this.wkUseStpStaDay = this.wk_GunStr;
		
		// ワーク．利用停止開始日 ＜ プラン課金開始年月日　の場合
		if (this.wkUseStpStaDay.compareTo(planChrgStaYmd) < 0)
		{
			this.wkUseStpStaDay = planChrgStaYmd;
		}
		
		// ワーク．利用停止開始日 ＜ 利用停止開始年月日　の場合
		if (this.wkUseStpStaDay.compareTo(useStpStaYmd) < 0)
		{
			this.wkUseStpStaDay = useStpStaYmd;
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setWkUseStpStaEndYmd][ワーク．利用停止開始日 = " + this.wkUseStpStaDay + "]");
		
		// 利用停止終了日の初期設定
		// 初期値：月末日
		this.wkUseStpEndDay = this.wk_GunEnd;
		
		// プラン課金終了年月日　≠　（空、空白）かつ
		// プラン課金終了年月日　＜　ワーク．利用停止終了日　の場合
		if(!JACStrConst.KARA_MOJI.equals(planChrgEndYmd.trim())
			&&  planChrgEndYmd.compareTo(this.wk_GunEnd) < 0)
		{
			this.wkUseStpEndDay = planChrgEndYmd;
		}

		// 利用停止終了年月日　≠　（空、空白）かつ
		// 利用停止終了年月日　＜　ワーク．利用停止終了日　の場合 ※作り上、利用停止終了年月日が空白になるケースは現状なし。
		if(null != useStpEndYmd && !JACStrConst.KARA_MOJI.equals(useStpEndYmd.trim())
			&&  useStpEndYmd.compareTo(this.wkUseStpEndDay) < 0)
		{
			this.wkUseStpEndDay = useStpEndYmd;
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setWkUseStpStaEndYmd][ワーク．利用停止終了日 = " + this.wkUseStpEndDay + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setWkUseStpStaEndYmd]");
	}

	// 2015/08/18 ANK-2163-00-00 ADD START
	/**
	 * 利用停止開始年月日（日割なし）、利用停止終了年月日（日割なし）の初期値設定 <br>
	 * @param useStpStaYmd 利用停止開始年月日
	 * @param useStpEndYmd 利用停止終了年月日
	 * @throws Exception
	 */
	private void setWkUseStpStaEndYmdHiwariNon(String useStpStaYmd, String useStpEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setWkUseStpStaEndYmdHiwariNon]");
		
		// 利用停止開始日（日割なし）の初期設定
		// 初期値：月初日
		this.wkUseStpStaDayHN = this.wk_GunStr;
		
		// ワーク．利用停止開始日（日割なし） ＜ 利用停止開始年月日　の場合
		if (this.wkUseStpStaDayHN.compareTo(useStpStaYmd) < 0)
		{
			this.wkUseStpStaDayHN = useStpStaYmd;
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setWkUseStpStaEndYmdHiwariNon][ワーク．利用停止開始日（日割なし） = " + this.wkUseStpStaDayHN + "]");
		
		// 利用停止終了日（日割なし）の初期設定
		// 初期値：月末日
		this.wkUseStpEndDayHN = this.wk_GunEnd;
		
		// 利用停止終了年月日（日割なし）　≠　（空、空白）かつ
		// 利用停止終了年月日（日割なし）　＜　ワーク．利用停止終了日　の場合 ※作り上、利用停止終了年月日が空白になるケースは現状なし。
		if(null != useStpEndYmd && !JACStrConst.KARA_MOJI.equals(useStpEndYmd.trim())
			&&  useStpEndYmd.compareTo(this.wkUseStpEndDayHN) < 0)
		{
			this.wkUseStpEndDayHN = useStpEndYmd;
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][setWkUseStpStaEndYmdHiwariNon][ワーク．利用停止終了日（日割なし） = " + this.wkUseStpEndDayHN + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setWkUseStpStaEndYmdHiwariNon]");
	}
	// 2015/08/18 ANK-2163-00-00 ADD END

	/**
	 * マンション契約情報取得処理 <br>
	 * @param inMap 入力ファイル（AKIFM003_検証対象契約情報）
	 * @throws Exception
	 */
	private void setMansKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][setMansKeiInfo]");
		
		String tkHoshikiKeiNo = inMap.getString(JBSbatAKIFM003.TK_HOSHIKI_KEI_NO);	// 提供方式契約番号
		
		if (!JACBatCommon.isNull(JPCUtilCommon.trim(tkHoshikiKeiNo)))
		{
			// ＳＱＬキーを設定する
			JBSbatCommonDBInterface keyList = new JBSbatCommonDBInterface();
			
			// 対象キーの設定
			keyList.setValue(tkHoshikiKeiNo);
			
			// SELECT文発行 提供方式契約
			this.executeKK_T_TK_HOSHIKI_KEI_AK_SELECT_001(keyList.getList().toArray());
			
			JBSbatCommonDBInterface dbMap = this.db_KK_T_TK_HOSHIKI_KEI.selectNext();
			
			if (null == dbMap)
			{
				// 警告メッセージ出力
				String[] msgParam = new String[] { JBSbatKK_T_TK_HOSHIKI_KEI.TABLE_NAME, keyList.getList().toString() };
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, msgParam);
			}
			else
			{
				// マンションID
				if (this.isListRslt(this.strList_TvKei, inMap.getString(JBSbatAKIFM003.PRC_GRP_CD)))
				{
					inMap.setString(JBSbatAKIFM003.MANSION_ID, dbMap.getString(JBSbatKK_T_KAISEN_USE_KEI.CATID));
				}
				else
				{
					inMap.setString(JBSbatAKIFM003.MANSION_ID, dbMap.getString(JBSbatKK_T_KAISEN_USE_KEI.MANSION_ID));
				}
				
				String kanyuKeiPayHoshikiCd = dbMap.getString(JBSbatKK_T_TK_HOSHIKI_KEI.KANYU_KEI_PAY_HOSHIKI_CD);	// 加入契約支払方式コード 
				// 支払契約識別コード
				if (this.isListRslt(this.strList_ManOwnr, inMap.getString(JBSbatAKIFM003.PRC_GRP_CD)))
				{
					inMap.setString(JBSbatAKIFM003.PAY_KEI_SKBT_CD, JACStrConst.PAY_KEI_SKBT_CD_OWNR);
				}
				else
				{
					// 提供方式契約．加入契約支払方式コード = "001"（ベース）　または
					//                                        "002"（個別）　または
					//                                        "003"（全戸一括）　または
					//                                        "004"（住居者一括）の場合
					if (JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd)
							|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(kanyuKeiPayHoshikiCd)
							|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(kanyuKeiPayHoshikiCd)
							|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd))
					{
						inMap.setString(JBSbatAKIFM003.PAY_KEI_SKBT_CD, JACStrConst.PAY_KEI_SKBT_CD_KNYSHA);
					}
					// 上記以外の場合（加入契約支払方法コード設定なし）
					else 
					{
						inMap.setString(JBSbatAKIFM003.PAY_KEI_SKBT_CD, JACStrConst.PAY_KEI_SKBT_CD_OTHER);
					}
				}
				
				// 加入契約支払方式コード
				if (JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd)
						|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(kanyuKeiPayHoshikiCd)
						|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(kanyuKeiPayHoshikiCd)
						|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd))
				{
					inMap.setString(JBSbatAKIFM003.KANYU_KEI_PAY_HOSHIKI_CD, dbMap.getString(JBSbatKK_T_TK_HOSHIKI_KEI.KANYU_KEI_PAY_HOSHIKI_CD));
				}
				else
				{
					inMap.setString(JBSbatAKIFM003.KANYU_KEI_PAY_HOSHIKI_CD, JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO);
				}
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][setMansKeiInfo]");
	}
	
	/**
	 * 出力ファイル判定処理 <br>
	 * @param inMap 入力ファイル（AKIFM003_検証対象契約情報）
	 * @return boolean（true：1．請求パターン付加検証対象契約情報、false：2．請求パターン付加検証対象契約情報（オーナーダミー））
	 * @throws Exception
	 */
	private void judgeOutFile(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		String kanyuKeiPayHoshikiCd = inMap.getString(JBSbatKK_T_TK_HOSHIKI_KEI.KANYU_KEI_PAY_HOSHIKI_CD);	// 加入契約支払方式コード 

		// 入力．料金グループコードがオーナー用料金グループコード配列に存在する　かつ
		// 　加入契約支払方式コード　＝　"001"（ベース）　または
		//                             　"002"（個別）
		//                             　"003"（全戸一括）
		//                             　"004"（居住者一括）　　　の場合
		// 　　請求パターン付加検証対象契約情報（オーナーダミー）へ出力する。
		if (this.isListRslt(this.strList_ManOwnr, inMap.getString(JBSbatAKIFM003.PRC_GRP_CD)))
		{
			if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd) 
					|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(kanyuKeiPayHoshikiCd)
					|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(kanyuKeiPayHoshikiCd)
					|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd))
			{
				// 2．請求パターン付加検証対象契約情報（オーナーダミー）へ出力する
				skyPtnOwnrDummyOutFlg =  true;
			}
		}
		// （入力．料金グループコードがオーナー用料金グループコード配列に存在する　かつ 
		// 　加入契約支払方法コード　＝　"001"（ベース）　または 　"002"（個別）　または 　"004"（居住者一括）
		//   または　"000"（マンション定額以外の場合の固定値））以外の場合
		// 　請求パターン付加検証対象契約情報へ出力する。
		if (!(this.isListRslt(this.strList_ManOwnr, inMap.getString(JBSbatAKIFM003.PRC_GRP_CD))
				&& (JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd) 
				|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(kanyuKeiPayHoshikiCd)
				|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd)
				|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_ZERO.equals(kanyuKeiPayHoshikiCd))))
		{
			// 2．請求パターン付加検証対象契約情報へ出力する
			skyPtnOutFlg = true;
		}
	}
	
	/**
	 * 配列内検索処理<br>
	 * 配列（inStrList）にchkValの値が存在するか判定します。
	 * @param inStrList 判定対象の配列
	 * @param chkVal 判定値
	 * @return boolean 判定結果（true：存在する、false：存在しない）
	 * @throws Exception
	 */
	private boolean isListRslt(String[] inStrList, String chkVal) throws Exception
	{
		// inStrListの要素数分、繰り返し
		for (int i = 0; i <= inStrList.length - 1; i++)
		{
			// 存在する場合
			if(inStrList[i].equals(chkVal))
			{
				return true;
			}
		}
		
		// 存在しない
		return false;
	}

	
}