/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：WribAplyKnsho
*	ソースファイル名	：WribAplyKnsho.java
*	作成者				：富士通　
*	作成日				：2012年09月05日
*＜機能概要＞
*　割引適用検証部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2012/09/05   富士通		新規作成
*********************************************************************/
package eo.business.service;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;

import com.fujitsu.futurity.model.common.check.CharacterCheck;
import com.fujitsu.futurity.rule.common.JRuleXMLHandler;
import com.fujitsu.futurity.rule.xml.compare.JRuleXMLPattern;

import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCCBatCommon;
import eo.business.common.JKKBatConst;
import eo.business.util.file.JBSbatKVIFM002;
import eo.business.util.file.JBSbatKVIFM003;
import eo.business.util.table.JBSbatDK_T_HAISO;
import eo.business.util.table.JBSbatKK_M_WRIB_SVC;
import eo.business.util.table.JBSbatKK_M_WRIB_SVC_DTL;
import eo.business.util.table.JBSbatKK_T_KKTK_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_MSKM;
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_PRG;
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.business.util.table.JBSbatKK_T_WRISVC_KEI_UCWK;
import eo.business.util.table.JBSbatKK_T_WRISVC_TG_KEI;
import eo.business.util.table.JBSbatZM_M_CD_NM_KANRI;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatOutputFileUtil;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatAplConst;
import eo.framework.util.JBSbatDateUtil;
import eo.framework.util.JBSbatStringUtil;
import eo.framework.util.JCCBatchEsbInterface;

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

	/** テーブル(進捗)*/
	private static final String D_TBL_NAME_KK_T_PRG = "KK_T_PRG";

	/** テーブル(サービス契約)*/
	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_WRISVC_TG_KEI = "KK_T_WRISVC_TG_KEI";

	/** テーブル(割引サービス詳細)*/
	private static final String D_TBL_NAME_KK_M_WRIB_SVC_DTL = "KK_M_WRIB_SVC_DTL";

	/** テーブル(割引サービス契約内訳)*/
	private static final String D_TBL_NAME_KK_T_WRISVC_KEI_UCWK = "KK_T_WRISVC_KEI_UCWK";

	/** テーブル(配送対象物品)*/
	private static final String D_TBL_NAME_DK_T_HAISO_TG_BPIN = "DK_T_HAISO_TG_BPIN";

	/** テーブル(配送)*/
	private static final String D_TBL_NAME_DK_T_HAISO = "DK_T_HAISO";

	/** テーブル(申込明細)*/
	private static final String D_TBL_NAME_KK_T_MSKM_DTL = "KK_T_MSKM_DTL";

	/** テーブル(コード名称管理)*/
	private static final String D_TBL_NAME_ZM_M_CD_NM_KANRI = "ZM_M_CD_NM_KANRI";

	/** テーブル(申込)*/
	private static final String D_TBL_NAME_KK_T_MSKM = "KK_T_MSKM";

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

	/** SQL定義キー(KK_SELECT_034)*/
	private static final String KK_T_WRIB_SVC_KEI_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_016)*/
	private static final String KK_T_PRG_KV_SELECT_003 = "KV_SELECT_003";

	/** SQL定義キー(KK_SELECT_024→KV_SELECT_002)*/
	private static final String KK_T_PRG_KV_SELECT_002 = "KV_SELECT_002";

	/** SQL定義キー(KK_SELECT_002)*/
	private static final String KK_T_WRISVC_TG_KEI_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_024→KV_SELECT_005)*/
	private static final String KK_T_SVC_KEI_KV_SELECT_005 = "KV_SELECT_005";

	/** SQL定義キー(KK_SELECT_079)*/
	private static final String KK_T_SVC_KEI_UCWK_KV_SELECT_002 = "KV_SELECT_002";

	/** SQL定義キー(KK_SELECT_090)*/
	private static final String KK_T_KKTK_SVC_KEI_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_071)*/
	private static final String KK_T_OP_SVC_KEI_KV_SELECT_003 = "KV_SELECT_003";

	/** SQL定義キー(KK_SELECT_005)*/
	private static final String KK_T_SBOP_SVC_KEI_KV_SELECT_003 = "KV_SELECT_003";

	/** SQL定義キー(KK_SELECT_013)*/
	private static final String KK_T_SEIOPSVC_KEI_KV_SELECT_001 = "KV_SELECT_001";

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

	/** SQL定義キー(KK_SELECT_012)*/
	private static final String KK_T_WRISVC_KEI_UCWK_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_004)*/
	private static final String KK_M_WRIB_SVC_KV_SELECT_002 = "KV_SELECT_002";

	/** SQL定義キー(KK_SELECT_002)*/
	private static final String KK_M_WRIB_SVC_DTL_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_003)*/
	private static final String DK_T_HAISO_TG_BPIN_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_006)*/
	private static final String DK_T_HAISO_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_005)*/
	private static final String ZM_M_CD_NM_KANRI_KV_SELECT_001 = "KV_SELECT_001";

	/** SQL定義キー(KK_SELECT_002)*/
	private static final String KK_T_MSKM_KV_SELECT_002 = "KV_SELECT_002";

	/** テーブルアクセスクラス(割引サービス)*/
	private JBSbatSQLAccess db_KK_M_WRIB_SVC = null;

	/** テーブルアクセスクラス(進捗)*/
	private JBSbatSQLAccess db_KK_T_PRG = 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_WRISVC_TG_KEI = null;

	/** テーブルアクセスクラス(割引サービス詳細)*/
	private JBSbatSQLAccess db_KK_M_WRIB_SVC_DTL = null;

	/** テーブルアクセスクラス(割引サービス契約内訳)*/
	private JBSbatSQLAccess db_KK_T_WRISVC_KEI_UCWK = null;

	/** テーブルアクセスクラス(配送対象物品)*/
	private JBSbatSQLAccess db_DK_T_HAISO_TG_BPIN = null;

	/** テーブルアクセスクラス(配送)*/
	private JBSbatSQLAccess db_DK_T_HAISO = null;

	/** テーブルアクセスクラス(申込明細)*/
	private JBSbatSQLAccess db_KK_T_MSKM_DTL = null;

	/** テーブルアクセスクラス(コード名称管理)*/
	private JBSbatSQLAccess db_ZM_M_CD_NM_KANRI = null;

	/** テーブルアクセスクラス(申込)*/
	private JBSbatSQLAccess db_KK_T_MSKM = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/** FREE項目から取得した開始日 */
	private String prmStartDay = null;
	/** FREE項目から取得した終了日 */
	private String prmEndDay = null;

	/** 進捗 検索結果 */
	private ArrayList<JBSbatCommonDBInterface> prgrsMapList = null;
	/** 進捗 検索結果(登録完了データ) */
	private ArrayList<JBSbatCommonDBInterface> prgrsListTrk = null;

	/** 割引サービス契約内訳 検索結果リスト */
	private ArrayList<JBSbatCommonDBInterface> wrbkSvcKUwList = null;
	/** サービス契約内訳 検索結果リスト */
	private ArrayList<JBSbatCommonDBInterface> svcKUwList = null;
	/** サービス契約 検索結果リスト */
	private ArrayList<JBSbatCommonDBInterface> svcKeiList = null;

	/** 進捗 データ */
	private JBSbatCommonDBInterface prgrsMap = null;
	/** 割引サービス契約 データ */
	private JBSbatCommonDBInterface wrbkSvcKMap = null;
	/** 割引サービス契約(2回目) データ */
//	private JBSbatCommonDBInterface wrbkSvcKMap35 = null;
	/** 割引サービス契約内訳 データ */
	private JBSbatCommonDBInterface wrbkSvcKUWMap = null;
	/** 割引サービス データ */
	private JBSbatCommonDBInterface wrbkSvcM = null;

	/** サービス契約 データ */
	private JBSbatCommonDBInterface svcKeiMap = null;
	/** サービス契約内訳 データ */
	private JBSbatCommonDBInterface svcKUWMap = null;

	/** 機器提供サービス契約 データ */
	private JBSbatCommonDBInterface kktkSvcKeiMap = null;
	/** オプションサービス契約 データ */
	private JBSbatCommonDBInterface optSvcKMap = null;
	/** サブオプションサービス契約 データ */
	private JBSbatCommonDBInterface sbOptSvcKMap = null;
	/** 請求オプションサービス契約 データ */
	private JBSbatCommonDBInterface skyOptSvcKMap = null;
	/** 割引サービス対象 データ */
	private JBSbatCommonDBInterface wrbkSvcTgMap = null;
	/** 割引サービス詳細 データ */
	private JBSbatCommonDBInterface wrbkSvcDtlM = null;
	/** 進捗 検索結果(登録完了データ) */
	private JBSbatCommonDBInterface prgrsTrk = null;

	/** 割引サービス契約 サービス課金開始年月日(最速) */
