/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatKKTgOpSvcKeiStaBase
*	ソースファイル名	：JBSbatKKTgOpSvcKeiStaBase.java
*	作成者				：富士通　
*	作成日				：2014年08月04日
*＜機能概要＞
*　オプションサービス契約サービス開始機能の基底クラスです
*　注意　）排他制御は呼び出し元で行うこと。
*　継承元）JBSBatKKKkOpSvkeiStAdRun
*　メモ　）2014/8/5 JBSbatKKTgOpSvcKeiUpdと双子資産
*　　　　　※将来的にはJBSbatKKTgOpSvcKeiUpdも継承させる方針
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v9.00.00	2014/08/05   富士通		新規作成【OM-2014-0002580】障害対応
*	v12.00.00	2015/01/19	 富士通)柿坂		【OM-2014-0003115】障害対応
*   v22.00.00	2015/12/28	 FJ)余野木			【ANK-2732-00-00】プロジェクト正常化 サービス開始に関するソース可読性向上
*********************************************************************/
package eo.business.service;

import java.util.ArrayList;
import java.util.HashMap;

import com.fujitsu.futurity.rule.common.JRuleXMLHandler;
import com.fujitsu.futurity.rule.xml.compare.JRuleXMLPattern;

import eo.business.common.JBSbatBusinessService;
import eo.business.common.JBSbatKKConst;
import eo.business.common.JCCBatCommon;
import eo.business.common.JKKBatCommon;
import eo.business.util.file.JBSbatKKIFM030;
import eo.business.util.table.JBSbatCH_M_PRC_SCHDL_TEIGI;
import eo.business.util.table.JBSbatDK_T_HAISO;
import eo.business.util.table.JBSbatKK_T_KAP_KEI;
import eo.business.util.table.JBSbatKK_T_KKOP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_MSKM;
import eo.business.util.table.JBSbatKK_T_OPSVKEI_ISP;
import eo.business.util.table.JBSbatKK_T_OP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.common.constant.JPCBatchMessageConstant;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatDateUtil;
import eo.framework.util.JBSbatOracleSeqUtil;
import eo.framework.util.JBSbatStringUtil;

/**
 * オプションサービス契約サービス開始機能の基底クラス
 * 
 * @author FUJITSU
 * @since 2014-08-05
 */
public abstract class JBSbatKKTgOpSvcKeiUpdBase extends JBSbatBusinessService
{

	//▼▼▼▼▼▼呼び出し元でも使用する 開始▼▼▼▼▼▼*/
	/** key:オプションサービス契約情報*/
	protected static final String key_opSvcKeiInfo = "key_opSvcKeiInfo";
	/** key:実行に必要な情報*/
	protected static final String key_exeInfo = "key_exeInfo";
	/** key:基準日*/
	protected static final String key_kjnYmd = "key_kjnYmd";
	/** key:サービス開始処理種別コード */
	protected static final String key_svcKisSrsbCd = "key_svcKisSrsbCd";
	/** key:サービスコード */
	protected static final String key_SvcCd = "key_SvcCd";
	/** key:料金グループコード */
	protected static final String key_PrcGrpCd = "key_PrcGrpCd";
	/** key:サービス課金開始日 */
	protected static final String key_SvcChrgStaYmd = "key_SvcChrgStaYmd";
	/** サービス開始処理種別コード（10：サービス開始）*/
	protected static final String svcKisSrsbCd_10 = "10";
	/** サービス開始処理種別コード（20：サービス開始）*/
	protected static final String svcKisSrsbCd_20 = "20";
	/** サービス開始処理種別コード（30：サービス開始）*/
	protected static final String svcKisSrsbCd_30 = "30";
	/** サービス開始処理種別コード（40：サービス開始）*/
	protected static final String svcKisSrsbCd_40 = "40";
	//▲▲▲▲▲▲呼び出し元でも使用する 終了▲▲▲▲▲▲*/

	/** テーブル(サービス契約)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI = "KK_T_SVC_KEI";

	/** テーブル(料金スケジュール定義)*/
	private static final String D_TBL_NAME_CH_M_PRC_SCHDL_TEIGI = "CH_M_PRC_SCHDL_TEIGI";

	/** テーブル(申込明細)*/
	private static final String D_TBL_NAME_KK_T_MSKM_DTL = "KK_T_MSKM_DTL";

	/** テーブル(オプションサービス契約)*/
	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_SVKEI_EXC_CTRL = "KK_T_SVKEI_EXC_CTRL";
	
	/** テーブル(機器提供サービス契約)*/
	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_IDO_RSV = "KK_T_IDO_RSV";

	/** テーブル(割賦契約)*/
	private static final String D_TBL_NAME_KK_T_KAP_KEI = "KK_T_KAP_KEI";

//	/** SQL定義キー(KK_SELECT_028)*/
//	private static final String KK_T_SVC_KEI_KK_SELECT_028 = "KK_SELECT_028";

	/** SQL定義キー(KK_SELECT_012)*/
	private static final String CH_M_PRC_SCHDL_TEIGI_KK_SELECT_012 = "KK_SELECT_012";

	/** SQL定義キー(KK_SELECT_055)*/
	private static final String KK_T_OP_SVC_KEI_KK_SELECT_069 = "KK_SELECT_069";
	
	/** SQL定義キー(KK_SELECT_080)*/
	private static final String KK_T_OP_SVC_KEI_KK_SELECT_080 = "KK_SELECT_080";

	/** SQL定義キー(KK_SELECT_081)*/
	private static final String KK_T_KKTK_SVC_KEI_KK_SELECT_081 = "KK_SELECT_081";

	/** SQL定義キー(KK_SELECT_098)*/
	private static final String KK_T_OP_SVC_KEI_KK_SELECT_098 = "KK_SELECT_098";

	/** SQL定義キー(KK_SELECT_024)*/
	private static final String KK_T_MSKM_DTL_KK_SELECT_024 = "KK_SELECT_024";

	/** SQL定義キー(KK_SELECT_051)*/
	private static final String KK_T_IDO_RSV_KK_SELECT_051 = "KK_SELECT_051";
	
	/** SQL定義キー(KK_SELECT_178)*/
	private static final String KK_T_KKTK_SVC_KEI_KK_SELECT_178 = "KK_SELECT_178";

	/** SQL定義キー(KK_SELECT_010)*/
	private static final String KK_T_KAP_KEI_KK_SELECT_010 = "KK_SELECT_010";

	/** テーブルアクセスクラス(サービス契約)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI = null;

	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI = null;
	
//	/** テーブルアクセスクラス(サービス契約排他制御)*/
//	private JBSbatSQLAccess db_KK_T_SVKEI_EXC_CTRL = null;
	
	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI_069 = null;

	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI_080 = null;
	
	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI_098 = null;

	/** テーブルアクセスクラス(機器提供サービス契約)*/
	private JBSbatSQLAccess db_KK_T_KKTK_SVC_KEI = null;
	
	/** テーブルアクセスクラス(申込明細)*/
	private JBSbatSQLAccess db_KK_T_MSKM_DTL = null;

	/** テーブルアクセスクラス(料金スケジュール定義)*/
	private JBSbatSQLAccess db_CH_M_PRC_SCHDL_TEIGI = null;
	
	/** テーブルアクセスクラス(異動予約)*/
	private JBSbatSQLAccess db_KK_T_IDO_RSV = null;

	/** テーブルアクセスクラス(割賦契約)*/
	private JBSbatSQLAccess db_KK_T_KAP_KEI = null;

	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/**
	 * DBインターフェース共通クラス
	 */
	private JBSbatCommonDBInterface opSvcKeiKey = null;
	
	/**
	 * サービス開始対象契約番号
	 */
//	protected String svcKisTisKeiNo = ""; //使用箇所無し
	/**
	 * 処理年月日
	 */
//	protected String sriYmd = ""; //OUTファイル出力用なので不要
	/**
	 * サービス開始処理種別コード
	 */
	private String svcKisSrsbCd = "";
	
	/**
	 * サービス開始処理単位コード
	 */
//	protected String svcKisSrtiCd = ""; //OUTファイル出力用なので不要
	/**
	 * サービス契約番号
	 */
	private String svcKeiNo = "";
	/**
	 * サービス契約内訳番号
	 */
	private String svcKeiUcwkNo = "";
	/**
	 * 基準年月日
	 */
	private String kjnYmd = "";
	
	/**
	 * 世代登録年月日時分秒
	 */
	private String geneAddDtm = "";
	
	// ++++++++++ v22.00.00 削除開始 ++++++++++
//	/** 
//	 * サービス契約ステータス（サービス提供中）
//	 * */
//	private static final String CD00037_100 = "100";
	// ++++++++++ v22.00.00 削除終了 ++++++++++

	/** 
	 * オプションサービス契約番号
	 * */
	private String opSvcKeiNo = "";

	/** 
	 * 変更前サービス開始年月日 
	 */
//	protected String hnkMaeSvcStaYmd = ""; //OUTファイル出力用なので不要

	/** 
	 * 変更前サービス課金開始年月日 
	 */
//	protected String hnkMaeSvcChrgStaymd = ""; //OUTファイル出力用なので不要

	/** 
	 * 変更後サービス開始年月日 
	 */
//	protected String hnkAtoSvcStaYmd = ""; //OUTファイル出力用なので不要

	/** 
	 * 変更後サービス課金開始年月日 
	 */
	private String hnkAtoSvcChrgStaymd = "";
	
	/** 
	 * 補正前サービス課金開始年月日
	 */
//	protected String hoseiBfSvcChrgStaymd = ""; //OUTファイル出力用なので不要
	
	/** 
	 * 補正後サービス課金開始年月日
	 */
//	protected String hoseiAfSvcChrgStaymd = ""; //OUTファイル出力用なので不要
	
	/** 
	 * サービスコード 
	 */
	private String svcCd = "";
	
	/** 
	 * オプションサービスコード 
	 */
	private String opSvcCd = "";
	
	/** 
	 * 異動区分 
	 */
	private String idoDiv = "";
	
	/** 
	 * サービス課金開始年月日 
	 */
	private String svcChrgStaymd = "";
	
	/** 
	 * 料金グループコード 
	 */
	private String prcGrpCd = "";
	
	/**
	 *  基準日
	 */
	private String stdDt = "";
	
	/**
	 *  基準日からの相対日
	 */
	private String relativeDateCount = "";
	
	/**
	 *  実日/営業日
	 */
	private String countMethod = "";
	
	/**
	 *  優先基準日
	 */
	private String priorityStdDt = "";
	
	/** 
	 * サービス開始年月日(サービス契約) 
	 */
	private String svcStaYmdSvc = "";
	
	/** 
	 * 予約適用開始年月日(オプションサービス契約) 
	 */
	private String rsvAplyYmdOp = "";
	
	/** 
	 * 申込年月日(オプションサービス契約) 
	 */
	private String mskmYmdOp = "";
	
	/** 
	 * 終了日初期値
	 * */
	private static final String END_DATE = "20991231";
	
	// ++++++++++ v22.00.00 削除開始 ++++++++++
//	/** 
//	 * オプション　サービスコード　Ｍｙホームページ
//	 * */
//	private static final String op_svcCd_myHp = "B002";
//	
//	/** 
//	 * 異動区分　オプション引継
//	 * */
//	private static final String idoDiv_opHktgi = "00003";
	// ++++++++++ v22.00.00 削除終了 ++++++++++
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	protected void initialJBSbatKKTgOpSvcKeiUpdBase(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
// 呼出元から引き継ぐ
//		// 共通パラメータを設定します
//		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_KK_T_OP_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_OP_SVC_KEI);
		db_CH_M_PRC_SCHDL_TEIGI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_SCHDL_TEIGI);
//		db_KK_T_SVKEI_EXC_CTRL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVKEI_EXC_CTRL);
		db_KK_T_MSKM_DTL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_MSKM_DTL);
		db_KK_T_OP_SVC_KEI_069 = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_OP_SVC_KEI);
		db_KK_T_OP_SVC_KEI_080 = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_OP_SVC_KEI);
		db_KK_T_OP_SVC_KEI_098 = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_OP_SVC_KEI);
		db_KK_T_KKTK_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KKTK_SVC_KEI);
		db_KK_T_IDO_RSV = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_IDO_RSV);
		db_KK_T_KAP_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KAP_KEI);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

// 共通機能とする為、execute削除
//	/**
//	 * 主処理
//	 * @param inMap　入力電文
//	 * @return JBSbatOutputItem　出力情報
//	 * @throws Exception
//	 */
//	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap) throws Exception
//	{
//	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
//		
//		super.logPrint.printDebugLog("execute_START");
//		
//		// 中間ファイルの読み込みを行います。
//		getKkifm030(inMap);
//		
//		// オプションサービス契約情報の更新処理を行います。
//		if(!updateOpSvcKei())
//		{
//			return null;
//		}
//		
//		// 出力共通電文を生成する。
//		JBSbatOutputItem outputBean = new JBSbatOutputItem();
//		// サービス開始対象契約取得ファイルのファイル出力
//		outputBean = createKkifm030();
//		
//		super.logPrint.printDebugLog("execute_END");
//		
//		return outputBean;
//	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
//	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	protected void terminalJBSbatKKTgOpSvcKeiUpdBase() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_KK_T_SVC_KEI.close();
		db_KK_T_OP_SVC_KEI.close();
		db_CH_M_PRC_SCHDL_TEIGI.close();
