/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatAKKeistatJdg
*	ソースファイル名	：JBSbatAKKeistatJdg.java
*	作成者				：富士通　
*	作成日				：2012年07月19日
*＜機能概要＞
*　契約状態判定部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v3.00.00	2012/07/19   FJ）冨井	新規作成
*	v4.00.00	2013/03/06   FJ）高橋	長期継続割引制度対応
*	v4.00.01	2013/04/08   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 課金開始前排除対応
*	v5.00.00	2013/07/03   FJ）黒木	【ANK-1464-00-00】料金検証不具合対応
*	v5.00.01	2013/07/10   FJ）黒木	【ANK-1464-00-00】料金検証不具合対応
*	v5.00.02	2013/07/25   FJ）黒木	【ANK-1464-00-00】料金検証不具合対応
*	v5.00.03	2013/08/06   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 プラン課金終了日補正対応
*	v5.00.04	2013/08/06   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 課金開始前解約時の継続月数、継続日数0日化対応
*	v5.00.05	2013/08/13   FJ）高橋	【ANK-1464-00-00】料金検証不具合対応 料金検証契約状態コードの設定処理変更（継続月の設定）
*	v5.01.00	2013/10/16   FJ）高橋	【OM-2013-0003491】料金検証不具合対応
*	v7.00.00	2013/12/13   FJ) 前田   【ANK-1578-00-00】多機能ルータ対応
*	v9.00.00	2014/04/25   FJ) 前田   【ANK-2054-00-00】スマートリンク端末保障対応
*	v9.01.00	2014/07/11   FJ) 前田	【OM-2014-0002411】前月以前解約当月回復対応
*********************************************************************/
package eo.business.service;

import java.util.HashMap;

import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatSchdlUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCCBatCommon;
import eo.business.util.file.JBSbatAKIFM003;
import eo.business.util.file.JBSbatAKIFM061;
import eo.business.util.table.JBSbatAK_M_PRCKNS_IDO_KIST;
import eo.business.util.table.JBSbatKK_T_KKOP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_KKTK_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_OP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SBOP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SEIOPSVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI_UCWK;
import eo.business.util.table.JBSbatKK_T_WRIB_SVC_KEI;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.util.JBSbatDateUtil;
import eo.framework.db.JBSbatSQLAccess;