//	private String wbSvcKSvcSt ="";
//	/** 割引サービス契約 サービス課金終了年月日(最遅) */
//	private String wbSvcKSvcEnd ="";
	/** 出力ファイル用(件数) */
	private JBSbatOutputItem outputBean = new JBSbatOutputItem();
	/** 出力ファイル用(エラー) */
	private JBSbatOutputItem outputBeanErr = new JBSbatOutputItem();
	/** キャンセル・解約フラグ */
	private boolean cnclDslFlg = false;
	/** 個別設定日付設定フラグ */
	private boolean kobetlFlg = false;
	/** エラー項目名 */
	private ArrayList<String> errKomk = new ArrayList<String>();
	/** 自動適用チェック実施(F050以外) */
	private boolean autoJudge = false;
	/** 自動適用チェック結果 */
	private boolean autoCheckRslt = false;
	/** エラーメッセージ */
	private String errStr = "";
	/** 自動適用CCリターンCD */
	private String returnCode  = "";
	
	/** エラーメッセージ1 */
	private static final String ERR_MSG_1 = 
		"割引適用有りにも関わらず、割引サービス契約明細が存在しませんでした。";
	/** エラーメッセージ2 */
	private static final String ERR_MSG_2 = "自動適用無しにも関わらず、割引サービス契約明細が存在します。";
	/** エラーメッセージ3 */
	private static final String ERR_MSG_3 = "異動区分:キャンセルで、キャンセル年月日が設定されていません。";
	/** エラーメッセージ4 */
	private static final String ERR_MSG_4 = "異動区分:解約で、サービス解約年月日が設定されていません。";
	/** エラーメッセージ5 */
	private static final String ERR_MSG_5 = "異動区分:解約で、サービス終了年月日が設定されていません。";
	/** エラーメッセージ6 */
	private static final String ERR_MSG_6 = "異動区分:解約で、サービス課金終了年月日が設定されていません。";

	/** エラーメッセージ7 */
	private static final String ERR_MSG_7 = "サービス課金開始年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ8 */
	private static final String ERR_MSG_8 = "サービス課金終了年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ9 */
	private static final String ERR_MSG_9 = "サービス開始年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ10 */
	private static final String ERR_MSG_10 = "サービス終了年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ11 */
	private static final String ERR_MSG_11 = "プラン開始年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ12 */
	private static final String ERR_MSG_12 = "プラン終了年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ13 */
	private static final String ERR_MSG_13 = "プラン課金開始年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ14 */
	private static final String ERR_MSG_14 = "プラン課金終了年月日がサービス契約と割引サービス契約で異なります。";
	/** エラーメッセージ15 */
	private static final String ERR_MSG_15 = "割引サービス契約ステータスが｢サービス提供中｣ではありません。";
	/** エラーメッセージ17 */
	private static final String ERR_MSG_17 = "サービス課金開始年月日とサービス課金終了年月日が異なります。";
	/** KEY (割引サービス自動適用ＣＣ) */
	private static final String FIXED_KEY = "WrisvcAutoAplyCC";
	/** 割引サービス自動適用マップ作成 */
	private static final String CC_WRI_SVC_AUTO_APLY_MAP = "JKKWrisvcAutoAplyCCMap";

	/** キャンペーン開始コードセット */
	private HashSet<String> campaignStaCdWribSet = null;

	
	enum CampaignStaCdWribEnum{CD51,CD52,CD53,CD54,CD55,CD56,CD57}

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

		// フリー項目を分割して日付を取得する。
		String[] freeItemArray = commonItem.getFreeItem().split("@");
		prmStartDay = freeItemArray[0];
		prmEndDay = freeItemArray[1];

		outputBean.addOutMapList(setRcvCntInfoInit());
		outputBeanErr.addOutMapList_2(setRcvErrInit());

		// DBアクセスクラスを生成します
		db_KK_M_WRIB_SVC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_M_WRIB_SVC);
		db_KK_T_PRG = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_PRG);
		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_WRISVC_TG_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_WRISVC_TG_KEI);
		db_KK_M_WRIB_SVC_DTL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_M_WRIB_SVC_DTL);
		db_KK_T_WRISVC_KEI_UCWK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_WRISVC_KEI_UCWK);
		db_DK_T_HAISO_TG_BPIN = new JBSbatSQLAccess(commonItem, D_TBL_NAME_DK_T_HAISO_TG_BPIN);
		db_DK_T_HAISO = new JBSbatSQLAccess(commonItem, D_TBL_NAME_DK_T_HAISO);
		db_KK_T_MSKM_DTL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_MSKM_DTL);
		db_ZM_M_CD_NM_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_CD_NM_KANRI);
		db_KK_T_MSKM = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_MSKM);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/

		// キャンペーン開始コードセット設定
		campaignStaCdWribSet = new HashSet<String>();
		for(CampaignStaCdWribEnum cd:CampaignStaCdWribEnum.values()){
			campaignStaCdWribSet.add(cd.name());
		}

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

	/**
	 * 主処理
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		autoJudge = false;
		autoCheckRslt = false;
		errKomk.clear();
		if(!checkParm()) return null;
		ArrayList<JBSbatCommonDBInterface> wrbkSvcMapList = getWrbkSvc();
		if(null == wrbkSvcMapList) return null;	//ない場合、終了
		//対象の割引サービスコードが明細上に適用されていることを確認
		for(JBSbatCommonDBInterface wrbkSvcMap : wrbkSvcMapList)
		{
			//適用件数　要確認 キャンセル・開始が両方空白の場合も取得
			int cnt = getWrbkSvcKeiCnt(wrbkSvcMap);
			if(0 < cnt)
			{
				wrbkSvcMap.setValue("cnt", cnt);
				//割引適用数ファイル出力
				outputBean.addOutMapList(setRcvCntInfo(wrbkSvcMap));
			}
		}

		//割引適用数出力 (件数ファイル)
		if(1 < outputBean.getOutMapList().size())
		{
			setOutPutFile("KVIFM002.def", outputBean.getOutMapList());
		}

		//(5)指定期間を持つ明細が存在しないか確認
		//進捗からサービス契約番号を取得
		prgrsMapList = getPrgrs();

		//指定ステータス以外は以下チェックしない 要確認
		ArrayList<String> checkStatList = new ArrayList<String>();
		checkStatList.add("1304");
		checkStatList.add("2204");
		checkStatList.add("1201");
		checkStatList.add("B302");

		JBSbatCommonDBInterface latestPrg = null;	//最新進捗保持
		String svckNo = null;
		int i = 0;
		outPrg:for(JBSbatCommonDBInterface prgrs : prgrsMapList)
		{
			cnclDslFlg = false;
			kobetlFlg = false;
			returnCode = "";
			prgrsMap = prgrs;//進捗セット

			//進捗のサービス契約番号
			String svcKeiNoPrg = prgrs.getString(JBSbatKK_T_PRG.SVC_KEI_NO);

			//ログ
			commonItem.getLogPrint().printDebugLog("-- 進捗番号:"
					+ prgrsMap.getString(prgrsMap.getString(JBSbatKK_T_PRG.PRG_NO)) +
					" (進捗)サービス契約番号:"+ svcKeiNoPrg);

			//異なる場合、セット
			if(!svcKeiNoPrg.equals(svckNo))
			{
				i = 0;
				svckNo = svcKeiNoPrg;
			}

			//異動区分・進捗ステータス確認
			if("F050".equals(prgrsMap.getString(JBSbatKK_T_PRG.PRG_STAT)) &&
					"00049".equals(prgrsMap.getString(JBSbatKK_T_PRG.IDO_DIV)))
			{
				continue outPrg;
			}
			//同一サービス契約番号は、2回目以降読み飛ばす
			if(0 == i)
			{
				//サービス契約関連データ取得
				if(!getSvcTbls(svcKeiNoPrg)) continue outPrg;
				//進捗から最新取得
				latestPrg = getPrgrsLatest(svcKeiNoPrg);
				if(null == latestPrg) continue outPrg;	//あり得ないけど
				i++;
			}

			//異動区分・進捗ステータス確認
			String prgStat = prgrsMap.getString(JBSbatKK_T_PRG.PRG_STAT);
			if(!"F050".equals(prgStat) || !checkStatList.contains(prgStat))
			{
//				autoJudge = true;
				//自動適用チェック部品 //結局割引サービス契約みてる？
//				autoCheckRslt = autoCcCheck(svcKeiNoPrg);
				//異常終了の場合、次進捗へ
//				if(!JCCBatchEsbInterface.RETURN_CODE_SUCCESS.equals(returnCode))
//				{
//					commonItem.getLogPrint().printDebugLog(
//							"自動適用CC_リターンコード:" + returnCode);
//					continue outPrg;
//				}
//				if(autoCheckRslt) commonItem.getLogPrint().printDebugLog("自動適用あり");
			}else
			{
				autoJudge = false;
				commonItem.getLogPrint().printDebugLog(svcKeiNoPrg + " " +
						prgStat + ":自動適用チェック不要");
			}
			//要確認(自動適用ありなら,指定ステータス(解約・キャンセル)以外は最新のみチェック)
			if(autoCheckRslt && !checkStatList.contains(prgStat))
//			if(!checkStatList.contains(prgrsMap.getString(JBSbatKK_T_PRG.PRG_STAT)))
			{
				if(!cnvNullToEmp(latestPrg.getString(JBSbatKK_T_PRG.IDO_DTM)).equals(
						cnvNullToEmp(prgrsMap.getString(JBSbatKK_T_PRG.IDO_DTM))))
				{
					commonItem.getLogPrint().printDebugLog("最新明細以外 " + 
							prgrsMap.getString(JBSbatKK_T_PRG.IDO_DTM));
					continue outPrg;
				}
			}
			//明細チェックは自動適用に関わらず実施
			//割引サービス対象契約検索
			wrbkSvcTgMap = getWrbkSvcTgKei(svcKeiNoPrg);
			//自動適用アリなのに明細なければ、次の進捗データへ
			if(!checkContinue()) continue outPrg;

			//割引サービス契約検索
			wrbkSvcKMap = getWrbkSvcKei(wrbkSvcTgMap.getString(JBSbatKK_T_WRISVC_TG_KEI.WRIB_SVC_KEI_NO));
			if(null == wrbkSvcKMap) continue outPrg;	//なければ、次の進捗データへ
			//割引サービス契約内訳 複数
			wrbkSvcKUwList = getWrbkSvcKeiUtwk012(wrbkSvcTgMap.getString(JBSbatKK_T_WRISVC_TG_KEI.WRIB_SVC_KEI_NO));

			//異動区分によるキャンセル・解約チェック
			if(!checkIdoKbn(checkKaiyaku(prgrs.getString(JBSbatKK_T_PRG.IDO_DIV))))
			{
				outputBeanErr.addOutMapList_2(setRcvInfo());
			}
			if(cnclDslFlg) continue outPrg;	//解約・キャンセルなら次進捗へ

			//割引サービス 検索(割引サービスコード・名・タイプコード取得)
			wrbkSvcM = getWrbkSvcWrbkSvcSbtCd(
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD));
			if(null == wrbkSvcM)	continue outPrg;	//割引サービスない場合、次進捗へ
			//割引タイプコードによるチェック[個別]
			if(!checkWrbkSvcInfo())
			{
				outputBeanErr.addOutMapList_2(setRcvInfo());
			}
			if(kobetlFlg) continue outPrg;  //個別日付なら次進捗へ

			//割引サービス検索 割引サービスコードで検索
			wrbkSvcUw:for(JBSbatCommonDBInterface wrbkSvcKUw : wrbkSvcKUwList)
			{
				//テスト用ログ
				if("CRS00RR133".equals(prgrsMap.getString(JBSbatKK_T_PRG.SVC_KEI_NO)))
				{
					commonItem.getLogPrint().printDebugLog("");
				}

				wrbkSvcKUWMap = wrbkSvcKUw;

				commonItem.getLogPrint().printDebugLog("割引サービス契約内訳_詳細コード:"
						+ wrbkSvcKUw.getString(JBSbatKK_T_WRISVC_KEI_UCWK.WRIB_SVC_DTL_CD)
						+ " 割引サービスCD:" + wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD));

				//割引サービス詳細
				wrbkSvcDtlM = getWrbkSvcDtl(
						wrbkSvcKUw.getString(JBSbatKK_T_WRISVC_KEI_UCWK.WRIB_SVC_DTL_CD));
				if(null == wrbkSvcDtlM) continue wrbkSvcUw;	//なければ、次の割引サービスへ 要確認
				//割引サービス種別コードによる判定 割引サービス種別コードを取得
				if(!checkWrbkSvcCd(wrbkSvcM.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_SBT_CD)))
				{
					//（エラー時のみ、ファイル出力）
					outputBeanErr.addOutMapList_2(setRcvInfo());
					continue wrbkSvcUw;
				}
			}
		}
		//エラーなしの場合、出力しない？要確認
		return outputBeanErr;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_KK_M_WRIB_SVC.close();
		db_KK_T_PRG.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_WRISVC_TG_KEI.close();
		db_KK_M_WRIB_SVC_DTL.close();
		db_KK_T_WRISVC_KEI_UCWK.close();
		db_DK_T_HAISO_TG_BPIN.close();
		db_DK_T_HAISO.close();
		db_KK_T_MSKM_DTL.close();	//申込明細
		db_ZM_M_CD_NM_KANRI.close();
		db_KK_T_MSKM.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

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

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

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

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

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

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

	/**
	 * SQLKEY(KK_SELECT_024)で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_PRG_KV_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());
		// DBアクセスを実行します
		db_KK_T_PRG.selectBySqlDefine(paramList, KK_T_PRG_KV_SELECT_003);
	}

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

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

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

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

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

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

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

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

	/**
	 * SQLKEY(KK_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	選択明細の割引サービスコード
	 *		 	選択明細の割引サービス詳細コード
	 *		 	選択明細の割引サービスコード
	 *		 	選択明細の割引サービス詳細コード
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_M_WRIB_SVC_DTL_KV_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_M_WRIB_SVC_DTL.selectBySqlDefine(paramList, KK_M_WRIB_SVC_DTL_KV_SELECT_001);
	}

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

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

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

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

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

		// DBアクセスを実行します
		db_DK_T_HAISO.selectBySqlDefine(paramList, DK_T_HAISO_KV_SELECT_001);
	}
	
	/**
	 * SQLKEY(KK_SELECT_024)で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_MSKM_KV_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		// DBアクセスを実行します
		db_KK_T_MSKM.selectBySqlDefine(paramList, KK_T_MSKM_KV_SELECT_002);
	}

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

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

	//申込明細検索
	private void executeKK_T_MSKM_DTL_KK_SELECT_016(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

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

	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/

	/**サービス契約関連データ取得 */
	private boolean getSvcTbls(String svcKeiNo) throws Exception
	{
		boolean rslt = false;
		//(7)サービス契約検索 複数かも
		svcKeiMap = getSvcKei(svcKeiNo);
		if(null == svcKeiMap) return rslt;
		//サービス契約内訳 
		svcKUwList = getSvcKeiUtwk(svcKeiNo);
		if(null == svcKUwList) return rslt;
		//機器提供サービス検索
		kktkSvcKeiMap = getKktkSvcKei(svcKeiNo);
//		if(null == kktkSvcKeiMap) return rslt;
		//オプションサービス契約検索
		optSvcKMap = getOpSvcKei(svcKeiNo);
//		if(null == optSvcKMap) return rslt;
		//サブオプションサービス契約検索 引数：オプションサービス契約
		if(null != optSvcKMap)
		{
			sbOptSvcKMap = getSbOpSvcKei(cnvNullToEmp(
					optSvcKMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO)));
		}
//		if(null == sbOptSvcKMap) return rslt;
		//請求オプションサービス契約検索
		skyOptSvcKMap = getSkyOpSvcKei(svcKeiNo);
