/*********************************************************************
*	All Right reserved,Copyright c Fujitsu, 2011
**********************************************************************
*＜プログラム内容＞
*	システム名		：プロジェクト共通
*	モジュール名	：JKKBatStringUtil
*	ソースファイル名：JKKBatStringUtil.java
*	作成者			：富士通
*	日付			：2011年05月16日
*＜機能概要＞
*	文字列編集を行う共通機能を提供する。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/05/16	富士通		新規作成
*
**********************************************************************/
package eo.business.common;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

import eo.business.util.table.JBSbatCK_T_CUST_GRP_SETTE;
import eo.business.util.table.JBSbatKK_M_ENQUETE;
import eo.business.util.table.JBSbatKK_M_WRIB_SVC;
import eo.business.util.table.JBSbatKK_M_WRISVC_TG_MKSBT;
import eo.business.util.table.JBSbatKK_M_WRISVC_TG_SVC;
import eo.business.util.table.JBSbatKK_T_INTR;
import eo.business.util.table.JBSbatKK_T_KKTK_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_MSKM_DTL;
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_WRIB_SVC_KEI;
import eo.common.util.JPCDateUtil;
import eo.framework.application.JCCbatFrameworkException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;


/**
 * 割引サービスの設定や解除を行う共通クラスです。<p>
 * <br>
 * @author 富士通
 */
public class JKKBatWribSvcChk
{

	/** オプションサービス契約リスト */
	private static final String OPSVCKEILIST = "OPSVCKEILIST";
	
	/** サブオプションサービス契約リスト */
	private static final String SBOPSVCKEILIST = "SBOPSVCKEILIST";
	
	/** 機器提供サービス契約リスト */
	private static final String KKTKSVCKEILIST = "KKTKSVCKEILIST";

	/** 請求オプションサービス契約リスト */
	private static final String SEIOPSVCKEILIST = "SEIOPSVCKEILIST";