//		db_KK_T_SVKEI_EXC_CTRL.close();
		db_KK_T_OP_SVC_KEI_069.close();
		db_KK_T_OP_SVC_KEI_080.close();
		db_KK_T_OP_SVC_KEI_098.close();
		db_KK_T_KKTK_SVC_KEI.close();
		db_KK_T_MSKM_DTL.close();
		db_KK_T_IDO_RSV.close();
		db_KK_T_KAP_KEI.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		JKKBatCommon.closeSubTypeConnection();
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	

	/**
	 * SQLKEY(KK_SELECT_051)で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_IDO_RSV_KK_SELECT_051(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

		// DBアクセスを実行します
		db_KK_T_IDO_RSV.selectBySqlDefine(paramList, KK_T_IDO_RSV_KK_SELECT_051);
	}
	
//	/**
//	 * SQLKEY(KK_SELECT_028)で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_KK_SELECT_028(Object[] param) throws Exception
//	{
//		// バイント変数のリストを生成します
//		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
//		paramList.setValue(param[0].toString());
//		paramList.setValue(param[1].toString());
//		paramList.setValue(param[2].toString());
//		paramList.setValue(param[3].toString());
//		paramList.setValue(param[4].toString());
//		paramList.setValue(param[5].toString());
//		paramList.setValue(param[6].toString());
//
//		// DBアクセスを実行します
//		db_KK_T_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_KK_SELECT_028);
//	}
	
	/**
	 * PK(ＰＫ　検索)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で条件マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	OP_SVC_KEI_NO
	 *		 	GENE_ADD_DTM
	 * </pre>
	 * <p>
	 * @param whereParam 条件項目の値。
	 * @return JBSbatCommonDBInterface 検索の結果。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface executeKK_T_OP_SVC_KEI_PKSELECT(Object[] whereParam) throws Exception
	{
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("OP_SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("GENE_ADD_DTM", whereParam[1]);

		// DBアクセスを実行します
		return db_KK_T_OP_SVC_KEI.selectByPrimaryKeys(whereMap);
	}
	
	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	異動予約番号				IDO_RSV_NO
	 *		 	異動区分				IDO_DIV
	 *		 	異動予約詳細コード				IDO_RSV_DTL_CD
	 *		 	予約適用年月日				RSV_APLY_YMD
	 *		 	異動予約反映年月日				IDO_RSV_HANEI_YMD
	 *		 	異動予約取消年月日				IDO_RSV_CL_YMD
	 *		 	異動予約状態コード				IDO_RSV_STAT_CD
	 *		 	申込明細番号				MSKM_DTL_NO
	 *		 	ＳＹＳＩＤ				SYSID
	 *		 	請求契約番号				SEIKY_KEI_NO
	 *		 	サービス契約番号				SVC_KEI_NO
	 *		 	サービス契約内訳番号				SVC_KEI_UCWK_NO
	 *		 	オプションサービス契約番号				OP_SVC_KEI_NO
	 *		 	サブオプションサービス契約番号				SBOP_SVC_KEI_NO
	 *		 	機器提供サービス契約番号				KKTK_SVC_KEI_NO
	 *		 	割引サービス契約番号				WRIB_SVC_KEI_NO
	 *		 	サービス契約回線内訳番号				SVC_KEI_KAISEN_UCWK_NO
	 *		 	併合先ＳＹＳＩＤ				HEIGO_SK_SYSID
	 *		 	分割先ＳＹＳＩＤ				BUNKATSU_SK_SYSID
	 *		 	併合先請求契約番号				HEIGO_SK_SEIKY_KEI_NO
	 *		 	分割先請求契約番号				BUNKATSU_SK_SEIKY_KEI_NO
	 *		 	新料金グループコード				NEW_PRC_GRP_CD
	 *		 	新料金コースコード				NEW_PCRS_CD
	 *		 	新料金プランコード				NEW_PPLAN_CD
	 *		 	新提供方式契約番号				NEW_TK_HOSHIKI_KEI_NO
	 *		 	新電波障害案件番号				NEW_DMPS_ANKEN_NO
	 *		 	旧料金グループコード				OLD_PRC_GRP_CD
	 *		 	旧料金コースコード				OLD_PCRS_CD
	 *		 	旧料金プランコード				OLD_PPLAN_CD
	 *		 	旧提供方式契約番号				OLD_TK_HOSHIKI_KEI_NO
	 *		 	旧電波障害案件番号				OLD_DMPS_ANKEN_NO
	 *		 	工事案件番号				KOJIAK_NO
	 *		 	違約金発生コード				PNLTY_HASSEI_CD
	 *		 	オプション引継先サービス契約番号				OP_HKTGI_SK_SVC_KEI_NO
	 *		 	サービス休止課金開始年月日				SVC_PAUSE_CHRG_STA_YMD
	 *		 	サービス課金終了年月日				SVC_CHRG_ENDYMD
	 *		 	プラン課金開始年月日				PLAN_CHRG_STAYMD
	 *		 	プラン課金終了年月日				PLAN_CHRG_ENDYMD
	 *			異動予約理由コード				IDO_RSV_RSN_CD
	 *			異動予約理由メモ				IDO_RSV_RSN_MEMO
	 *		 	登録年月日時分秒				ADD_DTM
	 *		 	登録オペレータアカウント				ADD_OPEACNT
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	削除年月日時分秒				DEL_DTM
	 *		 	削除オペレータアカウント				DEL_OPEACNT
	 *		 	無効フラグ				MK_FLG
	 *		 	登録運用年月日				ADD_UNYO_YMD
	 *		 	登録処理ＩＤ				ADD_TRN_ID
	 *		 	更新運用年月日				UPD_UNYO_YMD
	 *		 	更新処理ＩＤ				UPD_TRN_ID
	 *		 	削除運用年月日				DEL_UNYO_YMD
	 *		 	削除処理ＩＤ				DEL_TRN_ID
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_IDO_RSV_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("IDO_RSV_NO", setParam[0]);
		setMap.setValue("IDO_DIV", setParam[1]);
		setMap.setValue("IDO_RSV_DTL_CD", setParam[2]);
		setMap.setValue("RSV_APLY_YMD", setParam[3]);
		setMap.setValue("IDO_RSV_HANEI_YMD", setParam[4]);
		setMap.setValue("IDO_RSV_CL_YMD", setParam[5]);
		setMap.setValue("IDO_RSV_STAT_CD", setParam[6]);
		setMap.setValue("MSKM_DTL_NO", setParam[7]);
		setMap.setValue("SYSID", setParam[8]);
		setMap.setValue("SEIKY_KEI_NO", setParam[9]);
		setMap.setValue("SVC_KEI_NO", setParam[10]);
		setMap.setValue("SVC_KEI_UCWK_NO", setParam[11]);
		setMap.setValue("OP_SVC_KEI_NO", setParam[12]);
		setMap.setValue("SBOP_SVC_KEI_NO", setParam[13]);
		setMap.setValue("KKTK_SVC_KEI_NO", setParam[14]);
		setMap.setValue("WRIB_SVC_KEI_NO", setParam[15]);
		setMap.setValue("SVC_KEI_KAISEN_UCWK_NO", setParam[16]);
		setMap.setValue("HEIGO_SK_SYSID", setParam[17]);
		setMap.setValue("BUNKATSU_SK_SYSID", setParam[18]);
		setMap.setValue("HEIGO_SK_SEIKY_KEI_NO", setParam[19]);
		setMap.setValue("BUNKATSU_SK_SEIKY_KEI_NO", setParam[20]);
		setMap.setValue("NEW_PRC_GRP_CD", setParam[21]);
		setMap.setValue("NEW_PCRS_CD", setParam[22]);
		setMap.setValue("NEW_PPLAN_CD", setParam[23]);
		setMap.setValue("NEW_TK_HOSHIKI_KEI_NO", setParam[24]);
		setMap.setValue("NEW_DMPS_ANKEN_NO", setParam[25]);
		setMap.setValue("OLD_PRC_GRP_CD", setParam[26]);
		setMap.setValue("OLD_PCRS_CD", setParam[27]);
		setMap.setValue("OLD_PPLAN_CD", setParam[28]);
		setMap.setValue("OLD_TK_HOSHIKI_KEI_NO", setParam[29]);
		setMap.setValue("OLD_DMPS_ANKEN_NO", setParam[30]);
		setMap.setValue("KOJIAK_NO", setParam[31]);
		setMap.setValue("PNLTY_HASSEI_CD", setParam[32]);
		setMap.setValue("OP_HKTGI_SK_SVC_KEI_NO", setParam[33]);
		setMap.setValue("SVC_PAUSE_CHRG_STA_YMD", setParam[34]);
		setMap.setValue("SVC_CHRG_ENDYMD", setParam[35]);
		setMap.setValue("PLAN_CHRG_STAYMD", setParam[36]);
		setMap.setValue("PLAN_CHRG_ENDYMD", setParam[37]);
		setMap.setValue("IDO_RSV_RSN_CD", setParam[38]);
		setMap.setValue("IDO_RSV_RSN_MEMO", setParam[39]);
		setMap.setValue("ADD_DTM", setParam[40]);
		setMap.setValue("ADD_OPEACNT", setParam[41]);
		setMap.setValue("UPD_DTM", setParam[42]);
		setMap.setValue("UPD_OPEACNT", setParam[43]);
		setMap.setValue("DEL_DTM", setParam[44]);
		setMap.setValue("DEL_OPEACNT", setParam[45]);
		setMap.setValue("MK_FLG", setParam[46]);
		setMap.setValue("ADD_UNYO_YMD", setParam[47]);
		setMap.setValue("ADD_TRN_ID", setParam[48]);
		setMap.setValue("UPD_UNYO_YMD", setParam[49]);
		setMap.setValue("UPD_TRN_ID", setParam[50]);
		setMap.setValue("DEL_UNYO_YMD", setParam[51]);
		setMap.setValue("DEL_TRN_ID", setParam[52]);
	
		// DBアクセスを実行します
		db_KK_T_IDO_RSV.insertByPrimaryKeys(setMap);
	}

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	オプションサービス契約番号				OP_SVC_KEI_NO
	 *		 	世代登録年月日時分秒				GENE_ADD_DTM
	 *		 	オプションサービス契約ステータス				OP_SVC_KEI_STAT
	 *		 	オプションサービスコード				OP_SVC_CD
	 *		 	料金コースコード				PCRS_CD
	 *		 	料金プランコード				PPLAN_CD
	 *		 	親契約識別コード				OYA_KEI_SKBT_CD
	 *		 	サービス契約番号				SVC_KEI_NO
	 *		 	サービス契約内訳番号				SVC_KEI_UCWK_NO
	 *		 	法人サービス契約受付番号				HOJIN_SVC_KEI_UK_NO
	 *		 	ＳＹＳＩＤ				SYSID
	 *		 	申込明細番号				MSKM_DTL_NO
	 *		 	試用加入年月日				FTRIAL_KANYU_YMD
	 *		 	試用期間終了年月日				FTRIAL_PRD_ENDYMD
	 *		 	本加入年月日				HONKANYU_YMD
	 *		 	本加入移行期限年月日				HONKANYU_IKO_KIGEN_YMD
	 *		 	サービス利用開始希望年月日				SVC_USE_STA_KIBO_YMD
	 *		 	予約適用開始希望年月日				RSV_TSTA_KIBO_YMD
	 *		 	オプションサービス契約後続業務依頼年月日				OP_SVC_KEI_KZKWRK_REQYMD
	 *		 	照査年月日				SHOSA_YMD
	 *		 	照査取消年月日				SHOSA_CL_YMD
	 *		 	審査結果送信コード				SKEKKA_SEND_CD
	 *		 	契約締結年月日				KEI_CNC_YMD
	 *		 	予約適用年月日				RSV_APLY_YMD
	 *		 	予約取消年月日				RSV_CL_YMD
	 *		 	予約適用コード				RSV_APLY_CD
	 *		 	プラン開始年月日				PLAN_STAYMD
	 *		 	プラン終了年月日				PLAN_ENDYMD
	 *		 	プラン課金開始年月日				PLAN_CHRG_STAYMD
	 *		 	プラン課金終了年月日				PLAN_CHRG_ENDYMD
	 *		 	プラン終了種別コード				PLAN_END_SBT_CD
	 *		 	サービスキャンセル年月日				SVC_CANCEL_YMD
	 *		 	サービスキャンセル理由コード				SVC_CANCEL_RSN_CD
	 *		 	サービス開始年月日				SVC_STAYMD
	 *		 	サービス開始時分秒				SVC_STA_HMS
	 *		 	表示用サービス提供開始年月日				DSP_SVCTK_STAYMD
	 *		 	サービス課金開始年月日				SVC_CHRG_STAYMD
	 *		 	サービス停止年月日				SVC_STP_YMD
	 *		 	サービス停止理由コード				SVC_STP_RSN_CD
	 *		 	サービス停止解除年月日				SVC_STP_RLS_YMD
	 *		 	サービス停止解除理由コード				SVC_STP_RLS_RSN_CD
	 *		 	休止中断コード				PAUSE_STP_CD
	 *		 	サービス休止年月日				SVC_PAUSE_YMD
	 *		 	サービス休止理由コード				SVC_PAUSE_RSN_CD
	 *		 	サービス休止理由メモ				SVC_PAUSE_RSN_MEMO
	 *		 	サービス休止解除年月日				SVC_PAUSE_RLS_YMD
	 *		 	サービス休止解除理由コード				SVC_PAUSE_RLS_RSN_CD
	 *		 	サービス休止解除理由メモ				SVC_PAUSE_RLS_RSN_MEMO
	 *		 	サービス終了年月日				SVC_ENDYMD
	 *		 	サービス終了時分秒				SVC_END_HMS
	 *		 	サービス課金終了年月日				SVC_CHRG_ENDYMD
	 *		 	サービス解約年月日				SVC_DSL_YMD
	 *		 	サービス解約理由コード				SVC_DLRE_CD
	 *		 	サービス解約理由メモ				SVC_DLRE_MEMO
	 *		 	解約担当ユーザーＩＤ				DSL_TNT_USER_ID
	 *		 	サービス解約手続完了フラグ				SVC_DSL_TTDKI_FIN_FLG
	 *		 	回復年月日				KAIHK_YMD
	 *		 	サービスキャンセル取消年月日				SVC_CANCEL_CL_YMD
	 *		 	サービス解約取消年月日				SVC_DSL_CL_YMD
	 *		 	課金開始年月日補正有無				CHRG_STA_YMD_HOSEI_UM
	 *		 	サービス休止課金開始年月日				SVC_PAUSE_CHRG_STA_YMD
	 *		 	オプションサービス契約引継発生年月日				OP_SVC_KEI_HKHASYMD
	 *		 	違約金発生コード				PNLTY_HASSEI_CD
	 *		 	異動区分				IDO_DIV
	 *		 	照査解約完了コード				SHOSA_DSL_FIN_CD
	 *		 	サービス提供物消去処理実施年月日時分秒				SVCTK_BUT_DEL_TRN_JSSI_DTM
	 *		 	登録年月日時分秒				ADD_DTM
	 *		 	登録オペレータアカウント				ADD_OPEACNT
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	削除年月日時分秒				DEL_DTM
	 *		 	削除オペレータアカウント				DEL_OPEACNT
	 *		 	無効フラグ				MK_FLG
	 *		 	登録運用年月日				ADD_UNYO_YMD
	 *		 	登録処理ＩＤ				ADD_TRN_ID
	 *		 	更新運用年月日				UPD_UNYO_YMD
	 *		 	更新処理ＩＤ				UPD_TRN_ID
	 *		 	削除運用年月日				DEL_UNYO_YMD
	 *		 	削除処理ＩＤ				DEL_TRN_ID
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_OP_SVC_KEI_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("OP_SVC_KEI_NO", setParam[0]);
		setMap.setValue("GENE_ADD_DTM", setParam[1]);
		setMap.setValue("OP_SVC_KEI_STAT", setParam[2]);
		setMap.setValue("OP_SVC_CD", setParam[3]);
		setMap.setValue("PCRS_CD", setParam[4]);
		setMap.setValue("PPLAN_CD", setParam[5]);
		setMap.setValue("OYA_KEI_SKBT_CD", setParam[6]);
		setMap.setValue("SVC_KEI_NO", setParam[7]);
		setMap.setValue("SVC_KEI_UCWK_NO", setParam[8]);
		setMap.setValue("HOJIN_SVC_KEI_UK_NO", setParam[9]);
		setMap.setValue("SYSID", setParam[10]);
		setMap.setValue("MSKM_DTL_NO", setParam[11]);
		setMap.setValue("FTRIAL_KANYU_YMD", setParam[12]);
		setMap.setValue("FTRIAL_PRD_ENDYMD", setParam[13]);
		setMap.setValue("HONKANYU_YMD", setParam[14]);
		setMap.setValue("HONKANYU_IKO_KIGEN_YMD", setParam[15]);
		setMap.setValue("SVC_USE_STA_KIBO_YMD", setParam[16]);
		setMap.setValue("RSV_TSTA_KIBO_YMD", setParam[17]);
		setMap.setValue("OP_SVC_KEI_KZKWRK_REQYMD", setParam[18]);
		setMap.setValue("SHOSA_YMD", setParam[19]);
		setMap.setValue("SHOSA_CL_YMD", setParam[20]);
		setMap.setValue("SKEKKA_SEND_CD", setParam[21]);
		setMap.setValue("KEI_CNC_YMD", setParam[22]);
		setMap.setValue("RSV_APLY_YMD", setParam[23]);
		setMap.setValue("RSV_CL_YMD", setParam[24]);
		setMap.setValue("RSV_APLY_CD", setParam[25]);
		setMap.setValue("PLAN_STAYMD", setParam[26]);
		setMap.setValue("PLAN_ENDYMD", setParam[27]);
		setMap.setValue("PLAN_CHRG_STAYMD", setParam[28]);
		setMap.setValue("PLAN_CHRG_ENDYMD", setParam[29]);
		setMap.setValue("PLAN_END_SBT_CD", setParam[30]);
		setMap.setValue("SVC_CANCEL_YMD", setParam[31]);
		setMap.setValue("SVC_CANCEL_RSN_CD", setParam[32]);
		setMap.setValue("SVC_STAYMD", setParam[33]);
		setMap.setValue("SVC_STA_HMS", setParam[34]);
		setMap.setValue("DSP_SVCTK_STAYMD", setParam[35]);
		setMap.setValue("SVC_CHRG_STAYMD", setParam[36]);
		setMap.setValue("SVC_STP_YMD", setParam[37]);
		setMap.setValue("SVC_STP_RSN_CD", setParam[38]);
		setMap.setValue("SVC_STP_RLS_YMD", setParam[39]);
		setMap.setValue("SVC_STP_RLS_RSN_CD", setParam[40]);
		setMap.setValue("PAUSE_STP_CD", setParam[41]);
		setMap.setValue("SVC_PAUSE_YMD", setParam[42]);
		setMap.setValue("SVC_PAUSE_RSN_CD", setParam[43]);
		setMap.setValue("SVC_PAUSE_RSN_MEMO", setParam[44]);
		setMap.setValue("SVC_PAUSE_RLS_YMD", setParam[45]);
		setMap.setValue("SVC_PAUSE_RLS_RSN_CD", setParam[46]);
		setMap.setValue("SVC_PAUSE_RLS_RSN_MEMO", setParam[47]);
		setMap.setValue("SVC_ENDYMD", setParam[48]);
		setMap.setValue("SVC_END_HMS", setParam[49]);
		setMap.setValue("SVC_CHRG_ENDYMD", setParam[50]);
		setMap.setValue("SVC_DSL_YMD", setParam[51]);
		setMap.setValue("SVC_DLRE_CD", setParam[52]);
		setMap.setValue("SVC_DLRE_MEMO", setParam[53]);
		setMap.setValue("DSL_TNT_USER_ID", setParam[54]);
		setMap.setValue("SVC_DSL_TTDKI_FIN_FLG", setParam[55]);
		setMap.setValue("KAIHK_YMD", setParam[56]);
		setMap.setValue("SVC_CANCEL_CL_YMD", setParam[57]);
		setMap.setValue("SVC_DSL_CL_YMD", setParam[58]);
		setMap.setValue("CHRG_STA_YMD_HOSEI_UM", setParam[59]);
		setMap.setValue("SVC_PAUSE_CHRG_STA_YMD", setParam[60]);
		setMap.setValue("OP_SVC_KEI_HKHASYMD", setParam[61]);
		setMap.setValue("PNLTY_HASSEI_CD", setParam[62]);
		setMap.setValue("IDO_DIV", setParam[63]);
		setMap.setValue("SHOSA_DSL_FIN_CD", setParam[64]);
		setMap.setValue("SVCTK_BUT_DEL_TRN_JSSI_DTM", setParam[65]);
		setMap.setValue("ADD_DTM", setParam[66]);
		setMap.setValue("ADD_OPEACNT", setParam[67]);
		setMap.setValue("UPD_DTM", setParam[68]);
		setMap.setValue("UPD_OPEACNT", setParam[69]);
		setMap.setValue("DEL_DTM", setParam[70]);
		setMap.setValue("DEL_OPEACNT", setParam[71]);
		setMap.setValue("MK_FLG", setParam[72]);
		setMap.setValue("ADD_UNYO_YMD", setParam[73]);
		setMap.setValue("ADD_TRN_ID", setParam[74]);
		setMap.setValue("UPD_UNYO_YMD", setParam[75]);
		setMap.setValue("UPD_TRN_ID", setParam[76]);
		setMap.setValue("DEL_UNYO_YMD", setParam[77]);
		setMap.setValue("DEL_TRN_ID", setParam[78]);
	
		// DBアクセスを実行します
		db_KK_T_OP_SVC_KEI.insertByPrimaryKeys(setMap);
	}
	
	/**
	 * PK(ＰＫ　更新)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.引数で条件マップを作ります。<br>
	 *
	 * 3.DBアクセスを実行します。<br>
	 * 
	 * 4.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	サービス課金開始年月日				SVC_CHRG_STAYMD
	 *		 	プラン課金開始年月日				PLAN_CHRG_STAYMD
	 *		 	サービス終了年月日					SVC_ENDYMD
	 *		 	サービス課金終了年月日				SVC_CHRG_ENDYMD
	 *		 	プラン終了年月日					PLAN_ENDYMD
	 *		 	プラン課金終了年月日				PLAN_CHRG_ENDYMD
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	OP_SVC_KEI_NO
	 *		 	GENE_ADD_DTM
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @param whereParam 条件項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_OP_SVC_KEI_PKUPDATE(Object[] setParam, Object[] whereParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("SVC_CHRG_STAYMD", setParam[0]);
		setMap.setValue("PLAN_CHRG_STAYMD", setParam[0]);
		setMap.setValue("SVC_ENDYMD", END_DATE);
		setMap.setValue("SVC_CHRG_ENDYMD", END_DATE);
		setMap.setValue("PLAN_ENDYMD", END_DATE);
		setMap.setValue("PLAN_CHRG_ENDYMD", END_DATE);
	
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("OP_SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("GENE_ADD_DTM", whereParam[1]);

		// DBアクセスを実行します
		db_KK_T_OP_SVC_KEI.updateByPrimaryKeys(whereMap, setMap);
	}
	
	/**
	 * SQLKEY(KK_SELECT_069)で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_KK_SELECT_069(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_069.selectBySqlDefine(paramList, KK_T_OP_SVC_KEI_KK_SELECT_069);
	}

	/**
	 * SQLKEY(KK_SELECT_080)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	OP_SVC_KEI_NO
	 *		 	RSV_APLY_YMD
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_OP_SVC_KEI_KK_SELECT_080(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_080.selectBySqlDefine(paramList, KK_T_OP_SVC_KEI_KK_SELECT_080);
	}

	/**
	 * SQLKEY(KK_SELECT_081)で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_KK_SELECT_081(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());

		// DBアクセスを実行します
		db_KK_T_KKTK_SVC_KEI.selectBySqlDefine(paramList, KK_T_KKTK_SVC_KEI_KK_SELECT_081);
	}

	/**
	 * SQLKEY(KK_SELECT_098)で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_KK_SELECT_098(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_098.selectBySqlDefine(paramList, KK_T_OP_SVC_KEI_KK_SELECT_098);
	}

	/**
	 * 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_DTL_KK_SELECT_024(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

		// DBアクセスを実行します
		db_KK_T_MSKM_DTL.selectBySqlDefine(paramList, KK_T_MSKM_DTL_KK_SELECT_024);
	}
	
	/**
	 * 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 executeCH_M_PRC_SCHDL_TEIGI_KK_SELECT_012(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

		// DBアクセスを実行します
		db_CH_M_PRC_SCHDL_TEIGI.selectBySqlDefine(paramList, CH_M_PRC_SCHDL_TEIGI_KK_SELECT_012);
	}
	
	/**
	 * SQLKEY(KK_SELECT_178)で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_KK_SELECT_178(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());

		// DBアクセスを実行します
		db_KK_T_KKTK_SVC_KEI.selectBySqlDefine(paramList, KK_T_KKTK_SVC_KEI_KK_SELECT_178);
	}
	
	/**
	 * SQLKEY(KK_SELECT_010)で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_KAP_KEI_KK_SELECT_010(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_KAP_KEI.selectBySqlDefine(paramList, KK_T_KAP_KEI_KK_SELECT_010);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
//	/**
//	 * 
//	 * 中間ファイルの読み込みを行います。
//	 * 
//	 * @param inMap 中間ファイルの値。
//	 * @throws Exception メソッド内で発生した例外全般。
//	 */
//	private void getKkifm030(JBSbatServiceInterfaceMap inMap) throws Exception 
//	{
//		
//		sriYmd              = inMap.getString(JBSbatKKIFM030.SRI_YMD);						// 処理年月日
//		svcKisSrsbCd        = inMap.getString(JBSbatKKIFM030.SVC_KIS_SRSB_CD);				// サービス開始処理種別コード
//		svcKisSrtiCd        = inMap.getString(JBSbatKKIFM030.SVC_KIS_SRTI_CD);				// サービス開始処理単位コード
//		svcKeiNo            = inMap.getString(JBSbatKKIFM030.SVC_KEI_NO);					// サービス契約番号
//		svcKeiUcwkNo        = inMap.getString(JBSbatKKIFM030.SVC_KEI_UCWK_NO);				// サービス契約内訳番号
//		kjnYmd              = inMap.getString(JBSbatKKIFM030.KJN_YMD);						// 基準年月日
//		hnkMaeSvcStaYmd     = inMap.getString(JBSbatKKIFM030.HNK_MAE_SVC_STA_YMD);			// 変更前サービス開始年月日
//		hnkMaeSvcChrgStaymd = inMap.getString(JBSbatKKIFM030.HNK_MAE_SVC_CHRG_STAYMD);		// 変更前サービス課金開始年月日
//		hnkAtoSvcStaYmd     = inMap.getString(JBSbatKKIFM030.HNK_ATO_SVC_STA_YMD);			// 変更後サービス開始年月日
//		hnkAtoSvcChrgStaymd = inMap.getString(JBSbatKKIFM030.HNK_ATO_SVC_CHRG_STAYMD);		// 変更後サービス課金開始年月日
//		hoseiBfSvcChrgStaymd = inMap.getString(JBSbatKKIFM030.HOSEI_BF_SVC_CHRG_STAYMD);	// 補正前サービス課金開始年月日
//		hoseiAfSvcChrgStaymd = inMap.getString(JBSbatKKIFM030.HOSEI_AF_SVC_CHRG_STAYMD);	// 補正後サービス課金開始年月日
//		
//		// ※サービス契約．サービス開始日(svcStaYmdSvc)について
//		// 先行JOBにてサービス開始時に使用した基準日をサービス契約のサービス開始年月日として使用する。
//		// 基準日(kjnYmd)は処理終了後にオプションサービス契約の開始日が設定されるので初期読込時に代入。
//		svcStaYmdSvc = kjnYmd;
//	}

	/**
	 * 主処理
	 * オプションサービス契約更新処理
	 * 
	 * @return 更新有無
	 * @throws Exception メソッド内で発生した例外全般。
	 */
	protected boolean executeJBSbatKKTgOpSvcKeiUpdBase(HashMap<String, Object> map) throws Exception 
	{
		super.logPrint.printDebugLog("executeJBSbatKKTgOpSvcKeiUpdBase_START");
		
		// フィールド変数の初期化を行う。
		kjnYmd = "";
		svcKisSrsbCd = "";
		svcStaYmdSvc = "";
		svcCd   = "";
		opSvcCd = "";
		rsvAplyYmdOp = "";
		svcChrgStaymd = "";
		mskmYmdOp = "";
		idoDiv = "";
		prcGrpCd = "";
		
		if(map == null)
		{
			return false;
		}
		
		JBSbatCommonDBInterface opSvcKeiMap = (JBSbatCommonDBInterface)map.get(key_opSvcKeiInfo);
		HashMap<String, Object> exeMap = (HashMap<String, Object>)map.get(key_exeInfo);
		
		kjnYmd = (String) exeMap.get(key_kjnYmd);
		svcKisSrsbCd = (String) exeMap.get(key_svcKisSrsbCd);
		
		// 基準日、サービス開始処理種別が設定されて場合は処理終了
		if(kjnYmd==null || "".equals(kjnYmd) || svcKisSrsbCd == null || "".equals(svcKisSrsbCd))
		{
			return false;
		}
		svcStaYmdSvc = kjnYmd;
			
		String svcCd_028 = JBSbatStringUtil.Rtrim((String)exeMap.get(key_SvcCd));
		String opSvcKeiNo_028 = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		String svcKeiUcwkNo_028 = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_KEI_UCWK_NO));
		String opSvcCd_028 = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		
		super.logPrint.printDebugLog("サービスコード：：：：：：：：：：：：：：：：：：：：：" + svcCd_028);
		super.logPrint.printDebugLog("オプションサービス契約番号：：：：：：：：：：：：：：：" + opSvcKeiNo_028);
		super.logPrint.printDebugLog("サービス契約内訳番号（オプションサービス契約番号の親）：" + svcKeiUcwkNo_028);
		super.logPrint.printDebugLog("オプションサービスコード：：：：：：：：：：：：：：：：" + opSvcCd_028);
		
		// サービス開始処理種別コードが「10：サービス開始」、「20：サービス開始登録（工事起因）」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("10".equals(svcKisSrsbCd) || "20".equals(svcKisSrsbCd))
		if(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_10.equals(svcKisSrsbCd) || JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_20.equals(svcKisSrsbCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			super.logPrint.printDebugLog(
					"サービス開始処理種別コード「10：サービス開始」、「20：サービス開始登録（工事起因）」");
			
			// ※ KK_T_SVC_KEI_KK_SELECT_028にてオプションサービス契約ステータス取得を追加
			//    KK_T_SVC_KEI_KK_SELECT_028にてオプションサービス契約．親契約識別コードを条件に追加
			// 締結済み以外のオプションサービス契約はサービス開始対象外とする。
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if (!"030".equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			if (!JBSbatKKConst.SVC_KEI_STAT_CNC_ZM .equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				return false;
			}
			
			// サービス利用開始希望年月
			String svcUseStaKiboYmd = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_USE_STA_KIBO_YMD));
			
			if(!"".equals(svcUseStaKiboYmd))
			{
				// 対象オプションサービスコードが"B068"(ｅｏ光テレビガイド誌)の以外の場合、サービス利用開始希望年月日判定を行います。
				// ++++++++++ v22.00.00 変更開始 ++++++++++
//				if (!"B068".equals(opSvcCd_028))
				if (!JBSbatKKConst.OP_SVC_CD_CABLE_GUDMG.equals(opSvcCd_028))
				// ++++++++++ v22.00.00 変更終了 ++++++++++
				{
					super.logPrint.printDebugLog("対象オプションサービスコードが「B068」(ｅｏ光テレビガイド誌)以外：サービス利用開始希望年月日判定実施");
					
					// サービス利用開始希望年月日が運用日より未来日の場合は処理対象外
					if(0 > opeDate.compareTo(svcUseStaKiboYmd))
					{
						super.logPrint.printDebugLog("サービス利用開始希望年月が運用日より未来日のため対象外：" + svcUseStaKiboYmd);
						super.logPrint.printDebugLog("運用日：" + opeDate);
						super.logPrint.printDebugLog("オプションサービス契約番号：" + opSvcKeiNo_028);
						return false;
					}
				}
			}
		}
		// 「30：サービス開始（補正）」、「40：サービス開始（補正）電話」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		else if("30".equals(svcKisSrsbCd) || "40".equals(svcKisSrsbCd))
		else if(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_30.equals(svcKisSrsbCd) || JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_40.equals(svcKisSrsbCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			super.logPrint.printDebugLog(
				"サービス開始処理種別コード「30：サービス開始（補正）」、「40：サービス開始（補正）電話」");
			
			// 提供中以外のオプションサービス契約はサービス開始対象外とする。
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if (!"100".equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			if (!JBSbatKKConst.SVC_KEI_STAT_SVCTK_CHU.equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				return false;
			}
			
			// サービス契約内訳番号の同一チェックを実施します。
			// サービスコードが「02：電話」の場合、オプションサービス契約番号に紐づくサービス契約内訳番号が、
			//   「サービス開始対象契約取得ファイル」のサービス契約内訳番号と同一で無い場合対象外とします。
			if (!isUpdateTrgtTel(svcCd_028, svcKeiUcwkNo_028))
			{
				super.logPrint.printDebugLog("サービス契約内訳番号の同一チェック：NG");
				
				// サービス開始対象外とします。
				return false;
			}
		}
		// サービス開始処理種別コードが「50：課金開始日変更」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		else if("50".equals(svcKisSrsbCd))
		else if(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_50.equals(svcKisSrsbCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			super.logPrint.printDebugLog("サービス開始処理種別コード「50：課金開始日変更」");
			
			// サービス提供中以外のオプションサービス契約は対象外とする。
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if (!"100".equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			if (!JBSbatKKConst.SVC_KEI_STAT_SVCTK_CHU.equals(JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_STAT))))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				return false;
			}
			
			// サービス契約内訳番号の同一チェックを実施します。
			// サービスコードが「02：電話」の場合、オプションサービス契約番号に紐づくサービス契約内訳番号が、
			//   「サービス開始対象契約取得ファイル」のサービス契約内訳番号と同一で無い場合対象外とします。
			if (!isUpdateTrgtTel(svcCd_028, svcKeiUcwkNo_028))
			{
				super.logPrint.printDebugLog("サービス契約内訳番号の同一チェック：NG");
				
				// サービス開始対象外とします。
				return false;
			}
		}
		
		
		svcCd   = JBSbatStringUtil.Rtrim((String)exeMap.get(key_SvcCd));
		opSvcCd = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		
		// オプションサービス契約の予約適用年月日を取得
		rsvAplyYmdOp = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_APLY_YMD));
		
		// 起因となる契約のサービス課金開始年月日を取得（サービス契約or機器オプションサービス契約）
		// JBSbatKK_T_KKOP_SVC_KEI.SVC_CHRG_STAYMDもJBSbatKK_T_SVC_KEI.SVC_CHRG_STAYMDも共に定数"SVC_CHRG_STAYMD"
		svcChrgStaymd = JBSbatStringUtil.Rtrim((String)exeMap.get(key_SvcChrgStaYmd));
		
		// オプションサービス契約番号を取得
		opSvcKeiNo = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		
		// 異動区分
		idoDiv = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.IDO_DIV));
		
		// サービス契約の料金グループコードを取得
		prcGrpCd = JBSbatStringUtil.Rtrim((String)exeMap.get(key_PrcGrpCd));
		
		String mskmPrd = "";
		
		// 対象オプションサービスコードが"B068"(ｅｏ光テレビガイド誌)の以外の場合、申込期間取得(相関ルール:申込期間判定呼出)を行います。
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if (!"B068".equals(opSvcCd_028))
		if (!JBSbatKKConst.OP_SVC_CD_CABLE_GUDMG.equals(opSvcCd_028))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			mskmPrd = getMskmPrd(opSvcKeiMap);
		}
		// ｅｏ光テレビガイド誌の場合パターンＡ
		else
		{
			mskmPrd = "1";
		}
		
		super.logPrint.printDebugLog("申込期間----->" + mskmPrd);
		
		// 申込期間が取得できない場合は、対象外
		if("0".equals(mskmPrd))
		{
			return false;
		}
		
		// 相関ルール名：開始日設定定義（オプションサービス）を呼び出す。
		ArrayList<ArrayList<HashMap<String, Object>>> checkList074 = callRule0074001(mskmPrd);
		
		// ルール呼出結果によるサービス開始年月日算出用データ取得を呼び出す。
		getSvcStaymd(checkList074, JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_USE_STA_KIBO_YMD)));
		
		// 基準日が設定されなかった場合は対象外とする。
		if("".equals(kjnYmd))
		{
			return false;
		}
		
		// 設定された基準日（オプションサービス契約開始日）が運用日＋１日より未来日の場合は、対象外
		if(Integer.parseInt(JBSbatDateUtil.adjustDate(super.opeDate, 1)) < Integer.parseInt(kjnYmd))
		{
			// 補正の場合は未来日開始を許容する、補正以外は開始しない。
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if(!"30".equals(svcKisSrsbCd) && !"50".equals(svcKisSrsbCd))
			if(!JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_30.equals(svcKisSrsbCd) && !JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_50.equals(svcKisSrsbCd))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				super.logPrint.printDebugLog("▼判定した基準日が未来日のため対象外：" + kjnYmd);
				
				//対象オプションサービスコードが"B068"(ｅｏ光テレビガイド誌)の場合異動予約登録を行う
				// ++++++++++ v22.00.00 変更開始 ++++++++++
//				if("B068".equals(opSvcCd))
				if(JBSbatKKConst.OP_SVC_CD_CABLE_GUDMG.equals(opSvcCd))
				// ++++++++++ v22.00.00 変更終了 ++++++++++
				{
					super.logPrint.printDebugLog("★★★対象オプションサービスコードが「B068」(ｅｏ光テレビガイド誌)：異動予約登録実施★★★");
					
					//異動予約が存在しない場合登録
					setIdoRsv(opSvcKeiMap, mskmPrd);
				}
				return false;
			}
		}
		