//		if(null == skyOptSvcKMap) return rslt;
		return true;
	}
	//ヘッダー出力 要確認
	private JBSbatServiceInterfaceMap setRcvCntInfoInit() throws Exception
	{
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatKVIFM002.PRD, "対象期間            ");
		outMap.set(JBSbatKVIFM002.WRISVC_CD, "割引サービスコード");
		outMap.set(JBSbatKVIFM002.WRISVC_FSTNM, "割引サービス名");
		outMap.set(JBSbatKVIFM002.APLY_CNT, "適用数");
		outMap.setOutFlg(true);
		return outMap;
	}

	//ヘッダー出力 要確認
	private JBSbatServiceInterfaceMap setRcvErrInit() throws Exception
	{
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatKVIFM003.PRG_NO, "進捗番号");
		outMap.set(JBSbatKVIFM003.SVKEI_NO, "サービス契約契約番号");
		outMap.set(JBSbatKVIFM003.IDIV, "異動区分");
		outMap.set(JBSbatKVIFM003.PRG_STAT, "進捗ステータス ");
		outMap.set(JBSbatKVIFM003.IDO_DTM, "異動年月日時分秒");
		outMap.set(JBSbatKVIFM003.WRIBSVK_NO, "割引サービス契約番号");
		outMap.set(JBSbatKVIFM003.WRIB_WRIBSVK_STAT, "割引サービス契約ステータス");
		outMap.set(JBSbatKVIFM003.WRIB_WRISVC_CD, "割引サービスコード");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_CNCL_YMD, "サービスキャンセル年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_STAYMD, "サービス開始年月日");

		outMap.set(JBSbatKVIFM003.WRIB_SVC_CHRG_STAYMD, "サービス課金開始年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_ENDYMD, "サービス終了年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_CHRG_ENDYMD, "サービス課金終了年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_DSL_YMD, "サービス解約年月日");
		outMap.set(JBSbatKVIFM003.WRIB_KAIHK_YMD, "回復年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_CNCL_CL_YMD, "サービスキャンセル取消年月日");
		outMap.set(JBSbatKVIFM003.WRIB_SVC_DSL_CL_YMD, "サービス解約取消年月日");
		outMap.set(JBSbatKVIFM003.WRIB_WRSV_NM, "割引サービス名");//名
		outMap.set(JBSbatKVIFM003.WRIB_PCRS_CD, "料金コースコード");
		outMap.set(JBSbatKVIFM003.WRIB_PPLAN_CD, "料金プランコード");

		outMap.set(JBSbatKVIFM003.WRIB_PLAN_STAYMD, "プラン開始年月日");
		outMap.set(JBSbatKVIFM003.WRIB_PLAN_ENDYMD, "プラン終了年月日");
		outMap.set(JBSbatKVIFM003.WRIB_PLAN_CHRG_STAYMD, "プラン課金開始年月日");
		outMap.set(JBSbatKVIFM003.WRIB_PLAN_CHRG_ENDYMD, "プラン課金終了年月日");
		outMap.set(JBSbatKVIFM003.WRIB_PLAN_END_SBT_CD, "プラン終了種別コード");
		//サ−ビス契約側のデータをセット
		outMap.set(JBSbatKVIFM003.SVC_SVC_CNCL_YMD, "svc_サービスキャンセル年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_STAYMD, "サービス開始年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_CHRG_STAYMD, "サービス課金開始年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_STP_YMD, "サービス停止年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_STP_RLS_YMD, "サービス停止解除年月日");

		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_YMD, "サービス休止年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_RLS_YMD, "サービス休止解除年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_ENDYMD, "サービス終了年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_CHRG_ENDYMD, "サービス課金終了年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_KISAN_YMD, "サービス解約起算年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_YMD, "サービス解約年月日");
		outMap.set(JBSbatKVIFM003.SVC_KAIHK_YMD, "回復年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_CNCL_CL_YMD, "サービスキャンセル取消年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_CL_YMD, "サービス解約取消年月日");
		outMap.set(JBSbatKVIFM003.SVC_IDIV, "異動区分");

		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_CHRG_STAYMD, "サービス休止課金開始年月日");
		outMap.set(JBSbatKVIFM003.SVC_SVKEI_STAT, "サービス契約ステータス");
		outMap.set(JBSbatKVIFM003.SVC_SVC_CD, "サービスコード");
		outMap.set(JBSbatKVIFM003.KIKI_KKTSVKEI_STAT, "機器提供サービス契約ステータス");
		outMap.set(JBSbatKVIFM003.OP_OPSVKEI_STAT, "オプションサービス契約ステータス");
		outMap.set(JBSbatKVIFM003.OP_OP_SVC_CD, "オプションサービス契約ステータス");
		outMap.set(JBSbatKVIFM003.SBOP_SBOPSVKEI_STAT, "サブオプションサービス契約ステータス");
		outMap.set(JBSbatKVIFM003.SBOP_SBOP_SVC_CD, "サブオプションサービスコード");
		outMap.set(JBSbatKVIFM003.SIKY_OP_SEIOPSVKEI_STAT, "請求オプションサービス契約ステータス");
		outMap.set(JBSbatKVIFM003.ERR_NAIYO, "エラー内容");
		outMap.setOutFlg(true);
		return outMap;
	}

	//ファイル情報をセット(エラー)
	private JBSbatServiceInterfaceMap setRcvCntInfo(JBSbatCommonDBInterface dbMap) throws Exception
	{
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
//後で確認 \s 要確認
		outMap.set(JBSbatKVIFM002.PRD, prmStartDay + " 〜 " + prmEndDay);
		outMap.set(JBSbatKVIFM002.WRISVC_CD, "         "+dbMap.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_CD));
		outMap.set(JBSbatKVIFM002.WRISVC_FSTNM, dbMap.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_NM));
		outMap.set(JBSbatKVIFM002.APLY_CNT, dbMap.getString("cnt"));
		outMap.setOutFlg(true);
		return outMap;
	}

	//ファイル情報をセット(エラー)
	private JBSbatServiceInterfaceMap setRcvInfo() throws Exception
	{
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		//コード名称取得
		String idoNm = getCdNｍ("CD00576", prgrsMap.getString(JBSbatKK_T_PRG.IDO_DIV));
		String prgStatNm = getCdNｍ("CD00647", prgrsMap.getString(JBSbatKK_T_PRG.PRG_STAT));
		String svcIdoNm = getCdNｍ("CD00576", svcKeiMap.getString(JBSbatKK_T_SVC_KEI.IDO_DIV));

		//割引サービス名
		String wrbkSvcNm = "";
		if(null != wrbkSvcM)
		{
			wrbkSvcNm = wrbkSvcM.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_NM);
		}
		//機器提供サービス契約
		String kkTkSvcSta = "";
		if(null != kktkSvcKeiMap)
		{
			kkTkSvcSta = cnvNullToEmp(kktkSvcKeiMap.getString(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_KEI_STAT));
		}
		//オプションサービス契約
		String optSvcKSta = "";
		String optSvcKCd = "";
		if(null != optSvcKMap)
		{
			optSvcKSta = cnvNullToEmp(optSvcKMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT));
			optSvcKCd = cnvNullToEmp(optSvcKMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		}
		//サブオプションサービス契約
		String sbOpSvcSta = "";
		String sbOpSvcCd = "";
		if(null != sbOptSvcKMap)
		{
			sbOpSvcSta = cnvNullToEmp(sbOptSvcKMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_KEI_STAT));
			sbOpSvcCd = cnvNullToEmp(sbOptSvcKMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_CD));
		}
		//請求オプションサービス契約
		String skyOptSvcKSta = "";
		if(null != skyOptSvcKMap)
		{
			skyOptSvcKSta = cnvNullToEmp(skyOptSvcKMap.getString(JBSbatKK_T_SEIOPSVC_KEI.SEIOPSVC_KEI_STAT));
		}

		//エラーマーク表示
		String wrbSta = "";
		String wrbSvcStr = "";
		String wrbSvcEnd = "";
		String wrbChrStr = "";
		String wrbChrEnd = "";
		String plnStr = "";
		String plnEnd = "";
		String plnChrStr = "";
		String plnChrEnd = "";
		String wrbSvcDsl = "";
		String wrbCncl = "";

		String svcChrSta = "";
		String svcChrEnd = "";
		String svcStaYmd = "";
		String svcEndYmd = "";
		String svcDslYmd = "";
//		String svcPlnStaYmd = "";
//		String svcPlnEndYmd = "";
//		String svcPlnChStaYmd = "";
//		String svcPlnChEndYmd = "";
		
		if(0 != errKomk.size())
		{
			String errMrk = checkErrNya();
			//割引サービス契約
			if(errKomk.contains("wrbkSta")) wrbSta = errMrk;
			if(errKomk.contains("wrbSvcStr")) wrbSvcStr = errMrk;
			if(errKomk.contains("wrbSvcEnd")) wrbSvcEnd = errMrk;
			if(errKomk.contains("wrbChrStr")) wrbChrStr = errMrk;
			if(errKomk.contains("wrbChrEnd")) wrbChrEnd = errMrk;
			if(errKomk.contains("plnStr")) plnStr = errMrk;
			if(errKomk.contains("plnEnd")) plnEnd = errMrk;
			if(errKomk.contains("plnChrStr")) plnChrStr = errMrk;
			if(errKomk.contains("plnChrEnd")) plnChrEnd = errMrk;
			if(errKomk.contains("wrbSvcDsl")) wrbSvcDsl = errMrk;
			if(errKomk.contains("wrbCncl")) wrbCncl = errMrk;
			//サービス契約
			if(errKomk.contains("svcChrSta")) svcChrSta = errMrk;
			if(errKomk.contains("svcChrEnd")) svcChrEnd = errMrk;
			if(errKomk.contains("svcStaYmd")) svcStaYmd = errMrk;
			if(errKomk.contains("svcEndYmd")) svcEndYmd = errMrk;
			if(errKomk.contains("svcDslYmd")) svcDslYmd = errMrk;
			
//			if(errKomk.contains("wrbCncl")) svcPlnStaYmd = errMrk;
//			if(errKomk.contains("wrbCncl")) svcPlnEndYmd = errMrk;
//			if(errKomk.contains("wrbCncl")) svcPlnChStaYmd = errMrk;
//			if(errKomk.contains("wrbCncl")) svcPlnChEndYmd = errMrk;
		}

		outMap.set(JBSbatKVIFM003.PRG_NO, cnvNullToEmp(prgrsMap.getString(JBSbatKK_T_PRG.PRG_NO)));
		outMap.set(JBSbatKVIFM003.SVKEI_NO, cnvNullToEmp(prgrsMap.getString(JBSbatKK_T_PRG.SVC_KEI_NO)));
		outMap.set(JBSbatKVIFM003.IDIV, idoNm);
		outMap.set(JBSbatKVIFM003.PRG_STAT, prgStatNm);
		outMap.set(JBSbatKVIFM003.IDO_DTM, prgrsMap.getString(JBSbatKK_T_PRG.IDO_DTM));
		if(null != wrbkSvcKMap)
		{
			outMap.set(JBSbatKVIFM003.WRIBSVK_NO, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_NO)));
			outMap.set(JBSbatKVIFM003.WRIB_WRIBSVK_STAT, wrbSta + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_STAT)));
			outMap.set(JBSbatKVIFM003.WRIB_WRISVC_CD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_CNCL_YMD, wrbCncl + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CANCEL_YMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_STAYMD,  wrbSvcStr + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_STA_YMD)));
	
			outMap.set(JBSbatKVIFM003.WRIB_SVC_CHRG_STAYMD, wrbChrStr + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_ENDYMD, wrbSvcEnd + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_CHRG_ENDYMD, wrbChrEnd + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_DSL_YMD, wrbSvcDsl + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_YMD)));
			outMap.set(JBSbatKVIFM003.WRIB_KAIHK_YMD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.KAIHK_YMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_CNCL_CL_YMD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CANCEL_CL_YMD)));
			outMap.set(JBSbatKVIFM003.WRIB_SVC_DSL_CL_YMD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_CL_YMD)));
			outMap.set(JBSbatKVIFM003.WRIB_WRSV_NM, cnvNullToEmp(wrbkSvcNm));//名
			outMap.set(JBSbatKVIFM003.WRIB_PCRS_CD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PCRS_CD)));
			outMap.set(JBSbatKVIFM003.WRIB_PPLAN_CD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PPLAN_CD)));
	
			outMap.set(JBSbatKVIFM003.WRIB_PLAN_STAYMD, plnStr + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_STAYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_PLAN_ENDYMD, plnEnd + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_ENDYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_PLAN_CHRG_STAYMD, plnChrStr + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_STAYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_PLAN_CHRG_ENDYMD, plnChrEnd + cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_ENDYMD)));
			outMap.set(JBSbatKVIFM003.WRIB_PLAN_END_SBT_CD, cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_END_SBT_CD)));
		}

		//サ−ビス契約側のデータをセット
		outMap.set(JBSbatKVIFM003.SVC_SVC_CNCL_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CANCEL_CL_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_STAYMD, svcStaYmd + cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_STA_YMD)));
		outMap.set(JBSbatKVIFM003.SVC_SVC_CHRG_STAYMD, svcChrSta + cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD)));
		outMap.set(JBSbatKVIFM003.SVC_SVC_STP_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_STP_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_STP_RLS_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_STP_RLS_YMD));

		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_PAUSE_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_RLS_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_PAUSE_RLS_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_ENDYMD, svcEndYmd + cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_ENDYMD)));
		outMap.set(JBSbatKVIFM003.SVC_SVC_CHRG_ENDYMD, svcChrEnd + cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_ENDYMD)));
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_KISAN_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_KISAN_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_YMD, svcDslYmd + cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD)));
		outMap.set(JBSbatKVIFM003.SVC_KAIHK_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.KAIHK_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_CNCL_CL_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CANCEL_CL_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVC_DSL_CL_YMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_CL_YMD));
		outMap.set(JBSbatKVIFM003.SVC_IDIV, svcIdoNm);

		outMap.set(JBSbatKVIFM003.SVC_SVC_PAUSE_CHRG_STAYMD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_PAUSE_CHRG_STA_YMD));
		outMap.set(JBSbatKVIFM003.SVC_SVKEI_STAT, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_STAT));
		outMap.set(JBSbatKVIFM003.SVC_SVC_CD, svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CD));
		outMap.set(JBSbatKVIFM003.KIKI_KKTSVKEI_STAT, kkTkSvcSta);
		outMap.set(JBSbatKVIFM003.OP_OPSVKEI_STAT, optSvcKSta);
		outMap.set(JBSbatKVIFM003.OP_OP_SVC_CD, optSvcKCd);
		outMap.set(JBSbatKVIFM003.SBOP_SBOPSVKEI_STAT, sbOpSvcSta);
		outMap.set(JBSbatKVIFM003.SBOP_SBOP_SVC_CD, sbOpSvcCd);
		outMap.set(JBSbatKVIFM003.SIKY_OP_SEIOPSVKEI_STAT, skyOptSvcKSta);
		outMap.set(JBSbatKVIFM003.ERR_NAIYO, errStr);

		outMap.setOutFlg(true);
		errStr = "";
		errKomk.clear();	//クリア
		return outMap;
	}

	//出力ファイル設定
	private JBSbatOutputFileUtil setOutPutFile(String defFile,
			ArrayList<JBSbatServiceInterfaceMap> outBeanList)throws Exception
	{
		String outFileDefName = JBSbatAplConst.getAplConstValue("OTD") + defFile;
		// ファイル出力部品を取得
		JBSbatOutputFileUtil fileUtil = super.commonItem.getOutPutFile();
		// 出力定義ファイルオブジェクトを生成する
		JBSbatDefFileUtil outFileDef = new JBSbatDefFileUtil(outFileDefName, fileUtil);
		fileUtil.createWriter();
		//共通電文に設定
		super.commonItem.setOutPutFile(fileUtil);

		for(JBSbatServiceInterfaceMap intrfc : outBeanList)
		{
			// ファイルに出力する
			fileUtil.print(intrfc, outFileDef);
		}
		return fileUtil;
	}

	//割引サービス検索
	private ArrayList<JBSbatCommonDBInterface> getWrbkSvc() throws Exception
	{
		String[] param = {prmStartDay, prmEndDay};
		executeKK_M_WRIB_SVC_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_M_WRIB_SVC.selectNext();

		if(null == dataMap)
		{
			String errParam = "、開始日: " + param[0] + " 終了日: "  + param[1];
			commonItem.getLogPrint().printDebugLog(
					"割引サービス契約該当なし" + errParam);
//			notFoundError(new String[]{"割引サービス" ,errParam});
			return null;
		}
		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_M_WRIB_SVC.selectNext();
		}

		return mapArray;
	}

	//割引サービス契約 件数検索
	private int getWrbkSvcKeiCnt(JBSbatCommonDBInterface parmDb) throws Exception
	{
		String[] param = {parmDb.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_CD),
				padRightZro(prmStartDay, 17), prmEndDay + "235959999"};
		executeKK_T_WRIB_SVC_KEI_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_WRIB_SVC_KEI.selectNext();
		if(null == dataMap || 1 > Integer.parseInt(dataMap.getString("CNT")))
		{
			commonItem.getLogPrint().printDebugLog(
					"割引サービス契約該当なし。割引サービスコード:" + param[0]);
//			notFoundError(new String[]{"割引サービス", param[0]});
			return 0;
		}
		return Integer.parseInt(dataMap.getString("CNT"));
	}

	//進捗検索
	private ArrayList<JBSbatCommonDBInterface> getPrgrs() throws Exception
	{
		String[] param = {padRightZro(prmStartDay, 17), prmEndDay + "235959999"};
		executeKK_T_PRG_KV_SELECT_002(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_PRG.selectNext();
		if(null == dataMap)
		{
			commonItem.getLogPrint().printDebugLog(
					"進捗に該当なし。開始日:" + param[0] + " 終了日:"  + param[1]);
			String errParam = "、開始日:" + param[0] + " 終了日:"  + param[1];
			notFoundError(new String[]{"進捗" ,errParam});
		}

		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_T_PRG.selectNext();
		}
		return mapArray;
	}

	//進捗検索 最新取得