	/**
	 * <dd>メソッド名	：getWribSvc
	 * <dd>メソッド説明	：割引サービスの情報取得を行う。
	 * @param  cmnItem 業務共通電文
	 * @param  mskmKisanDay 申込起算日
	 * @return wribSvcList：割引サービスリスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<JBSbatCommonDBInterface> getWribSvc(JBSbatCommonItem cmnItem, String mskmKisanDay) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		
		String mskmKisanDayHm = null;
		
		try 
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_M_WRIB_SVC.TABLE_NAME);
			
			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// 申込起算日時分
			mskmKisanDayHm = mskmKisanDay + "0000";
			dbList.setValue(mskmKisanDayHm);
			// 申込起算日
			dbList.setValue(mskmKisanDay);
			
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_M_WRIB_SVC_KK_SELECT_001);
			
			// 返却するインスタンスを生成
			ArrayList<JBSbatCommonDBInterface> wribSvcList = new ArrayList<JBSbatCommonDBInterface>();
			
			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();
			
			// 取得したレコードの数だけ繰り返します
			while (null != inMap)
			{
				// 取得した内容をListに設定します
				wribSvcList.add(inMap);
				// 次の1件を取得します
				inMap = stmt.selectNext();
			}

			return wribSvcList; 

		} 
		catch(SQLException e) 
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
	}
	
	/**
	 * <dd>メソッド名	：getWribSvcMskm
	 * <dd>メソッド説明	：割引サービスの情報取得を行う。
	 * @param  cmnItem 業務共通電文
	 * @param  mskmSbt 申込種別
	 * @param  mskmKisanDay 申込起算日
	 * @return wribSvcList：割引サービスリスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<JBSbatCommonDBInterface> getWribSvcMskm(JBSbatCommonItem cmnItem, String mskmSbt, String mskmKisanDay) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		
		String mskmKisanDayHm = null;
		try 
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_M_WRISVC_TG_MKSBT.TABLE_NAME);
			
			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			
			// SQLを実行するために引数を設定します
			// 申込起算日時分
			mskmKisanDayHm = mskmKisanDay + "0000";
			dbList.setValue(mskmKisanDayHm);
			// 申込起算日
			dbList.setValue(mskmKisanDay);
			// 申込種別コード
			dbList.setValue(mskmSbt);
			// 申込起算日
			dbList.setValue(mskmKisanDay);
			
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_M_WRISVC_TG_MKSBT_KK_SELECT_001);
			
			// 返却するインスタンスを生成
			ArrayList<JBSbatCommonDBInterface> wribSvcList = new ArrayList<JBSbatCommonDBInterface>();
			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();
			
			// 取得したレコードの数だけ繰り返します
			while (null != inMap)
			{
				// 取得した内容をListに設定します
				wribSvcList.add(inMap);
				// 次の1件を取得します
				inMap = stmt.selectNext();
			}

			return wribSvcList; 

		} 
		catch(SQLException e) 
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
	}
	
	/**
	 * <dd>メソッド名	：doAddTmgChk
	 * <dd>メソッド説明	：割引サービス適用の登録タイミングのチェックを行う。
	 * @param  cmnItem 業務共通電文
	 * @param  stdardYmd 基準年月日
	 * @param  staCd 開始コード
	 * @param  staAd 開始調整期間
	 * @param  staAdCd 開始調整コード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doAddTmgChk(JBSbatCommonItem cmnItem, String stdardYmd, String staCd, String staAd, String staAdCd) throws Exception
	{
		//開始コード=03(登録月)、開始コード=04(翌月)、開始コード=05(翌月(初日は当月))の場合はチェック不要
		if("03".equals(staCd) || ("04".equals(staCd) || ("05".equals(staCd))))
		{
			return true;
		}
		//開始コード=07(プラン変更)、開始コード=08(機種変更)、開始コード=09(出荷日+n日)の場合はチェック不要
		if("07".equals(staCd) || ("08".equals(staCd) || ("09".equals(staCd))))
		{
			return true;
		}
		//開始コード=06(課金開始前月)、かつ開始調整がnull値の場合はチェック不要
		if("06".equals(staCd) && (staAd == null))
		{
			return true;
		}
		
		JBSbatSQLAccess stmt = null;
		try 
		{
			//TODO 料金スケジュールマスタが作成され次第実装（料金計算日を取得する）
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatCK_T_CUST_GRP_SETTE.TABLE_NAME);

			// 検索キーを設定
//			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			
			// SQLを実行するために引数を設定します
			// 運用日
			
			// 割引サービス対象申込種別テーブルにアクセスするSQLを実行します
			
			// 返却するインスタンスを生成
			
			// テスト用ロジック開始（料金計算日設定）
			String ryoKei = "20120101";
			// テスト用ロジック終了（料金計算日設定）
			
			// 基準年月日をint型に変換します
			int stdardYmd1 = new Integer(stdardYmd);
			// 開始調整期間をint型に変換します
			int staAd1 = new Integer(staAd);
			// 料金計算日をint型に変換します
			int ryoKei1 = new Integer(ryoKei);
			
			// 開始調整期間の値がNullの場合は料金計算日と基準日付の比較を行います
			// 開始調整期間の値がNull以外の場合は基準日付と開始調整期間を元に日付の加減算処理を行った結果と料金計算日の比較を行います
			if(staAd == null)
			{
				if(stdardYmd1 <= ryoKei1)
				{
					return true;
				}
				else
				{
					return false;
				}
			}
			//日付加減算処理後の値を格納する変数を定義します
			String staAd_Aft = null;
			
			// 開始コードと開始調整コードの値に従い、日付の加減算処理を行います
			if((("01".equals(staCd)) || ("02".equals(staCd))) && ("2".equals(staAdCd)))
			{
				staAd_Aft = JPCDateUtil.addMonth(stdardYmd, staAd1);
			}
			
			if((("01".equals(staCd)) || ("02".equals(staCd))) && ("3".equals(staAdCd)))
			{
				staAd_Aft = JPCDateUtil.addDay(stdardYmd, staAd1);
			}
			
			if("06".equals(staCd))
			{
				String staAd_Aft1 = JPCDateUtil.addMonth(stdardYmd, -1);
				
				if("2".equals(staAdCd))
				{
					staAd_Aft = JPCDateUtil.addMonth(staAd_Aft1, staAd1);
				}
				
				if("3".equals(staAdCd))
				{
					staAd_Aft = JPCDateUtil.addDay(staAd_Aft1, staAd1);
				}
			}
			
			// 日付加減算処理後の変数をint型に変換します
			int staAd_Aft2 = new Integer(staAd_Aft);
			
			if(staAd_Aft2 <= ryoKei1)
			{
				return true;
			}
			else
			{
				return false;
			}
		} 
		catch(SQLException e) 
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
	}

	/**
	 * <dd>メソッド名	：doUpplAplyCntChk
	 * <dd>メソッド説明	：割引サービスの上限適用回数のチェックを行う。
	 * @param  cmnItem 業務共通電文
	 * @param  wribSvcCd 割引サービスコード
	 * @param  upplAplyCnt 上限適用回数
	 * @param  wribAgingPrd 割引エイジング期間
	 * @param  sysid SYSID
	 * @param  mskmKisanDay 申込起算日
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doUpplAplyCntChk(JBSbatCommonItem cmnItem, String wribSvcCd, 
												String upplAplyCnt, String wribAgingPrd, 
												String sysid, String mskmKisanDay) throws Exception
	{
		// 割引サービス契約ステータス
		String wribSvcKeiStat = null;
		// サービス終了年月日時分秒
		String svcEndDtm = null;
		// サービス終了年月日
		String svcEndYmd = null;
		// 運用年月日
		String unyoYmd = cmnItem.getOpeDate();
		// 適用件数カウント用変数
		int aplyCnt = 0;
		
		JBSbatSQLAccess stmt = null;
		try 
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_WRIB_SVC_KEI.TABLE_NAME);
			
			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// 割引サービスコード
			dbList.setValue(wribSvcCd);
			// ＳＹＳＩＤ
			dbList.setValue(sysid);
			// 申込起算日
			dbList.setValue(mskmKisanDay);
			
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_T_WRIB_SVC_KEI_KK_SELECT_006);

			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();
			
			// 取得したレコードの数だけ繰り返し、割引サービス契約ステータスの値に従い、適用中件数をカウントします。
			while (null != inMap)
			{
				// 取得したレコードより割引サービス契約ステータスを取り出します
				wribSvcKeiStat = inMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_STAT);
				// サービス終了年月日時分秒よりサービス終了年月日を取り出します
				svcEndYmd = inMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD).substring(1, 8);
				
				if("010".equals(wribSvcKeiStat) || "100".equals(wribSvcKeiStat))
				{
					// 割引サービス契約ステータスが「受付済み」「サービス提供中」の場合、適用中１件でカウントします
					aplyCnt = aplyCnt + 1;
				}
				
				if("300".equals(wribSvcKeiStat) || "910".equals(wribSvcKeiStat) || "920".equals(wribSvcKeiStat))
				{
					// サービス終了年月日に割引エイジング期間を加算した日付を算出します
					// 割引エイジング期間をint型に変換します
					int agingPrd = new Integer(wribAgingPrd);
					String svcEndYmd_agingPrd = JPCDateUtil.addMonth(svcEndYmd, agingPrd);
					// 割引エイジング期間加算後のサービス終了年月日と運用年月日をint型に変換し、比較します
					int unyoYmd_AFT = new Integer(unyoYmd);
					int svcEndYmd_AFT = new Integer(svcEndYmd_agingPrd);
					if(unyoYmd_AFT < svcEndYmd_AFT)
					{
						// 割引サービス契約ステータスが「適用済」「解約済」「キャンセル済」、かつサービス終了年月日を基準日として
						// 割引エイジング期間に設定されている月数が過ぎていれば、適用中１件でカウントします
						aplyCnt = aplyCnt + 1;
					}
				}
				// 次の1件を取得します
				inMap = stmt.selectNext();
			}
			// 上限適用回数をint型に変換します
			int upplAplyCnt_AFT = new Integer(upplAplyCnt);
			// 上限適用回数と適用中件数を比較します
			if(upplAplyCnt_AFT < aplyCnt)
			{
				return false;
			}
			else
			{
				return true;
			} 

		} 
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
	}

	/**
	 * <dd>メソッド名	：doUpplKeiCntChk
	 * <dd>メソッド説明	：割引サービスの上限契約数のチェックを行う。
	 * @param  cmnItem 業務共通電文
	 * @param  wribSvcCd 割引サービスコード
	 * @param  upplKeiCnt 上限契約数
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doUpplKeiCntChk(JBSbatCommonItem cmnItem, String wribSvcCd, String upplKeiCnt) throws Exception
	{
		// 割引サービス上限契約数
		int wribSvcKeiCnt = 0;
		
		JBSbatSQLAccess stmt = null;
		try 
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_WRIB_SVC_KEI.TABLE_NAME);
			
			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// 割引サービスコード
			dbList.setValue(wribSvcCd);
			
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_T_WRIB_SVC_KEI_KK_SELECT_007);
			
			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();
			
			// 取得したレコードより該当の割引サービスが適用中である件数を取り出します
			wribSvcKeiCnt = inMap.getBigDecimal("WRIB_CNT").intValue();
			
			// 上限契約数をint型に変換します
			int upplKeiCnt_AFT = new Integer(upplKeiCnt);
			// 上限契約数と適用中件数を比較します
			if(upplKeiCnt_AFT < wribSvcKeiCnt)
			{
				return false;
			}
			else
			{
				return true;
			} 

		} 
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
	}
	
	/**
	 * <dd>メソッド名	：doGrpSbtCdChk
	 * <dd>メソッド説明	：グループ種別コードのチェックを行う。
	 * @param  cmnItem 業務共通電文
	 * @param  sysid SYSID
	 * @param  grpSbtCd グループ種別コード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doGrpSbtCdChk(JBSbatCommonItem cmnItem, String sysid, String grpSbtCd) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatCK_T_CUST_GRP_SETTE.TABLE_NAME);

			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// ＳＹＳＩＤ
			dbList.setValue(sysid);
			// グループ種別
			dbList.setValue(grpSbtCd);
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.CK_T_CUST_GRP_SETTE_CK_SELECT_001);

			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			// 検索結果が0件の場合
			while(null == inMap)
			{
				return false;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
		return true;
	}
	
	/**
	 * <dd>メソッド名	：doEnqueteNoChk
	 * <dd>メソッド説明	：アンケート番号のチェックを行う。
	 * @param  cmnItem 業務共通電文
	 * @param  sysid SYSID
	 * @param  enqueteNo アンケート番号
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doEnqueteNoChk(JBSbatCommonItem cmnItem, String sysid, String enqueteNo) throws Exception
	{
		// 運用年月日
		String unyoYmd = cmnItem.getOpeDate();
		
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_M_ENQUETE.TABLE_NAME);

			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// アンケート番号（アンケート）
			dbList.setValue(enqueteNo);
			// 運用年月日
			dbList.setValue(unyoYmd);
			// ＳＹＳＩＤ
			dbList.setValue(sysid);
			// アンケート番号（アンケート回答）
			dbList.setValue(enqueteNo);
			
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_M_ENQUETE_KK_SELECT_001);

			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			// 検索結果が0件の場合
			while(null == inMap)
			{
				return false;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt)
			{
				stmt.close();
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：doIntrUmChk
	 * <dd>メソッド説明	：紹介コードのチェックを行う
	 * @param  cmnItem 業務共通電文
	 * @param  intrCd 紹介コード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static boolean doIntrUmChk(JBSbatCommonItem cmnItem, String intrCd) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_INTR.TABLE_NAME);

			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// 紹介者コード
			dbList.setValue(intrCd);

			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_T_INTR_KK_SELECT_002);

			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();
			boolean bRet = false;

			while(inMap != null)
			{
				// 紹介種別コード
				String intrSbtCd = "";
				if(inMap.getValue(JBSbatKK_T_INTR.INTR_SBT_CD) != null)
				{
					intrSbtCd = inMap.getValue(JBSbatKK_T_INTR.INTR_SBT_CD).toString();
				}
				// SYSID(紹介)
				String intrSysid = inMap.getValue(JBSbatKK_T_INTR.TABLE_NAME + "_" + JBSbatKK_T_INTR.SYSID).toString();
				// SYSID(サービス契約)
				String svcKeiSysid = inMap.getValue(JBSbatKK_T_SVC_KEI.TABLE_NAME + "_" + JBSbatKK_T_SVC_KEI.SYSID).toString();

				// 紹介種別コード=1(紹介者)の場合
				if(JKKBatConst.CD_SBT_INTR_SBT_CD_1.equals(intrSbtCd))
				{
					// SYSID(紹介)とSYSID(サービス契約)が異なる場合
					if(!intrSysid.equals(svcKeiSysid))
					{
						return false;
					}

				}
				// 紹介種別コード=2(被紹介者)の場合
				else if(JKKBatConst.CD_SBT_INTR_SBT_CD_2.equals(intrSbtCd))
				{
					// SYSID(紹介)とSYSID(サービス契約)が同じ場合
					if(intrSysid.equals(svcKeiSysid))
					{
						return false;
					}
				}
				else
				{
					return false;
				}

				// 次の1件を取得
				inMap = stmt.selectNext();
				bRet = true;
			}

			// 検索結果が0件の場合
			if(!bRet)
			{
				return false;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(stmt != null)
			{
				stmt.close();
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：doMskmFormCdChk
	 * <dd>メソッド説明	：申込形態コードのチェックを行う
	 * @param  cmnItem 業務共通電文
	 * @param  sysid SYSID
	 * @param  mskmFormCd 申込形態コード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static boolean doMskmFormCdChk(JBSbatCommonItem cmnItem, String sysid, String mskmFormCd) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_MSKM_DTL.TABLE_NAME);

			// 検索キーを設定
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// SYSID
			dbList.setValue(sysid);
			// 申込種別コード
			dbList.setValue(mskmFormCd);

			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_T_MSKM_DTL_KK_SELECT_002);

			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			// 検索結果が0件の場合
			if(inMap == null)
			{
				return false;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(stmt != null)
			{
				stmt.close();
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：doAgntCdChk
	 * <dd>メソッド説明	：代理店コードのチェックを行う
	 * @param  cmnItem 業務共通電文
	 * @param  agntCd 代理店コード
	 * @param  sysid SYSID
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static boolean doAgntCdChk(JBSbatCommonItem cmnItem, String agntCd, String sysid) throws Exception
	{
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成する
			stmt = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_SVC_KEI.TABLE_NAME);

			// 検索キーを設定する
			JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
			// 代理店コード(前方一致)
			dbList.setValue(agntCd + "%");
			// SYSID
			dbList.setValue(sysid);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());

			// DBよりレコードを取得する
			stmt.selectBySqlDefine(dbList, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_018);
			// 1件目のレコードを取得します
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			// 検索結果が0件の場合
			if(inMap == null)
			{
				return false;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(stmt != null)
			{
				stmt.close();
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：getTgSvckei
	 * <dd>メソッド説明	：対象サービス契約の取得を行う
	 * @param  cmnItem 業務共通電文
	 * @param  sysid SYSID
	 * @param  svcKeyNo サービス契約番号
	 * @param  wribAddJokenCd 割引登録条件コード
	 * @return ArrayList サービス契約のリスト
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static ArrayList<HashMap<?, ?>> getTgSvckei(JBSbatCommonItem cmnItem
														, String sysid
														, String svcKeyNo
														, String wribAddJokenCd) throws Exception
	{
		ArrayList<HashMap<?, ?>> infoMapList = null;
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// 割引登録条件コードが"01"(条件無し)の場合
		if(JKKBatConst.CD_SBT_WRIB_ADD_JOKEN_CD_01.equals(wribAddJokenCd))
		{
			// SYSID
			dbList.setValue(sysid);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// 対象サービス契約の取得
			infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_T_SVC_KEI.TABLE_NAME, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_022);
		}
		// 割引登録条件コードが"02"(同一お客様のみ)の場合
		else if(JKKBatConst.CD_SBT_WRIB_ADD_JOKEN_CD_02.equals(wribAddJokenCd))
		{
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// サービス契約番号
			dbList.setValue(svcKeyNo);
			// 対象サービス契約の取得
			infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_T_SVC_KEI.TABLE_NAME, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_023);
		}
		// 割引登録条件コードが"03"(同一請求先のみ)の場合
		else if(JKKBatConst.CD_SBT_WRIB_ADD_JOKEN_CD_03.equals(wribAddJokenCd))
		{
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// サービス契約番号
			dbList.setValue(svcKeyNo);
			// 対象サービス契約の取得
			infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_T_SVC_KEI.TABLE_NAME, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_024);
		}
		// 割引登録条件コードが"04"(同一回線のみ)の場合
		else if(JKKBatConst.CD_SBT_WRIB_ADD_JOKEN_CD_04.equals(wribAddJokenCd))
		{
			// SYSID
			dbList.setValue(sysid);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// サービス契約番号
			dbList.setValue(svcKeyNo);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// 対象サービス契約の取得
			infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_T_SVC_KEI.TABLE_NAME, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_025);
		}
		// 割引登録条件コードが"05"(同一お客様請求先)の場合
		else if(JKKBatConst.CD_SBT_WRIB_ADD_JOKEN_CD_05.equals(wribAddJokenCd))
		{
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// サービス契約番号
			dbList.setValue(svcKeyNo);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// サービス契約番号
			dbList.setValue(svcKeyNo);
			// バッチ運用日
			dbList.setValue(cmnItem.getOpeDate());
			// 対象サービス契約の取得
			infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_T_SVC_KEI.TABLE_NAME, JKKBatConst.KK_T_SVC_KEI_KK_SELECT_026);
		}
		return infoMapList;
	}

	/**
	 * <dd>メソッド名	：addSvcKeiKmk
	 * <dd>メソッド説明	：サービス契約リストへの項目付与を行う。
	 * @param  cmnItem 業務共通電文
	 * @param  svcKeiList サービス契約リスト
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<HashMap<?, ?>> addSvcKeiKmk(JBSbatCommonItem cmnItem, ArrayList<HashMap<?, ?>> svcKeiList) throws Exception
	{
		
		JBSbatSQLAccess stmt1 = null;
		JBSbatSQLAccess stmt2 = null;
		JBSbatSQLAccess stmt3 = null;
		JBSbatSQLAccess stmt4 = null;
		HashMap<?, ?> svc_kei_henshu_map = null;

		int count = 0;
		try 
		{
			while(null != svcKeiList)
			{
					
				svc_kei_henshu_map = new HashMap<String, ArrayList<JBSbatCommonDBInterface>>();
				// ディレイド処理依頼テーブルアクセスを生成
				stmt1 = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_OP_SVC_KEI.TABLE_NAME);
				
				// 検索キーを設定(オプションサービス契約)
				JBSbatCommonDBInterface dbList1 = new JBSbatCommonDBInterface();
				// 予約適用年月日
				dbList1.setValue(cmnItem.getOpeDate());
				// サービス契約番号
				dbList1.setValue(cmnItem.getOpeDate());
				
				// DBよりレコードを取得
				stmt1.selectBySqlDefine(dbList1, JKKBatConst.KK_T_OP_SVC_KEI_KK_SELECT_001);
				
				// 返却するインスタンスを生成
				ArrayList<JBSbatCommonDBInterface> opSvcKeiList = new ArrayList<JBSbatCommonDBInterface>();
				// 1件目のレコードを取得
				JBSbatCommonDBInterface inMap1 = stmt1.selectNext();
				
				// 取得したレコードの数だけ繰り返します
				while (null != inMap1)
				{
					// 取得した内容をListに設定します
					opSvcKeiList.add(inMap1);
					// 次の1件を取得します
					inMap1 = stmt1.selectNext();
				}
				
				// ディレイド処理依頼テーブルアクセスを生成
				stmt2 = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_SBOP_SVC_KEI.TABLE_NAME);
				
				// 検索キーを設定(サブオプションサービス契約)
				JBSbatCommonDBInterface dbList2 = new JBSbatCommonDBInterface();
				// 予約適用年月日
				dbList2.setValue(cmnItem.getOpeDate());
				// サービス契約番号
				dbList2.setValue(cmnItem.getOpeDate());
				
				// DBよりレコードを取得
				stmt2.selectBySqlDefine(dbList2, JKKBatConst.KK_T_SBOP_SVC_KEI_KK_SELECT_001);
				
				// 返却するインスタンスを生成
				ArrayList<JBSbatCommonDBInterface> sbopSvcKeiList = new ArrayList<JBSbatCommonDBInterface>();
				// 1件目のレコードを取得
				JBSbatCommonDBInterface inMap2 = stmt2.selectNext();
				
				// 取得したレコードの数だけ繰り返します
				while (null != inMap2)
				{
					// 取得した内容をListに設定します
					sbopSvcKeiList.add(inMap2);
					// 次の1件を取得します
					inMap2 = stmt2.selectNext();
				}
				
				// ディレイド処理依頼テーブルアクセスを生成
				stmt3 = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_KKTK_SVC_KEI.TABLE_NAME);
				
				// 検索キーを設定(機器提供サービス契約)
				JBSbatCommonDBInterface dbList3 = new JBSbatCommonDBInterface();
				// 予約適用年月日
				dbList3.setValue(cmnItem.getOpeDate());
				// サービス契約番号
				dbList3.setValue(cmnItem.getOpeDate());
				
				// DBよりレコードを取得
				stmt3.selectBySqlDefine(dbList3, JKKBatConst.KK_T_KKTK_SVC_KEI_KK_SELECT_001);
				
				// 返却するインスタンスを生成
				ArrayList<JBSbatCommonDBInterface> kktkSvcKeiList = new ArrayList<JBSbatCommonDBInterface>();
				// 1件目のレコードを取得
				JBSbatCommonDBInterface inMap3 = stmt3.selectNext();
				
				// 取得したレコードの数だけ繰り返します
				while (null != inMap3)
				{
					// 取得した内容をListに設定します
					kktkSvcKeiList.add(inMap3);
					// 次の1件を取得します
					inMap3 = stmt3.selectNext();
				}
				
				// ディレイド処理依頼テーブルアクセスを生成
				stmt4 = new JBSbatSQLAccess(cmnItem, JBSbatKK_T_KKTK_SVC_KEI.TABLE_NAME);
				
				// 検索キーを設定(機器提供サービス契約)
				JBSbatCommonDBInterface dbList4 = new JBSbatCommonDBInterface();
				// 予約適用年月日
				dbList4.setValue(cmnItem.getOpeDate());
				// サービス契約番号
				dbList4.setValue(cmnItem.getOpeDate());
				
				// DBよりレコードを取得
				stmt4.selectBySqlDefine(dbList4, JKKBatConst.KK_T_KKTK_SVC_KEI_KK_SELECT_001);
				
				// 返却するインスタンスを生成
				ArrayList<JBSbatCommonDBInterface> seiopSvcKeiList = new ArrayList<JBSbatCommonDBInterface>();
				// 1件目のレコードを取得
				JBSbatCommonDBInterface inMap4 = stmt4.selectNext();
				
				// 取得したレコードの数だけ繰り返します
				while (null != inMap4)
				{
					// 取得した内容をListに設定します
					seiopSvcKeiList.add(inMap4);
					// 次の1件を取得します
					inMap4 = stmt4.selectNext();
				}
				
				// ディレイド処理結果コード
//				svc_kei_henshu_map.put(OPSVCKEILIST, svcKeiList.get(count));			// サービス契約リスト
//				svc_kei_henshu_map.put(OPSVCKEILIST, opSvcKeiList);						// オプションサービス契約リスト
//				svc_kei_henshu_map.put(SBOPSVCKEILIST, sbopSvcKeiList);					// サブオプションサービス契約リスト
//				svc_kei_henshu_map.put(KKTKSVCKEILIST, kktkSvcKeiList);					// 機器提供サービス契約リスト
//				svc_kei_henshu_map.put(SEIOPSVCKEILIST, seiopSvcKeiList);				// 請求オプションサービス契約リスト
				
				count = count + 1;
			}

			return null; 

		} 
		catch(SQLException e) 
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(null != stmt1)
			{
				stmt1.close();
			}
			if(null != stmt2)
			{
				stmt2.close();
			}
			if(null != stmt3)
			{
				stmt3.close();
			}
			if(null != stmt4)
			{
				stmt4.close();
			}
		}
	}

	/**
	 * <dd>メソッド名	：getWribSvcTgSvc
	 * <dd>メソッド説明	：割引サービス対象サービスの取得を行う。
	 * @param  cmnItem 業務共通電文
	 * @param  wribSvcCd 割引サービスコード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<HashMap<?, ?>> getWribSvcTgSvc(JBSbatCommonItem cmnItem, String wribSvcCd) throws Exception
	{
		ArrayList<HashMap<?, ?>> infoMapList = null;
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		// 割引サービスコード
		dbList.setValue(wribSvcCd);
		
		// 対象サービス契約の取得
		infoMapList = getDbDataListMap(cmnItem, dbList, JBSbatKK_M_WRISVC_TG_SVC.TABLE_NAME, JKKBatConst.KK_M_WRISVC_TG_SVC_KK_SELECT_001);
		
		return infoMapList;
		
	}

	/**
	 * <dd>メソッド名	：doWribSvcAplyJokenChk
	 * <dd>メソッド説明	：割引サービスの適用条件のチェックを行う。
	 * @param  svcKeiList サービス契約リスト
	 * @param  wribSvcTrgtSvcList 割引サービス対象サービスリスト
	 * @return ArrayList サービス契約のリスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<HashMap<?, ?>> doWribSvcAplyJokenChk(ArrayList<HashMap<?, ?>> svcKeiList
																	, ArrayList<HashMap<?, ?>> wribSvcTrgtSvcList) throws Exception
	{
		// リストが存在しない場合
		if(svcKeiList == null || wribSvcTrgtSvcList == null)
		{
			return null;
		}

		ArrayList<HashMap<?, ?>> retSvcKeiList = new ArrayList<HashMap<?, ?>>();
		for(int i = 0; i < wribSvcTrgtSvcList.size(); i++)
		{
			boolean svcKeiFlg = false;
			HashMap<?, ?> wribSvcMap = wribSvcTrgtSvcList.get(i);

			// 対象サービス判別コード(条件無し)の場合
			if(JKKBatConst.CD_SBT_TRGT_SVC_HAMBET_CD_0.equals(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_SVC_HAMBET_CD)))
			{
				continue;
			}
			// 対象サービス判別コード(新規申込のみ)の場合
			else if(JKKBatConst.CD_SBT_TRGT_SVC_HAMBET_CD_1.equals(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_SVC_HAMBET_CD)))
			{
				// 受付済、照査済、締結済以外の場合
				if(!JKKBatConst.CD_SBT_SVC_KEI_STAT_010.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT))
					&& !JKKBatConst.CD_SBT_SVC_KEI_STAT_020.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT))
					&& !JKKBatConst.CD_SBT_SVC_KEI_STAT_030.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT)))
				{
					continue;
				}
			}
			// 対象サービス判別コード(既存契約のみ)の場合
			else if(JKKBatConst.CD_SBT_TRGT_SVC_HAMBET_CD_2.equals(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_SVC_HAMBET_CD)))
			{
				// サービス提供中、休止・中断中、停止中以外の場合
				if(!JKKBatConst.CD_SBT_SVC_KEI_STAT_100.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT))
					&& !JKKBatConst.CD_SBT_SVC_KEI_STAT_210.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT))
					&& !JKKBatConst.CD_SBT_SVC_KEI_STAT_220.equals(wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT)))
				{
					continue;
				}
			}

			// サービス契約リストと割引サービス対象サービスリストの比較
			for(int j = 0; j < svcKeiList.size(); j++)
			{
				HashMap<?, ?> svcKeiMap = svcKeiList.get(j);
				// サービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SVC_KEI.SVC_CD), wribSvcMap.get(JBSbatKK_T_SVC_KEI.SVC_CD)))
				{
					continue;
				}
				// 料金グループコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SVC_KEI.PRC_GRP_CD), wribSvcMap.get(JBSbatKK_T_SVC_KEI.PRC_GRP_CD)))
				{
					continue;
				}
				// 料金コースコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SVC_KEI.PCRS_CD), wribSvcMap.get(JBSbatKK_T_SVC_KEI.PCRS_CD)))
				{
					continue;
				}
				// 料金プランコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SVC_KEI.PPLAN_CD), wribSvcMap.get(JBSbatKK_T_SVC_KEI.PPLAN_CD)))
				{
					continue;
				}
				// オプションサービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD), wribSvcMap.get(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD)))
				{
					continue;
				}
				// サブオプションサービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_CD), wribSvcMap.get(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_CD)))
				{
					continue;
				}
				// 機器提供サービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_CD), wribSvcMap.get(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_CD)))
				{
					continue;
				}
				// 機器提供種別コードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SBT_CD), wribSvcMap.get(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SBT_CD)))
				{
					continue;
				}
				// 請求オプションサービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_T_SEIOPSVC_KEI.SEIOPSVC_CD), wribSvcMap.get(JBSbatKK_T_SEIOPSVC_KEI.SEIOPSVC_CD)))
				{
					continue;
				}
				// サービス契約年数の比較
				if(!chkCompString(svcKeiMap.get("SVC_KEI_YEAR"), wribSvcMap.get("SVC_KEI_YEAR")))
				{
					continue;
				}
				// Listに格納
				retSvcKeiList.add(svcKeiMap);
				svcKeiFlg = true;
				break;
			}
			// 一件も一致するデータがない場合
			if(!svcKeiFlg)
			{
				retSvcKeiList = null;
				break;
			}
		}
		return retSvcKeiList;
	}

	/**
	 * <dd>メソッド名	：doTrgtSvcKeiUpplCntChk
	 * <dd>メソッド説明	：対象となるサービス契約の上限数のチェックを行う。
	 * @param  svcKeiList サービス契約リスト
	 * @param  wribSvcTrgtSvcList 割引サービス対象サービスリスト
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doTrgtSvcKeiUpplCntChk(ArrayList<HashMap<?, ?>> svcKeiList, ArrayList<HashMap<?, ?>> wribSvcTrgtSvcList) throws Exception
	{
		// リストが存在しない場合
		if(svcKeiList == null || wribSvcTrgtSvcList == null)
		{
			return false;
		}

		// サービスコード情報の取得
		ArrayList<HashMap<?, ?>> svcCntList = getSvcCdInfoList(svcKeiList);

		// サービスコード単位でのループの開始
		sortArrayList(wribSvcTrgtSvcList);
		for(int i = 0; i < svcCntList.size(); i++)
		{
			HashMap<?, ?> svcCntMap = svcCntList.get(i);
			for(int j = 0; j < wribSvcTrgtSvcList.size(); j++)
			{
				HashMap<?, ?> wribSvcMap = wribSvcTrgtSvcList.get(j);
				// サービスコードの比較
				if(!chkCompString(svcCntMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD)))
				{
					continue;
				}

				// カウント件数の取得
				int svcCnt = 0;
				if(svcCntMap.get("SVC_CD_COUNT") != null)
				{
					svcCnt = Integer.parseInt(svcCntMap.get("SVC_CD_COUNT").toString());
				}

				// 対象契約サービス数の取得
				int keiSvcCnt = 0;
				if(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_KEI_SVC_CNT) != null)
				{
					keiSvcCnt = Integer.parseInt(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_KEI_SVC_CNT).toString());
				}

				// 対象契約サービス上限の取得
				int keiSvcUppl = 0;
				if(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_KEI_SVC_UPPL) != null)
				{
					keiSvcUppl = Integer.parseInt(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.TRGT_KEI_SVC_UPPL).toString());
				}

				// カウント件数＜対象契約サービス数の場合
				if(svcCnt < keiSvcCnt)
				{
					return false;
				}
				// カウント件数＝対象契約サービス数の場合
				else if(svcCnt == keiSvcCnt)
				{
					// カウント件数＞対象契約サービス上限の場合
					if(svcCnt > keiSvcUppl)
					{
						return false;
					}
				}
				// カウント件数＞対象契約サービス数の場合
				else if(svcCnt > keiSvcCnt)
				{
					// 「カウント件数＞対象契約サービス上限」且つ「上限超適用可否＝否」の場合
					if(svcCnt > keiSvcUppl && JKKBatConst.CD_SBT_KH_CD_0.equals(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.UPPL_AUTO_APLY_KH)))
					{
						return false;
					}
				}
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：doTrgtSvcKeiKoseiChk
	 * <dd>メソッド説明	：対象となるサービス契約の構成チェックを行う。
	 * @param  svcKeiList サービス契約リスト
	 * @param  wribSvcTrgtSvcList 割引サービス対象サービスリスト
	 * @param  aplyJokenCd 適用条件コード
	 * @return true：チェックOK false：チェックNG
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean doTrgtSvcKeiKoseiChk(ArrayList<HashMap<?, ?>> svcKeiList
												, ArrayList<HashMap<?, ?>> wribSvcTrgtSvcList
												, String aplyJokenCd) throws Exception
	{
		// リストが存在しない場合
		if(svcKeiList == null || wribSvcTrgtSvcList == null)
		{
			return false;
		}

		// サービスコード情報の取得
		ArrayList<HashMap<?, ?>> svcCntList = getSvcCdInfoList(svcKeiList);
		sortArrayList(wribSvcTrgtSvcList);

		// 適用条件コードが全て一致の場合
		if(JKKBatConst.CD_SBT_APLY_JOKEN_CD_1.equals(aplyJokenCd))
		{
			// データの件数が異なる場合
			if(svcCntList.size() != wribSvcTrgtSvcList.size())
			{
				return false;
			}

			for(int i = 0; i < wribSvcTrgtSvcList.size(); i++)
			{
				HashMap<?, ?> svcCntMap = svcCntList.get(i);
				HashMap<?, ?> wribSvcMap = wribSvcTrgtSvcList.get(i);
				// サービスコードの比較
				if(!chkCompString(svcCntMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD)))
				{
					return false;
				}
			}
		}
		// 適用条件コードが一部でも可の場合
		else if(JKKBatConst.CD_SBT_APLY_JOKEN_CD_2.equals(aplyJokenCd))
		{
			for(int i = 0; i < wribSvcTrgtSvcList.size(); i++)
			{
				HashMap<?, ?> wribSvcMap = wribSvcTrgtSvcList.get(i);
				for(int j = 0; j < svcCntList.size(); j++)
				{
					HashMap<?, ?> svcCntMap = svcCntList.get(j);
					// サービスコードの比較
					if(chkCompString(svcCntMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD)))
					{
						return true;
					}
				}
			}
		}
		// 適用条件コードがグループで一致の場合
		else if(JKKBatConst.CD_SBT_APLY_JOKEN_CD_3.equals(aplyJokenCd))
		{
			boolean bGroup = false;
			for(int i = 0; i < wribSvcTrgtSvcList.size(); i++)
			{
				HashMap<?, ?> wribSvcMap = wribSvcTrgtSvcList.get(i);
				for(int j = 0; j < svcCntList.size(); j++)
				{
					HashMap<?, ?> svcCntMap = svcCntList.get(j);
					// サービスコードの比較
					if(chkCompString(svcCntMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD)))
					{
						bGroup = true;
					}
				}

				// 最終レコードの場合
				if(i == (wribSvcTrgtSvcList.size() - 1))
				{
					if(!bGroup)
					{
						return false;
					}
				}
				else
				{
					HashMap<?, ?> nextWribSvcMap = wribSvcTrgtSvcList.get(i + 1);
					// 適用条件グループがNULLの場合
					if(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP) == null
						|| nextWribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP) == null)
					{
						throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
					}
					// 適用条件グループの比較
					if(chkCompString(wribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP), nextWribSvcMap.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP)))
					{
						continue;
					}
					if(!bGroup)
					{
						return false;
					}
					bGroup = false;
				}
			}
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：doDojiAplyKhChk
	 * <dd>メソッド説明	：対象となる割引サービスの同時適用可否のチェックを行う。
	 * @param  trgtWribSvcList 対象割引サービスリスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static void doDojiAplyKhChk(ArrayList trgtWribSvcList) throws Exception
	{
	}

	/**
	 * <dd>メソッド名	：getDbDataListMap
	 * <dd>メソッド説明	：DBよりデータの取得を行う
	 * @param  cmnItem 業務共通電文
	 * @param  dbList 検索キー
	 * @param  tableName テーブル名
	 * @param  sqlKey SQL定義キー
	 * @return ArrayList DBより取得したデータのリスト(HashMap)
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static ArrayList<HashMap<?, ?>> getDbDataListMap(JBSbatCommonItem cmnItem
																, JBSbatCommonDBInterface dbList
																, String tableName
																, String sqlKey) throws Exception
	{
		ArrayList<HashMap<?, ?>> infoMapList = null;
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, tableName);
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, sqlKey);
			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			infoMapList = new ArrayList<HashMap<?, ?>>();
			while(inMap != null)
			{
				infoMapList.add(inMap.getMap());
				// 次の1件を取得
				inMap = stmt.selectNext();
			}

			// 検索結果が0件の場合NULLを返し処理を終了する。
			if(infoMapList.size() <= 0)
			{
				return null;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(stmt != null)
			{
				stmt.close();
			}
		}
		return infoMapList;
	}

	/**
	 * <dd>メソッド名	：getDbDataListDbif
	 * <dd>メソッド説明	：DBよりデータの取得を行う
	 * @param  cmnItem 業務共通電文
	 * @param  dbList 検索キー
	 * @param  tableName テーブル名
	 * @param  sqlKey SQL定義キー
	 * @return ArrayList DBより取得したデータのリスト(JBSbatCommonDBInterface)
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public static ArrayList<JBSbatCommonDBInterface> getDbDataListDbif(JBSbatCommonItem cmnItem
																		, JBSbatCommonDBInterface dbList
																		, String tableName
																		, String sqlKey) throws Exception
	{
		ArrayList<JBSbatCommonDBInterface> infoMapList = null;
		JBSbatSQLAccess stmt = null;
		try
		{
			// ディレイド処理依頼テーブルアクセスを生成
			stmt = new JBSbatSQLAccess(cmnItem, tableName);
			// DBよりレコードを取得
			stmt.selectBySqlDefine(dbList, sqlKey);
			// 1件目のレコードを取得
			JBSbatCommonDBInterface inMap = stmt.selectNext();

			infoMapList = new ArrayList<JBSbatCommonDBInterface>();
			while(inMap != null)
			{
				infoMapList.add(inMap);
				// 次の1件を取得
				inMap = stmt.selectNext();
			}

			// 検索結果が0件の場合NULLを返し処理を終了する。
			if(infoMapList.size() <= 0)
			{
				return null;
			}
		}
		catch(SQLException e)
		{
			throw new JCCbatFrameworkException("ディレイド処理依頼取得処理で例外が発生しました。");
		}
		finally
		{
			if(stmt != null)
			{
				stmt.close();
			}
		}
		return infoMapList;
	}

	/**
	 * <dd>メソッド名	：chkCompString
	 * <dd>メソッド説明	：NULLと空文字を除外した値の比較を行う。
	 * @param  objComp1 比較対象文字列
	 * @param  objComp2 比較対象文字列
	 * @return true：値の一致 false：値の不一致
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static boolean chkCompString(Object objComp1, Object objComp2) throws Exception
	{
		if(objComp1 == null || objComp2 == null)
		{
			return false;
		}
		if("".equals(objComp1) || "".equals(objComp2))
		{
			return false;
		}
		if(!objComp1.equals(objComp2))
		{
			return false;
		}
		return true;
	}

	/**
	 * <dd>メソッド名	：sortArrayList
	 * <dd>メソッド説明	：サービスコード、適用条件グループでソートを行う。
	 * @param  dataList データリスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static void sortArrayList(ArrayList<HashMap<?, ?>> dataList) throws Exception
	{
		Collections.sort(dataList, new Comparator<HashMap<?, ?>>()
		{

			/**
			 * <dd>メソッド名	：compare
			 * <dd>メソッド説明	：ハッシュマップの比較を行う。
			 * @param  m1 ハッシュマップ
			 * @param  m2 ハッシュマップ
			 * @return 比較結果
			 */
			public int compare(HashMap<?, ?> m1, HashMap<?, ?> m2)
			{
				String str1 = "";
				if(m1.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD) != null)
				{
					str1 = m1.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD).toString();
				}
				String str2 = "";
				if(m2.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD) != null)
				{
					str2 = m2.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD).toString();
				}
				int result = str1.compareTo(str2);
				if(result == 0)
				{
					String str3 = "";
					if(m1.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP) != null)
					{
						str3 = m1.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP).toString();
					}
					String str4 = "";
					if(m2.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP) != null)
					{
						str4 = m2.get(JBSbatKK_M_WRISVC_TG_SVC.APLY_JOKEN_GRP).toString();
					}
					return str3.compareTo(str4);
				}
				return result;
			}
		});
	}

	/**
	 * <dd>メソッド名	：getSvcCdInfoList
	 * <dd>メソッド説明	：サービスコード情報のリストを作成する。
	 * @param  dataList データリスト
	 * @return ArrayList サービス情報リスト
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	public static ArrayList<HashMap<?, ?>> getSvcCdInfoList(ArrayList<HashMap<?, ?>> dataList) throws Exception
	{
		Object refSvcCd = null;
		HashMap<String, Object> svcCntMap = null;
		ArrayList<HashMap<?, ?>> svcCntList = new ArrayList<HashMap<?, ?>>();
		sortArrayList(dataList);
		int cnt = 1;

		// サービスコード単位の件数を取得
		for(int i = 0; i < dataList.size(); i++)
		{
			HashMap<?, ?> svcKeiMap = dataList.get(i);
			// サービスコードがない場合
			if(svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD) == null || "".equals(svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD)))
			{
				continue;
			}

			// 最終レコードの場合
			if(i == (dataList.size() - 1))
			{
				// サービスコードの比較
				if(!chkCompString(svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), refSvcCd))
				{
					svcCntMap = new HashMap<String, Object>();
					svcCntMap.put(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD, refSvcCd);
					svcCntMap.put("SVC_CD_COUNT", cnt);
					svcCntList.add(svcCntMap);
					cnt = 1;
				}
				else
				{
					cnt++;
				}
				svcCntMap = new HashMap<String, Object>();
				svcCntMap.put(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD, svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD));
				svcCntMap.put("SVC_CD_COUNT", cnt);
				svcCntList.add(svcCntMap);
				break;
			}

			// サービスコードの比較
			if(!chkCompString(svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD), refSvcCd))
			{
				// 初回レコードの場合
				if(i == 0)
				{
					refSvcCd = svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD);
					continue;
				}
				svcCntMap = new HashMap<String, Object>();
				svcCntMap.put(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD, refSvcCd);
				svcCntMap.put("SVC_CD_COUNT", cnt);
				svcCntList.add(svcCntMap);
				cnt = 1;
			}
			else
			{
				cnt++;
			}
			refSvcCd = svcKeiMap.get(JBSbatKK_M_WRISVC_TG_SVC.SVC_CD);
		}
		return svcCntList;
	}
}