/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatKKTmcpSvcKeiStaAdd
*	ソースファイル名	：JBSbatKKTmcpSvcKeiStaAdd.java
*	作成者				：富士通　
*	作成日				：2018年09月27日
*＜機能概要＞
*　端末補償サービス契約開始登録部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v39.00.00	2018/10/01	FJ)周藤		【ANK-3484-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.JBSbatKKIFM862;
import eo.business.util.table.JBSbatKK_T_OP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SBOP_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.common.constant.JPCBatchMessageConstant;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatInputFileUtil;
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;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatKKTmcpSvcKeiStaAdd extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(オプションサービス契約)*/
	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";

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

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

	/** テーブルアクセスクラス(オプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_OP_SVC_KEI = null;

	/** テーブルアクセスクラス(サブオプションサービス契約)*/
	private JBSbatSQLAccess db_KK_T_SBOP_SVC_KEI = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/**
	 * DBインターフェース(オプションサービス契約)
	 */
	protected JBSbatCommonDBInterface opSvcKeiKey = null;
	
	/**
	 * DBインターフェース(サブオプションサービス契約)
	 */
	protected JBSbatCommonDBInterface sbopSvcKeiKey = null;
	
	/** データ(1件) */
	private String dataLine = null;

	/** 端末補償サービス契約開始対象ファイルパス */
	private String tmcpSvcKeiStaTgFilePath = null;

	/** 端末補償サービス契約開始対象ファイルオブジェクト */
	private JBSbatInputFileUtil tmcpSvcKeiStaTgFileObj = null;

	/** 端末補償サービス契約開始対象ファイルオブジェクト */
	private JBSbatDefFileUtil tmcpSvcKeiStaTgFileDefObj = null;

	/** サービス開始年月日(オプション) */
	protected String svcStaYmdOp = "";
	 
	/** サービス課金開始年月日(オプション) */
	protected String svcStaChrgYmdOp = "";
	 
	/** サービス開始年月日(サブオプション) */
	protected String svcStaYmdSbop = "";
	 
	/** サービス課金開始年月日(サブサブション) */
	protected String svcStaChrgYmdSbop = "";
	
	/** 引継元サービス課金終了年月日(オプション) */
	protected String hktgSvcChrgEndymdOp = "";
	 
	/** 引継元サービス課金終了年月日(サブオプション) */
	protected String hktgSvcChrgEndymdSbop = "";
	
	/** 終了日初期値*/
	private static final String END_DATE = "20991231";
	
	/** オプションサービス契約項目数*/
	private static final int OP_SVC_KEI_COLNUM = 79;
	
	/** サブオプションサービス契約項目数*/
	private static final int SBOP_SVC_KEI_COLNUM = 70;

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

		// DBアクセスクラスを生成します
		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);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		// FreeItem取得(FREE項目には「入力ファイル定義名;入力ファイルパス」が設定されている)
		String[] freeItems = commonItem.getFreeItem().split(";");
		
		if (null != freeItems && freeItems.length == 2)
		{
			// 端末補償サービス契約開始対象ファイルパス
			tmcpSvcKeiStaTgFilePath = freeItems[1];
			// 端末補償サービス契約開始対象ファイルオブジェクトを生成する
			tmcpSvcKeiStaTgFileObj = new JBSbatInputFileUtil(tmcpSvcKeiStaTgFilePath);
			// 端末補償サービス契約開始対象定義ファイル名を取得する
			String tmcpSvcKeiStaTgFileDefName = JBSbatAplConst.getAplConstValue("IND") + freeItems[0] + ".def";
			// 端末補償サービス契約開始対象定義ファイルオブジェクトを生成する
			tmcpSvcKeiStaTgFileDefObj  = new JBSbatDefFileUtil(tmcpSvcKeiStaTgFileDefName, tmcpSvcKeiStaTgFileObj);
			// Readerオブジェクトを生成する。
			tmcpSvcKeiStaTgFileObj.createReader();
		}
		else 
		{
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EKKB0130CE, new String[]{"FREE"});
		}
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param inMap　入力電文
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/

		// レコード数分処理を繰り返す
		while (tmcpSvcKeiStaTgFileObj.ready())
		{
			// ファイルレコード取得
			dataLine = tmcpSvcKeiStaTgFileObj.readLine();
			
			// 定義ファイルに設定された区切り文字で分割
			String[] cols = dataLine.split(tmcpSvcKeiStaTgFileDefObj.getDelimiter(), -1);
			
			// 分割データをマップに登録
			HashMap<String, String> splitData = setMap(cols);
			
			// オプションサービス契約の更新(世代登録)を行う
			addOpSvc(splitData);
			
			// サブオプションサービス契約の更新(世代登録)を行う
			addSbopSvc(splitData);

		}
		return null;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

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

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**
	 * SQLKEY(KK_SELECT_136)で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_136(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_OP_SVC_KEI.selectBySqlDefine(paramList, KK_T_OP_SVC_KEI_KK_SELECT_136);
	}

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

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

	/**
	 * 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マップに入れます。項目キーは以下に説明します。
	 *		 	オプションサービス契約番号				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.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	OP_SVC_KEI_NO
	 *		 	SBOP_SVC_KEI_NO
	 *		 	GENE_ADD_DTM
	 * </pre>
	 * <p>
	 * @param whereParam 条件項目の値。
	 * @return JBSbatCommonDBInterface 検索の結果。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface executeKK_T_SBOP_SVC_KEI_PKSELECT(Object[] whereParam) throws Exception
	{
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("OP_SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("SBOP_SVC_KEI_NO", whereParam[1]);
		whereMap.setValue("GENE_ADD_DTM", whereParam[2]);

		// DBアクセスを実行します
		return db_KK_T_SBOP_SVC_KEI.selectByPrimaryKeys(whereMap);
	}

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	オプションサービス契約番号				OP_SVC_KEI_NO
	 *		 	サブオプションサービス契約番号				SBOP_SVC_KEI_NO
	 *		 	世代登録年月日時分秒				GENE_ADD_DTM
	 *		 	サブオプションサービス契約ステータス				SBOP_SVC_KEI_STAT
	 *		 	サブオプションサービスコード				SBOP_SVC_CD
	 *		 	料金コースコード				PCRS_CD
	 *		 	料金プランコード				PPLAN_CD
	 *		 	申込明細番号				MSKM_DTL_NO
	 *		 	試用加入年月日				FTRIAL_KANYU_YMD
	 *		 	試用期間終了年月日				FTRIAL_PRD_ENDYMD
	 *		 	本加入年月日				HONKANYU_YMD
	 *		 	本加入移行期限年月日				HONKANYU_IKO_KIGEN_YMD
	 *		 	サービス利用開始希望年月日				SVC_USE_STA_KIBO_YMD
	 *		 	予約適用開始希望年月日				RSV_TSTA_KIBO_YMD
	 *		 	サブオプションサービス契約後続業務依頼年月日				SBOP_SVC_KEI_KZKWRK_REQYMD
	 *		 	照査年月日				SHOSA_YMD
	 *		 	照査取消年月日				SHOSA_CL_YMD
	 *		 	契約締結年月日				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
	 *		 	表示用サービス提供開始年月日				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_CHRG_ENDYMD
	 *		 	サービス解約年月日				SVC_DSL_YMD
	 *		 	サービス解約理由コード				SVC_DLRE_CD
	 *		 	サービス解約理由メモ				SVC_DLRE_MEMO
	 *		 	サービス解約手続完了フラグ				SVC_DSL_TTDKI_FIN_FLG
	 *		 	回復年月日				KAIHK_YMD
	 *		 	サービスキャンセル取消年月日				SVC_CANCEL_CL_YMD
	 *		 	サービス解約取消年月日				SVC_DSL_CL_YMD
	 *		 	審査結果送信コード				SKEKKA_SEND_CD
	 *		 	課金開始年月日補正有無				CHRG_STA_YMD_HOSEI_UM
	 *		 	サービス休止課金開始年月日				SVC_PAUSE_CHRG_STA_YMD
	 *		 	違約金発生コード				PNLTY_HASSEI_CD
	 *		 	異動区分				IDO_DIV
	 *		 	照査解約完了コード				SHOSA_DSL_FIN_CD
	 *		 	登録年月日時分秒				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_SBOP_SVC_KEI_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("OP_SVC_KEI_NO", setParam[0]);
		setMap.setValue("SBOP_SVC_KEI_NO", setParam[1]);
		setMap.setValue("GENE_ADD_DTM", setParam[2]);
		setMap.setValue("SBOP_SVC_KEI_STAT", setParam[3]);
		setMap.setValue("SBOP_SVC_CD", setParam[4]);
		setMap.setValue("PCRS_CD", setParam[5]);
		setMap.setValue("PPLAN_CD", setParam[6]);
		setMap.setValue("MSKM_DTL_NO", setParam[7]);
		setMap.setValue("FTRIAL_KANYU_YMD", setParam[8]);
		setMap.setValue("FTRIAL_PRD_ENDYMD", setParam[9]);
		setMap.setValue("HONKANYU_YMD", setParam[10]);
		setMap.setValue("HONKANYU_IKO_KIGEN_YMD", setParam[11]);
		setMap.setValue("SVC_USE_STA_KIBO_YMD", setParam[12]);
		setMap.setValue("RSV_TSTA_KIBO_YMD", setParam[13]);
		setMap.setValue("SBOP_SVC_KEI_KZKWRK_REQYMD", setParam[14]);
		setMap.setValue("SHOSA_YMD", setParam[15]);
		setMap.setValue("SHOSA_CL_YMD", setParam[16]);
		setMap.setValue("KEI_CNC_YMD", setParam[17]);
		setMap.setValue("RSV_APLY_YMD", setParam[18]);
		setMap.setValue("RSV_CL_YMD", setParam[19]);
		setMap.setValue("RSV_APLY_CD", setParam[20]);
		setMap.setValue("PLAN_STAYMD", setParam[21]);
		setMap.setValue("PLAN_ENDYMD", setParam[22]);
		setMap.setValue("PLAN_CHRG_STAYMD", setParam[23]);
		setMap.setValue("PLAN_CHRG_ENDYMD", setParam[24]);
		setMap.setValue("PLAN_END_SBT_CD", setParam[25]);
		setMap.setValue("SVC_CANCEL_YMD", setParam[26]);
		setMap.setValue("SVC_CANCEL_RSN_CD", setParam[27]);
		setMap.setValue("SVC_STAYMD", setParam[28]);
		setMap.setValue("DSP_SVCTK_STAYMD", setParam[29]);
		setMap.setValue("SVC_CHRG_STAYMD", setParam[30]);
		setMap.setValue("SVC_STP_YMD", setParam[31]);
		setMap.setValue("SVC_STP_RSN_CD", setParam[32]);
		setMap.setValue("SVC_STP_RLS_YMD", setParam[33]);
		setMap.setValue("SVC_STP_RLS_RSN_CD", setParam[34]);
		setMap.setValue("PAUSE_STP_CD", setParam[35]);
		setMap.setValue("SVC_PAUSE_YMD", setParam[36]);
		setMap.setValue("SVC_PAUSE_RSN_CD", setParam[37]);
		setMap.setValue("SVC_PAUSE_RSN_MEMO", setParam[38]);
		setMap.setValue("SVC_PAUSE_RLS_YMD", setParam[39]);
		setMap.setValue("SVC_PAUSE_RLS_RSN_CD", setParam[40]);
		setMap.setValue("SVC_PAUSE_RLS_RSN_MEMO", setParam[41]);
		setMap.setValue("SVC_ENDYMD", setParam[42]);
		setMap.setValue("SVC_CHRG_ENDYMD", setParam[43]);
		setMap.setValue("SVC_DSL_YMD", setParam[44]);
		setMap.setValue("SVC_DLRE_CD", setParam[45]);
		setMap.setValue("SVC_DLRE_MEMO", setParam[46]);
		setMap.setValue("SVC_DSL_TTDKI_FIN_FLG", setParam[47]);
		setMap.setValue("KAIHK_YMD", setParam[48]);
		setMap.setValue("SVC_CANCEL_CL_YMD", setParam[49]);
		setMap.setValue("SVC_DSL_CL_YMD", setParam[50]);
		setMap.setValue("SKEKKA_SEND_CD", setParam[51]);
		setMap.setValue("CHRG_STA_YMD_HOSEI_UM", setParam[52]);
		setMap.setValue("SVC_PAUSE_CHRG_STA_YMD", setParam[53]);
		setMap.setValue("PNLTY_HASSEI_CD", setParam[54]);
		setMap.setValue("IDO_DIV", setParam[55]);
		setMap.setValue("SHOSA_DSL_FIN_CD", setParam[56]);
		setMap.setValue("ADD_DTM", setParam[57]);
		setMap.setValue("ADD_OPEACNT", setParam[58]);
		setMap.setValue("UPD_DTM", setParam[59]);
		setMap.setValue("UPD_OPEACNT", setParam[60]);
		setMap.setValue("DEL_DTM", setParam[61]);
		setMap.setValue("DEL_OPEACNT", setParam[62]);
		setMap.setValue("MK_FLG", setParam[63]);
		setMap.setValue("ADD_UNYO_YMD", setParam[64]);
		setMap.setValue("ADD_TRN_ID", setParam[65]);
		setMap.setValue("UPD_UNYO_YMD", setParam[66]);
		setMap.setValue("UPD_TRN_ID", setParam[67]);
		setMap.setValue("DEL_UNYO_YMD", setParam[68]);
		setMap.setValue("DEL_TRN_ID", setParam[69]);
	
		// DBアクセスを実行します
		db_KK_T_SBOP_SVC_KEI.insertByPrimaryKeys(setMap);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * オプションサービス契約の更新(世代登録)を行う。<br>
	 * @param cols 設定項目の値
	 * @return splitData 設定項目マップ
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private HashMap<String, String> setMap(String[] cols) throws Exception 
	{
		// マップ初期化
		HashMap<String, String> splitData = new HashMap<String, String>();
		
		// オプションサービス契約番号
		splitData.put(JBSbatKKIFM862.OP_SVC_KEI_NO, cols[0]);
		// 世代登録年月日（オプション）
		splitData.put(JBSbatKKIFM862.GENE_ADD_DTM_OP, cols[1]);
		// オプションサービスコード
		splitData.put(JBSbatKKIFM862.OP_SVC_CD, cols[2]);
		// サブオプションサービス契約番号
		splitData.put(JBSbatKKIFM862.SBOP_SVC_KEI_NO, cols[3]);
		// 世代登録年月日（サブオプション）
		splitData.put(JBSbatKKIFM862.GENE_ADD_DTM_SBOP, cols[4]);
		// サブオプションサービスコード
		splitData.put(JBSbatKKIFM862.SBOP_SVC_CD, cols[5]);
		// 端末補償契約番号（オプション）
		splitData.put(JBSbatKKIFM862.TMCP_KEI_NO, cols[6]);
		// 端末補償申込年月日（オプション）
		splitData.put(JBSbatKKIFM862.TMCP_MSKM_YMD_OP, cols[7]);
		// 端末補償住所変更引継有無（オプション）
		splitData.put(JBSbatKKIFM862.TMCP_ADCHG_HKTGI_UM_OP, cols[8]);
		// 端末補償申込年月日（サブオプション）
		splitData.put(JBSbatKKIFM862.TMCP_MSKM_YMD_SBOP, cols[9]);
		// 端末補償住所変更引継有無（サブオプション）
		splitData.put(JBSbatKKIFM862.TMCP_ADCHG_HKTGI_UM_SBOP, cols[10]);
		// 元サービス契約課金開始年月日
		splitData.put(JBSbatKKIFM862.SVC_CHRG_STAYMD, cols[11]);
		// サービスコード
		splitData.put(JBSbatKKIFM862.SVC_CD, cols[12]);
		// オプションサービス契約ステータス
		splitData.put(JBSbatKKIFM862.OP_SVC_KEI_STAT, cols[13]);
		
		return splitData;
	}
	
	/**
	 * オプションサービス契約の更新(世代登録)を行う。<br>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addOpSvc(HashMap<String, String>  splitData) throws Exception 
	{
		// オプションサービス契約ステータス = "030"(締結済)以外の場合、以下の処理をスキップする。
		if(!JBSbatKKConst.SVC_KEI_STAT_CNC_ZM.equals(splitData.get(JBSbatKKIFM862.OP_SVC_KEI_STAT)))
		{
			return;
		}
		
		// 相関ルール名：開始日設定定義（オプションサービス）を呼び出す。
		ArrayList<ArrayList<HashMap<String, Object>>> checkList074 = callRule0074001(splitData);
		
		// ルール呼出結果によるサービス開始年月日算出用データ取得を呼び出す。
		getOpSvcStaymd(checkList074, splitData);
		
		// オプション契約サービス開始日が設定されている場合
		// オプションサービス開始年月日 <= バッチ運用日+1の場合、以下の処理を行う。
		if(!"".equals(svcStaYmdOp) && 0 >= svcStaYmdOp.compareTo(JBSbatDateUtil.adjustDate(commonItem.getOpeDate(), 1)))
		{
			// 相関ルール名：課金開始日設定定義（オプションサービス）を呼び出す。
			ArrayList<ArrayList<HashMap<String, Object>>> checkList066 = callRule0066001(splitData);
			
			// ルール呼出結果によるサービス課金開始年月日算出用データ取得を呼び出す。
			getOpSvcChrgStaymd(checkList066, splitData);
			
			// オプションサービス契約から更新対象のレコードを取得する。
			JBSbatCommonDBInterface opScvKeiMap = getOpSvckei(splitData);
			// オプションサービス契約が取得できた場合、登録を行う。
			if(opScvKeiMap != null)
			{
				addOpSvckei(opScvKeiMap);
			}
		}	
	}
	
	/**
	 * サブオプションサービス契約の更新(世代登録)を行う。<br>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addSbopSvc(HashMap<String, String>  splitData) throws Exception 
	{
		// サブオプションサービス契約番号 = nullまたは""の場合、以下の処理をスキップする。
		if(splitData.get(JBSbatKKIFM862.SBOP_SVC_KEI_NO) == null
				|| "".equals(splitData.get(JBSbatKKIFM862.SBOP_SVC_KEI_NO)))
		{
			return;
		}
		
		// 相関ルール名：開始日設定定義（サブオプションサービス）を呼び出す。
		ArrayList<ArrayList<HashMap<String, Object>>> checkList076 = callRule0076001(splitData);
		
		// ルール呼出結果によるサービス開始年月日算出用データ取得を呼び出す。
		getSbopSvcStaymd(checkList076, splitData);
		
		// サブオプション契約サービス開始日が設定されている場合
		// サブオプションサービス開始年月日 <= バッチ運用日の場合、以下の処理を行う。
		if(!"".equals(svcStaYmdSbop) && 0 >= svcStaYmdSbop.compareTo(JBSbatDateUtil.adjustDate(commonItem.getOpeDate(), 1)))
		{
			// 相関ルール名：開始日設定定義（サブオプションサービス）を呼び出す。
			ArrayList<ArrayList<HashMap<String, Object>>> checkList068 = callRule0068001(splitData);
			
			// ルール呼出結果によるサービス課金開始年月日算出用データ取得を呼び出す。
			getSbopSvcChrgStaymd(checkList068, splitData);
			
			// サブオプションサービス契約から更新対象のレコードを取得する。
			JBSbatCommonDBInterface sbopScvKeiMap = getSbopSvckei(splitData);
			// サブオプションサービス契約が取得できた場合、登録を行う。
			if(sbopScvKeiMap != null)
			{
				addSbopSvckei(sbopScvKeiMap);
			}
		}	
	}
	
	/**
	 * 
	 * Ｎヶ月前(後)の日付を返却します。
	 * 
	 * @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 splitData 設定項目の値
	 * @return resultList rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception 
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0074001(HashMap<String, String> splitData) throws Exception 
	{
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		
		// サービスコード = 入力ファイル.サービスコード
		map.put("SVC_CD", splitData.get(JBSbatKKIFM862.SVC_CD));
		// オプションサービスコード = 入力ファイル.オプションサービスコード
		map.put("OP_SVC_CD", splitData.get(JBSbatKKIFM862.OP_SVC_CD));
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0074001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		return resultList;
	}
	
	/**
	 * 
	 * ルール呼出結果によるオプションサービス開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList074 ArrayList<ArrayList<HashMap<String, Object>>>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getOpSvcStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList074, HashMap<String, String> splitData) throws Exception
	{
		// フィールド変数の初期化
		String stdDt               = "";
		String relativeDateCount   = "";
		String countMethod         = "";
		String priorityStdDt       = "";
		String kjnYmd              = "";
		svcStaYmdOp                = "";
		
		// 入力ファイルから項目取得
		// 端末補償申込年月日(オプション)
		String tcmpMskmYmdOp = splitData.get(JBSbatKKIFM862.TMCP_MSKM_YMD_OP);
		// サービス契約サービス課金開始日
		String svcChrgStaymd = splitData.get(JBSbatKKIFM862.SVC_CHRG_STAYMD);
		
		// 端末補償申込年月日(オプション)が取得できない場合、算出処理を行わない
		if(tcmpMskmYmdOp == null || "".equals(tcmpMskmYmdOp))
		{
			return;
		}
		
		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("7".equals(stdDt))
			{
				// 入力ファイルの端末補償申込年月日(オプション)を設定する。
				if(!"".equals(tcmpMskmYmdOp))
				{
					kjnYmd = tcmpMskmYmdOp;
					super.logPrint.printDebugLog("■■オプションサービス開始基準年月日：" +  kjnYmd);
				}
			}
			
			// 基準日からの相対日の取得
			// 基準日からの相対日が"翌々月月初"の場合
			if("3".equals(relativeDateCount))
			{
				// 基準日の翌々月1日を設定する。
				kjnYmd = adjustMonth(kjnYmd, 2);
			}
			
			// 実日/営業日の取得
			// 実日/営業日が"実日"の場合
			if("0".equals(countMethod))
			{
				// 基準日の増減が無いのでそのままとする。
			}
			
			// 優先基準日の取得
			// 優先基準日が"元のサービス契約のサービス課金開始日との大きい方"の場合
			if("7".equals(priorityStdDt))
			{
				super.logPrint.printDebugLog("■■元のサービス契約のサービス課金開始年月日：" + svcChrgStaymd);
				super.logPrint.printDebugLog("■■優先基準日：" +  priorityStdDt);
				
				// 元のサービス契約のサービス課金開始年月日のほうが設定した基準日より大きい場合
				if(0 > kjnYmd.compareTo(svcChrgStaymd))
				{
					// 元のサービス契約のサービス課金開始年月日を設定
					svcStaYmdOp = svcChrgStaymd;
				}
				else
				{
					// 基準日を設定
					svcStaYmdOp = kjnYmd;
				}
			}
		}
		super.logPrint.printDebugLog("相関ルール(RULE0074001)--->" + svcStaYmdOp);
	}
	
	/**
	 * 
	 * 相関ルール：課金開始日（オプション）パターン判定の呼び出しをを行います。
	 * 
	 * @param splitData 設定項目の値
	 * @return resultList rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception 
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0066001(HashMap<String, String> splitData) throws Exception 
	{
		// パラメータマップ初期化
		HashMap<String, Object> map = new HashMap<String, Object>();
		// 引継元サービス課金終了年月日
		hktgSvcChrgEndymdOp = null;
		
		// 端末補償住所変更引継有無(オプション) = "1"(有)のとき、引継元サービス課金終了年月日を取得する。
		if(JBSbatKKConst.TMCP_ADCHG_HKTGI_UM_YU.equals(splitData.get(JBSbatKKIFM862.TMCP_ADCHG_HKTGI_UM_OP)))
		{
			hktgSvcChrgEndymdOp = getHktgSvcChrgEndymdOp(splitData);
		}		
		// サービスコード = 入力ファイル.サービスコード
		map.put("SVC_CD", splitData.get(JBSbatKKIFM862.SVC_CD));
		// オプションサービスコード = 入力ファイル.オプションサービスコード
		map.put("OP_SVC_CD", splitData.get(JBSbatKKIFM862.OP_SVC_CD));
		// サービス開始年月 = サービス開始年月日(オプション)の年月
		map.put("SVC_STA_YM", svcStaYmdOp.substring(0, 6));
		// 引継元サービス課金終了年月 = 取得した引継元サービス課金終了年月日の年月
		// 引継元サービス課金終了年月日がnullまたは空白以外の場合設定する。
		if(hktgSvcChrgEndymdOp != null && !"".equals(hktgSvcChrgEndymdOp))
		{
			map.put("HKTGMT_SVC_CHRG_ENDYM", hktgSvcChrgEndymdOp.substring(0, 6));
		}
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0066001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		return resultList;
	}
	
	/**
	 * 
	 * ルール呼出結果によるオプションサービス課金開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList066 ArrayList<ArrayList<HashMap<String, Object>>>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getOpSvcChrgStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList066, HashMap<String, String> splitData) throws Exception
	{
		// フィールド変数の初期化
		String stdDt               = "";
		String relativeDateCount   = "";
		String countMethod         = "";
		String kjnYmd              = "";
		svcStaChrgYmdOp            = "";
		
		if(null != checkList066.get(0))
		{
			// 各ルール結果を取得する。
			stdDt             = (String)checkList066.get(0).get(0).get("STD_DT");						// 基準日
			relativeDateCount = (String)checkList066.get(0).get(0).get("RELATIVE_DATE_COUNT");			// 基準日からの相対日
			countMethod       = (String)checkList066.get(0).get(0).get("COUNT_METHOD");					// 実日/営業日
			
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日）：" +  stdDt);
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日からの相対日）：" +  relativeDateCount);
			super.logPrint.printDebugLog("相関ルール呼出結果（実日/営業日 ）：" +  countMethod);
			super.logPrint.printDebugLog("オプションサービス開始年月日(RULE0074結果)：" +  svcStaYmdOp);
			super.logPrint.printDebugLog("引継元サービス契約の課金終了年月日：：：：" +  hktgSvcChrgEndymdOp);
			
			//呼び出したルール[RULE0066001_課金開始日（オプション）]の結果を元にサービス課金開始年月日算出用データを取得する。
			// 1:サービス開始日の場合
			if("1".equals(stdDt))
			{
				// オプションサービス開始年月日(RULE0074結果)を設定する。
				if(!"".equals(svcStaYmdOp))
				{
					kjnYmd = svcStaYmdOp;
					super.logPrint.printDebugLog("■■オプションサービス課金開始基準年月日：" +  kjnYmd);
				}
			}
			// 5:オプションサービス課金終了日の場合
			else if("5".equals(stdDt))
			{
				// 引継元サービス契約の課金終了年月日を設定する。
				if(!"".equals(hktgSvcChrgEndymdOp))
				{
					kjnYmd = hktgSvcChrgEndymdOp;
					super.logPrint.printDebugLog("■■オプションサービス課金開始基準年月日：" +  kjnYmd);
				}
			}
			
			// 基準日からの相対日の取得
			// 基準日からの相対日が"+0"の場合
			if("0".equals(relativeDateCount))
			{
				// 基準日の当日を設定する。
				svcStaChrgYmdOp = kjnYmd;
			}
			// 基準日からの相対日が"翌月月初"の場合
			else if("2".equals(relativeDateCount))
			{
				// 基準日の翌月1日を設定する。
				svcStaChrgYmdOp = adjustMonth(kjnYmd, 1);
			}
		}
		super.logPrint.printDebugLog("オプションサービス課金開始年月日--->" + svcStaChrgYmdOp);
		
	}
	
	/**
	 * 
	 * 相関ルール：開始日設定定義（サブオプションサービス）の呼び出しをを行います。
	 * 
	 * @param splitData 設定項目の値
	 * @return resultList rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception 
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0076001(HashMap<String, String> splitData) throws Exception 
	{
		
		HashMap<String, Object> map = new HashMap<String, Object>();
		
		// サービスコード = 入力ファイル.サービスコード
		map.put("SVC_CD", splitData.get(JBSbatKKIFM862.SVC_CD));
		// サブオプションサービスコード = 入力ファイル.サブオプションサービスコード
		map.put("SBOP_SVC_CD", splitData.get(JBSbatKKIFM862.SBOP_SVC_CD));
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0076001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		return resultList;
	}
	
	/**
	 * 
	 * ルール呼出結果によるサブオプションサービス開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList076 ArrayList<ArrayList<HashMap<String, Object>>>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getSbopSvcStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList076, HashMap<String, String> splitData) throws Exception
	{
		// フィールド変数の初期化
		String stdDt               = "";
		String relativeDateCount   = "";
		String countMethod         = "";
		String priorityStdDt       = "";
		String kjnYmd              = "";
		svcStaYmdSbop                = "";
		
		// 入力ファイルから項目取得
		// 端末補償申込年月日(サブオプション)
		String tcmpMskmYmdSbop = splitData.get(JBSbatKKIFM862.TMCP_MSKM_YMD_SBOP);
		// サービス契約サービス課金開始日
		String svcChrgStaymd = splitData.get(JBSbatKKIFM862.SVC_CHRG_STAYMD);
		
		// 端末補償申込年月日(サブオプション)が取得できない場合、算出処理を行わない
		if(tcmpMskmYmdSbop == null || "".equals(tcmpMskmYmdSbop))
		{
			return;
		}
		
		if(null != checkList076.get(0))
		{
			
			// 各ルール結果を取得する。
			stdDt             = (String)checkList076.get(0).get(0).get("STD_DT");						// 基準日
			relativeDateCount = (String)checkList076.get(0).get(0).get("RELATIVE_DATE_COUNT");			// 基準日からの相対日
			countMethod       = (String)checkList076.get(0).get(0).get("COUNT_METHOD");					// 実日/営業日
			priorityStdDt     = (String)checkList076.get(0).get(0).get("PRIORITY_STD_DT");				// 優先基準日
			
			super.logPrint.printDebugLog("相関ルール(RULE0076001)呼出結果（基準日）：" +  stdDt);
			super.logPrint.printDebugLog("相関ルール(RULE0076001)呼出結果（基準日からの相対日）：" +  relativeDateCount);
			super.logPrint.printDebugLog("相関ルール(RULE0076001)呼出結果（実日/営業日）：" +  countMethod);
			super.logPrint.printDebugLog("相関ルール(RULE0076001)呼出結果（優先基準日）：" +  priorityStdDt);
			
			//呼び出したルール[RULE0076001_開始日設定定義（サブオプションサービス）]の結果を元にサービス開始年月日を算出する。
			// 基準日の取得
			// 基準日が"端末補償申込年月日"の場合。
			if("3".equals(stdDt))
			{
				// 入力ファイルの端末補償申込年月日(オプション)を設定する。
				if(!"".equals(tcmpMskmYmdSbop))
				{
					kjnYmd = tcmpMskmYmdSbop;
					super.logPrint.printDebugLog("■■サブオプションサービス開始基準年月日：" +  kjnYmd);
				}
			}
			
			// 基準日からの相対日の取得
			// 基準日からの相対日が"翌々月月初"の場合
			if("1".equals(relativeDateCount))
			{
				// 基準日の翌々月1日を設定する。
				kjnYmd = adjustMonth(kjnYmd, 2);
			}
			
			// 実日/営業日の取得
			// 実日/営業日が"実日"の場合
			if("0".equals(countMethod))
			{
				// 基準日の増減が無いのでそのままとする。
			}
			
			// 優先基準日の取得
			// 優先基準日が"元のサービス契約のサービス課金開始日との大きい方"の場合
			if("2".equals(priorityStdDt))
			{
				super.logPrint.printDebugLog("■■元のサービス契約のサービス課金開始年月日：" + svcChrgStaymd);
				super.logPrint.printDebugLog("■■優先基準日：" +  priorityStdDt);
				
				// 元のサービス契約のサービス課金開始年月日のほうが設定した基準日より大きい場合
				if(0 > kjnYmd.compareTo(svcChrgStaymd))
				{
					// 元のサービス契約のサービス課金開始年月日を設定
					svcStaYmdSbop = svcChrgStaymd;
				}
				else
				{
					// 基準日を設定
					svcStaYmdSbop = kjnYmd;
				}
			}
		}
		super.logPrint.printDebugLog("相関ルール(RULE0076001)--->" + svcStaYmdSbop);
	}
	
	/**
	 * 
	 * 相関ルール：課金開始日（サブオプション）パターン判定の呼び出しをを行います。
	 * 
	 * @param splitData 設定項目の値
	 * @return resultList rrayList<ArrayList<HashMap<String, Object>>>
	 * @throws Exception 
	 */
	private ArrayList<ArrayList<HashMap<String, Object>>> callRule0068001(HashMap<String, String> splitData) throws Exception 
	{
		// パラメータマップ初期化
		HashMap<String, Object> map = new HashMap<String, Object>();
		// 引継元サービス課金終了年月日
		hktgSvcChrgEndymdSbop = null;
		
		// 端末補償住所変更引継有無(サブオプション) = "1"(有)のとき、引継元サービス課金終了年月日を取得する。
		if(JBSbatKKConst.TMCP_ADCHG_HKTGI_UM_YU.equals(splitData.get(JBSbatKKIFM862.TMCP_ADCHG_HKTGI_UM_SBOP)))
		{
			hktgSvcChrgEndymdSbop = getHktgSvcChrgEndymdSbop(splitData);
		}		
		// サービスコード = 入力ファイル.サービスコード
		map.put("SVC_CD", splitData.get(JBSbatKKIFM862.SVC_CD));
		// サブオプションサービスコード = 入力ファイル.サブオプションサービスコード
		map.put("SBOP_SVC_CD", splitData.get(JBSbatKKIFM862.SBOP_SVC_CD));
		// サービス開始年月 = サービス開始年月日(サブオプション)の年月
		map.put("SVC_STA_YM", svcStaYmdSbop.substring(0, 6));
		// 引継元サービス課金終了年月 = 取得した引継元サービス課金終了年月日の年月
		// 引継元サービス課金終了年月日がnullまたは空白以外の場合設定する。
		if(hktgSvcChrgEndymdSbop != null && !"".equals(hktgSvcChrgEndymdSbop))
		{
			map.put("HKTGMT_SVC_CHRG_ENDYM", hktgSvcChrgEndymdSbop.substring(0, 6));
		}
		
		JRuleXMLHandler xmlHandler = JCCBatCommon.createSokanRuleEngine("RULE0068001", JRuleXMLPattern.SINGLE_MODE_TYPE);
		ArrayList<ArrayList<HashMap<String, Object>>> resultList = JCCBatCommon.getCheckResultArray(xmlHandler, map);
		
		return resultList;
	}
	
	/**
	 * 
	 * ルール呼出結果によるサブオプションサービス課金開始年月日算出用データ取得を行います。
	 * 
	 * @param checkList068 ArrayList<ArrayList<HashMap<String, Object>>>
	 * @param splitData 設定項目の値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getSbopSvcChrgStaymd(ArrayList<ArrayList<HashMap<String, Object>>> checkList068, HashMap<String, String> splitData) throws Exception
	{
		// フィールド変数の初期化
		String stdDt               = "";
		String relativeDateCount   = "";
		String countMethod         = "";
		String kjnYmd              = "";
		svcStaChrgYmdSbop          = "";
		
		if(null != checkList068.get(0))
		{
			// 各ルール結果を取得する。
			stdDt             = (String)checkList068.get(0).get(0).get("STD_DT");						// 基準日
			relativeDateCount = (String)checkList068.get(0).get(0).get("RELATIVE_DATE_COUNT");			// 基準日からの相対日
			countMethod       = (String)checkList068.get(0).get(0).get("COUNT_METHOD");					// 実日/営業日
			
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日）：" +  stdDt);
			super.logPrint.printDebugLog("相関ルール呼出結果（基準日からの相対日）：" +  relativeDateCount);
			super.logPrint.printDebugLog("相関ルール呼出結果（実日/営業日 ）：" +  countMethod);
			super.logPrint.printDebugLog("サブオプションサービス開始年月日(RULE0076結果)：" +  svcStaYmdSbop);
			super.logPrint.printDebugLog("引継元サービス契約の課金終了年月日：：：：" +  hktgSvcChrgEndymdSbop);
			
			//呼び出したルール[RULE0068001_課金開始日（サブオプション）]の結果を元にサービス課金開始年月日算出用データを取得する。
			// 1:サービス開始日の場合
			if("1".equals(stdDt))
			{
				// サブオプションサービス開始年月日(RULE0076結果)を設定する。
				if(!"".equals(svcStaYmdSbop))
				{
					kjnYmd = svcStaYmdSbop;
					super.logPrint.printDebugLog("■■サブオプションサービス課金開始基準年月日：" +  kjnYmd);
				}
			}
			// 5:オプションサービス課金終了日の場合
			else if("5".equals(stdDt))
			{
				// 引継元サービス契約の課金終了年月日を設定する。
				if(!"".equals(hktgSvcChrgEndymdSbop))
				{
					kjnYmd = hktgSvcChrgEndymdSbop;
					super.logPrint.printDebugLog("■■サブオプションサービス課金開始基準年月日：" +  kjnYmd);
				}
			}
			
			// 基準日からの相対日の取得
			// 基準日からの相対日が"+0"の場合
			if("0".equals(relativeDateCount))
			{
				// 基準日の当日を設定する。
				svcStaChrgYmdSbop = kjnYmd;
			}
			// 基準日からの相対日が"翌月月初"の場合
			else if("2".equals(relativeDateCount))
			{
				// 基準日の翌月1日を設定する。
				svcStaChrgYmdSbop = adjustMonth(kjnYmd, 1);
			}
		}
		super.logPrint.printDebugLog("サブオプションサービス課金開始年月日--->" + svcStaChrgYmdSbop);
		
	}
	
	/**
	 * 引継元サービス課金終了日(オプションサービス)を取得する。<br>
	 * @param splitData 設定項目の値
	 * @return 引継元サービス課金終了日
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getHktgSvcChrgEndymdOp(HashMap<String, String> splitData) throws Exception 
	{
		// 設定値のマップを作成する
		Object[] setParam = new Object[4];
		// 予約適用年月日
		setParam[0] = commonItem.getOpeDate();
		// 予約適用年月日
		setParam[1] = commonItem.getOpeDate();
		// オプションサービス契約番号
		setParam[2] = splitData.get(JBSbatKKIFM862.OP_SVC_KEI_NO);
		// オプションサービスコード
		setParam[3] = splitData.get(JBSbatKKIFM862.OP_SVC_CD);
		
		// DBアクセスを実行する
		executeKK_T_OP_SVC_KEI_KK_SELECT_136(setParam);
		// 結果を取得
		JBSbatCommonDBInterface result = db_KK_T_OP_SVC_KEI.selectNext();
		
		// 引継元サービス課金終了日を取得
		if(result != null)
		{
			if(result.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CHRG_ENDYMD) != null
					&& !"".equals(result.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CHRG_ENDYMD)))
			{
				return result.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CHRG_ENDYMD);
			}
		}
		
		// サービス課金終了日が存在しない場合、nullを返す。
		return null;
	}
	
	/**
	 * 引継元サービス課金終了日(サブオプションサービス)を取得する。<br>
	 * @param splitData 設定項目の値
	 * @return 引継元サービス課金終了日
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getHktgSvcChrgEndymdSbop(HashMap<String, String> splitData) throws Exception 
	{
		// 設定値のマップを作成する
		Object[] setParam = new Object[5];
		// 予約適用年月日
		setParam[0] = commonItem.getOpeDate();
		// 予約適用年月日
		setParam[1] = commonItem.getOpeDate();
		// 予約適用年月日
		setParam[2] = commonItem.getOpeDate();
		// サブオプションサービス契約番号
		setParam[3] = splitData.get(JBSbatKKIFM862.SBOP_SVC_KEI_NO);
		// サブオプションサービスコード
		setParam[4] = splitData.get(JBSbatKKIFM862.SBOP_SVC_CD);
		
		// DBアクセスを実行する
		executeKK_T_SBOP_SVC_KEI_KK_SELECT_032(setParam);
		// 結果を取得
		JBSbatCommonDBInterface result = db_KK_T_SBOP_SVC_KEI.selectNext();
		
		// 引継元サービス課金終了日を取得
		if(result != null)
		{
			if(result.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CHRG_ENDYMD) != null
					&& !"".equals(result.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CHRG_ENDYMD)))
			{
				return result.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CHRG_ENDYMD);
			}
		}
		
		// サービス課金終了日が存在しない場合、nullを返す。
		return null;
	}
	
	/**
	 * オプションサービス契約から更新対象のレコードを取得する。<br>
	 * @param splitData 設定項目の値
	 * @return オプションサービス契約検索結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface getOpSvckei(HashMap<String, String> splitData) throws Exception 
	{
		// 設定値のマップを作成する
		Object[] setParam = new Object[2];
		// オプションサービス契約番号
		setParam[0] = splitData.get(JBSbatKKIFM862.OP_SVC_KEI_NO);
		// 世代登録年月日（オプション）
		setParam[1] = splitData.get(JBSbatKKIFM862.GENE_ADD_DTM_OP);
		
		// PK検索を行う
		opSvcKeiKey = executeKK_T_OP_SVC_KEI_PKSELECT(setParam);
		
		// オプションサービス契約情報が取得できた場合
		if(null != opSvcKeiKey)
		{
			return opSvcKeiKey;
		}
		// 検索結果が存在しない場合、nullを返す。
		return null;
	}
	
	/**
	 * オプションサービス契約を登録します。
	 * <br>
	 * @param opScvKeiMap オプションサービス契約検索結果
	 * @throws Exception 
	 */
	private void addOpSvckei(JBSbatCommonDBInterface opScvKeiMap) throws Exception
	{
		// 登録用データ格納
		Object[] param_add = new Object[OP_SVC_KEI_COLNUM];
		
		// システム日付を取得
		String sysdate = JBSbatDateUtil.getSystemDateTimeStamp();
		
		// オプションサービス契約番号を取得
		String opSvcKeiNo = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKKIFM862.OP_SVC_KEI_NO));
		
		// オプションサービスコード
		String opSvcCd = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKKIFM862.OP_SVC_CD));
		
		super.logPrint.printDebugLog("★オプションサービスコード★" + opSvcCd + "★" + opSvcKeiNo);
		
		// オプションサービス契約番号
		param_add[0] = opSvcKeiNo;
		// 世代登録年月日時分秒 → システム日付を設定
		param_add[1] = sysdate;
		// オプションサービス契約ステータス → 100：サービス提供中を設定
		param_add[2] = JBSbatKKConst.SVC_KEI_STAT_SVCTK_CHU;
		// オプションサービスコード
		param_add[3] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_CD));
		// 料金コースコード
		param_add[4] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.PCRS_CD));
		// 料金プランコード
		param_add[5] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.PPLAN_CD));
		// 親契約識別コード
		param_add[6] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OYA_KEI_SKBT_CD));
		// サービス契約番号
		param_add[7] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_KEI_NO));
		// サービス契約内訳番号
		param_add[8] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_KEI_UCWK_NO));
		// 法人サービス契約受付番号
		param_add[9] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.HOJIN_SVC_KEI_UK_NO));
		// SYSID
		param_add[10] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SYSID));
		// 申込明細番号
		param_add[11] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.MSKM_DTL_NO));
		// 試用加入年月日
		param_add[12] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.FTRIAL_KANYU_YMD));
		// 試用期間終了年月日
		param_add[13] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.FTRIAL_PRD_ENDYMD));
		// 本加入年月日
		param_add[14] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.HONKANYU_YMD));
		// 本加入移行期限年月日
		param_add[15] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.HONKANYU_IKO_KIGEN_YMD));
		// サービス利用開始希望年月日
		param_add[16] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_USE_STA_KIBO_YMD));
		// 予約適用開始希望年月日
		param_add[17] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_TSTA_KIBO_YMD));
		// オプションサービス契約後続業務依頼年月日
		param_add[18] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_KZKWRK_REQYMD));
		// 照査年月日
		param_add[19] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_YMD));
		// 照査取消年月日
		param_add[20] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_CL_YMD));
		// 審査結果送信コード
		param_add[21] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SKEKKA_SEND_CD));
		// 契約締結年月日
		param_add[22] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.KEI_CNC_YMD));
		// 予約適用年月日
		param_add[23] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_APLY_YMD));
		// 予約取消年月日
		param_add[24] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_CL_YMD));
		// 予約適用コード
		param_add[25] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.RSV_APLY_CD));
		// プラン開始年月日 → サービス開始年月日(RULE0074結果)を設定
		param_add[26] = svcStaYmdOp;
		// プラン終了年月日 → 20991231を設定
		param_add[27] = END_DATE;
		// プラン課金開始年月日 → サービス課金開始年月日(RULE0066結果)を設定
		param_add[28] = svcStaChrgYmdOp;
		// プラン課金終了年月日 → 20991231を設定
		param_add[29] = END_DATE;
		// プラン終了種別コード
		param_add[30] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.PLAN_END_SBT_CD));
		// サービスキャンセル年月日
		param_add[31] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_YMD));
		// サービスキャンセル理由コード
		param_add[32] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_RSN_CD));
		// サービス開始年月日 → サービス開始年月日(RULE0074結果)を設定
		param_add[33] = svcStaYmdOp;
		// サービス開始時分秒
		param_add[34] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STA_HMS));
		// 表示用サービス提供開始年月日
		param_add[35] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.DSP_SVCTK_STAYMD));
		// サービス課金開始年月日 → サービス課金開始年月日(RULE0066結果)を設定
		param_add[36] = svcStaChrgYmdOp;
		// サービス停止年月日
		param_add[37] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_YMD));
		// サービス停止理由コード
		param_add[38] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RSN_CD));
		// サービス停止解除年月日
		param_add[39] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RLS_YMD));
		// サービス停止解除理由コード
		param_add[40] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_STP_RLS_RSN_CD));
		// 休止中断コード
		param_add[41] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.PAUSE_STP_CD));
		// サービス休止年月日
		param_add[42] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_YMD));
		// サービス休止理由コード
		param_add[43] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RSN_CD));
		// サービス休止理由メモ
		param_add[44] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RSN_MEMO));
		// サービス休止解除年月日
		param_add[45] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_YMD));
		// サービス休止解除理由コード
		param_add[46] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_RSN_CD));
		// サービス休止解除理由メモ
		param_add[47] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_RLS_RSN_MEMO));
		// サービス終了年月日 → 20991231を設定
		param_add[48] = END_DATE;
		// サービス終了時分秒
		param_add[49] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_END_HMS));
		// サービス課金終了年月日 → 20991231を設定
		param_add[50] = END_DATE;
		// サービス解約年月日
		param_add[51] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_YMD));
		// サービス解約理由コード
		param_add[52] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DLRE_CD));
		// サービス解約理由メモ
		param_add[53] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DLRE_MEMO));
		// 解約担当ユーザーID
		param_add[54] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.DSL_TNT_USER_ID));
		// サービス解約手続完了フラグ
		param_add[55] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_TTDKI_FIN_FLG));
		// 回復年月日
		param_add[56] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.KAIHK_YMD));
		// サービスキャンセル取消年月日
		param_add[57] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_CANCEL_CL_YMD));
		// サービス解約取消年月日
		param_add[58] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_DSL_CL_YMD));
		// 課金開始年月日補正有無
		param_add[59] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.CHRG_STA_YMD_HOSEI_UM));
		// サービス休止課金開始年月日
		param_add[60] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SVC_PAUSE_CHRG_STA_YMD));
		// オプションサービス契約引継発生年月日
		param_add[61] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.OP_SVC_KEI_HKHASYMD));
		// 違約金発生コード
		param_add[62] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.PNLTY_HASSEI_CD));
		// 異動区分
		param_add[63] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.IDO_DIV));
		// 照査解約完了コード
		param_add[64] = JBSbatStringUtil.Rtrim(opScvKeiMap.getString(JBSbatKK_T_OP_SVC_KEI.SHOSA_DSL_FIN_CD));
		// サービス提供物消去処理実施年月日時分秒
		param_add[65] = JBSbatStringUtil.Rtrim(opScvKeiMap.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：有効を設定
		param_add[72] = JBSbatKKConst.MK_FLG_YK;
		// 登録運用年月日
		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(opScvKeiMap.getString(JBSbatKK_T_SVC_KEI.GENE_ADD_DTM)), sysdate);
	}
	
	/**
	 * サブオプションサービス契約から更新対象のレコードを取得する。<br>
	 * @param splitData 設定項目の値
	 * @return サブオプションサービス契約検索結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface getSbopSvckei(HashMap<String, String> splitData) throws Exception 
	{
		// 設定値のマップを作成する
		Object[] setParam = new Object[3];
		// オプションサービス契約番号
		setParam[0] = splitData.get(JBSbatKKIFM862.OP_SVC_KEI_NO);
		// サブオプションサービス契約番号
		setParam[1] = splitData.get(JBSbatKKIFM862.SBOP_SVC_KEI_NO);
		// 世代登録年月日（サブオプション）
		setParam[2] = splitData.get(JBSbatKKIFM862.GENE_ADD_DTM_SBOP);
		
		// PK検索を行う
		sbopSvcKeiKey = executeKK_T_SBOP_SVC_KEI_PKSELECT(setParam);
		
		// オプションサービス契約情報が取得できた場合
		if(null != sbopSvcKeiKey)
		{
			return sbopSvcKeiKey;
		}
		// 検索結果が存在しない場合、nullを返す。
		return null;
	}
	
	/**
	 * サブオプションサービス契約を登録します。
	 * <br>
	 * @param sbopScvKeiMap サブオプションサービス契約検索結果
	 * @throws Exception 
	 */
	private void addSbopSvckei(JBSbatCommonDBInterface sbopScvKeiMap) throws Exception
	{
		
		// 登録用データ格納
		Object[] param_add = new Object[SBOP_SVC_KEI_COLNUM];
		
		// システム日付を取得
		String sysdate = JBSbatDateUtil.getSystemDateTimeStamp();
		
		// オプションサービス契約番号を取得
		String opSvcKeiNo = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.OP_SVC_KEI_NO));
		
		// サブオプションサービス契約番号を取得
		String sbopSvcKeiNo = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_KEI_NO));
		
		// サブオプションサービスコードを取得
		String sbopSvcCd = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_CD));
		
		super.logPrint.printDebugLog("★サブオプションサービスコード★" + sbopSvcCd + "★" + sbopSvcKeiNo);
		
		// オプションサービス契約番号
		param_add[0] = opSvcKeiNo;
		// サブオプションサービス契約番号
		param_add[1] = sbopSvcKeiNo;
		// 世代登録年月日時分秒 → システム日付を設定
		param_add[2] = sysdate;
		// サブオプションサービス契約ステータス → 100：サービス提供中を設定
		param_add[3] = JBSbatKKConst.SVC_KEI_STAT_SVCTK_CHU;
		// サブオプションサービスコード
		param_add[4] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_CD));
		// 料金コースコード
		param_add[5] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.PCRS_CD));
		// 料金プランコード
		param_add[6] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.PPLAN_CD));
		// 申込明細番号
		param_add[7] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.MSKM_DTL_NO));
		// 試用加入年月日
		param_add[8] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.FTRIAL_KANYU_YMD));
		// 試用期間終了年月日
		param_add[9] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.FTRIAL_PRD_ENDYMD));
		// 本加入年月日
		param_add[10] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.HONKANYU_YMD));
		// 本加入移行期限年月日
		param_add[11] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.HONKANYU_IKO_KIGEN_YMD));
		// サービス利用開始希望年月日
		param_add[12] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_USE_STA_KIBO_YMD));
		// 予約適用開始希望年月日
		param_add[13] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.RSV_TSTA_KIBO_YMD));
		// サブオプションサービス契約後続業務依頼年月日
		param_add[14] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SBOP_SVC_KEI_KZKWRK_REQYMD));
		// 照査年月日
		param_add[15] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SHOSA_YMD));
		// 照査取消年月日
		param_add[16] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SHOSA_CL_YMD));
		// 契約締結年月日
		param_add[17] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.KEI_CNC_YMD));
		// 予約適用年月日
		param_add[18] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.RSV_APLY_YMD));
		// 予約取消年月日
		param_add[19] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.RSV_CL_YMD));
		// 予約適用コード
		param_add[20] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.RSV_APLY_CD));
		// プラン開始年月日 → RULE0076結果（基準日）
		param_add[21] = svcStaYmdSbop;
		// プラン終了年月日 → 20991231
		param_add[22] = END_DATE;
		// プラン課金開始年月日 → RULE0068結果
		param_add[23] = svcStaChrgYmdSbop;
		// プラン課金終了年月日 → 20991231
		param_add[24] = END_DATE;
		// プラン終了種別コード
		param_add[25] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.PLAN_END_SBT_CD));
		// サービスキャンセル年月日
		param_add[26] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CANCEL_YMD));
		// サービスキャンセル理由コード
		param_add[27] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CANCEL_RSN_CD));
		// サービス開始年月日 → RULE0076結果（基準日）
		param_add[28] = svcStaYmdSbop;
		// 表示用サービス提供開始年月日
		param_add[29] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.DSP_SVCTK_STAYMD));
		// サービス課金開始年月日 → RULE0068結果
		param_add[30] = svcStaChrgYmdSbop;
		// サービス停止年月日
		param_add[31] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_STP_YMD));
		// サービス停止理由コード
		param_add[32] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_STP_RSN_CD));
		// サービス停止解除年月日
		param_add[33] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_STP_RLS_YMD));
		// サービス停止解除理由コード
		param_add[34] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_STP_RLS_RSN_CD));
		// 休止中断コード
		param_add[35] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.PAUSE_STP_CD));
		// サービス休止年月日
		param_add[36] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_YMD));
		// サービス休止理由コード
		param_add[37] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_RSN_CD));
		// サービス休止理由メモ
		param_add[38] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_RSN_MEMO));
		// サービス休止解除年月日
		param_add[39] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_RLS_YMD));
		// サービス休止解除理由コード
		param_add[40] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_RLS_RSN_CD));
		// サービス休止解除理由メモ
		param_add[41] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_RLS_RSN_MEMO));
		// サービス終了年月日 → 20991231
		param_add[42] = END_DATE;
		// サービス課金終了年月日 → 20991231
		param_add[43] = END_DATE;
		// サービス解約年月日
		param_add[44] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_DSL_YMD));
		// サービス解約理由コード
		param_add[45] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_DLRE_CD));
		// サービス解約理由メモ
		param_add[46] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_DLRE_MEMO));
		// サービス解約手続完了フラグ
		param_add[47] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_DSL_TTDKI_FIN_FLG));
		// 回復年月日
		param_add[48] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.KAIHK_YMD));
		// サービスキャンセル取消年月日
		param_add[49] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_CANCEL_CL_YMD));
		// サービス解約取消年月日
		param_add[50] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_DSL_CL_YMD));
		// 審査結果送信コード
		param_add[51] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SKEKKA_SEND_CD));
		// 課金開始年月日補正有無
		param_add[52] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.CHRG_STA_YMD_HOSEI_UM));
		// サービス休止課金開始年月日
		param_add[53] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SVC_PAUSE_CHRG_STA_YMD));
		// 違約金発生コード
		param_add[54] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.PNLTY_HASSEI_CD));
		// 異動区分
		param_add[55] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.IDO_DIV));
		// 照査解約完了コード
		param_add[56] = JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SBOP_SVC_KEI.SHOSA_DSL_FIN_CD));
		// 登録年月日時分秒
		param_add[57] = sysdate;
		// 登録オペレータアカウント
		param_add[58] = batchUserId;
		// 更新年月日時分秒
		param_add[59] = sysdate;
		// 更新オペレータアカウント
		param_add[60] = batchUserId;
		// 削除年月日時分秒
		param_add[61] = "";
		// 削除オペレータアカウント
		param_add[62] = "";
		// 無効フラグ → 0：有効を設定
		param_add[63] = JBSbatKKConst.MK_FLG_YK;
		// 登録運用年月日
		param_add[64] = "";
		// 登録処理ID
		param_add[65] = "";
		// 更新運用年月日
		param_add[66] = "";
		// 更新処理ID
		param_add[67] = "";
		// 削除運用年月日
		param_add[68] = "";
		// 削除処理ID
		param_add[69] = "";
		
		// サブオプションサービス契約の登録を行います。
		this.executeKK_T_SBOP_SVC_KEI_PKINSERT(param_add);
		
		// サブオプションサービス契約番号に紐づくサブクラスの登録を行います。
		JKKBatCommon.createSubTypeKK0401(commonItem, opSvcKeiNo, sbopSvcKeiNo,
				JBSbatStringUtil.Rtrim(sbopScvKeiMap.getString(JBSbatKK_T_SVC_KEI.GENE_ADD_DTM)), sysdate);
	}
}