//	private ArrayList<JBSbatCommonDBInterface> getPrgrs16(String svcKeiNo) throws Exception
	private JBSbatCommonDBInterface getPrgrsLatest(String svcKeiNo) throws Exception
	{
		String[] param = {svcKeiNo};
		executeKK_T_PRG_KV_SELECT_003(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_PRG.selectNext();
		if(null == dataMap)
		{
			String errParam = " サービス契約番号:" +svcKeiNo;
			commonItem.getLogPrint().printDebugLog("進捗に該当なし。(F050)"+ errParam);
			return null;
//			notFoundError(new String[]{"進捗" ,errParam});
		}
//		return dataMap;
		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_T_PRG.selectNext();
		}
		//最新
		return mapArray.get(0);
	}
	//サービス契約検索
	private JBSbatCommonDBInterface getSvcKei(String svckeiNo) throws Exception
	{
		String[] param = {svckeiNo, svckeiNo};
		executeKK_T_SVC_KEI_KV_SELECT_005(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_SVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号:" + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"サービス契約該当なし " + errParam);
//			notFoundError(new String[]{"サービス契約" ,errParam, svckeiNo});
			return null;
		}

		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_T_SVC_KEI.selectNext();
		}
		//格納しておく
		svcKeiList = mapArray;
		if(1 < mapArray.size()) commonItem.getLogPrint().printDebugLog("サービス契約複数件:" + mapArray.size());
		//１件目を返す
		return mapArray.get(0);
	}
	//サービス契約内訳
	private ArrayList<JBSbatCommonDBInterface> getSvcKeiUtwk(String svckeiNo) throws Exception
	{
		String[] param =  {svckeiNo, svckeiNo};
		executeKK_T_SVC_KEI_UCWK_KV_SELECT_002(param);
		JBSbatCommonDBInterface dataMap = db_KK_T_SVC_KEI_UCWK.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号:" + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"サービス契約該当なし " + errParam);
//			notFoundError(new String[]{"サービス契約" ,errParam});
			return null;
		}
		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_T_SVC_KEI_UCWK.selectNext();
		}
		return mapArray;
	}
	
	//オプションサービス契約検索
	private JBSbatCommonDBInterface getOpSvcKei(String svckeiNo) throws Exception
	{
		String[] param =  {svckeiNo, svckeiNo};
		executeKK_T_OP_SVC_KEI_KV_SELECT_003(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_OP_SVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号:" + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"オプションサービス契約該当なし " + errParam);
//			notFoundError(new String[]{"オプションサービス契約" ,errParam});
			return null;
		}
		return dataMap;
	}

	//サブオプションサービス契約検索
	private JBSbatCommonDBInterface getSbOpSvcKei(String opSvckeiNo) throws Exception
	{
		if("".equals(opSvckeiNo)) return null;
		String[] param =  {opSvckeiNo, opSvckeiNo};
		executeKK_T_SBOP_SVC_KEI_KV_SELECT_003(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_SBOP_SVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "オプションサービス契約番号:" + opSvckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"サブオプションサービス契約該当なし " + errParam);
//			notFoundError(new String[]{"サブオプションサービス契約" ,errParam});
			return null;
		}
		return dataMap;
	}

	//機器提供サービス契約検索
	private JBSbatCommonDBInterface getKktkSvcKei(String svckeiNo) throws Exception
	{
		String[] param =  {svckeiNo, svckeiNo};
		executeKK_T_KKTK_SVC_KEI_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_KKTK_SVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号: " + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"機器提供サービス契約該当なし " + errParam);
//			notFoundError(new String[]{"機器提供サービス契約" ,errParam});
			return null;
		}
		return dataMap;
	}

	//請求オプションサービス契約検索
	private JBSbatCommonDBInterface getSkyOpSvcKei(String svckeiNo) throws Exception
	{
		String[] param =  {svckeiNo, svckeiNo};
		executeKK_T_SEIOPSVC_KEI_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_SEIOPSVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号: " + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"請求オプションサービス契約該当なし " + errParam);
//			notFoundError(new String[]{"請求オプションサービス契約" ,errParam});
			return null;
		}
		return dataMap;
	}

	//割引サービス契約内訳
	private ArrayList<JBSbatCommonDBInterface> getWrbkSvcKeiUtwk012(String svckeiNo) throws Exception
	{
		String wrbkSvckeiNoEdit = padRightSpc(svckeiNo, 12);
		String[] param = {wrbkSvckeiNoEdit, wrbkSvckeiNoEdit};
		executeKK_T_WRISVC_KEI_UCWK_KV_SELECT_001(param);
		JBSbatCommonDBInterface dataMap = db_KK_T_WRISVC_KEI_UCWK.selectNext();

		if(null == dataMap)
		{
			String errParam = "サービス契約番号:" + svckeiNo;
			commonItem.getLogPrint().printDebugLog("割引サービス契約内訳該当なし " + errParam);
//			notFoundError(new String[]{"割引サービス契約内訳" ,errParam});
		}
		//複数件取得
		ArrayList<JBSbatCommonDBInterface> mapArray = new ArrayList<JBSbatCommonDBInterface>();
		while(null != dataMap)
		{
			mapArray.add(dataMap);
			dataMap = db_KK_T_WRISVC_KEI_UCWK.selectNext();
		}
		if(1 < mapArray.size())
		{
			commonItem.getLogPrint().printDebugLog(mapArray.size() + "件(割引サービス契約内訳)"+ wrbkSvckeiNoEdit);
		}
		return mapArray;
	}

	//割引サービス契約検索
	private JBSbatCommonDBInterface getWrbkSvcKei(String wrbkSvckeiNo) throws Exception
	{
		String wrbkSvckeiNoEdit = padRightSpc(wrbkSvckeiNo, 12);
		String[] param = {wrbkSvckeiNoEdit, wrbkSvckeiNoEdit};
		executeKK_T_WRIB_SVC_KEI_KV_SELECT_002(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_WRIB_SVC_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号: " + wrbkSvckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"割引サービス契約該当なし " + errParam);
//			notFoundError(new String[]{"割引サービス契約", errParam, wrbkSvckeiNo});
			return null;
		}
		return dataMap;
	}
	//割引サービス対象契約検索
	private JBSbatCommonDBInterface getWrbkSvcTgKei(String svckeiNo) throws Exception
	{
		String[] param = {svckeiNo, svckeiNo};
		executeKK_T_WRISVC_TG_KEI_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_T_WRISVC_TG_KEI.selectNext();
		if(null == dataMap)
		{
			String errParam = "サービス契約番号: " + svckeiNo;
			commonItem.getLogPrint().printDebugLog(
					"割引サービス対象契約 該当なし " + errParam);
			return null;
		}
		return dataMap;
	}

	//割引サービス詳細検索
	private JBSbatCommonDBInterface getWrbkSvcDtl(String wrbkSvcDtlCd) throws Exception
	{
		String[] param = {wrbkSvcDtlCd,
				wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD),
				wrbkSvcDtlCd, wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD)};
		executeKK_M_WRIB_SVC_DTL_KV_SELECT_001(param);

		JBSbatCommonDBInterface dataMap = db_KK_M_WRIB_SVC_DTL.selectNext();
		if(null == dataMap)
		{
			String errParam = "割引サービス詳細コード:" + param[0] +
			" 割引サービスコード:" + param[1];
			commonItem.getLogPrint().printDebugLog(
					" 割引サービス詳細該当なし " + errParam);
//			notFoundError(new String[]{"割引サービス詳細" ,errParam, "" });
			return null;
		}
		//複数件取得
//		wrbkSvcKDtlMapList = new ArrayList<JBSbatCommonDBInterface>();
//		while(null != dataMap)
//		{
//			wrbkSvcKDtlMapList.add(dataMap);
//			dataMap = db_KK_M_WRIB_SVC_DTL.selectNext();
//		}
//		return wrbkSvcKMapList;

		return dataMap;
	}

	//配送対象物品 検索
//	private String getHaisoTgBpn(String kktkSvcKNo) throws Exception
//	{
//		String[] param = {kktkSvcKNo, kktkSvcKNo};
//		executeDK_T_HAISO_TG_BPIN_KV_SELECT_001(param);
//		JBSbatCommonDBInterface dataMap = db_DK_T_HAISO_TG_BPIN.selectNext();
//		if(null == dataMap)
//		{
//			String errParam = "機器提供サービス契約番号: " + param[0];
//			commonItem.getLogPrint().printDebugLog("配送対象物品該当なし " + errParam);
//			notFoundError(new String[]{"配送対象物品" ,errParam});
//		}
//		return dataMap.getString(JBSbatDK_T_HAISO_TG_DOHUBT.HAISO_NO);
//	}

	//配送 検索
	private String getHaiso(String haisoNo) throws Exception
	{
		String[] param = {haisoNo};	//機器提供サービス契約番号
		executeDK_T_HAISO_KV_SELECT_001(param);
		JBSbatCommonDBInterface dataMap = db_DK_T_HAISO.selectNext();
		if(null == dataMap)
		{
			String errParam = "機器提供サービス契約番号: " + param[0];
			commonItem.getLogPrint().printDebugLog("配送該当なし " + errParam);
			notFoundError(new String[]{"配送" ,errParam});
		}
		return dataMap.getString(JBSbatDK_T_HAISO.HAISO_FIN_YMD);
	}
//	private String getHaiso(String haisoNo) throws Exception
//	{
//		String[] param = {haisoNo, haisoNo};
//		executeDK_T_HAISO_KK_SELECT_006(param);
//		JBSbatCommonDBInterface dataMap = db_DK_T_HAISO.selectNext();
//		if(null == dataMap)
//		{
//			String errParam = "配送番号: " + param[0];
//			commonItem.getLogPrint().printDebugLog("配送該当なし " + errParam);
//			notFoundError(new String[]{"配送" ,errParam});
//		}
//		return dataMap.getString(JBSbatDK_T_HAISO.HAISO_FIN_YMD);
//	}

	/**
	 * 割引サービスから、割引サービス種別コードを取得
	 * @param svckeiNo
	 * @return
	 * @throws Exception
	 */
	private JBSbatCommonDBInterface getWrbkSvcWrbkSvcSbtCd(String svckeiNo) throws Exception
	{
		String[] param = {svckeiNo, svckeiNo};
		executeKK_M_WRIB_SVC_KV_SELECT_002(param);

		JBSbatCommonDBInterface dataMap = db_KK_M_WRIB_SVC.selectNext();
		if(null == dataMap)
		{
			commonItem.getLogPrint().printDebugLog(
					"割引サービス該当なし(種別) サービス契約番号:" + param[0]);
			String errParam = "サービス契約番号: " + svckeiNo;
			notFoundError(new String[]{"割引サービス" ,errParam});
		}
		return dataMap;
//		return dataMap.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_SBT_CD);
	}

	/**
	 * コード名称管理から、コード区分名を取得
	 * @param cdSbtCd
	 * @param cdDiv
	 * @return コード区分名
	 * @throws Exception
	 */
	private String getCdNｍ(String cdSbtCd, String cdDiv) throws Exception
	{
		String[] param = {cdSbtCd, cdDiv};

		if("CD00576".equals(cdSbtCd) && "00000".equals(cdDiv))
		{
			return "";
		}

		executeZM_M_CD_NM_KANRI_KV_SELECT_001(param);
		JBSbatCommonDBInterface dataMap = db_ZM_M_CD_NM_KANRI.selectNext();
		if(null == dataMap)
		{
			String errParam = "コード種別コード: " + param[0] + " コード区分:" + param[1];
			commonItem.getLogPrint().printDebugLog(
					"コード名称管理に該当なし " + errParam);
//			notFoundError(new String[]{"コード名称管理" ,errParam});
			return "";
		}
		return dataMap.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV_NM);
	}
	//申込年月日を取得
	private String getMskmYmd(String mskmDtlCd) throws Exception
	{
		executeKK_T_MSKM_DTL_KK_SELECT_016(new String[]{mskmDtlCd});
		JBSbatCommonDBInterface dataMap = db_KK_T_MSKM_DTL.selectNext();
		if(null == dataMap)
		{
			String errParam = "申込明細番号: " + mskmDtlCd;
			commonItem.getLogPrint().printDebugLog(
					"申込明細に該当なし " + errParam);
			return "";
		}
		return cnvNullToEmp(dataMap.getString(JBSbatKK_T_MSKM_DTL.MSKM_YMD));
	}

	//割引サービス種別コードを元にチェック
	private boolean checkWrbkSvcCd(String wrbkSvcCd) throws Exception
	{
		//割引サービス種別コードによるチェック
		if("01".equals(wrbkSvcCd))
		{
			return checkReplace();
		}
		else if("02".equals(wrbkSvcCd))
		{
			return checkNebiki();
		}
		return true;
	}

	//置換の場合のチェック
	private boolean checkReplace() throws Exception
	{
		boolean rslt = true;
		String replc = "[置換]";
		String wrbkSvcKNo = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_NO);
		String plnStr = "";
		String plnChrStr = "";
		commonItem.getLogPrint().printDebugLog(
				replc + "チェック開始 割引サービス契約番号:" + wrbkSvcKNo);
		//�@
		if(!"100".equals(
				wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_STAT)))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo + replc + ERR_MSG_15);
			errStr = replc + ERR_MSG_15;
			errKomk.add("wrbkSta");
			rslt = false;
		}
		String mskmKsnYmd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.MSKM_KISAN_YMD));
		String svcStrYmd = cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_STA_YMD));

		if("000000000072".equals(wrbkSvcKNo))
		{
			commonItem.getLogPrint().printDebugLog("");
		}
		
		//起算日の方が、サービス開始年月日より過去か未来か
		if(svcStrYmd.compareTo(mskmKsnYmd) >= 0)
		{
			commonItem.getLogPrint().printDebugLog("申込起算日:"+ mskmKsnYmd +" 過去・同日");

			//サービス開始年月日 最大値
			String maxSvcSta = getOldestDay(
					getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_STA_YMD, svcKeiList));
			//最大サービス開始日 翌月初日
			String firstOfNM = getFirstOfNextMonth(maxSvcSta);

			//サービス開始年月日 最大値？　maxSvcStaと比較？
			String svcSt = cnvNullToEmp(
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_STA_YMD));
			if(!svcSt.equals(maxSvcSta))
			{
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo  + replc +
				" サービス契約[最古]と割引サービス契約のサービス開始日が異なる。" + 
				maxSvcSta + " 割引サービス契約:" + svcSt);
				errStr = errStr + replc + getErrMsg16("[割引サービス契約]サービス開始年月日:" + svcSt, maxSvcSta);
				errKomk.add("wrbSvcStr");
				rslt = false;
			}
			plnStr = maxSvcSta;

			//サービス課金開始年月日
			String svcChSt = cnvNullToEmp(
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD));
			if(!firstOfNM.equals(svcChSt))
			{
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
					" 申込起算日翌月初日とサービス課金開始日が異なる。" + 
					firstOfNM + " [割引サービス契約]サービス課金開始年月日:" + svcChSt);
				errStr = errStr + replc + getErrMsg16("[割引サービス契約]サービス課金開始年月日", firstOfNM);
				errKomk.add("wrbChrStr");