/* ++++++++++ v12.00.00 削除開始 ++++++++++ */
//		// 追加申込されたオプションに対する処理
//		// 親のサービス契約のサービス開始年月日とオプションサービス契約の予約適用年月日を比較し、遅い方の日付を基準日とする。
//		if(!"".equals(svcStaYmdSvc) && !"".equals(rsvAplyYmdOp))
//		{
//			if(Integer.parseInt(svcStaYmdSvc) < Integer.parseInt(rsvAplyYmdOp))
//			{
//				kjnYmd = rsvAplyYmdOp;
//				super.logPrint.printDebugLog("◆親のサービス契約のサービス開始年月日とオプションサービス契約の予約適用年月日を比較し、遅い方の日付を基準日とする。◆" + kjnYmd);
//			}
//		}
/* ++++++++++ v12.00.00 削除終了 ++++++++++ */
		
		// 相関ルール名：課金開始日設定定義（サービス）を呼び出す。
		ArrayList<ArrayList<HashMap<String, Object>>> checkList = null;
		
		// 「50：課金開始日変更」で基準年月日が"20991231"の場合、
		// 工事完了取消のため、課金開始日算出処理を行わない。
		// ※工事完了取消の条件はUI設計書【RULE0082_工事完了状況判定】より判断。
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if(!("50".equals(svcKisSrsbCd) && "20991231".equals(kjnYmd))){
		if(!(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_50.equals(svcKisSrsbCd) && "20991231".equals(kjnYmd))){
		// ++++++++++ v22.00.00 変更終了 ++++++++++
			// 相関ルール名：課金開始日設定定義（サービス）を呼び出す。
			checkList = callRule0066001(opSvcKeiMap, mskmPrd);
		}
		
		// ルール呼出結果によるサービス課金開始年月日算出用データ取得を呼び出す。
		getSvcChrgStaymd(checkList);
		
		// ＩＰｖ６アドレスの場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("B070".equals(opSvcCd))
		if(JBSbatKKConst.OP_SVC_CD_IPV6_AD.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// 検索条件の設定
			Object[] param = {opSvcKeiNo, super.opeDate};
			
			// 検索処理の実施。
			executeKK_T_OP_SVC_KEI_KK_SELECT_069(param);
			JBSbatCommonDBInterface outMap = db_KK_T_OP_SVC_KEI_069.selectNext();
			
			// IPv6アドレス情報が取得できない場合はサービス開始対象外とします。
			if(null == outMap)
			{
				return false;
			}
			
			// IPv6アドレス(インターフェイスID)が取得できない場合はサービス開始対象外とします。
			if("".equals(JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OPSVKEI_ISP.IPV6_AD_IFID))))
			{
				return false;
			}
		}
		// Ｍｙホームページの場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		else if("B002".equals(opSvcCd))
		else if(JBSbatKKConst.OP_SVC_CD_MY_HP.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// 検索条件の設定
			Object[] param = {opSvcKeiNo, super.opeDate};
			
			// 検索処理の実施。
			executeKK_T_OP_SVC_KEI_KK_SELECT_080(param);
			JBSbatCommonDBInterface outMap = db_KK_T_OP_SVC_KEI_080.selectNext();
			
			// オプションサービス契約<ISP>情報が取得できない場合はサービス開始対象外とします。
			if(null == outMap)
			{
				return false;
			}
			
			// URL(ドメイン)またはURL(アカウント)が未設定の場合はサービス開始対象外とします。
			if("".equals(JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OPSVKEI_ISP.URL_DOMAIN)))
					|| "".equals(JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OPSVKEI_ISP.URL_ACCOUNT))))
			{
				return false;
			}
		}
		
		// オプションサービス契約の登録を行う。
		this.createOpSvcKei(opSvcKeiMap);
		