/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatAKKeistatJdg extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(料金検証異動契約状態)*/
	private static final String D_TBL_NAME_AK_M_PRCKNS_IDO_KIST = "AK_M_PRCKNS_IDO_KIST";

	/** テーブル(サービス契約)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI = "KK_T_SVC_KEI";

	/** テーブル(サービス契約内訳)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI_UCWK = "KK_T_SVC_KEI_UCWK";

	/** テーブル(オプションサービス契約)*/
	private static final String D_TBL_NAME_KK_T_OP_SVC_KEI = "KK_T_OP_SVC_KEI";

	/** テーブル(サブオプションサービス契約)*/
	private static final String D_TBL_NAME_KK_T_SBOP_SVC_KEI = "KK_T_SBOP_SVC_KEI";

	/** テーブル(機器提供サービス契約)*/
	private static final String D_TBL_NAME_KK_T_KKTK_SVC_KEI = "KK_T_KKTK_SVC_KEI";

	/** テーブル(請求オプションサービス契約)*/
	private static final String D_TBL_NAME_KK_T_SEIOPSVC_KEI = "KK_T_SEIOPSVC_KEI";

	/** テーブル(割引サービス契約)*/
	private static final String D_TBL_NAME_KK_T_WRIB_SVC_KEI = "KK_T_WRIB_SVC_KEI";

	/** テーブル(機器オプションサービス契約)*/
	private static final String D_TBL_NAME_KK_T_KKOP_SVC_KEI = "KK_T_KKOP_SVC_KEI";

	/** SQL定義キー(AK_SELECT_001)*/
	private static final String AK_M_PRCKNS_IDO_KIST_AK_SELECT_001 = "AK_SELECT_001";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_SVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_SVC_KEI_UCWK_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_OP_SVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_SBOP_SVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_KKTK_SVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_SEIOPSVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_003)*/
	private static final String KK_T_WRIB_SVC_KEI_AK_SELECT_003 = "AK_SELECT_003";

	/** SQL定義キー(AK_SELECT_001)*/
	private static final String KK_T_KKOP_SVC_KEI_AK_SELECT_001 = "AK_SELECT_001";
	
	/** テーブルアクセスクラス(料金検証異動契約状態)*/
	private JBSbatSQLAccess db_AK_M_PRCKNS_IDO_KIST = null;

	/** テーブルアクセスクラス(サービス契約)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI = null;

	/** テーブルアクセスクラス(サービス契約内訳)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI_UCWK = null;

	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI = null;

	/** テーブルアクセスクラス(サブオプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_SBOP_SVC_KEI = null;

	/** テーブルアクセスクラス(機器提供サービス契約)*/
	private JBSbatSQLAccess db_KK_T_KKTK_SVC_KEI = null;

	/** テーブルアクセスクラス(請求オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_SEIOPSVC_KEI = null;

	/** テーブルアクセスクラス(割引サービス契約)*/
	private JBSbatSQLAccess db_KK_T_WRIB_SVC_KEI = null;
	
	/** テーブルアクセスクラス(機器オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_KKOP_SVC_KEI = null;

	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/** 退避．料金検証異動契約状態マップ */
	private HashMap<String, String> tmpPrcKnsStatMap = null;
	
	/** 退避．請求年月 */
	private String tmpSeikyYm = null;
	
	/** 退避．月初日 */
	private String tmpMonStaDay = null;
	
	/** 退避．月末日 */
	private String tmpMonEndDay = null;
	
	/** 退避．料金計算日 */
	private String tmpEventYmd = null;
	
	/** 退避．請求年月の暦日数 */
	int tmpCalDay = 0;
	
	/** 退避．前月月末日 */
	private String tmpPrvMonEndDay = null;
	
	/** 退避．請求年月前月 */
	private String tmpPrvSeikyYm = null;
	
	/** 退避．前月月初日 */
	private String tmpPrvMonStaDay = null;
	
	/** 退避．請求年月前月の暦日数 */
	int tmpCalPrvDay = 0;
	
	/** 固定値：日付差分フラグ（両日付を差に含める） */
	private static final String DIFF_NAI_FLG 		= "1";
	
	/** 割引サービス契約ステータス（サービス提供中） */
	public static final String WRIB_SVC_KEI_STAT_SVCTK_CHU = "100";
	
	/**割引サービス契約ステータス(適用済)  */
	private static final String WRIB_SVC_KEI_STAT_APLY = "300";
	
	/** 固定値：一日前 */
	private static final int BE_ONE_DAY  = -1;
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_AK_M_PRCKNS_IDO_KIST = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AK_M_PRCKNS_IDO_KIST);
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_KK_T_SVC_KEI_UCWK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI_UCWK);
		db_KK_T_OP_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_OP_SVC_KEI);
		db_KK_T_SBOP_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SBOP_SVC_KEI);
		db_KK_T_KKTK_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KKTK_SVC_KEI);
		db_KK_T_SEIOPSVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SEIOPSVC_KEI);
		db_KK_T_WRIB_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_WRIB_SVC_KEI);
		db_KK_T_KKOP_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KKOP_SVC_KEI);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][opeDate=" + super.opeDate + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][freeItem=" + super.freeItem + "]");
		
		// 料金検証異動契約状態マップ作成
		this.makePrcKnsStatMap();
		
		// スケジュール取得
		this.getSchdlInfo();
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");
		
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param inMap　入力電文
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][inMap=" + inMap.getMap().toString() + "]");
		
		
		// プラン課金終了年月日補正処理
		hoseiPlanChrgEndYmd(inMap);
		
		// 契約状態判定@（日付項目判定）
		String[] ymdData = this.getKeiStatYmd(inMap);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][料金検証契約状態コード:" + ymdData[0] + "]");
		// 月中利用日数の算出
		int useDayCnt = this.getUseDayCnt(inMap, ymdData);
		// サービス継続月数、サービス継続日数の算出
		String[] svcData = this.getSvcKeizoku(inMap);
		// 課金継続月数、課金継続日数の算出
		String[] chrgData = this.getChrgKeizoku(inMap);
		// 検証対象契約情報（状態判定済み）出力
		JBSbatOutputItem outputItem = new JBSbatOutputItem();
		this.makeOutputInfo(inMap, ymdData, useDayCnt, svcData, chrgData, outputItem);
		
		// 契約状態判定A（異動区分判定）
		// 請求対象月の月初日　＜＝　予約適用年月日　　　　＜＝　請求対象月の月末日
		if(tmpMonStaDay.compareTo(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD)) <= 0 && 
				tmpMonEndDay.compareTo(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD)) >= 0)
		{
			// KEY:入力．異動区分＋契約状態判定付加条件コードは固定値："00"（付加条件なし）
			// 作成した料金検証異動契約状態ＭＡＰを検索する。
			// 判定条件取得
			String key = this.makeStr(inMap.getString(JBSbatAKIFM003.IDO_DIV), JACStrConst.KEI_STAT_JDG_HK_JKN_CD_NON);
			if(this.tmpPrcKnsStatMap.containsKey(key))
			{
				// ワーク．料金検証契約状態コード ← 料金検証異動契約状態ＭＡＰ．料金検証契約状態コード
				ymdData[0] = this.tmpPrcKnsStatMap.get(key);
				// 検証対象契約情報（状態判定済み）出力
				this.makeOutputInfo(inMap, ymdData, useDayCnt, svcData, chrgData, outputItem);
			}
		}
		
		// 契約状態判定B（異動区分＋番ポ判定）
		// 入力．番ポ有無 ＝ "1" の場合
		// 判定条件取得
		String bmpUm = inMap.getString(JBSbatAKIFM003.BMP_UM);
		if(JACStrConst.BMP_ARI.equals(bmpUm))
		{
			// 請求対象月の月初日　＜＝　サービス開始年月日　＜＝　請求対象月の月末日
			if(tmpMonStaDay.compareTo(inMap.getString(JBSbatAKIFM003.SVC_STA_YMD)) <= 0 && 
					tmpMonEndDay.compareTo(inMap.getString(JBSbatAKIFM003.SVC_STA_YMD)) >= 0)
			{
				// KEY:入力．異動区分＋契約状態判定付加条件コードは固定値："01"（番ポ工事有）
				// 作成した料金検証異動契約状態ＭＡＰを検索する。
				// 判定条件取得
				String key = this.makeStr(inMap.getString(JBSbatAKIFM003.IDO_DIV), JACStrConst.KEI_STAT_JDG_HK_JKN_CD_BMP_ARI);
				if(this.tmpPrcKnsStatMap.containsKey(key))
				{
					// ワーク．料金検証契約状態コード ← 料金検証異動契約状態ＭＡＰ．料金検証契約状態コード
					ymdData[0] = this.tmpPrcKnsStatMap.get(key);
					// 検証対象契約情報（状態判定済み）出力
					this.makeOutputInfo(inMap, ymdData, useDayCnt, svcData, chrgData, outputItem);
				}
			}
			// 請求対象月の月初日　＜＝　予約適用年月日　　　　＜＝　請求対象月の月末日
			else if(tmpMonStaDay.compareTo(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD)) <= 0 && 
					tmpMonEndDay.compareTo(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD)) >= 0)
			{
				// KEY:入力．異動区分＋契約状態判定付加条件コードは固定値："02"（番ポ工事有）
				// 作成した料金検証異動契約状態ＭＡＰを検索する。
				// 判定条件取得
				String key = this.makeStr(inMap.getString(JBSbatAKIFM003.IDO_DIV), JACStrConst.KEI_STAT_JDG_HK_JKN_CD_BPARIDO);
				if(this.tmpPrcKnsStatMap.containsKey(key))
				{
					// ワーク．料金検証契約状態コード ← 料金検証異動契約状態ＭＡＰ．料金検証契約状態コード
					ymdData[0] = this.tmpPrcKnsStatMap.get(key);
					// 検証対象契約情報（状態判定済み）出力
					this.makeOutputInfo(inMap, ymdData, useDayCnt, svcData, chrgData, outputItem);
				}
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		
		return outputItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_AK_M_PRCKNS_IDO_KIST.close();
		db_KK_T_SVC_KEI.close();
		db_KK_T_SVC_KEI_UCWK.close();
		db_KK_T_OP_SVC_KEI.close();
		db_KK_T_SBOP_SVC_KEI.close();
		db_KK_T_KKTK_SVC_KEI.close();
		db_KK_T_SEIOPSVC_KEI.close();
		db_KK_T_WRIB_SVC_KEI.close();
		db_KK_T_KKOP_SVC_KEI.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	
	/**
	 * SQLKEY(AK_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	料金検証異動契約状態適用年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAK_M_PRCKNS_IDO_KIST_AK_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

		// DBアクセスを実行します
		db_AK_M_PRCKNS_IDO_KIST.selectBySqlDefine(paramList, AK_M_PRCKNS_IDO_KIST_AK_SELECT_001);
	}

	/**
	 * 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_SVC_KEI_AK_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_KK_T_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_AK_SELECT_003);
	}

	/**
	 * 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_SVC_KEI_UCWK_AK_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_KK_T_SVC_KEI_UCWK.selectBySqlDefine(paramList, KK_T_SVC_KEI_UCWK_AK_SELECT_003);
	}

	/**
	 * 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_OP_SVC_KEI_AK_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_KK_T_OP_SVC_KEI.selectBySqlDefine(paramList, KK_T_OP_SVC_KEI_AK_SELECT_003);
	}

	/**
	 * 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_SBOP_SVC_KEI_AK_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());
		paramList.setValue(param[3].toString());
		paramList.setValue(param[4].toString());

		// DBアクセスを実行します
		db_KK_T_SBOP_SVC_KEI.selectBySqlDefine(paramList, KK_T_SBOP_SVC_KEI_AK_SELECT_003);
	}

	/**
	 * 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_KKTK_SVC_KEI_AK_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_KK_T_KKTK_SVC_KEI.selectBySqlDefine(paramList, KK_T_KKTK_SVC_KEI_AK_SELECT_003);
	}

	/**
	 * 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_SEIOPSVC_KEI_AK_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_KK_T_SEIOPSVC_KEI.selectBySqlDefine(paramList, KK_T_SEIOPSVC_KEI_AK_SELECT_003);
	}

	/**
	 * 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_WRIB_SVC_KEI_AK_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_KK_T_WRIB_SVC_KEI.selectBySqlDefine(paramList, KK_T_WRIB_SVC_KEI_AK_SELECT_003);
	}
	
	/**
	 * 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_KKOP_SVC_KEI_AK_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());
		paramList.setValue(param[3].toString());
		
		// DBアクセスを実行します
		db_KK_T_KKOP_SVC_KEI.selectBySqlDefine(paramList, KK_T_KKOP_SVC_KEI_AK_SELECT_001);
	}
	
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * 文字を連結します
	 * @param  string 文字
	 * @return strBuf 連結した文字列
	 */
	private String makeStr(String ...string)
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeStr]");
		
		StringBuffer strBuf = new StringBuffer();
		for(String str:string)
		{
			if(str == null)
			{
				strBuf.append(JACStrConst.KARA_MOJI);
			}
			else
			{
				strBuf.append(str);
			}
		}
		
		assert strBuf != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][strBuf][strBuf = " + strBuf.toString() + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeStr]");
		
		return strBuf.toString();
	}
	
	/**
	 * 料金検証異動契約状態マスタを検索して、異動区分・契約状態判定付加条件コード毎に料金検証異動契約状態マップを作成する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void makePrcKnsStatMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makePrcKnsStatMap]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 料金検証異動契約状態適用開始、終了年月日
		paramList.setValue(super.opeDate);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcKnsStatMap][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeAK_M_PRCKNS_IDO_KIST_AK_SELECT_001(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_AK_M_PRCKNS_IDO_KIST.selectNext();
		
		this.tmpPrcKnsStatMap = new HashMap<String, String>();
		
		// 取得件数分処理を繰り返す
		while (dbMap != null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcKnsStatMap][dbMap=" + dbMap.getMap().toString() + "]");
			// 取得した情報マップに設定
			// KEY：異動区分＋契約状態判定付加条件コード VALUE：料金検証契約状態コード
			this.tmpPrcKnsStatMap.put(makeStr(dbMap.getString(JBSbatAK_M_PRCKNS_IDO_KIST.IDO_DIV), 
												dbMap.getString(JBSbatAK_M_PRCKNS_IDO_KIST.KEI_STAT_JDG_HUKA_JKN_CD)), 
												dbMap.getString(JBSbatAK_M_PRCKNS_IDO_KIST.PRCKNS_KEI_STAT_CD));
			dbMap = db_AK_M_PRCKNS_IDO_KIST.selectNext();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makePrcKnsStatMap]");
		return;
	}
	
	/**
	 * 料金スケジュール定義アクセス部品を使用してスケジュール情報を取得する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getSchdlInfo() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSchdlInfo]");
		
		JACbatSchdlUtil schdlUtil = new JACbatSchdlUtil(commonItem);
		try
		{
			// 請求年月
			this.tmpSeikyYm 		= schdlUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_PRC_CALC_DAY);
			// 月初日[0] 月末日[1]
			String[] ymd 		= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
			this.tmpMonStaDay 	= ymd[0];
			this.tmpMonEndDay 	= ymd[1];
			// 料金計算日
			this.tmpEventYmd 	= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_PRC_CALC_DAY)[1];
			// 請求年月の暦日数
			this.tmpCalDay 		= JBSbatDateUtil.dayDiff(this.tmpMonEndDay, this.tmpMonStaDay, DIFF_NAI_FLG);
			
			// 前月月末日（月初日の前日）
			this.tmpPrvMonEndDay 	= JCCBatCommon.addDay(this.tmpMonStaDay, -1);
			// 請求年月前月
			this.tmpPrvSeikyYm		= schdlUtil.getBillDate(this.tmpPrvMonEndDay, JACStrConst.EVENT_CD_PRC_CALC_DAY); 
			// 前月月初日
			this.tmpPrvMonStaDay 	= schdlUtil.getUseStrEnd(this.tmpPrvSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD)[0];
			// 請求年月前月の暦日数
			this.tmpCalPrvDay 		= JBSbatDateUtil.dayDiff(this.tmpPrvMonEndDay, this.tmpPrvMonStaDay, DIFF_NAI_FLG);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月=" + this.tmpSeikyYm + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月初日=" + this.tmpMonStaDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月末日=" + this.tmpMonEndDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][料金計算日=" + this.tmpEventYmd + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月の暦日数=" + this.tmpCalDay + "]");
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月前月=" + this.tmpPrvSeikyYm + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][前月月初日=" + this.tmpPrvMonStaDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][前月月末日=" + this.tmpPrvMonEndDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月前月の暦日数=" + this.tmpCalPrvDay + "]");
		}
		finally
		{
			schdlUtil.close();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSchdlInfo]");
		return;
	}
	
	/**
	 * 契約状態判定@（日付項目判定）を行い、料金検証契約状態コードを返却します。
	 * @param inMap　入力電文
	 * @return String[] [0]:料金検証契約状態コード [1]:プラン課金終了年月日
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String[] getKeiStatYmd(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getKeiStatYmd]");
		
		String[] returnData = new String[2];
		
		String planChrgStaymd 	= inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);	// プラン課金開始年月日	
		// プラン課金開始年月日が空の場合
		if(JACStrConst.KARA_MOJI.equals(planChrgStaymd.trim()))
		{
			// ワーク．料金検証契約状態コード ← 空白
			returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKeiStatYmd][プラン課金開始年月日が空のため、契約状態に空白を設定]");
			return returnData;
		}

		// (a-0) 判定除外条件であれば以降の判定をスキップ
		// 判定条件取得
		String chstKeiSkbCd 		= inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD);			// 抽出契約識別コード
		String bmpUm		 		= inMap.getString(JBSbatAKIFM003.BMP_UM);					// 番ポ有無
		{
			if(JACStrConst.CHST_KEI_SKB_CD_SVC_KEI_UCWK.equals(chstKeiSkbCd) && JACStrConst.BMP_ARI.equals(bmpUm))
			{
				returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
				return returnData;
			}
		}

		// (a-1) 回復年月日（⇒解約同月回復、解約翌月回復）
		// 判定条件取得
		String kaihkYmd 			= inMap.getString(JBSbatAKIFM003.KAIHK_YMD);				// 回復年月日
		String svcChrgEndYmd 		= inMap.getString(JBSbatAKIFM003.SVC_CHRG_ENDYMD);			// サービス課金終了年月日
		{
			// @月初日〜月末日
			// （月初日 ≦ 回復年月日 かつ 回復年月日 ≦ 月末日）の場合
			if(this.tmpMonStaDay.compareTo(kaihkYmd) <= 0 && kaihkYmd.compareTo(this.tmpMonEndDay) <= 0)
			{
				JBSbatCommonDBInterface dbMap = this.getSvcChrgEndYmd(inMap);
				// 該当データありの場合
				if(dbMap != null)
				{
					// サービス課金終了年月日が、請求年月と同一月内
					// 判定条件取得
					String dbSvcChrgEndYmd = dbMap.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_ENDYMD);		// サービス課金終了年月日
					
					// （月初日 ≦ サービス課金終了年月日 かつ サービス課金終了年月日 ≦ 月末日 ）の場合
					if(this.tmpMonStaDay.compareTo(dbSvcChrgEndYmd) <= 0 && dbSvcChrgEndYmd.compareTo(this.tmpMonEndDay) <= 0)
					{
						// ワーク．料金検証契約状態コード ← "095"（解約同月回復）
						// 解約同月回復の場合、前回解約時のプラン課金終了年月日を退避する。
						returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_TOGTU_KAIHK;
						returnData[1] = dbMap.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD);
						return returnData;
					}
					// サービス課金終了年月日が、請求年月前月と同一月内
					// OM-2014-0002411 MOD START
					// // （前月月初日 ≦ サービス課金終了年月日　かつ サービス課金終了年月日 ≦ 前月月末日 ）場合
					// if(this.tmpPrvMonStaDay.compareTo(dbSvcChrgEndYmd) <= 0 && dbSvcChrgEndYmd.compareTo(this.tmpPrvMonEndDay) <= 0)
					
					// （サービス課金終了年月日 ≦ 前月月末日 ）場合
					if(dbSvcChrgEndYmd.compareTo(this.tmpPrvMonEndDay) <= 0)
					// OM-2014-0002411 MOD END
					{
						// ワーク．料金検証契約状態コード　←　"096"（解約翌月回復）
						returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_NEXT_KAIHK;
						return returnData;
					}
				}
			}
		}
		
		// (a-2) サービス課金終了年月日（⇒申出解約月、強制解約月、強制解約月翌月）
		// 判定条件取得
		String svcKeiStat 			= inMap.getString(JBSbatAKIFM003.SVC_KEI_STAT);				// サービス契約ステータス
		String svcDlreCd 			= inMap.getString(JBSbatAKIFM003.SVC_DLRE_CD);				// サービス解約理由コード
		{
			// @請求年月と同一月内
			// （月初日 ≦ サービス課金終了年月日 かつ サービス課金終了年月日 ≦ 月末日）
			if((this.tmpMonStaDay.compareTo(svcChrgEndYmd) <= 0 && svcChrgEndYmd.compareTo(this.tmpMonEndDay) <= 0)) 
			{
				// サービス契約ステータス ＝ "910"（解約済）
				// かつ サービス解約理由コード ＝ "01"（通常解約）
				// かつ サービス課金終了年月日 ＝ 請求対象年月月末日の場合
				if(JACStrConst.SVC_KEI_STAT_DSL.equals(svcKeiStat)
					&& JACStrConst.SVC_DSL_RSN_NORMAL.equals(svcDlreCd)
					&& svcChrgEndYmd.equals(this.tmpMonEndDay))
				{
					// ワーク．料金検証契約状態コード ← "092"月初解約月（強制解約月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KSI_DSL;
					return returnData;
				}
				// サービス契約ステータス ＝ "910"（解約済）
				// かつ サービス解約理由コード ＝ "01"（通常解約）
				// かつ サービス課金終了年月日 ≠ 請求対象年月月末日の場合
				else if(JACStrConst.SVC_KEI_STAT_DSL.equals(svcKeiStat)
							&& JACStrConst.SVC_DSL_RSN_NORMAL.equals(svcDlreCd)
							&& !svcChrgEndYmd.equals(this.tmpMonEndDay))
				{
					// ワーク．料金検証契約状態コード ← "091"通常解約月（申出解約月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_MOSHIDE_DSL;
					return returnData;
				}
				// サービス契約ステータス ＝ "910"（解約済）
				// かつ サービス解約理由コード ＝ "02"（強制解約） の場合
				else if(JACStrConst.SVC_KEI_STAT_DSL.equals(svcKeiStat)
							&& JACStrConst.SVC_DSL_RSN_KSI.equals(svcDlreCd))
				{
					// ワーク．料金検証契約状態コード ← "092"月初解約月（強制解約月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KSI_DSL;
					return returnData;
				}
				// 抽出契約識別コード＝"80"（割引適用対象契約）
				// かつ 割引サービス契約ステータス＝"100"（サービス提供中）
				// もしくは 割引サービス契約ステータス＝"300"（適用済） の場合
				else if(JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI.equals(chstKeiSkbCd)
					&& (WRIB_SVC_KEI_STAT_SVCTK_CHU.equals(svcKeiStat) || WRIB_SVC_KEI_STAT_APLY.equals(svcKeiStat)))
				{
					// ワーク．料金検証契約状態コード ← "011"（継続月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KEIZK_MON;
					return returnData;
				}
			}

			// A請求年月前月と同一月内
			// （前月月初日 ≦ サービス課金終了年月日　かつ サービス課金終了年月日 ≦ 前月月末日）
			if((this.tmpPrvMonStaDay.compareTo(svcChrgEndYmd) <= 0 && svcChrgEndYmd.compareTo(this.tmpPrvMonEndDay) <= 0))
			{
				// サービス契約ステータス ＝ "910"（解約済）
				// かつ　サービス解約理由コード ＝ "02"（強制解約）の場合
				if(JACStrConst.SVC_KEI_STAT_DSL.equals(svcKeiStat)
					&& JACStrConst.SVC_DSL_RSN_KSI.equals(svcDlreCd))
				{
						// ワーク．料金検証契約状態コード ← "093"（強制解約月翌月）
						returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KSI_NEXT;
						return returnData;
				}
				// サービス契約ステータス ＝ "910"（解約済）
				// かつ　サービス解約理由コード ＝ "01"（申出解約）
				// かつ　サービス課金終了年月日 ＝請求対象年月前月月末日の場合
				else if (JACStrConst.SVC_KEI_STAT_DSL.equals(svcKeiStat)
							&& JACStrConst.SVC_DSL_RSN_NORMAL.equals(svcDlreCd)
							&& svcChrgEndYmd.equals(this.tmpPrvMonEndDay))
				{
					// ワーク．料金検証契約状態コード ← "093"（強制解約月翌月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KSI_NEXT;
					return returnData;
				}
				// 上記以外の場合
				else
				{
					// ワーク．料金検証契約状態コード ← "097"（解約月翌月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_DSL_NEXT;
					return returnData;
				}
			}
		}

		// (b) プラン課金終了年月日（⇒プラン変更元終了月）
		// 判定条件取得
		String planChrgEndYmd 	= inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);				// プラン課金終了年月日
		String planEndSbtCd 	= inMap.getString(JBSbatAKIFM003.PLAN_END_SBT_CD);				// プラン終了種別コード
		{
			// @請求年月と同一月内
			// （月初日 ≦ プラン課金終了年月日 かつ プラン課金終了年月日 ≦ 月末日）
			// かつ プラン終了種別コード ＝ "1"（プラン変更による終了）の場合
			if((this.tmpMonStaDay.compareTo(planChrgEndYmd) <= 0 && planChrgEndYmd.compareTo(this.tmpMonEndDay) <= 0) 
					&& JACStrConst.PLAN_END_SBT_CD_PLAN_CHG_END.equals(planEndSbtCd))
			{
				// プラン課金開始年月日　≦　プラン課金終了年月日の場合
				if(planChrgStaymd.compareTo(planChrgEndYmd) <= 0)
				{
					// ワーク．料金検証契約状態コード ← "021"（プラン変更元終了月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_PLAN_END;
					return returnData;
				}
				else
				{
					// ワーク．料金検証契約状態コード ← 空白
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
					return returnData;
				}
			}
		}

		// (c) サービス課金開始年月日（⇒サービス課金開始月）
		// 判定条件取得
		String svcChrgStaymd 	= inMap.getString(JBSbatAKIFM003.SVC_CHRG_STAYMD);	// サービス課金開始年月日
		String svcChrgEndymd 	= inMap.getString(JBSbatAKIFM003.SVC_CHRG_ENDYMD);	// サービス課金終了年月日
		{
			// @請求年月と同一月内
			// （月初日 ≦ サービス課金開始年月日 かつ サービス課金開始年月日 ≦ 月末日 ） の場合
			if(this.tmpMonStaDay.compareTo(svcChrgStaymd) <= 0 && svcChrgStaymd.compareTo(this.tmpMonEndDay) <= 0)
			{
				// 以下の条件に合致する場合、ワーク．料金検証契約状態コードに空白を設定する。
				// サービス課金終了年月日が""以外　							且つ、
				// "20991231"以外　											且つ、
				// サービス課金終了年月日 < サービス課金開始年月日の場合
				if(!JACStrConst.KARA_MOJI.equals(svcChrgEndymd.trim())
						&& !JACStrConst.MAX_DATE.equals(svcChrgEndymd)
						&& svcChrgStaymd.compareTo(svcChrgEndymd) > 0)
				{
					// ワーク．料金検証契約状態コード ← 空白
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
				}
				// 上記以外の場合
				else
				{
					// プラン課金開始年月
					if(planChrgStaymd.compareTo(this.tmpMonEndDay) <= 0)
					{
					// ワーク．料金検証契約状態コード ← "002"（サービス課金開始月）
						returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SVC_CHRG;
					}
					else
					{
						// ワーク．料金検証契約状態コード ← 空白
						returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
					}
				}
				return returnData;
			}
		}

		// (d) サービス開始年月日（⇒サービス開始月）
		// 判定条件取得
		String svcStaYmd 	= inMap.getString(JBSbatAKIFM003.SVC_STA_YMD);	// サービス開始年月日
		{
			
			// @請求年月と同一月内
			// （月初日 ≦ サービス開始年月日 かつ サービス開始年月日 ≦ 月末日 ） の場合
			if(this.tmpMonStaDay.compareTo(svcStaYmd) <= 0 && svcStaYmd.compareTo(this.tmpMonEndDay) <= 0)
			{
				// ワーク．料金検証契約状態コード ← "001"（サービス開始月）
				returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SVC_STA;
				return returnData;
			}
		}

		// (e) サービス休止課金開始年月日、サービス休止解除年月日（⇒休止課金月）
		// 判定条件取得
		String svcPauseChrgStaYmd 	= inMap.getString(JBSbatAKIFM003.SVC_PAUSE_CHRG_STA_YMD);	// サービス休止課金開始年月日
		String svcPauseRlsYmd 		= inMap.getString(JBSbatAKIFM003.SVC_PAUSE_RLS_YMD);		// サービス休止解除年月日
		{
			// @請求年月と同一月内、かつ休止解除されていない
			// （月初日 ≦ サービス休止課金開始年月日 かつ サービス休止課金開始年月日 ≦ 月末日 ）
			//  かつ 月末日 ＜ サービス休止解除年月日 の場合
			if((this.tmpMonStaDay.compareTo(svcPauseChrgStaYmd) <= 0 && svcPauseChrgStaYmd.compareTo(this.tmpMonEndDay) <= 0) 
					&& this.tmpMonEndDay.compareTo(svcPauseRlsYmd) < 0)
			{
				// ワーク．料金検証契約状態コード　←　"012"（休止課金月）
				returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_PAUSE_CHRG;
				return returnData;
			}
		}

		// (f) プラン課金開始年月日（⇒プラン変更後課金開始月）
		{
			// @請求年月と同一月内
			// （月初日 ≦ プラン課金開始年月日 かつ プラン課金開始年月日 ≦ 月末日 ） の場合
			if(this.tmpMonStaDay.compareTo(planChrgStaymd) <= 0 && planChrgStaymd.compareTo(this.tmpMonEndDay) <= 0)
			{
				// （請求年月前月月初日 ≦ 回復年月日 かつ 回復年月日 ≦ 請求年月前月月末日）の場合
				if(this.tmpPrvMonStaDay.compareTo(kaihkYmd) <= 0 && kaihkYmd.compareTo(this.tmpPrvMonEndDay) <= 0)
				{
					// ワーク．料金検証契約状態コード ← "011"（継続月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KEIZK_MON;
					return returnData;
				}
				else
				{
					// ワーク．料金検証契約状態コード ← "022"（プラン変更後課金開始月）
					returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_PLAN_STA;
					return returnData;
				}
			}
		}

		// (h) 上記の各判定条件に当てはまらない場合（⇒継続月、空白）
		{
			String planChrgStaYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);	// プラン課金開始年月日
			// （サービス契約ステータス　＝　"100"（サービス提供中）
			// または "210"（休止・中断中）
			// または "220"（停止中））
			// かつ （プラン課金開始年月日 ≦ 月末日 ）の場合
			if((JACStrConst.SVC_KEI_STAT_SVCTK.equals(svcKeiStat) 
					|| JACStrConst.SVC_KEI_STAT_KYUSHI.equals(svcKeiStat) 
					|| JACStrConst.SKHK_SVKEI_STAT_CD_STP.equals(svcKeiStat))
				&& (planChrgStaYmd.compareTo(this.tmpMonStaDay) < 0
						&& this.tmpMonEndDay.compareTo(planChrgEndYmd) < 0))
			{
				// ワーク．料金検証契約状態コード ← "011"（継続月）
				returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_KEIZK_MON;
				return returnData;
			}
			else
			{
				// ワーク．料金検証契約状態コード ← 空白
				returnData[0] = JACStrConst.PRCKNS_KEI_STAT_CD_SP;
				return returnData;
			}	
		}
	}
	
	/**
	 * 抽出契約識別コードに応じて各種サービス契約スキーマを検索し、直近のサービス課金終了年月日を取得する。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSvcChrgEndYmd(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcChrgEndYmd]");

		JBSbatCommonDBInterface dbMap = null;
		// 判定条件取得
		String chstKeiSkbCd 		= inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD);		// 抽出契約識別コード
		// 入力．抽出契約識別コード ＝ "10"（サービス契約） の場合
		if(JACStrConst.CHST_KEI_SKB_CD_SVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：サービス契約を検索
			dbMap = this.getSvcKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "20"（サービス契約内訳） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_SVC_KEI_UCWK.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：サービス契約内訳を検索
			dbMap = this.getSvcKeiUcwkInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "30"（オプションサービス契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_OP_SVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：オプションサービス契約を検索
			dbMap = this.getOpSvcKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "40"（サブオプションサービス契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_SBOP_SVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：サブオプションサービス契約を検索
			dbMap = this.getSbopSvcKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "50"（機器提供サービス契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_KKTK_SVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：機器提供サービス契約を検索
			dbMap = this.getKktkSvcKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "60"（請求オプションサービス契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_SEIOPSVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：請求オプションサービス契約を検索
			dbMap = this.getSeiopsvcKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "70"（割引サービス契約）
		// または 入力．抽出契約識別コード ＝ "80"（割引適用対象契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_WRIB_SVC_KEI.equals(chstKeiSkbCd)
				|| JACStrConst.CHST_KEI_SKB_CD_WRIB_TRG_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：割引サービス契約を検索
			dbMap = this.getWribTrgKeiInfo(inMap);
		}
		// 入力．抽出契約識別コード ＝ "51"（機器オプションサービス契約） の場合
		else if(JACStrConst.CHST_KEI_SKB_CD_KKOP_SVC_KEI.equals(chstKeiSkbCd))
		{
			// 検索対象スキーマ：機器オプションサービス契約を検索
			dbMap = this.getKkopSvcKeiInfo(inMap);
		}

		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcChrgEndYmd]");
		return dbMap;
	}
	
	/**
	 * サービス契約スキーマを検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO));
		// サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_SVC_KEI_AK_SELECT_003(paramList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeiInfo]");
		return dbMap;
	}
	
	/**
	 * サービス契約内訳を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSvcKeiUcwkInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeiUcwkInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// サービス契約内訳番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO));
		// サービス契約内訳番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SVC_KEI_UCWK_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeiUcwkInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_SVC_KEI_UCWK_AK_SELECT_003(paramList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI_UCWK.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_SVC_KEI_UCWK.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeiUcwkInfo]");
		return dbMap;
	}

	/**
	 * オプションサービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getOpSvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOpSvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO));
		// オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getOpSvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_OP_SVC_KEI_AK_SELECT_003(paramList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_KK_T_OP_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_OP_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOpSvcKeiInfo]");
		return dbMap;
	}

	/**
	 * サブオプションサービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSbopSvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSbopSvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO));
		// サブオプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO));
		// オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.OP_SVC_KEI_NO));
		// サブオプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SBOP_SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSbopSvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_SBOP_SVC_KEI_AK_SELECT_003(paramList.getList().toArray());
	
		JBSbatCommonDBInterface dbMap = db_KK_T_SBOP_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_SBOP_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSbopSvcKeiInfo]");
		return dbMap;
	}

	/**
	 * 機器提供サービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getKktkSvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getKktkSvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 機器提供サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO));
		// 機器提供サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.KKTK_SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKktkSvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_KKTK_SVC_KEI_AK_SELECT_003(paramList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_KK_T_KKTK_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_KKTK_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getKktkSvcKeiInfo]");
		return dbMap;
	}

	/**
	 * 請求オプションサービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSeiopsvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSeiopsvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 請求オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SEIOPSVC_KEI_NO));
		// 請求オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.SEIOPSVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSeiopsvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_SEIOPSVC_KEI_AK_SELECT_003(paramList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_KK_T_SEIOPSVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_SEIOPSVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSeiopsvcKeiInfo]");
		return dbMap;
	}

	/**
	 * 割引サービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getWribTrgKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getWribTrgKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 割引サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.WRIB_SVC_KEI_NO));
		// 割引サービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM003.WRIB_SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getWribTrgKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_WRIB_SVC_KEI_AK_SELECT_003(paramList.getList().toArray());
	
		JBSbatCommonDBInterface dbMap = db_KK_T_WRIB_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_WRIB_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getWribTrgKeiInfo]");
		return dbMap;
	}
	
	/**
	 * 機器オプションサービス契約を検索して、直近サービス課金終了年月日取得を取得します。
	 * @param inMap　入力電文
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getKkopSvcKeiInfo(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getKkopSvcKeiInfo]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 機器オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO));
		// 機器オプションサービス契約番号
		paramList.setValue(inMap.getString(JBSbatAKIFM061.KKOP_SVC_KEI_NO));
		// 予約適用年月日＋世代登録年月日時分秒
		paramList.setValue(this.makeStr(inMap.getString(JBSbatAKIFM003.RSV_APLY_YMD), inMap.getString(JBSbatAKIFM003.GENE_ADD_DTM)));
		// 機器オプションサービス契約ステータス"910"（解約済）
		paramList.setValue(JACStrConst.KKOP_SVC_KEI_STAT_DSL);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getKkopSvcKeiInfo][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_KKOP_SVC_KEI_AK_SELECT_001(paramList.getList().toArray());
	
		JBSbatCommonDBInterface dbMap = db_KK_T_KKOP_SVC_KEI.selectNext();
		
		if(dbMap == null)
		{
			String[] outCntMsg = {JBSbatKK_T_KKOP_SVC_KEI.TABLE_NAME, paramList.getList().toString()};
			// DB異常のメッセージ（【警告】ＤＢ未存在エラー）をLOGに出力する。
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0180CW, outCntMsg);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getKkopSvcKeiInfo]");
		return dbMap;
	}

	/**
	 * 請求年月、月初日、月末日、暦日数、およびプラン課金開始年月日、プラン課金終了年月日、回復年月日により月中利用日数を算出する。
	 * @param inMap　入力電文
	 * @param ymdData　契約状態判定@（日付項目判定）で取得した値
	 * @return JBSbatCommonDBInterface DBの取得結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private int getUseDayCnt(JBSbatServiceInterfaceMap inMap, String[] ymdData) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getUseDayCnt]");

		// ワーク領域を初期設定する。
		String wkPlanChrgStaymd = null;	// ワーク．プラン課金開始年月日
		int useDayCnt = 0;
		
		// 判定条件取得
		String kaihkYmd = inMap.getString(JBSbatAKIFM003.KAIHK_YMD);	// 回復年月日
		{
			// 月初日 ≦ 回復年月日 かつ 回復年月日 ≦ 月末日 の場合
			if(this.tmpMonStaDay.compareTo(kaihkYmd) <= 0 && kaihkYmd.compareTo(this.tmpMonEndDay) <= 0)
			{
				// ワーク．プラン課金開始年月日 ← 回復年月日
				wkPlanChrgStaymd = kaihkYmd;
			}
			else
			{
				// ワーク．プラン課金開始年月日 ← プラン課金開始年月日
				wkPlanChrgStaymd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);
			}
			// ワーク．月中利用日数クリア
			// ワーク．月中利用日数 ← ゼロ
			useDayCnt = 0;
			
		}
		// プラン課金開始年月日を考慮
		{
			// ワーク．プラン課金開始年月日 ＝ 空、空白 の場合
			if(isBlank(wkPlanChrgStaymd))
			{
				useDayCnt = 0;
			}
			// ワーク．プラン課金開始年月日 ≦ 月初日 の場合
			else if(wkPlanChrgStaymd.compareTo(this.tmpMonStaDay) <= 0)
			{
				// ワーク．月中利用日数 ← 暦日数
				useDayCnt = this.tmpCalDay;
			}
			// 月初日 ＜ ワーク．プラン課金開始年月日
			// かつ ワーク．プラン課金開始年月日 ≦ 月末日の場合
			else if(this.tmpMonStaDay.compareTo(wkPlanChrgStaymd) < 0
					&& wkPlanChrgStaymd.compareTo(this.tmpMonEndDay) <= 0)
			{
				// ワーク．プラン課金開始年月日から月末日までの日数を、ワーク．日数に求める。
				// ワーク．月中利用日数 ← ワーク．日数
				useDayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, wkPlanChrgStaymd, DIFF_NAI_FLG);
			}
			// 月末日 ＜ ワーク．プラン課金開始年月日 の場合
			else if(this.tmpMonEndDay.compareTo(wkPlanChrgStaymd) < 0)
			{
				// ワーク．月中利用日数 ← ゼロ
				useDayCnt = 0;
			}
		}
		// プラン課金終了年月日を考慮
		{
			// 判定条件取得
			String planChrgEndYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);	// プラン課金終了年月日
			// プラン課金終了年月日 ＝ （空、空白）
			// または プラン課金終了年月日 ＝ '20991231' の場合
			if(JACStrConst.KARA_MOJI.equals(planChrgEndYmd.trim())
					|| JACStrConst.MAX_DATE.equals(planChrgEndYmd))
			{
				// ワーク．月中利用日数のまま（何もしない）
			}
			// プラン課金終了年月日 ＜ 月初日
			// かつ ワーク．プラン課金開始年月日 ≦ プラン課金終了年月日 の場合
			else if(planChrgEndYmd.compareTo(this.tmpMonStaDay) < 0
					&& wkPlanChrgStaymd.compareTo(planChrgEndYmd) <= 0)
			{
				// ワーク．月中利用日数 ← ゼロ
				useDayCnt = 0;
			}
			// 月初日 ≦ プラン課金終了年月日 
			// かつ プラン課金終了年月日 ≦ 月末日
			// かつ ワーク．プラン課金開始年月日 ≦ プラン課金終了年月日 の場合
			else if(this.tmpMonStaDay.compareTo(planChrgEndYmd) <= 0
					&& planChrgEndYmd.compareTo(this.tmpMonEndDay) <= 0
					&& wkPlanChrgStaymd.compareTo(planChrgEndYmd)  <= 0) 
			{
				// 日付共通処理部品を使用し、プラン課金終了年月日から月末日までの日数を、ワーク．日数に求める。
				// ワーク．月中利用日数 ← ワーク．月中利用日数 − ワーク．日数 ＋ １
				int dayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, planChrgEndYmd, DIFF_NAI_FLG);
				useDayCnt = useDayCnt - dayCnt + 1;
			}
			// 月末日 ＜ プラン課金終了年月日 の場合
			else if(this.tmpMonEndDay.compareTo(planChrgEndYmd) < 0)
			{
				// ワーク．月中利用日数のまま（何もしない）
			}
		}
		// 解約同月回復を考慮
		{
			// 判定条件取得
			String prcknsKeiStat = ymdData[0];	// 料金検証契約状態
			// (1) で判定した料金検証契約状態 ＝ "095"（解約同月回復） かつ
			if(JACStrConst.PRCKNS_KEI_STAT_CD_TOGTU_KAIHK.equals(prcknsKeiStat))
			{
				// 判定条件取得
				String dbPlanChrgEndymd = ymdData[1];	// プラン課金終了年月日
				// 月初日 ≦ (1) で退避した前回解約時のプラン課金終了年月日 かつ
				// (1) で退避した前回解約時のプラン課金終了年月日 ≦ 月末日 の場合
				if(this.tmpMonStaDay.compareTo(dbPlanChrgEndymd) <= 0
						&& dbPlanChrgEndymd.compareTo(this.tmpMonEndDay) <= 0)
				{
					// 月初日から前回解約時のプラン課金終了年月日までの日数を、ワーク．日数に求める。
					int dayCnt = JBSbatDateUtil.dayDiff(dbPlanChrgEndymd, this.tmpMonStaDay, DIFF_NAI_FLG);
					// ワーク．月中利用日数　←　ワーク．月中利用日数　＋　ワーク．日数
					useDayCnt = useDayCnt + dayCnt;
					// 前回解約時のプラン課金終了年月日 ＝ 回復年月日 の場合
					if(kaihkYmd.compareTo(dbPlanChrgEndymd) == 0)
					{
						// 同日回復で１日重複するため１減算する。
						useDayCnt--;
					}
				}
			}
		}
		
		// 入力・プラン課金終了年月日　＜　ワーク．プラン課金開始年月日または
		// ワーク．月中利用日数　＜　ゼロの場合は、ワーク．月中利用日数にゼロを設定する。
		{
			String planChrgEndYmd = inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);	// プラン課金終了年月日
			if(useDayCnt < 0 || planChrgEndYmd.compareTo(wkPlanChrgStaymd) < 0)
			{
				// ワーク．月中利用日数　←　ゼロ
				useDayCnt = 0;
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getUseDayCnt][ワーク．プラン課金開始日=" + wkPlanChrgStaymd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getUseDayCnt][ワーク．月中利用日数=" + useDayCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getUseDayCnt]");
		return useDayCnt;
	}
	
	/**
	 * サービス開始年月日、サービス課金終了年月日、請求年月、月末日により、以下の様に算出する。
	 * @param inMap　入力電文
	 * @return String[] [0]:サービス継続月数 [1]:サービス継続日数
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String[] getSvcKeizoku(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeizoku]");
		
		String[] returnData = new String[2];
		
		// ワーク．サービス継続月数
		int wkMonCnt = 0;
		// ワーク．サービス継続日数
		int wkdayCnt = 0;
		
		// 判定条件取得
		String svcStaYmd 	= inMap.getString(JBSbatAKIFM003.SVC_STA_YMD);
		// サービス開始年月日 ≠ 空、空白の場合
		if(!isBlank(svcStaYmd))
		{
			// サービス開始年月日の1〜6桁目 → サービス開始年月
			String svcStaYm 	= svcStaYmd.substring(0, 6);
			
			// サービス課金終了年月日が未設定（空、空白、"20991231"）の場合
			// 判定条件取得
			String svcChrgEndymd = inMap.getString(JBSbatAKIFM003.SVC_CHRG_ENDYMD);	// サービス課金終了年月日
			
			if(JACStrConst.KARA_MOJI.equals(svcChrgEndymd.trim())
					|| JACStrConst.MAX_DATE.equals(svcChrgEndymd))
			{
				// ワーク．サービス継続月数 ← サービス開始年月から請求年月までの経過月数（共にその月を含む）
				wkMonCnt = JBSbatDateUtil.monthDiff(this.tmpSeikyYm, svcStaYm, DIFF_NAI_FLG);
				// ワーク．サービス継続日数 ← サービス開始年月日から請求年月の月末日までの経過日数（共にその日を含む）
				wkdayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, svcStaYmd, DIFF_NAI_FLG);
			}
			// サービス課金終了年月日に設定有（空、空白、"20991231"以外）の場合
			else
			{
				// サービス課金終了年月日の1〜6桁目を、サービス課金終了年月とする。
				String svcChrgEndym = svcChrgEndymd.substring(0, 6);
				
				// サービス課金終了年月日　＜　請求年月の月末日の場合
				if(svcChrgEndymd.compareTo(this.tmpMonEndDay) < 0)
				{
					// ワーク．サービス継続月数 ← サービス開始年月からサービス課金終了年月までの経過月数（共にその月を含む）
					wkMonCnt = JBSbatDateUtil.monthDiff(svcChrgEndym, svcStaYm, DIFF_NAI_FLG);
					// ワーク．サービス継続日数 ← サービス開始年月日からサービス課金終了年月日までの経過日数（共にその日を含む）
					wkdayCnt = JBSbatDateUtil.dayDiff(svcChrgEndymd, svcStaYmd, DIFF_NAI_FLG);
				}
				else
				{
					// ワーク．サービス継続月数 ← サービス開始年月から請求年月までの経過月数（共にその月を含む）
					wkMonCnt = JBSbatDateUtil.monthDiff(this.tmpSeikyYm, svcStaYm, DIFF_NAI_FLG);
					// ワーク．サービス継続日数 ← サービス開始年月日から請求年月の月末日までの経過日数（共にその日を含む）
					wkdayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, svcStaYmd, DIFF_NAI_FLG);
				}
			}
		}
		
		// 請求年月月末日　＜　サービス開始年月日の場合を考慮して、
		// ワーク．サービス継続月数　＜　ゼロの場合は、ワーク．サービス継続月数　←　ゼロ
		// ワーク．サービス継続日数　＜　ゼロの場合は、ワーク．サービス継続日数　←　ゼロ
		if(wkMonCnt < 0)
		{
			// ワーク．サービス継続月数　←　ゼロ
			wkMonCnt = 0;
		}
		
		if(wkdayCnt < 0)
		{
			// ワーク．サービス継続日数　←　ゼロ
			wkdayCnt = 0;
			
		}
		
		// 課金開始前解約判定
		if(isChrgStaBfDsl(inMap))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint,
					"[L][getSvcKeizoku][課金開始前解約のため、サービス継続月数、サービス継続日数をゼロに変更]");
			// ワーク．サービス継続月数　←　ゼロ
			wkMonCnt = 0;
			// ワーク．サービス継続日数　←　ゼロ
			wkdayCnt = 0;
			
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeizoku][ワーク．サービス継続月数=" + wkMonCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeizoku][ワーク．サービス継続日数=" + wkdayCnt + "]");
		returnData[0] = String.valueOf(wkMonCnt);
		returnData[1] = String.valueOf(wkdayCnt);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSvcKeizoku]");
		return returnData;
	}
	
	/**
	 * サービス課金開始年月日、サービス課金課金終了年月日、請求年月、月末日により、以下の様に算出する。
	 * @param inMap　入力電文
	 * @return String[] [0]:課金継続月数 [1]:課金継続日数
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String[] getChrgKeizoku(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getChrgKeizoku]");
		
		String[] returnData = new String[2];
		
		// ワーク．課金継続月数
		int wkMonCnt = 0;
		// ワーク．課金継続日数
		int wkdayCnt = 0;
		
		// 判定条件取得
		String svcChrgStaymd 	= inMap.getString(JBSbatAKIFM003.SVC_CHRG_STAYMD);
		
		// サービス課金開始年月日 ≠ ""（空、空白）の場合
		if(!isBlank(svcChrgStaymd))
		{
			// サービス課金開始年月日の1〜6桁目 → サービス課金開始年月
			String svcChrgStaym 	= svcChrgStaymd.substring(0, 6);
			
			// サービス課金終了年月日が未設定（空、空白、"20991231"）の場合
			// 判定条件取得
			String svcChrgEndymd = inMap.getString(JBSbatAKIFM003.SVC_CHRG_ENDYMD);	// サービス課金終了年月日
			
			if(JACStrConst.KARA_MOJI.equals(svcChrgEndymd.trim())
					|| JACStrConst.MAX_DATE.equals(svcChrgEndymd))
			{
				// ワーク．課金継続月数 ← サービス課金開始年月から請求年月までの経過月数（共にその月を含む）
				wkMonCnt = JBSbatDateUtil.monthDiff(this.tmpSeikyYm, svcChrgStaym, DIFF_NAI_FLG);
				// ワーク．課金継続日数 ← サービス課金開始年月日から請求年月の月末日までの経過日数（共にその日を含む）
				wkdayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, svcChrgStaymd, DIFF_NAI_FLG);
			}
			// サービス課金終了年月日に設定有（空、空白、"20991231"以外）の場合
			else
			{
				// サービス課金終了年月日の1〜6桁目を、サービス課金終了年月とする。
				String svcChrgEndym = svcChrgEndymd.substring(0, 6);
				
				// サービス課金終了年月日 ＜ 請求年月の月末日の場合
				if(svcChrgEndym.compareTo(this.tmpMonEndDay) < 0)
				{
					// ワーク．課金継続月数 ← サービス課金開始年月からサービス課金終了年月までの経過月数（共にその月を含む）
					wkMonCnt = JBSbatDateUtil.monthDiff(svcChrgEndym, svcChrgStaym, DIFF_NAI_FLG);
					// ワーク．課金継続日数 ← サービス課金開始年月日からサービス課金終了年月日までの経過日数（共にその日を含む）
					wkdayCnt = JBSbatDateUtil.dayDiff(svcChrgEndymd, svcChrgStaymd, DIFF_NAI_FLG);
				}
				else
				{
					// ワーク．課金継続月数 ← サービス開始年月から請求年月までの経過月数（共にその月を含む）
					wkMonCnt = JBSbatDateUtil.monthDiff(this.tmpSeikyYm, svcChrgStaym, DIFF_NAI_FLG);
					// ワーク．課金継続日数 ← サービス開始年月日から請求年月の月末日までの経過日数（共にその日を含む）
					wkdayCnt = JBSbatDateUtil.dayDiff(this.tmpMonEndDay, svcChrgStaymd, DIFF_NAI_FLG);
				}
			}
		}
		
		// 請求年月月末日　＜　プラン課金開始年月日の場合を考慮して
		// ワーク．課金継続月数　＜　ゼロの場合は、ワーク．課金継続月数　←　ゼロ
		// ワーク．課金継続日数　＜　ゼロの場合は、ワーク．課金継続日数　←　ゼロ
		if(wkMonCnt < 0)
		{
			// ワーク．課金継続月数　←　ゼロ
			wkMonCnt = 0;
		}
		
		if(wkdayCnt < 0)
		{
			// ワーク．課金継続日数　←　ゼロ
			wkdayCnt = 0;
		}
		
		// 課金開始前解約判定
		if(isChrgStaBfDsl(inMap))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeizoku][課金開始前解約のため、課金継続月数、課金継続日数をゼロに変更" + "]");
			// ワーク．サービス継続月数　←　ゼロ
			wkMonCnt = 0;
			// ワーク．サービス継続日数　←　ゼロ
			wkdayCnt = 0;
			
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeizoku][ワーク．課金継続月数=" + wkMonCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeizoku][ワーク．課金継続日数=" + wkdayCnt + "]");
		returnData[0] = String.valueOf(wkMonCnt);
		returnData[1] = String.valueOf(wkdayCnt);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getChrgKeizoku]");
		return returnData;
	}

	/**
	 * 検証対象契約情報（状態判定済み）出力します。
	 * @param inMap     入力電文
	 * @param ymdData   [0]:ワーク．料金検証契約状態コード [1]:プラン課金終了年月日（未使用）
	 * @param useDayCnt ワーク．月中利用日数
	 * @param svcData   [0]:ワーク．サービス継続月数 [1]:ワーク．サービス継続日数
	 * @param chrgData  [0]:ワーク．課金継続月数 [1]:ワーク．課金継続日数
	 * @param outputItem　出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputInfo(JBSbatServiceInterfaceMap inMap, String[] ymdData, int useDayCnt
			, String[] svcData, String[] chrgData, JBSbatOutputItem outputItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputInfo]");
		assert inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputInfo][inMap=" + inMap.toString() + "]") : true;
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		// 入力電文コピー
		outMap.getMap().putAll(inMap.getMap());
		// 差分設定
		outMap.set(JBSbatAKIFM003.PRCKNS_KEI_STAT_CD,	ymdData[0]);	// 料金検証契約状態コード
		outMap.set(JBSbatAKIFM003.USE_DAY_CNT,			useDayCnt);		// 月中利用日数
		outMap.set(JBSbatAKIFM003.SVC_KEIZOKU_MON_CNT,	svcData[0]);	// サービス継続月数
		outMap.set(JBSbatAKIFM003.SVC_KEIZOKU_DAY_CNT,	svcData[1]);	// サービス継続日数
		outMap.set(JBSbatAKIFM003.CHRG_KEIZOKU_MON_CNT,	chrgData[0]);	// 課金継続月数
		outMap.set(JBSbatAKIFM003.CHRG_KEIZOKU_DAY_CNT,	chrgData[1]);	// 課金継続日数
		
		// 出力フラグ設定
		outMap.setOutFlg(true);
		
		outputItem.addOutMapList(outMap);

		assert outMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutputInfo][outMap = " + outMap.getMap().toString() + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutputInfo]");

		return;
	}
	
	/**
	 * 入力電文．プラン課金終了年月日を補正します。
	 * @param inMap     入力電文
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void hoseiPlanChrgEndYmd(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][hoseiPlanChrgEndYmd]");
		
		String chstKeiSkbCd		= inMap.getString(JBSbatAKIFM003.CHST_KEI_SKB_CD);			// 抽出契約識別コード
		String planChrgEndYmd	= inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);			// プラン課金終了年月日	
		String svcDslYmd 		= inMap.getString(JBSbatAKIFM003.SVC_DSL_YMD);				// サービス解約年月日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][抽出契約識別コード=" + chstKeiSkbCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][プラン課金終了年月日=" + planChrgEndYmd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][サービス解約年月日=" + svcDslYmd + "]");
		
		// 抽出契約識別コードがサービス契約以外
		if(!JACStrConst.CHST_KEI_SKB_CD_SVC_KEI.equals(chstKeiSkbCd))
		{
			// プラン課金終了年月日が空文字、空白、または初期値（20991231）の場合
			if(JACStrConst.KARA_MOJI.equals(planChrgEndYmd.trim())
				|| (JACStrConst.MAX_DATE.equals(planChrgEndYmd)))
			{
				// 比較値に入力がないため、処理を終了
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][プラン課金終了年月日が空文字、空白、初期値のため補正せず終了]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][hoseiPlanChrgEndYmd]");
				return;
			}
			// サービス終了年月日が空文字、空白、または初期値（20991231）の場合
			if(JACStrConst.KARA_MOJI.equals(svcDslYmd.trim())
					|| (JACStrConst.MAX_DATE.equals(svcDslYmd)))
			{
				// 比較値に入力がないため、処理を終了
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][サービス終了年月日が空文字、空白、初期値のため補正せず終了]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][hoseiPlanChrgEndYmd]");
				return;
			}
			
			// サービス終了年月日 ＜＝ プラン課金終了年月日 の場合
			if(svcDslYmd.compareTo(planChrgEndYmd) <= 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][プラン課金終了年月日補正対象]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][（修正前）プラン課金終了年月日=" + planChrgEndYmd + "]");
				
				String tmpPlanChrgStaymd = JBSbatDateUtil.adjustDate(svcDslYmd, BE_ONE_DAY);
				inMap.setString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD, tmpPlanChrgStaymd);
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint,
						"[L][hoseiPlanChrgEndYmd][（修正後）プラン課金終了年月日=" + inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD) + "]");
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][hoseiPlanChrgEndYmd]");
	}

	/**
	 * 入力電文．プラン課金終了年月日を補正します。
	 * @param inMap     入力電文
	 * @return true:課金開始前解約 false:課金開始前解約以外
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isChrgStaBfDsl(JBSbatServiceInterfaceMap inMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isChrgStaBfDsl]");
		
		String planChrgStaYmd	= inMap.getString(JBSbatAKIFM003.PLAN_CHRG_STAYMD);			// プラン課金開始年月日
		String planChrgEndYmd	= inMap.getString(JBSbatAKIFM003.PLAN_CHRG_ENDYMD);			// プラン課金終了年月日	
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][プラン課金開始年月日=" + planChrgStaYmd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][hoseiPlanChrgEndYmd][プラン課金終了年月日=" + planChrgEndYmd + "]");
		
		// プラン課金開始年月日 ≠ （空、空白、"20991231"） かつ
		// プラン課金終了年月日 ≠ （空、空白、"20991231"） かつ
		// プラン課金終了年月日 ＜ プラン課金開始年月日 の場合
		if((!isBlankOrShkvYmd(planChrgStaYmd))
			&& (!isBlankOrShkvYmd(planChrgEndYmd))
			&& ((planChrgEndYmd.compareTo(planChrgStaYmd) < 0)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isChrgStaBfDsl][日付逆転のため、課金開始前解約と判定]");
			return true;
			
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isChrgStaBfDsl][課金開始前解約以外]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isChrgStaBfDsl]");
		return false;
	}
	
	/**
	 * 入力電文．プラン課金終了年月日を補正します。
	 * @param String trgtYmd  対象年月日
	 * @return true:空文字、空白、初期値 false:空文字、空白、初期値以外
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isBlankOrShkvYmd(String trgtYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isBlankOrShkvYmd]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlankOrShkvYmd][判定対象日付=" + trgtYmd + "]");
		
		//対象日付が空文字、空白、または初期値（20991231）の場合
		if(JACStrConst.KARA_MOJI.equals(trgtYmd.trim())
				|| (JACStrConst.MAX_DATE.equals(trgtYmd)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlankOrShkvYmd][判定日付が空文字、空白、初期値]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isBlankOrShkvYmd]");
			return true;
		}
	
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlankOrShkvYmd][判定日付が空文字、空白、初期値以外]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isBlankOrShkvYmd]");
		return false;
	}
	
	/**
	 * 判定文字列が空、空白かどうかを判定します。
	 * @param String trgtStr  判定文字列
	 * @return true:空文字、空白 false:空文字、空白
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isBlank(String trgtStr) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isBlank]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlank][判定対象=" + trgtStr + "]");
		
		//対象文字列が空文字、空白の場合
		if(JACStrConst.KARA_MOJI.equals(trgtStr.trim()))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlank][判定対象が空文字、空白]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isBlank]");
			return true;
		}
	
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isBlank][判定日付が空文字、空白以外]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isBlank]");
		return false;
	}
}