//				errKomk.add("svcChrSta");
				rslt = false;
			}
			plnChrStr = firstOfNM;
		}
		else
		{
			//未来日の場合
			commonItem.getLogPrint().printDebugLog("申込起算日:"+ mskmKsnYmd +" 未来");
			//申込起算年月日 翌月初日
			String firstOfMKsn = getFirstOfNextMonth(mskmKsnYmd);	// 20121001
			//サービス開始年月日
			String svcStr = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_STA_YMD));
			if(!firstOfMKsn.equals(svcStr))
			{
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
				" 割引サービス契約のサービス開始日がサービス開始日翌月初日と異なる。" +
				"申込起算日翌月初日:" + firstOfMKsn + " 割引サービス契約:" + svcStr);
				errStr = errStr + replc + getErrMsg16(
						"[割引サービス契約]サービス開始年月日:" + svcStr, firstOfMKsn);
				errKomk.add("wrbSvcStr");
				rslt = false;
			}
			plnStr = firstOfMKsn;

			//サービス課金開始年月日
			if(!firstOfMKsn.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD)))
			{
				String svcChSt = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD);
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
				" [割引サービス契約]サービス課金開始日が申込起算日翌月初日と異なる。申込起算日:" 
						+ firstOfMKsn + " [割引サービス契約]サービス課金開始日" + svcChSt);
				errStr = errStr + replc + getErrMsg16(
						"[割引サービス契約]サービス課金開始年月日:" + svcChSt, firstOfMKsn);
				errKomk.add("wrbChrStr");
				rslt = false;
			}
			plnChrStr = firstOfMKsn;
		}
		//サービス終了年月日
		if(!JKKBatConst.S_MAX_DATE.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD)))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
					" サービス終了年月日がシステム最大値ではない。");
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]サービス終了年月日:" +
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD), 
					JKKBatConst.S_MAX_DATE);
			errKomk.add("wrbSvcEnd");
			rslt = false;
		}
		//サービス課金終了年月日
		if(!JKKBatConst.S_MAX_DATE.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
					" サービス課金終了年月日がシステム最大値ではない。");
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]サービス課金終了年月日:" +
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD), 
					JKKBatConst.S_MAX_DATE);
			errKomk.add("wrbChrEnd");
			rslt = false;
		}
		
		//プラン開始年月日
		if(!plnStr.equals(wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_STAYMD)))
		{
			commonItem.getLogPrint().printDebugLog(
					wrbkSvcKNo + " " + plnStr + "プラン開始年月日が算出と異なる");
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]プラン開始年月日" +
					wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_STAYMD), plnStr);
			errKomk.add("plnStr");
			rslt = false;
		}
		//プラン終了年月日
		if(!JKKBatConst.S_MAX_DATE.equals(wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_ENDYMD)))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
					" プラン終了年月日がシステム最大値ではない。");
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]プラン終了年月日" +
					wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_ENDYMD), JKKBatConst.S_MAX_DATE);
			errKomk.add("plnEnd");
			rslt = false;
		}
		//プラン課金開始年月日
		if(!plnChrStr.equals(
				wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_STAYMD)))
		{
			commonItem.getLogPrint().printDebugLog(
					wrbkSvcKNo + " プラン課金開始年月日、算出日と異なる。" 
					+ plnChrStr + " [割引サービス契約]プラン課金開始年月日:"+ 
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_STAYMD));
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]プラン課金開始年月日:" +
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_STAYMD), plnChrStr);
			errKomk.add("plnChrStr");
			rslt = false;
		}
		//プラン課金終了年月日
		if(!JKKBatConst.S_MAX_DATE.equals(
				wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD)))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +
			" プラン課金終了年月日がシステム最大値ではない。");
			errStr = errStr + replc + getErrMsg16("[割引サービス契約]プラン課金終了年月日:" +
					wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD), 
					JKKBatConst.S_MAX_DATE);
			errKomk.add("plnChrEnd");
			rslt = false;
		}
		if(rslt)	commonItem.getLogPrint().printDebugLog(replc + "エラーなし");
		return rslt;
	}

	//値引の場合のチェック
	private boolean checkNebiki() throws Exception
	{
		boolean rslt = true;
		String nbk = "[値引]";
		String wrbkSvcKNo = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_NO);
		commonItem.getLogPrint().printDebugLog(
				prgrsMap.getString(JBSbatKK_T_PRG.SVC_KEI_NO) + nbk + "チェック開始");
		//�@検証
		if(!"100".equals(cnvNullToEmp(
				wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_KEI_STAT))))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo + " " + ERR_MSG_15);
			errStr = nbk + ERR_MSG_15;
			errKomk.add("wrbkSta");
			rslt = false;
		}

		//サービス開始年月日 キャンペーン開始コードにより課金開始年月日を算出 要確認
		String svcStrtRslt = getSvcChrgStr(getChrgStrtDay(wrbkSvcDtlM.getString(
				JBSbatKK_M_WRIB_SVC_DTL.CAMPAIGN_STA_CD)));
		//サービス開始年月日(割引サービス契約)
		String svcStr = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_STA_YMD));
		if(!svcStrtRslt.equals(svcStr))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス開始年月日(" + svcStrtRslt + 
					")と、[割引サービス契約]サービス開始年月日(" + svcStr + ")が異なる。");
			errStr = errStr + nbk + getErrMsg16(
					"[割引サービス契約]サービス開始年月日:" + svcStr, svcStrtRslt);
			errKomk.add("wrbSvcStr");
			rslt = false;
		}
		//サービス課金開始年月日
		String svcChStr = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD));
		if(!svcStrtRslt.equals(svcChStr))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス開始年月日(" + svcStrtRslt + 
					")と、[割引サービス契約]サービス課金開始年月日(" + svcChStr +")が異なる。");
			errKomk.add("wrbChrStr");
			errStr = errStr + nbk + getErrMsg16(
					"[割引サービス契約]サービス課金開始年月日:" + svcChStr, svcStrtRslt);
			rslt = false;
		}
		//プラン開始年月日
		String plnSrt = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_STAYMD));
		if(!svcStrtRslt.equals(plnSrt))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス開始年月日(" + svcStrtRslt + 
					")と、[割引サービス契約]プラン開始年月日(" + plnSrt + ")が異なる。");
			errKomk.add("plnStr");
			errStr = errStr + nbk + getErrMsg16("[割引サービス契約]プラン開始年月日:" + plnSrt, svcStrtRslt);
			rslt = false;
		}
		//プラン課金開始年月日
		String plnChSta = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_STAYMD));
		if(!svcStrtRslt.equals(plnChSta))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス開始年月日(" + svcStrtRslt + 
					")と、[割引サービス契約]プラン課金開始年月日(" + plnChSta +")が異なる。");
			errStr = errStr + nbk + getErrMsg16(
					"[割引サービス契約]プラン課金開始年月日:" + plnChSta, svcStrtRslt);
			
			errKomk.add("plnChrStr");
			rslt = false;
		}

		//�Bサービス課金開始年月日チェック(割引サービス契約内訳)
		String wrbkSvcKUwSvChrSt = cnvNullToEmp(
				wrbkSvcKUWMap.getString(JBSbatKK_T_WRISVC_KEI_UCWK.SVC_CHRG_STAYMD));
		if(!svcStrtRslt.equals(wrbkSvcKUwSvChrSt))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス課金開始年月日が異なる。"
					+ "[割引サービス契約内訳]課金開始年月日:" + wrbkSvcKUwSvChrSt + 
					" [算出]課金開始年月日:" + svcStrtRslt);
			errStr = errStr + nbk + ERR_MSG_7;
			errKomk.add("wrbChrStr");
			errKomk.add("svcChrSta");
			rslt = false;
		}

		//�C割引サービス契約のサービス課金開始・終了年月日チェック
		//最速(最古) 割引サービス契約内訳 サービス開始年月日
		String uwSvcChStr = getOldestDay(
				getWrbkLst(JBSbatKK_T_WRISVC_KEI_UCWK.SVC_CHRG_STAYMD, wrbkSvcKUwList));
		//最遅(最新) 割引サービス契約内訳 サービス終了年月日
		String uwSvcChEnd = getLatestDay(
				getWrbkLst(JBSbatKK_T_WRISVC_KEI_UCWK.SVC_CHRG_ENDYMD, wrbkSvcKUwList));

		//内訳に２つ以上データがなければ、ここだけエラーにはできない
		String wrbkSvcStr = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD));
		if(!uwSvcChStr.equals(wrbkSvcStr))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" 最速の割引サービス契約内訳:サービス課金開始年月日(" +
					uwSvcChStr + ")と[割引サービス契約]サービス課金開始年月日("+ wrbkSvcStr + ")が異なる。");
			errStr = errStr + nbk + getErrMsg16("[割引サービス契約]サービス課金開始年月日:" + wrbkSvcStr, uwSvcChStr);
			errKomk.add("wrbChrStr");
			rslt = false;
		}
		String wrbkSvcEnd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD));
		if(!uwSvcChEnd.equals(wrbkSvcEnd))
		{
			commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" 最遅の割引サービス契約内訳:サービス課金終了年月日(" +
					uwSvcChEnd + ")と[割引サービス契約]サービス課金終了年月日("+ wrbkSvcEnd + ")が異なる。");
			errKomk.add("wrbChrEnd");
			errStr = errStr + nbk + getErrMsg16("[割引サービス契約]サービス課金終了年月日:" + wrbkSvcEnd, uwSvcChEnd);
			rslt = false;
		}
		//�Dサービス課金開始年月日が設定されている場合(割引サービス契約内訳)
		if(!"".equals(wrbkSvcKUwSvChrSt))
		{
			commonItem.getLogPrint().printDebugLog(
					"■割引サービス契約内訳にサービス課金開始年月日あり:" + wrbkSvcKUwSvChrSt);
			//内訳のサービス課金開始年月日からサービス課金終了年月日を算出
			String svcEndRslt = getSvsChrgEnd(wrbkSvcKUwSvChrSt);//基本 20991231
			//�@終了年月日チェック
			String svcEndYmd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD));
			if(!svcEndRslt.equals(svcEndYmd))
			{
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" 算出サービス終了年月日("
						+ svcEndRslt +")と[割引サービス契約]サービス終了年月日("+ svcEndYmd +")が異なる。");
				errStr = errStr + nbk + getErrMsg16(
						"[割引サービス契約]サービス終了年月日"+ svcEndYmd, svcEndRslt);
				errKomk.add("wrbSvcEnd");
				rslt = false;
			}
			if(!svcEndRslt.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)))
			{
				String svcChEnd = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD);
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" サービス課金終了年月日("
						+ svcEndRslt +")と[割引サービス契約]サービス課金終了年月日("+ cnvNullToEmp(
						wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)) +")が異なる。");
				errStr = errStr + nbk + getErrMsg16(
						"[割引サービス契約]サービス課金終了年月日" + svcChEnd , svcEndRslt);
				errKomk.add("wrbChrEnd");
				rslt = false;
			}
			if(!svcEndRslt.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_ENDYMD)))
			{
				String plnSvcEnd = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_ENDYMD);
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" プラン終了年月日("
						+ svcEndRslt +")と[割引サービス契約]プラン終了年月日("+ 
						cnvNullToEmp(plnSvcEnd) + ")が異なる。");
				errStr = errStr + getErrMsg16(
						"[割引サービス契約]プラン終了年月日" + plnSvcEnd, svcEndRslt);
				errKomk.add("plnEnd");
				rslt = false;
			}
			if(!svcEndRslt.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_ENDYMD)))
			{
				String plnChEnd = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.PLAN_CHRG_ENDYMD);
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" プラン課金終了年月日("
						+ svcEndRslt +")と[割引サービス契約]プラン課金終了年月日("+ 
						cnvNullToEmp(plnChEnd) + ")が異なる。");
				errStr = errStr + nbk + getErrMsg16(
						"[割引サービス契約]プラン課金終了年月日" + plnChEnd, svcEndRslt);
				errKomk.add("plnChrEnd");
				rslt = false;
			}
			//�G割引サービス契約：サービス課金終了年月日と比較(該当明細？)要確認
			//上記のチェックと同じ？
			if(!svcEndRslt.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)))
			{
				String svcChEnd = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD);
				commonItem.getLogPrint().printDebugLog(wrbkSvcKNo +" 内訳から算出した課金終了年月日("
						+ svcEndRslt +")と[割引サービス契約]サービス課金終了年月日("+ 
						cnvNullToEmp(svcChEnd) + ")が異なる。");
				errStr = errStr + nbk +"内訳から算出した課金終了年月日:" + svcEndRslt +
						" と[割引サービス契約]サービス課金終了年月日:"+ svcChEnd +"が異なる。";
				errKomk.add("wrbChrEnd");
				rslt = false;
			}
		}
		if(rslt)	commonItem.getLogPrint().printDebugLog(nbk + "エラーなし");
		return rslt;
	}

	//サービス課金開始年月日の取得
	private String getSvcChrgStr(String chrgStrtDay) throws Exception
	{
		String rslt = chrgStrtDay;
		//即時適用フラグ
		if("1".equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.APLY_JUN)))
		{
			//当日日付(登録時)なのでチェックしない？登録日 要確認
			return rslt;
		}else
		{
			//課金開始年月日を取得
			String stAdjCd = wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.STA_ADJ_CD);
			String addDay = cnvNullToZero(
					wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.STA_ADJ_PRD));

			if("0".equals(addDay)) return rslt;
			if("2".equals(stAdjCd))
			{
				//月加算
				rslt = JBSbatDateUtil.adjustMonth(chrgStrtDay, Integer.parseInt(addDay));
				commonItem.getLogPrint().printDebugLog(chrgStrtDay + " "+ addDay +" 月加算後:" + rslt);
			}
			else if("3".equals(stAdjCd))
			{
				//日加算
				rslt = JBSbatDateUtil.adjustDate(chrgStrtDay, Integer.parseInt(addDay));
				commonItem.getLogPrint().printDebugLog(chrgStrtDay + " "+ addDay +" 日加算後:" + rslt);
			}
		}
		return cnvNullToEmp(rslt);
	}

	//サービス課金終了年月日を算出
	private String getSvsChrgEnd(String svcChrgStrt) throws Exception
	{
		//サービス課金終了年月日を想定
		String svcChrgEndDay = "";
		//割引サービス詳細から、適用数判別コード・適用数を取得
		String tkyhnbtCd = wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.APLY_CNT_HAMBET_CD);
		String tkyCnt = cnvNullToZero(wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.APLY_CNT));
		if("3".equals(tkyhnbtCd) && !"0".equals(tkyCnt))
		{
			svcChrgEndDay = JBSbatDateUtil.adjustMonth(svcChrgStrt, Integer.parseInt(tkyCnt));
			commonItem.getLogPrint().printDebugLog(svcChrgStrt + " "+ tkyCnt +" (サービス課金終了)月加算後:" + svcChrgEndDay);
		}
		else if("4".equals(tkyhnbtCd) && !"0".equals(tkyCnt))
		{
			svcChrgEndDay = JBSbatDateUtil.adjustDate(svcChrgStrt, Integer.parseInt(tkyCnt));
			commonItem.getLogPrint().printDebugLog(svcChrgStrt + " "+ tkyCnt +" (サービス課金終了)日加算後:" + svcChrgEndDay);
		}else if("0".equals(tkyCnt))
		{
			svcChrgEndDay = JKKBatConst.S_MAX_DATE;
		}
		return svcChrgEndDay;
	}

	//サービス課金終了年月日を算出(変更前)
	private String getSvsChrgEnd_(String svcChrgStrt) throws Exception
	{
		//サービス課金終了年月日を想定
		String svcChrgEndDay = "";
//		boolean rslt = false;

//		if(!"".equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CANCEL_YMD)) ||
//				!"".equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_YMD)))
//		{
//			String prgrIdoDay = prgrsMap.getString(JBSbatKK_T_PRG.IDO_DTM).substring(0, 8);
//			String wrbkSvcKSvcEnd = wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD);
//			if(!prgrIdoDay.equals(wrbkSvcKSvcEnd))
//			{
//				return rslt;
//			}
//		}else
//		{
		//割引サービス詳細から、適用数判別コード・適用数を取得
		String tkyhnbtCd = wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.APLY_CNT_HAMBET_CD);
		String tkyCnt = cnvNullToZero(wrbkSvcDtlM.getString(JBSbatKK_M_WRIB_SVC_DTL.APLY_CNT));
		if("3".equals(tkyhnbtCd) && !"".equals(tkyCnt) && !"0".equals(tkyCnt))
		{
			svcChrgEndDay = JBSbatDateUtil.adjustMonth(svcChrgStrt, Integer.parseInt(tkyCnt));
		}
		else if("4".equals(tkyhnbtCd) && !"".equals(tkyCnt) && !"0".equals(tkyCnt))
		{
			svcChrgEndDay = JBSbatDateUtil.adjustDate(svcChrgStrt, Integer.parseInt(tkyCnt));
		}else if("0".equals(tkyCnt))
		{
			svcChrgEndDay = JKKBatConst.S_MAX_DATE;
		}