//		// サービス契約排他制御への更新処理を実行する
//		this.updateSvkeiExcCtrl(svcKeiNo);
		
		super.logPrint.printDebugLog("executeJBSbatKKTgOpSvcKeiUpdBase_END");
		return true;
	}

	/**
	 * 
	 * ルール呼出結果によるサービス課金開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList ArrayList<ArrayList<HashMap<String, Object>>>
	 */
	private void getSvcChrgStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList)
	{
		
		// フィールド変数の初期化
		stdDt               = "";
		relativeDateCount   = "";
		countMethod         = "";
		
		/* ++++++++++ v8.00.04 修正開始 ++++++++++ */
//		if(null != checkList.get(0))
		if(null != checkList && null != checkList.get(0))
		/* ++++++++++ v8.00.04 修正終了 ++++++++++ */
		{
			
			// 各ルール結果を取得する。
			stdDt             = (String)checkList.get(0).get(0).get("STD_DT");						// 基準日
			relativeDateCount = (String)checkList.get(0).get(0).get("RELATIVE_DATE_COUNT");			// 基準日からの相対日
			countMethod       = (String)checkList.get(0).get(0).get("COUNT_METHOD");				// 実日/営業日
			
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日）：：：：：：：" +  stdDt);
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日からの相対日）：" +  relativeDateCount);
			super.logPrint.printDebugLog("相関ルール呼出結果（実日/営業日 ）：：：：" +  countMethod);
			
			super.logPrint.printDebugLog("RULE0074結果：：：：" +  kjnYmd);
			super.logPrint.printDebugLog("元のサービス契約の課金開始年月日：：：：" +  svcChrgStaymd);
			
			//呼び出したルール[RULE0066001_課金開始日（オプション）]の結果を元にサービス課金開始年月日算出用データを取得する。
			// 基準日の取得
			if("4".equals(stdDt))
			{
				// 基準日からの相対日が"+0"の場合
				if("0".equals(relativeDateCount))
				{
					// 元のサービス契約の課金開始年月日を設定
					hnkAtoSvcChrgStaymd = svcChrgStaymd;
				}
				// 基準日からの相対日が"翌月月初"の場合
				else if("2".equals(relativeDateCount))
				{
					// 元のサービス契約の課金開始年月日の翌月月初を設定
					hnkAtoSvcChrgStaymd = adjustMonth(svcChrgStaymd, 1);
				}
			}
			else
			{
				// 基準日からの相対日が"+0"の場合
				if("0".equals(relativeDateCount))
				{
					// サービス開始対象契約.基準年月日を用いる。(RULE0074結果)
					hnkAtoSvcChrgStaymd = kjnYmd;
				}
				// 基準日からの相対日が"翌月月初"の場合
				else
				{
					// サービス開始対象契約.基準年月日(RULE0074結果)の翌月1日を設定する。
					hnkAtoSvcChrgStaymd = adjustMonth(kjnYmd, 1);
				}
			}
		}
		else
		{
			hnkAtoSvcChrgStaymd = kjnYmd;
		}
		
		super.logPrint.printDebugLog("サービス課金開始年月日--->" + hnkAtoSvcChrgStaymd);
		
	}

	/**
	 * 
	 * Ｎヶ月前(後)の日付を返却します。
	 * 
	 * @param  date String
	 * @return date String
	 */
	private String adjustMonth(String date, int addMonth) 
	{
		
		if(null != date && !"".equals(date) && date.length() >= 6)
		{
			String date2 = JBSbatDateUtil.adjustMonth(date, addMonth);
			
			return date2.substring(0, 6) + "01";
		}
		
		return "";
	}

	/**
	 * 
	 * 相関ルールの呼び出しをを行います。
	 * @param opSvcKeiMap オプションサービス契約情報
	 * @param mskmPrd 申込期間
	 * @return checkList1 rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception メソッド内で発生した例外全般。
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0066001(JBSbatCommonDBInterface opSvcKeiMap, String mskmPrd) throws Exception
	{
		super.logPrint.printDebugLog("callRule0066001_START");
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		
		if(!"".equals(svcCd))
		{
			// サービスコード = KK_T_SVC_KEI.KK_SELECT_028.SVC_CD
			map.put("SVC_CD", svcCd);
		}
		
		// 更新契機は「1：開始時」を設定
		map.put("UP_OPTY", "1");
		
		if(!"".equals(opSvcCd))
		{
			super.logPrint.printDebugLog("異動区分------------------->" + idoDiv);
			super.logPrint.printDebugLog("オプションサービスコード--->" + opSvcCd);
			
			// 異動区分が「00042：光電話・番号変更」で、オプションサービスコードが「B028：通話明細送付」の場合、
			//   オプションサービスコードに"9999"をセットして新規契約に置き換え、ルール判定結果「基準日からの相対日」に
			//   「翌日月初」を取得します。
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if ("00042".equals(idoDiv) && "B028".equals(opSvcCd))
			if (JBSbatKKConst.CD00576_IDO_DIV_00042.equals(idoDiv) && JBSbatKKConst.OP_SVC_CD_TEL_DTL_SOHU.equals(opSvcCd))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				super.logPrint.printDebugLog("★オプションサービスコードに9999をセット★");
				map.put("OP_SVC_CD", "9999");
			}
			else
			{
				// オプションサービスコード = KK_T_SVC_KEI.KK_SELECT_028.OP_SVC_CD
				map.put("OP_SVC_CD", opSvcCd);
			}
		}
		
		// 料金グループコード
		// 呼出元からのマップよりサービス契約の料金グループコードを
		// 主処理内でクラス変数prcGrpCdに設定
		map.put("PRC_GRP_CD", prcGrpCd);
		
		// 申込期間
		map.put("MSKM_PRD", mskmPrd);
		
		// オプションサービスコードが「B077：スマートリンクプレミアム」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("B077".equals(opSvcCd))
		if(JBSbatKKConst.OP_SVC_CD_SMARTLINK_PREMIUM.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// 異動区分
			map.put("IDO_DIV", idoDiv);
			
			// 料金計算日より求めた料金計算済の請求年月の末日を取得
			String seikyYmd = getPrcCalc();
			// 請求年月の末日以前／以降を設定する
			if (svcChrgStaymd.compareTo(seikyYmd) <= 0)
			{
				// 元のサービス契約のサービス課金開始年月日＜＝料金計算日より求めた料金計算済の請求年月の末日
				map.put("SEIKYU_YM_ZENGO", "1");
			}
			else
			{
				map.put("SEIKYU_YM_ZENGO", "0");
			}
		}
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0066001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> checkList1 = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		super.logPrint.printDebugLog("callRule0066001_END");
		return checkList1;
	}
	
//	/**
//	 * 
//	 *  サービス開始対象契約取得ファイルの作成を行います。
//	 *  
//	 * @return outputBean JBSbatOutputItem
//	 * @throws Exception メソッド内で発生した例外全般。
//	 */
//	private JBSbatOutputItem createKkifm030() throws Exception
//	{
//		
//		// 出力共通電文を生成する。
//		JBSbatOutputItem outputBean = new JBSbatOutputItem();
//		//入出力インターフェースオブジェクトを生成
//		JBSbatServiceInterfaceMap outmap = new JBSbatServiceInterfaceMap();
//		
//		//項目を設定
//		outmap.setString(JBSbatKKIFM030.SRI_YMD, sriYmd);									// 処理年月日
//		outmap.setString(JBSbatKKIFM030.SVC_KIS_SRSB_CD, svcKisSrsbCd);						// サービス開始処理種別コード
//		outmap.setString(JBSbatKKIFM030.SVC_KIS_SRTI_CD, svcKisSrtiCd);						// サービス開始処理単位コード
//		outmap.setString(JBSbatKKIFM030.SVC_KEI_NO, svcKeiNo);								// サービス契約番号
//		outmap.setString(JBSbatKKIFM030.SVC_KEI_UCWK_NO, svcKeiUcwkNo);						// サービス契約内訳番号
//		outmap.setString(JBSbatKKIFM030.KJN_YMD, svcStaYmdSvc);								// 基準年月日(サービス開始対象契約．基準日を設定する。)
//		outmap.setString(JBSbatKKIFM030.HNK_MAE_SVC_STA_YMD, hnkMaeSvcStaYmd);				// 変更前サービス開始年月日
//		outmap.setString(JBSbatKKIFM030.HNK_MAE_SVC_CHRG_STAYMD, hnkMaeSvcChrgStaymd);		// 変更前サービス課金開始年月日
//		outmap.setString(JBSbatKKIFM030.HNK_ATO_SVC_STA_YMD, hnkAtoSvcStaYmd);				// 変更後サービス開始年月日
//		outmap.setString(JBSbatKKIFM030.HNK_ATO_SVC_CHRG_STAYMD, hnkAtoSvcChrgStaymd);		// 変更後サービス課金開始年月日
//		outmap.setString(JBSbatKKIFM030.HOSEI_BF_SVC_CHRG_STAYMD, hoseiBfSvcChrgStaymd);	// 補正前サービス課金開始年月日
//		outmap.setString(JBSbatKKIFM030.HOSEI_AF_SVC_CHRG_STAYMD, hoseiAfSvcChrgStaymd);	// 補正後サービス課金開始年月日
//		
//		//出力フラグを設定
//		outmap.setOutFlg(true);
//		//出力共通電文に入出力インターフェースを設定する。
//		outputBean.addOutMapList(outmap);
//		//出力共通電文を返却
//		return outputBean;
//	}	
	
	/**
	 * 
	 * 相関ルール：開始日設定定義（オプションサービス）の呼び出しをを行います。
	 * 
	 * @param mskmPrd 申込期間
	 * @return resultList rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception 
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0074001(String mskmPrd) throws Exception 
	{
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		
		if(!"".equals(svcCd))
		{
			// サービスコード = KK_T_SVC_KEI.KK_SELECT_028.SVC_CD
			map.put("SVC_CD", svcCd);
		}
		
		if(!"".equals(opSvcCd))
		{
			// オプションサービスコード = KK_T_SVC_KEI.KK_SELECT_028.OP_SVC_CD
			map.put("OP_SVC_CD", opSvcCd);
		}
		
		// 申込期間
		map.put("MSKM_PRD", mskmPrd);
		
		// オプションサービスコードがeo光テレビケーブルテレビガイド誌の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("B068".equals(opSvcCd))
		if(JBSbatKKConst.OP_SVC_CD_CABLE_GUDMG.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			if(!"".equals(svcStaYmdSvc))
			{
				//サービス開始日桁数チェック
				if(svcStaYmdSvc.length() < 8){
					throw new JBSbatBusinessException(JPCBatchMessageConstant.EKKB0090TE, 
							new String[]{"サービス開始日:" + svcStaYmdSvc});
				}
				String day = svcStaYmdSvc.substring(6, 8);
				if(15 >= new Integer(day) )
				{
					// 元(親)のサービス契約のサービス開始日が１から１５日までの場合
					map.put("KK0081_SVC_STA_YMD", "1");
				}
				else
				{
					// 元(親)のサービス契約のサービス開始日が１６から末日までの場合
					map.put("KK0081_SVC_STA_YMD", "2");
				}
			}
		}
		// オプションサービスコード="B077：スマートリンクプレミアム"
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		else if("B077".equals(opSvcCd))
		else if(JBSbatKKConst.OP_SVC_CD_SMARTLINK_PREMIUM.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// 異動区分
			map.put("IDO_KBN", idoDiv);
			
			// 異動区分="00075：割賦情報変更"
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if("00075".equals(idoDiv))
			if(JBSbatKKConst.CD00576_IDO_DIV_00075.equals(idoDiv))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				// 申込期間
				map.put("MSKM_PRD", "");
				// 元(親)のサービス契約の料金グループコード
				map.put("PRC_GRP_CD", prcGrpCd);
			}
		}
		
		// 即時／翌月　「01：即時」固定。
		map.put("SKJ_YKJT", "01");
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0074001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		return resultList;
	}
	
	/**
	 * 
	 * 相関ルール：申込期間判定の呼び出しをを行います。
	 * 
	 * @param opSvcKeiMap オプションサービス契約情報
	 * @return String 判定結果
	 * @throws Exception 
	 */
	private String getMskmPrd(JBSbatCommonDBInterface opSvcKeiMap) throws Exception
	{
		String result = "0";
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		
		// 申込年月日（オプションサービス契約の登録時の申込明細番号より）
		mskmYmdOp = getMskmYmd(opSvcKeiMap);
		super.logPrint.printDebugLog("申込年月日--->" + mskmYmdOp);
		// 申込年月日空白
		if("".equals(mskmYmdOp))
		{
			return result;
		}
		
		// サービス契約．サービス開始日が空白
		if("".equals(svcStaYmdSvc))
		{
			return result;
		}
		
		// 起因となる契約のサービス課金開始年月日を設定（サービス契約or機器オプションサービス契約）
		// 主処理内でクラス変数svcChrgStaymdに設定している。
		// サービス課金開始日空白
		if("".equals(svcChrgStaymd))
		{
			return result;
		}
		
		// 申込年月日
		map.put("MSKM_YMD", mskmYmdOp);
		
		// サービス開始日 → サービス契約．サービス開始日
		map.put("SVC_STAYMD", svcStaYmdSvc);
		
		// サービス課金開始日 → サービス契約．サービス課金開始日
		map.put("SVC_CHRG_STAYMD", svcChrgStaymd);
		
		// 相関ルール呼出
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0088001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		if(null != resultList.get(0))
		{
			// 判定結果
			result = (String)resultList.get(0).get(0).get("JUDGE_RSLT");
		}
		
		return result;
	}
	
	/**
	 * 
	 * 申込明細番号をキーに申込年月日の取得を行います。
	 * 
	 * @param opSvcKeiMap オプションサービス契約情報
	 * @return String 申込年月日
	 * @throws Exception 
	 */
	private String getMskmYmd(JBSbatCommonDBInterface opSvcKeiMap) throws Exception
	{
		String result = "";
		
		// オプションサービス契約番号より登録時の申込明細番号を取得する。
		String op_svc_kei_no = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		String[] param = {op_svc_kei_no, super.opeDate};
		this.executeKK_T_OP_SVC_KEI_KK_SELECT_098(param);
		JBSbatCommonDBInterface init_OpSvcKeiMap = db_KK_T_OP_SVC_KEI_098.selectNext();
		if(null != init_OpSvcKeiMap)
		{
			// 申込明細番号
			String mskmDtlNo = JBSbatStringUtil.Rtrim(init_OpSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.MSKM_DTL_NO));
			
			super.logPrint.printDebugLog("■オプションサービス契約より登録時の申込明細番号--->" + op_svc_kei_no + ":" + mskmDtlNo);
			
			executeKK_T_MSKM_DTL_KK_SELECT_024(new Object[]{mskmDtlNo});
			
			JBSbatCommonDBInterface dbInfo = db_KK_T_MSKM_DTL.selectNext();
			
			if(null != dbInfo)
			{
				result = JBSbatStringUtil.Rtrim(dbInfo.getString(JBSbatKK_T_MSKM.MSKM_YMD));
			}
		}
		return result;
	}

	/**
	 * 
	 * ルール呼出結果によるサービス課金開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList074 ArrayList<ArrayList<HashMap<String, Object>>>
	 * @param svc_use_sta_kibo_ymd サービス利用開始希望年月日
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getSvcStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList074, String svc_use_sta_kibo_ymd) throws Exception
	{
		// フィールド変数の初期化
		stdDt               = "";
		relativeDateCount   = "";
		countMethod         = "";
		priorityStdDt       = "";
		kjnYmd              = "";
		
		if(null != checkList074.get(0))
		{
			
			// 各ルール結果を取得する。
			stdDt             = (String)checkList074.get(0).get(0).get("STD_DT");						// 基準日
			relativeDateCount = (String)checkList074.get(0).get(0).get("RELATIVE_DATE_COUNT");			// 基準日からの相対日
			countMethod       = (String)checkList074.get(0).get(0).get("COUNT_METHOD");					// 実日/営業日
			priorityStdDt     = (String)checkList074.get(0).get(0).get("PRIORITY_STD_DT");				// 優先基準日
			
			super.logPrint.printDebugLog("相関ルール(RULE0074001)呼出結果（基準日）：：：：：：：" +  stdDt);
			super.logPrint.printDebugLog("相関ルール(RULE0074001)呼出結果（基準日からの相対日）：" +  relativeDateCount);
			super.logPrint.printDebugLog("相関ルール(RULE0074001)呼出結果（実日/営業日 ）：：：：" +  countMethod);
			super.logPrint.printDebugLog("相関ルール(RULE0074001)呼出結果（優先基準日 ）：：：：" +  priorityStdDt);
			
			//呼び出したルール[RULE0074001_開始日設定定義（オプションサービス）]の結果を元にサービス開始年月日を算出する。
			// 基準日の取得
			// 基準日が"サービス契約のサービス開始年月日"の場合。
			if("1".equals(stdDt))
			{
				// サービス契約のサービス開始年月日を基準日に設定する。
				if(!"".equals(svcStaYmdSvc))
				{
					super.logPrint.printDebugLog("■■サービス契約のサービス開始年月日：：" +  svcStaYmdSvc);
					kjnYmd = svcStaYmdSvc;
				}
			}
			// 基準日が"申込受付日"の場合。
			else if("2".equals(stdDt))
			{
				// オプションサービス契約の申込年月日を基準日に設定する。
				super.logPrint.printDebugLog("■■オプションサービス契約の申込年月日：：" +  mskmYmdOp);
				kjnYmd = mskmYmdOp;
			}
			// 基準日が"バッチ処理の運用日"の場合。
			else if("3".equals(stdDt))
			{
				// 現在の仕様ではここには入らない
			}
			// 基準日が"料金計算日より求めた請求年月の末日"の場合。
			else if("6".equals(stdDt))
			{
				// 料金計算済みの請求年月の末日を基準日に設定する。
				kjnYmd = getPrcCalc();
			}
			
			// 基準日が"ＮＨＫ指定の開始日"の場合。
			else
			{
				// 現在の仕様ではここには入らない
			}
			
			// 基準日からの相対日の取得
			// 基準日からの相対日が"+0"の場合
			if("0".equals(relativeDateCount))
			{
				// 基準日の増減が無いのでそのままとする。
			}
			// 基準日からの相対日が"翌月月初"の場合
			else if("2".equals(relativeDateCount))
			{
				// 基準日の翌月1日を設定する。
				kjnYmd = adjustMonth(kjnYmd, 1);
			}
			// 基準日からの相対日が"翌々月月初"の場合
			else if("3".equals(relativeDateCount))
			{
				// 基準日の翌々月1日を設定する。
				kjnYmd = adjustMonth(kjnYmd, 2);
			}
			
			// 実日/営業日の取得
			// 実日/営業日が"実日"の場合
			if("0".equals(countMethod))
			{
				// 基準日の増減が無いのでそのままとする。
			}
			
			// 優先基準日の取得
			// 優先基準日が"オプションサービスのサービス開始希望日との大きい方"の場合
			if("1".equals(priorityStdDt))
			{
				super.logPrint.printDebugLog("■サービス開始希望日：：" +  svc_use_sta_kibo_ymd);
				
				if(!"".equals(svc_use_sta_kibo_ymd))
				{
					// サービス利用開始希望年月日のほうが設定した基準日より大きい場合
					if(0 > kjnYmd.compareTo(svc_use_sta_kibo_ymd))
					{
						kjnYmd = svc_use_sta_kibo_ymd;
					}
				}
			}
			// 優先基準日が"オプションサービスのサービス開始希望日、運用日との大きい方"の場合
			if("2".equals(priorityStdDt))
			{
				super.logPrint.printDebugLog("■サービス開始希望日：：" +  svc_use_sta_kibo_ymd);
				super.logPrint.printDebugLog("■■優先基準日　：：" +  priorityStdDt);
				super.logPrint.printDebugLog("■■オプションサービスコード　：：" +  opSvcCd);
				super.logPrint.printDebugLog("■■異動区分：：" +  idoDiv);
				
				//OM-2014-0001180　障害対応
				// ++++++++++ v22.00.00 変更開始 ++++++++++
//				if(op_svcCd_myHp.equals(opSvcCd) && idoDiv_opHktgi.equals(idoDiv))
				if(JBSbatKKConst.OP_SVC_CD_MY_HP.equals(opSvcCd) && JBSbatKKConst.CD00576_IDO_DIV_00003.equals(idoDiv))
				// ++++++++++ v22.00.00 変更終了 ++++++++++
				{
					super.logPrint.printDebugLog("■■サービス利用開始希望年月日との比較のみ");
					if(!"".equals(svc_use_sta_kibo_ymd))
					{
						super.logPrint.printDebugLog("■■サービス開始希望日：：" +  svc_use_sta_kibo_ymd);
						// サービス利用開始希望年月日のほうが設定した基準日より大きい場合
						if(0 > kjnYmd.compareTo(svc_use_sta_kibo_ymd))
						{
							kjnYmd = svc_use_sta_kibo_ymd;
						}
					}
				
				}
				else
				{
					if(!"".equals(svc_use_sta_kibo_ymd))
					{
						// サービス利用開始希望年月日のほうが設定した基準日より大きい場合
						if(0 > kjnYmd.compareTo(svc_use_sta_kibo_ymd))
						{
							kjnYmd = svc_use_sta_kibo_ymd;
						}
					}
					
					// 運用日のほうが設定した基準日より大きい場合
					if(0 > kjnYmd.compareTo(super.opeDate))
					{
						kjnYmd = super.opeDate;
					}
				}

			}
			// 優先基準日が"運用日との大きい方"の場合
			else if("3".equals(priorityStdDt))
			{
				super.logPrint.printDebugLog("■■優先基準日　：：" +  priorityStdDt);
				super.logPrint.printDebugLog("■■オプションサービスコード　：：" +  opSvcCd);
				super.logPrint.printDebugLog("■■異動区分：：" +  idoDiv);
				//OM-2014-0001180　障害対応
				// ++++++++++ v22.00.00 変更開始 ++++++++++
//				if(op_svcCd_myHp.equals(opSvcCd) && idoDiv_opHktgi.equals(idoDiv))
				if(JBSbatKKConst.OP_SVC_CD_MY_HP.equals(opSvcCd) && JBSbatKKConst.CD00576_IDO_DIV_00003.equals(idoDiv))
				// ++++++++++ v22.00.00 変更終了 ++++++++++
				{
					//運用日との比較をしない。
					super.logPrint.printDebugLog("■■運用日との比較をしない。");
				}
				else
				{
					// 運用日のほうが設定した基準日より大きい場合
					if(0 > kjnYmd.compareTo(super.opeDate))
					{
						kjnYmd = super.opeDate;
					}
				}
			}
			// 優先基準日が"サービス契約のサービス課金開始年月日が、請求年月の末日より大きい場合はサービス課金開始年月日の前日と運用日の小さい方"の場合
			else if("4".equals(priorityStdDt))
			{
				// 請求年月の末日 < サービス課金開始年月日
				if(0 > kjnYmd.compareTo(svcChrgStaymd))
				{
					//サービス課金開始年月日桁数チェック
					if(svcChrgStaymd.length() < 6){
						throw new JBSbatBusinessException(JPCBatchMessageConstant.EKKB0090TE, 
								new String[]{"サービス課金開始年月日:" + svcChrgStaymd});
					}
					// サービス課金開始年月日の前日
					kjnYmd = JBSbatDateUtil.adjustDate(svcChrgStaymd, -1);
					
					// 設定した基準日のほうが運用日より大きい場合
					if(0 > super.opeDate.compareTo(kjnYmd))
					{
						kjnYmd = super.opeDate;
					}
				}
			}
			// 優先基準日が"関連機器出荷完了日+10日"の場合
			else if("5".equals(priorityStdDt))
			{
				// 配送完了日より基準日の再設定処理を行う。
				this.setkjnYmdTab();
			}
			// 優先基準日が"サービス契約のサービス課金開始年月日が、請求年月の末日より大きい場合はサービス課金開始年月日の同月末日と運用日の小さい方"の場合
			else if("6".equals(priorityStdDt))
			{
				// 請求年月の末日 < サービス課金開始年月日
				if(0 > kjnYmd.compareTo(svcChrgStaymd))
				{
					//サービス課金開始年月日桁数チェック
					if(svcChrgStaymd.length() < 6){
						throw new JBSbatBusinessException(JPCBatchMessageConstant.EKKB0090TE, 
								new String[]{"サービス課金開始年月日:" + svcChrgStaymd});
					}
					// サービス課金開始年月日の同月末日
					kjnYmd = svcChrgStaymd.substring(0, 6) + JBSbatDateUtil.getEndOfMonth(svcChrgStaymd.substring(0, 6));
					
					// 設定した基準日のほうが運用日より大きい場合
					if(0 > super.opeDate.compareTo(kjnYmd))
					{
						kjnYmd = super.opeDate;
					}
				}
			}
		}
		
		super.logPrint.printDebugLog("相関ルール(RULE0074001)--->" + kjnYmd);
		
	}
	
	/**
	 * 料金計算日より求めた料金計算済の請求年月の末日を取得します。
	 * <br>
	 * @return String
	 * @throws Exception 
	 * 
	 */
	private String getPrcCalc() throws Exception
	{
		String result = "";
		
		executeCH_M_PRC_SCHDL_TEIGI_KK_SELECT_012(new Object[]{"03", opeDate});
		
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_SCHDL_TEIGI.selectNext();
		
		if(null != dbMap)
		{
			// イベント年月日
			String eventYmd = JBSbatStringUtil.Rtrim(dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.EVENT_YMD));
			// 請求年月
			String seikyYm = JBSbatStringUtil.Rtrim(dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.SEIKY_YM));
			
			// 運用日が料金計算日当日の場合、請求年月を前月に置き換える
			if(opeDate.equals(eventYmd)){
				seikyYm = JBSbatDateUtil.adjustMonth(seikyYm, -1);
			}
			// 請求年月の末日
			result = seikyYm + JBSbatDateUtil.getEndOfMonth(seikyYm);
		}
		
		return result;
	}

	/**
	 * オプションサービス契約を登録します。
	 * <br>
	 * @param outMap オプションサービス契約検索結果
	 * @throws Exception 
	 */
	private void addOpsvckei(JBSbatCommonDBInterface outMap) throws Exception
	{
		// 登録用データ格納
		Object[] param_add = new Object[79];
		
		// システム日付を取得
		String sysdate = JBSbatDateUtil.getSystemDateTimeStamp();
		
		// オプションサービス契約番号を取得
		String opsvckeino = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		
		// オプションサービスコード
		String opSvcCd = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		super.logPrint.printDebugLog("★オプションサービスコード★" + opSvcCd + "★" + opsvckeino);
		
		// オプションサービス契約番号
		param_add[0] = opsvckeino;
		// 世代登録年月日時分秒 → システム日付を設定
		param_add[1] = sysdate;
		// オプションサービス契約ステータス → 100：サービス提供中を設定
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[2] = CD00037_100;
		param_add[2] = JBSbatKKConst.SVC_KEI_STAT_SVCTK_CHU;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// オプションサービスコード
		param_add[3] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		// 料金コースコード
		param_add[4] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.PCRS_CD));
		// 料金プランコード
		param_add[5] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.PPLAN_CD));
		// 親契約識別コード
		param_add[6] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OYA_KEI_SKBT_CD));
		// サービス契約番号
		param_add[7] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_KEI_NO));
		// サービス契約内訳番号
		param_add[8] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_KEI_UCWK_NO));
		// 法人サービス契約受付番号
		param_add[9] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.HOJIN_SVC_KEI_UK_NO));
		// SYSID
		param_add[10] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SYSID));
		// 申込明細番号
		param_add[11] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.MSKM_DTL_NO));
		// 試用加入年月日
		param_add[12] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.FTRIAL_KANYU_YMD));
		// 試用期間終了年月日
		param_add[13] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.FTRIAL_PRD_ENDYMD));
		// 本加入年月日
		param_add[14] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.HONKANYU_YMD));
		// 本加入移行期限年月日
		param_add[15] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.HONKANYU_IKO_KIGEN_YMD));
		// サービス利用開始希望年月日
		param_add[16] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_USE_STA_KIBO_YMD));
		// 予約適用開始希望年月日
		param_add[17] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_TSTA_KIBO_YMD));
		// オプションサービス契約後続業務依頼年月日
		param_add[18] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_KZKWRK_REQYMD));
		// 照査年月日
		param_add[19] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_YMD));
		// 照査取消年月日
		param_add[20] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_CL_YMD));
		// 審査結果送信コード
		param_add[21] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SKEKKA_SEND_CD));
		// 契約締結年月日
		param_add[22] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.KEI_CNC_YMD));
		// 予約適用年月日
		param_add[23] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_APLY_YMD));
		// 予約取消年月日
		param_add[24] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_CL_YMD));
		// 予約適用コード
		param_add[25] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_APLY_CD));
		// プラン開始年月日 → 基準日を設定
		param_add[26] = kjnYmd;
		// プラン終了年月日 → 20991231を設定
		param_add[27] = END_DATE;
		// プラン課金開始年月日 → RULE0066結果
		param_add[28] = hnkAtoSvcChrgStaymd;
		// プラン課金終了年月日 → 20991231を設定
		param_add[29] = END_DATE;
		// プラン終了種別コード
		param_add[30] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.PLAN_END_SBT_CD));
		// サービスキャンセル年月日
		param_add[31] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_YMD));
		// サービスキャンセル理由コード
		param_add[32] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_RSN_CD));
		// サービス開始年月日 → 基準日を設定
		param_add[33] = kjnYmd;
		// サービス開始時分秒
		param_add[34] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STA_HMS));
		
		// "B068:ｅｏ光テレビガイド誌"
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("B068".equals(opSvcCd))
		if(JBSbatKKConst.OP_SVC_CD_CABLE_GUDMG.equals(opSvcCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// 表示用サービス提供開始年月日 → 基準日を設定
			param_add[35] = kjnYmd;
		}
		else
		{
			// 表示用サービス提供開始年月日
			param_add[35] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.DSP_SVCTK_STAYMD));
		}
		
		// サービス課金開始年月日 → RULE0066結果
		param_add[36] = hnkAtoSvcChrgStaymd;
		// サービス停止年月日
		param_add[37] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_YMD));
		// サービス停止理由コード
		param_add[38] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RSN_CD));
		// サービス停止解除年月日
		param_add[39] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RLS_YMD));
		// サービス停止解除理由コード
		param_add[40] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RLS_RSN_CD));
		// 休止中断コード
		param_add[41] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.PAUSE_STP_CD));
		// サービス休止年月日
		param_add[42] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_YMD));
		// サービス休止理由コード
		param_add[43] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RSN_CD));
		// サービス休止理由メモ
		param_add[44] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RSN_MEMO));
		// サービス休止解除年月日
		param_add[45] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_YMD));
		// サービス休止解除理由コード
		param_add[46] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_RSN_CD));
		// サービス休止解除理由メモ
		param_add[47] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_RSN_MEMO));
		// サービス終了年月日 → 20991231を設定
		param_add[48] = END_DATE;
		// サービス終了時分秒
		param_add[49] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_END_HMS));
		// サービス課金終了年月日 → 20991231を設定
		param_add[50] = END_DATE;
		// サービス解約年月日
		param_add[51] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_YMD));
		// サービス解約理由コード
		param_add[52] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DLRE_CD));
		// サービス解約理由メモ
		param_add[53] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DLRE_MEMO));
		// 解約担当ユーザーID
		param_add[54] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.DSL_TNT_USER_ID));
		// サービス解約手続完了フラグ
		param_add[55] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_TTDKI_FIN_FLG));
		// 回復年月日
		param_add[56] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.KAIHK_YMD));
		// サービスキャンセル取消年月日
		param_add[57] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_CL_YMD));
		// サービス解約取消年月日
		param_add[58] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_CL_YMD));
		// 課金開始年月日補正有無
		param_add[59] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.CHRG_STA_YMD_HOSEI_UM));
		// サービス休止課金開始年月日
		param_add[60] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_CHRG_STA_YMD));
		// オプションサービス契約引継発生年月日
		param_add[61] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_HKHASYMD));
		// 違約金発生コード
		param_add[62] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.PNLTY_HASSEI_CD));
		// 異動区分
		param_add[63] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.IDO_DIV));
		// 照査解約完了コード
		param_add[64] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_DSL_FIN_CD));
		// サービス提供物消去処理実施年月日時分秒
		param_add[65] = JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_OP_SVC_KEI.SVCTK_BUT_DEL_TRN_JSSI_DTM));
		// 登録年月日時分秒
		param_add[66] = sysdate;
		// 登録オペレータアカウント
		param_add[67] = batchUserId;
		// 更新年月日時分秒
		param_add[68] = sysdate;
		// 更新オペレータアカウント
		param_add[69] = batchUserId;
		// 削除年月日時分秒
		param_add[70] = "";
		// 削除オペレータアカウント
		param_add[71] = "";
		// 無効フラグ → 0：有効を設定
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[72] = "0";
		param_add[72] = JBSbatKKConst.MK_FLG_YK;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// 登録運用年月日
		param_add[73] = "";
		// 登録処理ID
		param_add[74] = "";
		// 更新運用年月日
		param_add[75] = "";
		// 更新処理ID
		param_add[76] = "";
		// 削除運用年月日
		param_add[77] = "";
		// 削除処理ID
		param_add[78] = "";
		
		// オプションサービス契約の登録を行います。
		this.executeKK_T_OP_SVC_KEI_PKINSERT(param_add);
		
		// オプションサービス契約番号に紐づくサブクラスの登録を行います。
		JKKBatCommon.createSubTypeKK0351(commonItem, opsvckeino,
				JBSbatStringUtil.Rtrim(outMap.getString(JBSbatKK_T_SVC_KEI.GENE_ADD_DTM)), sysdate);
	}
	