//		}
//		//割引サービス契約内訳明細：サービス開始日の最速と異なればエラー
//		if(wbSvcKSvcSt.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD)))
//		{
//			return rslt;
//		}
//		//割引サービス契約内訳明細：サービス終了日の最遅と異なればエラー
//		if(wbSvcKSvcEnd.equals(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)))
//		{
//			return rslt;
//		}
		return svcChrgEndDay;
	}

	//指定項目をリスト化
	private ArrayList<String> getWrbkLst(String dbKomk,
			ArrayList<JBSbatCommonDBInterface> wrbkSvcKlst) throws Exception
	{
		ArrayList<String> lst = new ArrayList<String>();
		
		for(JBSbatCommonDBInterface wrbkMap : wrbkSvcKlst)
		{
			lst.add(cnvNullToEmp(wrbkMap.getString(dbKomk)));
		}
		return lst;
	}

	//最遅日を取得(過去)
	private String getOldestDay(ArrayList<String> dateLst)
	{
		//昇順ソート
		Collections.sort(dateLst);
		return dateLst.get(0);
	}

	//最速日を取得(最新)
	private String getLatestDay(ArrayList<String> dateLst) 
	{
		//降順ソート
		Collections.sort(dateLst);
		Collections.reverse(dateLst);
		return dateLst.get(0);
	}

	//必須項目チェック
	private boolean checkParm()
	{
		if(null == prmStartDay||"".equals(prmStartDay))
		{
			commonItem.getLogPrint().printDebugLog("必須項目：開始年月日がありません。");
			return false;
		}else if(null == prmEndDay||"".equals(prmEndDay))
		{
			commonItem.getLogPrint().printDebugLog("必須項目：終了年月日がありません。");
			return false;
		}
		//日付チェック
		if(!JBSbatDateUtil.checkDate(prmStartDay, 8))
		{
			commonItem.getLogPrint().printDebugLog("日付ではありません。開始日:" + prmStartDay);
			return false;
		}
		if(!JBSbatDateUtil.checkDate(prmEndDay, 8))
		{
			commonItem.getLogPrint().printDebugLog("日付ではありません。終了日:" + prmEndDay);
			return false;
		}

		//相関チェック
		if(prmStartDay.compareTo(prmEndDay) > 0)
		{
			commonItem.getLogPrint().printDebugLog("相関チェック：開始年月日の方が未来。"
					+ "開始:" + prmStartDay + " 終了:" + prmEndDay);
			return false;
		}
		return true;
	}

	//キャンペーン開始コードにより課金開始年月日を算出
	private String getChrgStrtDay(String cmpCd) throws Exception
	{
		String rslt = "";
		commonItem.getLogPrint().printDebugLog("キャンペーン開始コード_" + cmpCd);
		if("01".equals(cmpCd))
		{
			//最古サービス課金開始年月日
			rslt = getOldestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD, svcKeiList));
		}
		else if("02".equals(cmpCd))
		{
			//最古サービス開始年月日
			rslt = getOldestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_STA_YMD, svcKeiList));
		}
		else if("03".equals(cmpCd))
		{
			//割引を登録した年月日(申込年月日)
			//申込明細　要検索  サービス契約の申込明細番号 から
			rslt = getMskmYmd(wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.MSKM_DTL_NO));
		}
		else if("04".equals(cmpCd))
		{
			//割引を登録した翌月１日(申込年月日の翌月)
			rslt = getFirstOfNextMonth(
					getMskmYmd(wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.MSKM_DTL_NO)));
		}
		else if("05".equals(cmpCd))
		{
			String mskmYmd = getMskmYmd(wrbkSvcKMap.getString(JBSbatKK_T_SVC_KEI.MSKM_DTL_NO));
			//翌月初日を設定 引数：割引を登録した日
			if("".equals(mskmYmd) || 8 != mskmYmd.length())
			{
				rslt = "";
			}
			else if("01".equals(mskmYmd.substring(6, 8)))
			{
				rslt = mskmYmd;
			}
			else
			{
				rslt = getFirstOfNextMonth(mskmYmd);
			}
		}
		else if("06".equals(cmpCd))
		{
			//最古サービス課金開始年月日
			String oldestChrSt = getOldestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD, svcKeiList));
			if("".equals(oldestChrSt) || 8 > oldestChrSt.length())
			{
				rslt = "";
			}
			else
			{
				//前月１日
				rslt = JBSbatDateUtil.adjustMonth(oldestChrSt, -1).substring(0, 6) + "01";
			}
		}
		else if("07".equals(cmpCd))
		{
			//プラン変更完了日 要確認
			rslt = svcKeiMap.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_STAYMD);
		}
		else if("08".equals(cmpCd))
		{
			//機種変更完了日かどうやって判定？要確認
			rslt = svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD);
		}
		else if("09".equals(cmpCd))
		{
			if(null != kktkSvcKeiMap)
			{
				//配送検索
				rslt = getHaiso(
						kktkSvcKeiMap.getString(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_KEI_NO));

//				rslt = getHaiso(getHaisoTgBpn(
//						kktkSvcKeiMap.getString(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_KEI_NO)));
			}
		}
		else if(campaignStaCdWribSet.contains(cmpCd))
		{
			rslt=getChrgStrtDayWrib(cmpCd);
		}
		return cnvNullToEmp(rslt);
	}
	//異動区分によるチェック
	private boolean checkIdoKbn(String ido) throws Exception
	{
		boolean rslt = true;
//		commonItem.getLogPrint().printDebugLog(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO));
		if("2".equals(ido))//キャンセル
		{
			commonItem.getLogPrint().printDebugLog(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO));
			cnclDslFlg = true;
			if(!CharacterCheck.isNotNullCheck(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CANCEL_YMD)))
					//&&(!CharacterCheck.isNotNullCheck(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CANCEL_YMD))))
			{
				commonItem.getLogPrint().printDebugLog(ERR_MSG_3);
				errStr = ERR_MSG_3;
				errKomk.add("wrbCncl");
				rslt = false;
			}
		}
		else if("1".equals(ido))//解約
		{
			cnclDslFlg = true;
			String dsl = "[解約]";
			//サービス解約年月日 存在チェック
//			if(!CharacterCheck.isNotNullCheck(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD)))
			if(!CharacterCheck.isNotNullCheck(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_YMD)))
			{
				commonItem.getLogPrint().printDebugLog(ERR_MSG_4);
				errStr = dsl + ERR_MSG_4;
				errKomk.add("wrbSvcDsl");
				rslt = false;
			}
			//サービス終了年月日,存在チェック
			if(!CharacterCheck.isNotNullCheck(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD)))
			{
				commonItem.getLogPrint().printDebugLog(ERR_MSG_5);
				errStr = errStr + dsl + ERR_MSG_5;
				errKomk.add("wrbSvcEnd");
				rslt = false;
			}
			//サービス課金終了年月日,存在チェック
			if(!CharacterCheck.isNotNullCheck(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD)))
			{
				commonItem.getLogPrint().printDebugLog(ERR_MSG_6);
				errStr = errStr + dsl + ERR_MSG_6;
				errKomk.add("wrbChrEnd");
				rslt = false;
			}

			//割引サービス.サービス解約年月日 = サービス契約.サービス解約年月日 チェック
			String wrbkSvcDsl = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_YMD));
			String svcDsl = cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD));
			if(!wrbkSvcDsl.equals(svcDsl))
			{
				commonItem.getLogPrint().printDebugLog(
						getErrMsg18("サービス解約年月日:"+ wrbkSvcDsl + " " + svcDsl));
				errStr = errStr + dsl + getErrMsg18("サービス解約年月日:" + wrbkSvcDsl + " " + svcDsl);
				errKomk.add("wrbSvcDsl");
				errKomk.add("svcDslYmd");
				rslt = false;
			}

			//割引サービス契約:サービス解約日の月末とサービス終了年月日は等しいはず
			String endOfMonth = getYmdLastOfThisM(
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_DSL_YMD));
			String svcEnd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD));
			if(!endOfMonth.equals(svcEnd))
			{
				commonItem.getLogPrint().printDebugLog(
						"割引サービス契約:サービス解約日の月末とサービス終了年月日"
						+ svcEnd + "が異なる。");
				errStr = errStr + dsl + "サービス解約日の月末とサービス終了年月日が異なる(割引サービス契約)";
				errKomk.add("wrbSvcDsl");
				errKomk.add("wrbSvcEnd");
				rslt = false;
			}
			//サービス課金終了年月日とサービス終了年月日は等しいはず(共に割引サービス契約)
			if(!cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_ENDYMD)).equals(
					cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD))))
			{
				commonItem.getLogPrint().printDebugLog("[割引サービス契約]" +
						"サービス課金終了年月日とサービス終了年月日が異なる。");
				errKomk.add("wrbChrEnd");
				errKomk.add("wrbSvcEnd");
				errStr = errStr + dsl + "サービス課金終了年月日とサービス終了年月日が異なる(割引サービス契約)";
				rslt = false;
			}
		}
		return rslt;
	}

	//解約系判定
	private String checkKaiyaku(String ido) throws Exception
	{
		String rslt = "0";
		String prgSta = prgrsMap.getString(JBSbatKK_T_PRG.PRG_STAT);
		if("00005".equals(ido) && "1304".equals(prgSta))
		{
			rslt = "1";
		}
		else if("00006".equals(ido) && "1304".equals(prgSta))
		{
			rslt = "1";
		}
		else if("00007".equals(ido) && "2204".equals(prgSta))
		{
			rslt = "1";//モバイル？
		}
		else if("00043".equals(ido) && "1304".equals(prgSta))
		{
			rslt = "1";
		}
		else if("00008".equals(ido) && "1201".equals(prgSta))
		{
			rslt = "2";
		}
		return rslt;
	}

	//続行するか判定
	private boolean checkContinue() throws Exception
	{
		boolean rslt = false;
		if(autoJudge && autoCheckRslt)
		{
			if(null == wrbkSvcTgMap)
			{
				errStr = ERR_MSG_1;
				outputBeanErr.addOutMapList_2(setRcvInfo());
				return rslt;
				//continue outPrg;	//なければ、次の進捗データへ
			}
		}
		else if(autoJudge && !autoCheckRslt)
		{
			if(null != wrbkSvcTgMap)
			{
				errStr = ERR_MSG_2;
				outputBeanErr.addOutMapList_2(setRcvInfo());
				return rslt;
				//continue outPrg;	//エラー出力後、次の進捗データへ
			}else
			{
				return rslt;
				//continue outPrg;	//次の進捗データへ
			}
		}else if(!autoJudge)
		{
			if(null == wrbkSvcTgMap)
			{
				errStr = "割引サービス契約明細が存在しませんでした。";
				outputBeanErr.addOutMapList_2(setRcvInfo());
				return rslt;
				//continue outPrg;	//なければ、次の進捗データへ
			}
		}
		return true;
	}

	//割引サービスコードを元に、割引サービス情報を取得
	private boolean checkWrbkSvcInfo() throws Exception
	{
		boolean rslt = true;
		String kbt = "[個別]";
		String wrbkType = cnvNullToEmp(wrbkSvcM.getString(JBSbatKK_M_WRIB_SVC.WRIB_TYPE_CD));
		String wrbkSvcCd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.WRIB_SVC_CD));
		//ファミリーパック、割賦契約割引・一括契約割引、ハイブリッド割引
		if("20".equals(wrbkType)||"42".equals(wrbkType)||"W00000061".equals(wrbkSvcCd))
		{
			kobetlFlg = true;
			String svcChrgStrt = "";
			String wrbkSvcNm = wrbkSvcM.getString(JBSbatKK_M_WRIB_SVC.WRIB_SVC_NM);
			if("20".equals(wrbkType))
			{
				svcChrgStrt = cnvNullToEmp(optSvcKMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CHRG_STAYMD));
			}else
			{
				svcChrgStrt = cnvNullToEmp(svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD));
			}

			String svcKNo = svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO);
			if(!svcChrgStrt.equals(
					wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_STAYMD)))
			{
				commonItem.getLogPrint().printDebugLog(svcKNo + " 割引タイプ:" + wrbkSvcNm +
						" 個別設定：サービス課金開始年月日が異なる。");
				errKomk.add("wrbChrStr");
				errKomk.add("svcChrSta");
				errStr = kbt + ERR_MSG_7;
				rslt = false;
			}
			//サービス契約：サービス課金開始年月日の２４ヶ月後
			String twoYyrsAf = JBSbatDateUtil.adjustMonth(svcChrgStrt, 24);
			String wrbkSvsChEnd = cnvNullToEmp(wrbkSvcKMap.getString(JBSbatKK_T_WRIB_SVC_KEI.SVC_CHRG_ENDYMD));
			if(!twoYyrsAf.equals(wrbkSvsChEnd))
			{
				commonItem.getLogPrint().printDebugLog(svcKNo + " 割引タイプ:" + wrbkSvcNm +
						" 個別設定：割引サービス課金終了年月日が異なる。(24ヶ月後)" + twoYyrsAf + ":" + wrbkSvsChEnd);
				errKomk.add("wrbChrEnd");
//				errStr = errStr + kbt + getErrMsg16("サービス課金終了年月日:" + wrbkSvsChEnd + "(24ヶ月後ではない)");
				errStr = errStr + kbt + getErrMsg16(
						"サービス課金終了年月日:" + wrbkSvsChEnd + "(24ヶ月後ではない)", twoYyrsAf);
				rslt = false;
			}
		}
		return rslt;
	}

	//自動適用CCにセット
	private boolean autoCcCheck(String svcKeiNo) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_USECASE_ID, "KVSV0001");
		
		// サービスに渡す業務データを格納するMAPです。
		HashMap<String, Object> inputMap = new HashMap<String, Object>();
		// inputMapに設定するデータをHashMapで構築する。
		HashMap<String, String> dataMap = new HashMap<String, String>();

		//割引自動適用チェックマップ
		inputMap.put("KVSV000101CC", dataMap);
		//登録／変更区分
		dataMap.put("add_chge_div", "0");