//	/**
//	 * サービス契約排他制御への更新処理を行います。<br>
//	 * <p>
//	 * <b>処理フロー</b><br>
//	 * <pre>
//	 * 1.更新処理を実行します。<br>
//	 * 
//	 * </pre>
//	 * <p>
//	 * @param  var       サービス契約番号。
//	 * @throws Exception 業務サービス内で発生した例外全般。
//	 */
//	private void updateSvkeiExcCtrl(String var) throws Exception
//	{
//		// サービス契約排他制御の最終更新年月日時分秒の更新を行う。
//		JBSbatCommonDBInterface paramMap = new JBSbatCommonDBInterface();
//		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
//		
//		// サービス契約番号を設定
//		whereMap.setValue(JBSbatKK_T_SVKEI_EXC_CTRL.SVC_KEI_NO, var);
//		
//		// 最終更新年月日時分秒を更新。
//		paramMap.setValue(JBSbatKK_T_SVKEI_EXC_CTRL.LAST_UPD_DTM, JBSbatDateUtil.getSystemDateTimeStamp());
//		db_KK_T_SVKEI_EXC_CTRL.updateByPrimaryKeys(whereMap, paramMap);
//	}
	
	
	/**
	 * オプションサービス契約の登録または更新処理を行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.対象となるオプションサービス契約の抽出を行います。<br>
	 * 2.サービス開始処理種別コードにより処理を振り分けます。<br>
	 * 
	 * </pre>
	 * <p>
	 * @param  opSvcKeiMap　KK_T_SVC_KEI_KK_SELECT_028検索結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void createOpSvcKei(JBSbatCommonDBInterface opSvcKeiMap) throws Exception
	{
		// サービス開始処理種別コードが「10：サービス開始」、「20サービス開始登録（工事起因）」、
		// 「30：サービス開始（補正）」、「40：サービス開始（補正）電話」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if("10".equals(svcKisSrsbCd) || "20".equals(svcKisSrsbCd) || "30".equals(svcKisSrsbCd) || "40".equals(svcKisSrsbCd))
		if(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_10.equals(svcKisSrsbCd) || JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_20.equals(svcKisSrsbCd)
				|| JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_30.equals(svcKisSrsbCd) || JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_40.equals(svcKisSrsbCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// オプションサービス契約の登録を行う。
			this.insertOpSvcKei(opSvcKeiMap);
		}
		// サービス開始処理種別コードが「50：課金開始日変更」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		else if("50".equals(svcKisSrsbCd))
		else if(JBSbatKKConst.KKIFM030_SVC_KIS_SRSB_CD_50.equals(svcKisSrsbCd))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			// オプションサービス契約の更新を行う。
			this.updateOpSvcKei(opSvcKeiMap);
		}
	}
	
	/**
	 * 対象となるオプションサービス契約の登録処理を行います。<br>
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void insertOpSvcKei(JBSbatCommonDBInterface opSvcKeiPkMap) throws Exception
	{
		if(!"".equals(kjnYmd))
		{
			// フィールド変数の初期化を行う。
			opSvcKeiNo = "";
			geneAddDtm = "";
			
			opSvcKeiNo = JBSbatStringUtil.Rtrim(opSvcKeiPkMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
			geneAddDtm = JBSbatStringUtil.Rtrim(opSvcKeiPkMap.getString(JBSbatKK_T_OP_SVC_KEI.GENE_ADD_DTM));
			
			// 条件項目を設定します
			String [] whereParam = {opSvcKeiNo, geneAddDtm};
			
			// PK検索を行う
			opSvcKeiKey = executeKK_T_OP_SVC_KEI_PKSELECT(whereParam);
			
			// サービス契約情報が取得できた場合
			if(null != opSvcKeiKey)
			{
				// RULEの結果よりサービス開始希望日との関連でサービス開始日より課金開始日が早くなった場合
				if(0 > hnkAtoSvcChrgStaymd.compareTo(kjnYmd))
				{
					// 課金開始日はサービス開始日の翌月月初に補正する。
					String date2 = JBSbatDateUtil.adjustMonth(kjnYmd, 1);
					hnkAtoSvcChrgStaymd = date2.substring(0, 6) + "01";
				}
				
				// サービス契約を登録します。
				this.addOpsvckei(opSvcKeiKey);
			}
		}
	}
	
	/**
	 * 対象となるオプションサービス契約の更新処理を行います。<br>
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void updateOpSvcKei(JBSbatCommonDBInterface opSvcKeiPkMap) throws Exception
	{
		// フィールド変数の初期化を行う。
		opSvcKeiNo = "";
		geneAddDtm = "";
		
		opSvcKeiNo = JBSbatStringUtil.Rtrim(opSvcKeiPkMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		geneAddDtm = JBSbatStringUtil.Rtrim(opSvcKeiPkMap.getString(JBSbatKK_T_OP_SVC_KEI.GENE_ADD_DTM));
		
		// オプションサービス契約テーブルに排他制御処理を実行する。
		// 排他制御呼び出しメソッド：db_KK_T_OP_SVC_KEI.selectByPrimaryKeysForUpdate()
		// 下記パラメータを設定
		// (1)OP_SVC_KEI_NO = KK_T_OP_SVC_KEI.KK_SELECT_001.OP_SVC_KEI_NO
		// (2)GENE_ADD_DTM  = KK_T_OP_SVC_KEI.KK_SELECT_001.GENE_ADD_DTM
		opSvcKeiKey = new JBSbatCommonDBInterface();
		opSvcKeiKey.setValue(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO, opSvcKeiNo);
		opSvcKeiKey.setValue(JBSbatKK_T_OP_SVC_KEI.GENE_ADD_DTM, geneAddDtm);
		db_KK_T_OP_SVC_KEI.selectByPrimaryKeysForUpdateWait(opSvcKeiKey);
		
		// オプションサービス契約テーブルのPK更新を実行する。
		// PK更新呼び出しメソッド：executeKK_T_OP_SVC_KEI_PKUPDATE2(setParam,whereParam)
		// 下記パラメータを設定
		// setParam
		// (1)サービス課金開始年月日 = サービス開始対象契約取得ファイル．基準年月日
		// whereParam
		// (1)OP_SVC_KEI_NO = KK_T_OP_SVC_KEI.KK_SELECT_012.OP_SVC_KEI_NO
		// (2)GENE_ADD_DTM  = KK_T_OP_SVC_KEI.KK_SELECT_012.GENE_ADD_DTM
		// 設定項目を設定します
		String [] setParam = {hnkAtoSvcChrgStaymd};
		// 条件項目を設定します
		String [] whereParam = {opSvcKeiNo, geneAddDtm};
		
		executeKK_T_OP_SVC_KEI_PKUPDATE(setParam, whereParam);
	}
	
	/**
	 * 
	 * 宅内機器種別コードが「タブレット」の配送完了日より基準日の
	 * 再設定処理を行います。<br>
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void setkjnYmdTab() throws Exception
	{
		// タブレットあり、なし判定
		if(!isTabUmu())
		{
			super.logPrint.printDebugLog("■タブレットなし：" + svcKeiNo);
			// タブレットがない場合は、サービス契約の開始日
			kjnYmd = svcStaYmdSvc;
		}
		else
		{
			super.logPrint.printDebugLog("■タブレットあり：" + svcKeiNo);
			// 対象のオプションサービス契約から機器提供サービス契約の配送完了年月日を取得する。
			String[] param = {super.opeDate, svcKeiNo, super.opeDate};
			this.executeKK_T_KKTK_SVC_KEI_KK_SELECT_081(param);
			
			// 検索結果がある場合
			JBSbatCommonDBInterface resultMap = db_KK_T_KKTK_SVC_KEI.selectNext();
			
			if(null != resultMap)
			{
				super.logPrint.printDebugLog("■配送完了年月日の取得：" + JBSbatStringUtil.Rtrim(resultMap.getString(JBSbatDK_T_HAISO.HAISO_FIN_YMD)));
				
				// 配送完了年月日+10日と設定されている基準日を比較し、配送完了年月日+10日のほうが
				// 遅い場合は基準日として置き換える。
				String haiso_fin_ymd = JBSbatStringUtil.Rtrim(resultMap.getString(JBSbatDK_T_HAISO.HAISO_FIN_YMD));
				haiso_fin_ymd = JBSbatDateUtil.adjustDate(haiso_fin_ymd, 10);
				if("".equals(haiso_fin_ymd))
				{
					// 配送完了年月日+10日が設定されない場合は、処理対象外とする
					kjnYmd = "";
				}
				else
				{
					if(0 > kjnYmd.compareTo(haiso_fin_ymd))
					{
						kjnYmd = haiso_fin_ymd;
					}
				}
			}
			else
			{
				// 配送がない場合は、割賦契約ステータスチェック
				// 割賦契約ステータス="030:締結済"または、"100:完了済"
				if(isKapKeiStat())
				{
					// サービス契約の開始日
					super.logPrint.printDebugLog("■割賦契約ステータスチェックOK：" + svcKeiNo);
					kjnYmd = svcStaYmdSvc;
				}
				else
				{
					super.logPrint.printDebugLog("■割賦契約ステータスチェックNG：" + svcKeiNo);
					// 処理対象外とする
					kjnYmd = "";
				}
			}
		}
		
		super.logPrint.printDebugLog("★★★基準日★★★" + kjnYmd);
	}
	
	/**
	 * 
	 * 割賦契約ステータス判定
	 * @return true:OK
	 *          false:NG
	 * @throws Exception 
	 */
	private boolean isKapKeiStat() throws Exception
	{
		executeKK_T_KAP_KEI_KK_SELECT_010(new Object[]{super.opeDate, super.opeDate, svcKeiNo, super.opeDate});
		
		JBSbatCommonDBInterface dbMap = db_KK_T_KAP_KEI.selectNext();
		
		// 検索結果あり
		if(null != dbMap)
		{
			// 割賦契約ステータス
			String kapKeiStat = JBSbatStringUtil.Rtrim(dbMap.getString(JBSbatKK_T_KAP_KEI.KAP_KEI_STAT));
			
			// 割賦契約ステータス="030:締結済"または、"100:完了済"
			// ++++++++++ v22.00.00 変更開始 ++++++++++
//			if("030".equals(kapKeiStat) || "100".equals(kapKeiStat))
			if(JBSbatKKConst.KAP_KEI_STAT_TIKT.equals(kapKeiStat) || JBSbatKKConst.KAP_KEI_STAT_FIN.equals(kapKeiStat))
			// ++++++++++ v22.00.00 変更終了 ++++++++++
			{
				return true;
			}
		}
		
		return false;
	}

	/**
	 * 
	 * タブレットありなし判定
	 * @return true:タブレットあり
	 *          false:タブレットなし
	 * @throws Exception 
	 */
	private boolean isTabUmu() throws Exception
	{
		executeKK_T_KKTK_SVC_KEI_KK_SELECT_178(new Object[]{super.opeDate, svcKeiNo, super.opeDate});
		
		JBSbatCommonDBInterface dbMap = db_KK_T_KKTK_SVC_KEI.selectNext();
		
		// 検索結果なし
		if(null == dbMap)
		{
			super.logPrint.printDebugLog("★★★タブレットなし★★★" + svcKeiNo);
			return false;
		}
		
		return true;
	}
	
	/**
	 * 
	 * 異動予約情報を設定
	 * 
	 * @param  opSvcKeiMap　KK_T_SVC_KEI_KK_SELECT_028検索結果
	 * @param mskmPrd 申込期間
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void setIdoRsv(JBSbatCommonDBInterface opSvcKeiMap,String mskmPrd) throws Exception
	{
		super.logPrint.printDebugLog("▼異動予約情報を設定処理 setIdoRsv_start");
		// オプションサービス契約番号
		String op_svc_kei_no = JBSbatStringUtil.Rtrim(opSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_NO));
		
		//異動予約存在チェック
		String[] param1 = {op_svc_kei_no};
		executeKK_T_IDO_RSV_KK_SELECT_051(param1);
		JBSbatCommonDBInterface idoRsvMap = db_KK_T_IDO_RSV.selectNext();
		
		//存在する場合は終了
		if(null != idoRsvMap)
		{
			super.logPrint.printDebugLog("▼異動予約が既に存在するため登録対象外（オプションサービスコード：" +op_svc_kei_no+"）");
			return;
		}
		
		//登録情報取得
		// 申込明細番号
		String mskmDtlNo = ""; 
		
		String[] param = {op_svc_kei_no, super.opeDate};
		this.executeKK_T_OP_SVC_KEI_KK_SELECT_098(param);
		JBSbatCommonDBInterface init_OpSvcKeiMap = db_KK_T_OP_SVC_KEI_098.selectNext();
		if(null != init_OpSvcKeiMap)
		{
			// 申込明細番号
			mskmDtlNo = JBSbatStringUtil.Rtrim(init_OpSvcKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.MSKM_DTL_NO));
		}
		
		// 相関ルール名：課金開始日設定定義（サービス）を呼び出す。
		ArrayList<ArrayList<HashMap<String, Object>>> checkList = callRule0066001(opSvcKeiMap, mskmPrd);
		
		// ルール呼出結果によるサービス課金開始年月日算出用データ取得を呼び出す。
		getSvcChrgStaymd(checkList);
		
		// 異動予約TBL登録処理
		this.insertIdoRsv(mskmDtlNo, op_svc_kei_no);
		
		super.logPrint.printDebugLog("▼異動予約情報を設定処理 setIdoRsv_end");
		
	}
	
	/**
	 * 異動予約登録をします。
	 * <br>
	 * @param mskmDtlNo 申込明細番号
	 * @param opSvcKeiNo オプションサービス契約番号
	 * @throws Exception 
	 */
	private void insertIdoRsv(String mskmDtlNo, String opSvcKeiNo) throws Exception
	{
		super.logPrint.printDebugLog("insertIdoRsv_START");
		
		// システム日付を取得
		String sysdate = JBSbatDateUtil.getSystemDateTimeStamp();
		
		// 登録用データ格納
		Object[] param_add = new Object[53];
		
		// 異動予約番号 → 自動採番
		param_add[0] = JBSbatStringUtil.padNumFormString(
				JBSbatOracleSeqUtil.getNextSeq(commonItem.getConnection(), "SEQ_IDO_RSV_NO"), 15);;
		// 異動区分 → 00031：オプション設定
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[1] = "00031";
		param_add[1] = JBSbatKKConst.CD00576_IDO_DIV_00031;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// 異動予約詳細コード → 014：オプション開始
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[2] = "014";
		param_add[2] = JBSbatKKConst.CD01167_IDO_RSV_DTL_CD_014;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// 予約適用年月日 → サービス開始年月日
		param_add[3] = kjnYmd;
		// 異動予約反映年月日
		param_add[4] = "";
		// 異動予約取消年月日
		param_add[5] = "";
		// 異動予約状態コード → 00：未反映を設定
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[6] = "00";
		param_add[6] = JBSbatKKConst.CD01168_IDO_RSV_STAT_CD_00;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// 申込明細番号
		param_add[7] = mskmDtlNo;
		// SYSID
		param_add[8] = "";
		// 請求契約番号
		param_add[9] = "";
		// サービス契約番号
		param_add[10] = "";
		// サービス契約内訳番号
		param_add[11] = "";
		// オプションサービス契約番号
		param_add[12] = opSvcKeiNo;
		// サブオプションサービス契約番号
		param_add[13] = "";
		// 機器提供サービス契約番号
		param_add[14] = "";
		// 割引サービス契約番号
		param_add[15] = "";
		// サービス契約回線内訳番号
		param_add[16] = "";
		// 併合先SYSID
		param_add[17] = "";
		// 分割先SYSID
		param_add[18] = "";
		// 併合先請求契約番号
		param_add[19] = "";
		// 分割先請求契約番号
		param_add[20] = "";
		// 新料金グループコード
		param_add[21] = "";
		// 新料金コースコード
		param_add[22] = "";
		// 新料金プランコード
		param_add[23] = "";
		// 新提供方式契約番号
		param_add[24] = "";
		// 新電波障害案件番号
		param_add[25] = "";
		// 旧料金グループコード
		param_add[26] = "";
		// 旧料金コースコード
		param_add[27] = "";
		// 旧料金プランコード
		param_add[28] = "";
		// 旧提供方式契約番号
		param_add[29] = "";
		// 旧電波障害案件番号
		param_add[30] = "";
		// 工事案件番号
		param_add[31] = "";
		// 違約金発生コード
		param_add[32] = "";
		// オプション引継先サービス契約番号
		param_add[33] = "";
		// サービス休止課金開始年月日
		param_add[34] = "";
		// サービス課金終了年月日
		param_add[35] = "20991231";
		// プラン課金開始年月日
		param_add[36] = hnkAtoSvcChrgStaymd;
		// プラン課金終了年月日
		param_add[37] = "20991231";
		// 異動予約理由コード
		param_add[38] = "";
		// 異動予約理由メモ
		param_add[39] = "";
		// 登録年月日時分秒
		param_add[40] = sysdate;
		// 登録オペレータアカウント
		param_add[41] = batchUserId;
		// 更新年月日時分秒
		param_add[42] = sysdate;
		// 更新オペレータアカウント
		param_add[43] = batchUserId;
		// 削除年月日時分秒
		param_add[44] = "";
		// 削除オペレータアカウント
		param_add[45] = "";
		// 無効フラグ → 0：有効を設定
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		param_add[46] = "0";
		param_add[46] = JBSbatKKConst.MK_FLG_YK;
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		// 登録運用年月日
		param_add[47] = "";
		// 登録処理ID
		param_add[48] = "";
		// 更新運用年月日
		param_add[49] = "";
		// 更新処理ID
		param_add[50] = "";
		// 削除運用年月日
		param_add[51] = "";
		// 削除処理ID
		param_add[52] = "";
		
		// 異動予約の登録を行います。
		this.executeKK_T_IDO_RSV_PKINSERT(param_add);
		
		super.logPrint.printDebugLog("insertIdoRsv_END");
	}
	
	/**
	 * 電話レコード更新対象データチェック
	 * <br>
	 * @param svcCd028 サービスコード
	 * @param svcKeiUcwkNo028 サービス契約内訳番号
	 * @return true：チェックOK、false：チェックNG
	 * @throws Exception メソッド内で発生した例外全般。
	 */
	private boolean isUpdateTrgtTel(String svcCd028, String svcKeiUcwkNo028) throws Exception
	{
		super.logPrint.printDebugLog("isUpdateTrgtTel_START");
		
		boolean rslt = true;
		
		// サービスコードが「02：電話」の場合
		// ++++++++++ v22.00.00 変更開始 ++++++++++
//		if ("02".equals(svcCd028))
		if (JBSbatKKConst.SVC_CD_TEL_SVC.equals(svcCd028))
		// ++++++++++ v22.00.00 変更終了 ++++++++++
		{
			super.logPrint.printDebugLog("★サービスコード「02：電話」★");
			
			// サービス契約内訳番号の同一チェックを実施します。
			// オプションサービス契約番号に紐づくサービス契約内訳番号が、
			//   インプットファイルのサービス契約内訳番号と同一で無い場合対象外とします。
			if (!"".equals(svcKeiUcwkNo028))
			{
				super.logPrint.printDebugLog("★サービス契約内訳番号値あり★");
				
				if (!svcKeiUcwkNo.equals(svcKeiUcwkNo028))
				{
					super.logPrint.printDebugLog("★サービス契約内訳番号違い：対象外★");
					rslt = false;
				}
			}
			else
			{
				super.logPrint.printDebugLog("★サービス契約内訳番号値なし★");
			}
		}
		else
		{
			super.logPrint.printDebugLog("★サービスコード「02：電話」以外★");
		}
		
		super.logPrint.printDebugLog("isUpdateTrgtTel_END");
		return rslt;
	}
}