//		svcKeiMap = getSvcKei(prgrsMap.getString(JBSbatKK_T_PRG.SVC_KEI_NO));
		//null の場合あり？
		String[] param = {svcKeiMap.getString(JBSbatKK_T_SVC_KEI.MSKM_DTL_NO)
				        , svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SYSID)};
		if(null == param[0])
		{
			commonItem.getLogPrint().printDebugLog("自動適用check: 申込明細番号なし");
			return false;
		}
		if(null == param[1])
		{
			commonItem.getLogPrint().printDebugLog("自動適用check: SYSIDなし");
			return false;
		}

		executeKK_T_MSKM_KV_SELECT_002(param);

		JBSbatCommonDBInterface getDataMap = db_KK_T_MSKM.selectNext();
		if(null != getDataMap)
		{
			//ＳＹＳＩＤ
			dataMap.put("sysid", svcKeiMap.getString(JBSbatKK_T_SVC_KEI.SYSID));
			//申込番号
			dataMap.put("mskm_no", getDataMap.getString(JBSbatKK_T_MSKM.MSKM_NO));
			//申込種別コード
			dataMap.put("mskm_sbt_cd",getDataMap.getString(JBSbatKK_T_MSKM.MSKM_SBT_CD));
			//異動区分
			dataMap.put("ido_div", prgrsMap.getString(JBSbatKK_T_PRG.IDO_DIV));
			//機能コード
			dataMap.put("func_code", "2");
			// サービスの処理結果が格納されるMAP
			HashMap<String, Object> outputMap = new HashMap<String, Object>();
			
			//サービス契約照査チェック(API)を呼び出します。
			JCCBatchEsbInterface.invokeService(commonItem, paramMap, inputMap, outputMap);
			
			// リターンコードが正常以外の場合、次進捗へ
			returnCode = outputMap.get(JCCBatchEsbInterface.RETURN_CODE).toString();
			
			// サービスの処理結果が格納されたoutputMapから指定したキーで値を取得する。
			HashMap<String, String> resultMap = (HashMap<String, String>)outputMap.get("KVSV000101CC");
			commonItem.getLogPrint().printDebugLog("自動適用CCリターンCD:" 
					+ resultMap.get("WrisvcAutoAplyChk"));
			
			if("1".equals(resultMap.get("WrisvcAutoAplyChk")))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			commonItem.getLogPrint().printDebugLog("申込明細なし");
			return false;
		}
	}

	//エラー内容に＊または！を表示するかの判定
	private String checkErrNya() throws Exception
	{
		String rslt = "*";
		if(null == wrbkSvcM) return rslt;
		String type = wrbkSvcM.getString(JBSbatKK_M_WRIB_SVC.WRIB_TYPE_CD);
		if("30".equals(cnvNullToEmp(type)))
		{
			rslt = "!";
		}
		return rslt;
	}
	/** メッセージ16 */
	private String getErrMsg16(String para, String rslt) 
	{
		para = cnvNullToEmp(para);
		rslt = cnvNullToEmp(rslt);
		
		return "算出結果("+ rslt +")と設定値(" + para + ")が異なります。";
	}
	//追加メッセージ
	private String getErrMsg18(String para) {
		return  para + "がサービス契約と割引サービス契約で異なります。";
	}
	
	//指定月の翌月１日を算出する
	private String getFirstOfNextMonth(String ymd)
	{
		if(null == ymd||"".equals(ymd)) return "";
		String endOfMonth = JBSbatDateUtil.getEndOfMonth(ymd.substring(0, 6));
		return JBSbatDateUtil.adjustDate(ymd.substring(0, 6) + endOfMonth ,1);
	}

	//指定月の末日を算出後、年月日で返す
	private String getYmdLastOfThisM(String ymd)
	{
		if(null == ymd||"".equals(ymd)) return "";
		String ym = ymd.substring(0, 6);
		return ym + JBSbatDateUtil.getEndOfMonth(ym);
	}

	//右に"000000000" 追加
	public String padRightZro(String prm, int len) throws Exception
	{
		if(null == prm)
		{
			return "";
		}
		//空白の場合
		if("".equals(prm))
		{
			return "";
		}
		String rslt = JBSbatStringUtil.adjustCharSize(prm, len, "");
		return rslt.replace(" ", "0");
//		StringBuilder rslt = new StringBuilder(prm);
//		rslt = rslt.append("000000000"); //17
//		return String.valueOf(rslt);
	}

	//文字列の後ろに任意文字列を補填する
	public String padRightSpc(String para, int len) throws Exception
	{
		if(null == para)
		{
			return "";
		}
		//空白の場合
		if("".equals(para))
		{
			return "";
		}
		return JBSbatStringUtil.adjustCharSize(para, len, "");
	}

	/**
	 * null → ""に変換するメソッド
	 * @param val 文字列
	 * @return 変換後文字列
	 */
	private String cnvNullToEmp(String val)
	{
		String rslt = val;
		if( null == val)
		{
			rslt = "";
		}
		return rslt;
	}

	/**
	 * nullまたは "" をゼロに変換するメソッド
	 * @param val 文字列
	 * @return 変換後文字列
	 */
	private String cnvNullToZero(String val)
	{
		String rslt = val;
		if( null == val ||"".equals(val))
		{
			rslt = "0";
		}
		return rslt;
	}
	//エラーログ出力
	private void notFoundError(String[] params) throws Exception
	{
		params[1] = " " + params[1] + " ";
		// エラーフラグ設定
		super.commonItem.setErrFlg(true);
		commonItem.getLogPrint().printBusinessErrorLog("EKKB0630NW", params);
//%1%テーブルに%2%が存在しません。
//		commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.EKKB0210CE, params);
//		throw new JBSbatBusinessError();
	}


	/**
	 * キャンペーン開始コードに従って、
	 * サービス課金開始年月日の算出に必要な情報を取得し、
	 * 相関ルール：課金開始日設定定義（割引サービス）の呼び出しを行い、
	 * サービス課金開始年月日を算出し返却します。
	 * <br>
	 * @param campaignStaCd キャンペーン開始コード
	 * @return サービス課金開始年月日
	 * @throws Exception
	 */
	private String getChrgStrtDayWrib(String campaignStaCd)
			throws Exception {

		//割引登録年月日 
	    final String KK0451_WRIB_ADD_YMD="WRIB_ADD_YMD";
		//割引額算出基準年月日
	    final String KK0451_WRIB_AMNT_SNST_STDARDYMD="WRIB_AMNT_SNST_STDARDYMD";
		//割引課金開始月指定コード
	    final String KK0451_WRIB_CHRG_STA_MON_STI_CD="WRIB_CHRG_STA_MON_STI_CD";

		//割引登録年月日 
		String wribAddYmd=wrbkSvcKMap.getString(KK0451_WRIB_ADD_YMD);
		//割引額算出基準年月日
		String wribAmntSnstStdardymd=wrbkSvcKMap.getString(KK0451_WRIB_AMNT_SNST_STDARDYMD);
		//割引課金開始月指定コード
		String wribChrgStaMonStiCd=wrbkSvcKMap.getString(KK0451_WRIB_CHRG_STA_MON_STI_CD);

		//サービス照査年月日(ネット) サービス契約中の最新サービス照査年月日とみなしてよい
		String svcShosaYmdNet=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SHOSA_YMD, svcKeiList));
		//サービス開始年月日(ネット) サービス契約中の最新サービス開始年月日とみなしてよい
		String svcStaYmdNet=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_STA_YMD, svcKeiList));
		//サービス課金開始年月日(ネット) サービス契約中の最新サービス課金開始年月日とみなしてよい
		String svcChrgStaymdNet=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD, svcKeiList));
		//サービス開始年月日(電話) サービス契約中の最新サービス開始年月日とみなしてよい
		String svcStaYmdTel=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_STA_YMD, svcKeiList));
		//サービス課金開始年月日(電話) サービス契約中の最新サービス課金開始年月日とみなしてよい
		String svcChrgStaymdTel=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD, svcKeiList));
		//サービス開始年月日(TV) サービス契約中の最新サービス開始年月日とみなしてよい
		String svcStaYmdTv=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_STA_YMD, svcKeiList));
		//サービス課金開始年月日(モバイル) サービス契約中の最新サービス課金開始年月日とみなしてよい
		String svcChrgStaymdMob=getLatestDay(getWrbkLst(JBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMD, svcKeiList));
		
		return resolveChrgStrtDayWrib(campaignStaCd, wribAddYmd, wribAmntSnstStdardymd, wribChrgStaMonStiCd, svcShosaYmdNet, svcStaYmdNet, svcChrgStaymdNet, svcStaYmdTel, svcChrgStaymdTel, svcStaYmdTv, svcChrgStaymdMob);
			
	}

	/**
	 * キャンペーン開始コードに従って、
	 * 相関ルール：課金開始日設定定義（割引サービス）の呼び出しを行い、
	 * サービス課金開始年月日を算出し返却します。
	 * <br>
	 * @param campaignStaCd キャンペーン開始コード
	 * @param wribAddYmd 割引登録年月日
	 * @param wribAmntSnstStdardymd 割引額算出基準年月日
	 * @param wribChrgStaMonStiCd 割引課金開始月指定コード
	 * @param svcShosaYmdNet サービス照査年月日(ネット)
	 * @param svcStaYmdNet サービス開始年月日(ネット)
	 * @param svcChrgStaymdNet サービス課金開始年月日(ネット)
	 * @param svcStaYmdTel サービス開始年月日(電話)
	 * @param svcChrgStaymdTel サービス課金開始年月日(電話)
	 * @param svcStaYmdTv サービス開始年月日(TV)
	 * @param svcChrgStaymdMob サービス課金開始年月日(モバイル)
	 * @return サービス課金開始年月日
	 * @throws Exception
	 */
	private String resolveChrgStrtDayWrib(String campaignStaCd,
			String wribAddYmd, String wribAmntSnstStdardymd,
			String wribChrgStaMonStiCd, String svcShosaYmdNet,
			String svcStaYmdNet, String svcChrgStaymdNet, String svcStaYmdTel,
			String svcChrgStaymdTel, String svcStaYmdTv, String svcChrgStaymdMob)
			throws Exception {
		//キャンペーン開始コードが処理対象のものであることをチェック。
		if(!campaignStaCdWribSet.contains("CD" + campaignStaCd)){
			return "";
		}
		
		CampaignStaCdWribEnum campaignStaCdWribEnum;
		
		campaignStaCdWribEnum = CampaignStaCdWribEnum.valueOf("CD" + campaignStaCd);

		//割引サービス契約サービス課金開始年月日
		String wribSvcKeiChrgStaymd;
		
		//キャンペーン開始コードに応じた入力に対して、
		//項目チェックを行い、
		//割引サービス課金開始年月日のルールによる導出を行う。
		
		switch(campaignStaCdWribEnum){
		case CD51:
			//項目チェックエラーの場合は導出対象としない
			if(!isGenuineDateStyle(svcChrgStaymdNet)&&!isGenuineDateStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcChrgStaymdNet, "", wribAddYmd, "");
			break;
		case CD52:
			//項目チェックエラーの場合は導出対象としない
			if(!isGenuineDateStyle(svcChrgStaymdNet)&&!isGenuineDateStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcChrgStaymdNet, "", wribAddYmd, "");
			break;
		case CD53:
			//項目チェックエラーの場合は導出対象としない
			if(!isGenuineDateStyle(svcStaYmdNet)&&!isGenuineCodeStyle(wribChrgStaMonStiCd)){
				return "";
			}

			//割引額算定基準年月日が空ではなくかつ項目チェックエラーの場合は導出対象としない
			boolean isEmptyWribAmntSnstStdardymd=(null==wribAmntSnstStdardymd)||("".equals(wribAmntSnstStdardymd));
			if(!isEmptyWribAmntSnstStdardymd&&!isGenuineDateStyle(wribAmntSnstStdardymd)){
				return "";
			}
			
			//割引額算定基準年月日が空の場合はサービス開始年月日（ネット）を割引額算定基準年月日とする。
			wribAmntSnstStdardymd=isEmptyWribAmntSnstStdardymd?svcStaYmdNet:wribAmntSnstStdardymd;
			
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, wribAmntSnstStdardymd, "", wribAddYmd, wribChrgStaMonStiCd);
			break;
		case CD54:
			if(!isGenuineDateStyle(svcStaYmdNet)&&!isGenuineCodeStyle(svcStaYmdTv)&&!isGenuineCodeStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcStaYmdNet, svcStaYmdTv, wribAddYmd, "");
			break;
		case CD55:
			if(!isGenuineDateStyle(svcChrgStaymdNet)&&!isGenuineCodeStyle(svcChrgStaymdTel)&&!isGenuineCodeStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcChrgStaymdNet, svcChrgStaymdTel, wribAddYmd, "");
			break;
		case CD56:
			if(!isGenuineDateStyle(svcStaYmdTel)&&!isGenuineCodeStyle(svcStaYmdTv)&&!isGenuineCodeStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcStaYmdTel, svcStaYmdTv, wribAddYmd, "");
			break;
		case CD57:
			if(!isGenuineDateStyle(svcShosaYmdNet)&&!isGenuineCodeStyle(svcChrgStaymdMob)&&!isGenuineCodeStyle(wribAddYmd)){
				return "";
			}
			wribSvcKeiChrgStaymd=resolveChrgStaYmdRule0089(campaignStaCd, svcShosaYmdNet, svcChrgStaymdMob, wribAddYmd, "");
			break;
		default:
			return "";
		}
		return wribSvcKeiChrgStaymd;
	}




	/**
	 * 引数の形式の正当性(半角数字8桁)を確認し結果を返却します。
	 * <br>
	 * @param target 確認対象
	 * @return boolean 成否
	 */
	private boolean isGenuineDateStyle(String target) {
		return (target==null)?false:target.matches("^\\d\\{8\\}$");
	}

	/**
	 * 引数の形式の正当性(半角数字1桁)を確認し結果を返却します。
	 * <br>
	 * @param target 確認対象
	 * @return boolean 成否
	 */
	private boolean isGenuineCodeStyle(String target) {
		return (target==null)?false:target.matches("^\\d$");
	}

	/**
	 * 相関ルール：課金開始日設定定義（割引サービス）の呼び出しを行い、
	 * サービス課金開始年月日を算出し返却します。
	 * <br>
	 * @return String RULE89の結果により算出した日付
	 * @throws Exception メソッド内で発生した例外全般。
	 */
	private String resolveChrgStaYmdRule0089(String campaignStaCd,String baseYmd1,String baseYmd2,String wribAddYmd,String wribChrgStaMonStiCd) throws Exception
	{

		//割引適用基準年月日判定情報
		String judgeWribTekioStdardymd= callRule0089001(campaignStaCd, baseYmd1, baseYmd2,wribAddYmd);
		//割引適用基準年月日
		String wribTekioStdardymd="";
		
		//割引適用基準年月日判定情報 基準日１
		final String RULE_0089001_RESULT_1_BASE_YMD_1="1";
		//割引適用基準年月日判定情報 基準日２
		final String RULE_0089001_RESULT_2_BASE_YMD_2="2";
		//割引適用基準年月日判定情報 基準日１の26ヶ月目の1日
		final String RULE_0089001_RESULT_9_BASE_YMD_1_AFTER="9";
		
		if(RULE_0089001_RESULT_1_BASE_YMD_1.equals(judgeWribTekioStdardymd)){
			//基準日１
			wribTekioStdardymd=baseYmd1;
		}
		if(RULE_0089001_RESULT_2_BASE_YMD_2.equals(judgeWribTekioStdardymd)){
			//基準日２
			wribTekioStdardymd=baseYmd2;
		}
		if(RULE_0089001_RESULT_9_BASE_YMD_1_AFTER.equals(judgeWribTekioStdardymd)){
			//基準日１の26ヶ月目の1日
			
			//基準日１の26ヶ月目
			String afterMonthYmd=JCCBatCommon.addMonth(baseYmd1, 26);
			//基準日１の26ヶ月目の1日
			wribTekioStdardymd=toFirstMonthDayYmd(afterMonthYmd);
		}

		if("".equals(wribTekioStdardymd)){
			return "";
		}

		//割引サービス課金開始年月日判定情報
		String judgeChrgStaYmd= callRule0089002(campaignStaCd,wribAddYmd,wribTekioStdardymd,wribChrgStaMonStiCd);
		//割引サービス課金開始年月日
		String chrgStaYmd="";
		
		//割引適用基準年月日判定情報 割引適用基準年月日
		final String RULE_0089002_RESULT_1_WRIB_TEKIO_STDARDYMD="1";
		//割引適用基準年月日判定情報 割引登録年月日の翌月１日
		final String RULE_0089002_RESULT_2_WRIB_ADD_YMD_NEXT_MONTH_FIRST_DAY="2";
		//割引適用基準年月日判定情報 割引登録年月日の前月１日
		final String RULE_0089002_RESULT_3_WRIB_ADD_YMD_PREV_MONTH_FIRST_DAY="3";
		//割引適用基準年月日判定情報 割引登録年月日の当月１日
		final String RULE_0089002_RESULT_4_WRIB_ADD_YMD_FIRST_DAY="4";
		//割引適用基準年月日判定情報 割引適用基準年月日の当月１日
		final String RULE_0089002_RESULT_5_WRIB_TEKIO_STDARDYMD_FIRST_DAY="5";

		
		
		if(RULE_0089002_RESULT_1_WRIB_TEKIO_STDARDYMD.equals(judgeChrgStaYmd)){
			//割引適用基準年月日
			chrgStaYmd=wribTekioStdardymd;
		}
		if(RULE_0089002_RESULT_2_WRIB_ADD_YMD_NEXT_MONTH_FIRST_DAY.equals(judgeChrgStaYmd)){
			//割引登録年月日の翌月１日
			chrgStaYmd=toFirstMonthDayYmd(JCCBatCommon.addMonth(wribAddYmd, 1));
		}
		if(RULE_0089002_RESULT_3_WRIB_ADD_YMD_PREV_MONTH_FIRST_DAY.equals(judgeChrgStaYmd)){
			//割引登録年月日の前月１日
			chrgStaYmd=toFirstMonthDayYmd(JCCBatCommon.addMonth(wribAddYmd, -1));
		}
		if(RULE_0089002_RESULT_4_WRIB_ADD_YMD_FIRST_DAY.equals(judgeChrgStaYmd)){
			//割引登録年月日の当月１日
			chrgStaYmd=toFirstMonthDayYmd(wribAddYmd);
		}
		if(RULE_0089002_RESULT_5_WRIB_TEKIO_STDARDYMD_FIRST_DAY.equals(judgeChrgStaYmd)){
			//割引適用月の当月１日(割引適用基準年月日の当月１日)
			chrgStaYmd=toFirstMonthDayYmd(wribTekioStdardymd);
		}

		return chrgStaYmd;
	}

	/**
	 * @param ymd
	 * @return
	 */
	private String toFirstMonthDayYmd(String ymd) {
		return JCCBatCommon.toYearFromYmd(ymd)+JCCBatCommon.toMonthFromYmd(ymd)+"01";
	}

	/**
	 * @param campaignStaCd
	 * @param baseYmd1
	 * @param baseYmd2
	 * @param wribAddYmd
	 * @return
	 * @throws ParseException
	 */
	private String callRule0089001(String campaignStaCd, String baseYmd1,
			String baseYmd2, String wribAddYmd) throws ParseException {
		//割引サービス契約の割引登録年月日の月初
		String wribAddYmdFirst=toFirstMonthDayYmd(wribAddYmd);
		//割引サービス契約の割引登録年月日の翌月月初
		String wribAddYmdYkgtuFirst=JCCBatCommon.addMonth(wribAddYmdFirst, 1);

		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("CAMPAIGN_STA_CD", campaignStaCd);
		map.put("BASE_YMD_1", baseYmd1);
		map.put("BASE_YMD_2", baseYmd2);
		map.put("WRIB_ADD_YMD_FIRST", wribAddYmdFirst);
		map.put("WRIB_ADD_YMD_YKGTU_FIRST", wribAddYmdYkgtuFirst);
		
		// ルールの呼び出し
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0089001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		if(resultList.get(0)==null){
			return "";
		}
		//ルール出力(割引適用基準年月日)
		String judgeRslt=(String)resultList.get(0).get(0).get("JUDGE_RSLT");
		return judgeRslt;
	}
	/**
	 * @param campaignStaCd
	 * @param baseYmd1
	 * @param baseYmd2
	 * @param wribAddYmd
	 * @return
	 * @throws ParseException
	 */


	private String callRule0089002(String campaignStaCd,String wribAddYmd,String wribTekioStdardymd,String wribChrgStaMonStiCd) throws ParseException {

		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("CAMPAIGN_STA_CD", campaignStaCd);
		map.put("WRIB_ADD_YMD", wribAddYmd);
		map.put("WRIB_TEKIO_STDARDYMD", wribTekioStdardymd);
		map.put("WRIB_CHRG_STA_MON_STI_CD", wribChrgStaMonStiCd);
		
		// ルールの呼び出し
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0089002", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		if(resultList.get(0)==null){
			return "";
		}
		//ルール出力(割引サービス課金開始年月日)
		String judgeRslt=(String)resultList.get(0).get(0).get("JUDGE_RSLT");
		return judgeRslt;
	}

}