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

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;

import eo.business.common.JBSbatBusinessService;
import eo.business.common.JKKBatCommon;
import eo.business.util.table.JBSbatCK_T_CUST;
import eo.business.util.table.JBSbatKK_T_KAKINS;
import eo.business.util.table.JBSbatKK_T_MSKM_DTL;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVKEIUW_EOH_NET;
import eo.business.util.table.JBSbatZM_M_WORK_PARAM_KNRI;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.util.JBSbatCheckUtil;
import eo.framework.util.JBSbatDateUtil;

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

	/** テーブル(お客様)*/
	private static final String D_TBL_NAME_CK_T_CUST = "CK_T_CUST";

	/** テーブル(課金先)*/
	private static final String D_TBL_NAME_KK_T_KAKINS = "KK_T_KAKINS";

	/** テーブル(サービス契約内訳＜ｅｏ光ネット＞)*/
	private static final String D_TBL_NAME_KK_T_SVKEIUW_EOH_NET = "KK_T_SVKEIUW_EOH_NET";

	/** テーブル(請求契約)*/
	private static final String D_TBL_NAME_KK_T_SEIKY_KEI = "KK_T_SEIKY_KEI";

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

	/** テーブル(個人情報削除判定ワーク)*/
	private static final String D_TBL_NAME_KK_T_KJNIFDEL_JDG_WK = "KK_T_KJNIFDEL_JDG_WK";

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

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

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

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

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

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

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

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

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

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

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

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

	/** テーブルアクセスクラス(サービス契約)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI = null;

	/** テーブルアクセスクラス(お客様)*/
	private JBSbatSQLAccess db_CK_T_CUST = null;

	/** テーブルアクセスクラス(課金先)*/
	private JBSbatSQLAccess db_KK_T_KAKINS = null;

	/** テーブルアクセスクラス(サービス契約内訳＜ｅｏ光ネット＞)*/
	private JBSbatSQLAccess db_KK_T_SVKEIUW_EOH_NET = null;

	/** テーブルアクセスクラス(請求契約)*/
	private JBSbatSQLAccess db_KK_T_SEIKY_KEI = null;

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

	/** テーブルアクセスクラス(個人情報削除判定ワーク)*/
	private JBSbatSQLAccess db_KK_T_KJNIFDEL_JDG_WK = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/** 課金開始後削除対象外期間*/
	private static final String CHRG_AF_DEL_PRD = "KK_CHRG_AF_DEL_PRD";
	
	/** 課金開始前解約削除対象外期間*/
	private static final String CHRG_BF_DEL_PRD = "KK_CHRG_BF_DSL_PRD";
	
	/** 課金開始前キャンセル削除対象外期間*/
	private static final String CHRG_BF_CNCL_PRD = "KK_CHRG_BF_CNCL_PRD" ;
	
	/** 無効フラグ(有効)*/
	private static final String MK_FLG = "0";
	
	/** 異動区分*/
	/** 新規契約*/
	private static final String NEW_KEI = "00001";
	/** サービス追加*/
	private static final String ADD_SVC = "00002";
	
	/** 個人情報削除理由コード*/
	/** 01:解約（課金開始後）*/
	private static final String KAIYAKU_KAKINGO = "01";
	/** 02:解約（課金開始前）*/
	private static final String KAIYAKU_KAKINMAE = "02";
	/** 03:キャンセル（課金開始後）*/
	private static final String CANCEL_KAKINGO = "03";
	/** 04:キャンセル（課金開始前）*/
	private static final String CANCEL_KAKINMAE = "04";
	
	/** カレントデータ識別コード*/
	/** 1：カレントデータ*/
	private static final String CRNT_DATA = "1";
	/** 2：履歴データ*/
	private static final String RIREKI_DATA = "2";
	
	/** ALL0 */
	private static final String ALL0 = "0000000000";
	
	/** DB読込件数(カレントデータ) */
	private int intSelectCnt_Crnt = 0;
	/** DB読込件数(履歴データ) */
	private int intSelectCnt_Rrk = 0;
	
	/** DB登録件数 */
	private int intInsertCnt = 0;

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

		// DBアクセスクラスを生成します
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_CK_T_CUST = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CK_T_CUST);
		db_KK_T_KAKINS = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KAKINS);
		db_KK_T_SVKEIUW_EOH_NET = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVKEIUW_EOH_NET);
		db_KK_T_SEIKY_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SEIKY_KEI);
		db_KK_T_MSKM_DTL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_MSKM_DTL);
		db_KK_T_KJNIFDEL_JDG_WK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KJNIFDEL_JDG_WK);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		super.logPrint.printDebugLog("execute_START");
		
		// 削除対象期間検索
		String[] targetKikan = new String[3];
		// 削除対象データ抽出
		ArrayList<String[]> lstDelData = new ArrayList<String[]>(); 
		// 登録データ抽出
		ArrayList<String[]> lstInsData = new ArrayList<String[]>();
		
		// バッチ運用日
		String investDate = super.opeDate;
		
		// 削除対象期間経過データ取得
		targetKikan = getDelOverTerm(investDate);
		
		// サービス契約より削除対象データのサービス契約番号(カレント)を取得する
		lstDelData = getDelData(targetKikan, investDate);
		
		//DB読込件数取得
		//intSelectCnt_Crnt = lstDelData.size();
		
		// サービス契約情報を元に、削除対象となる情報(履歴)を取得し、カレントデータと併せて登録用にデータ編集を行う
		lstInsData = getTorokuDelData(lstDelData, investDate);
		
		// 個人情報削除判定ワークへ取得した情報を登録する
		insertDelData(lstInsData, investDate);
		
		super.logPrint.printDebugLog("execute_END");
		return null;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/

		//DB読込件数ログ出力(カレントデータ)
		super.logPrint.printBusinessErrorLog("EKKB0770AI", new String[]{"サービス契約（カレント）", Integer.toString(intSelectCnt_Crnt)});
		//DB読込件数ログ出力(履歴データ)
		super.logPrint.printBusinessErrorLog("EKKB0770AI", new String[]{"サービス契約（履歴）", Integer.toString(intSelectCnt_Rrk)});		
		//DB登録件数ログ出力
		super.logPrint.printBusinessErrorLog("EKKB0790AI", new String[]{"個人情報削除判定ワーク", Integer.toString(intInsertCnt)});
		
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_KK_T_SVC_KEI.close();
		db_CK_T_CUST.close();
		db_KK_T_KAKINS.close();
		db_KK_T_SVKEIUW_EOH_NET.close();
		db_KK_T_SEIKY_KEI.close();
		db_KK_T_MSKM_DTL.close();
		db_KK_T_KJNIFDEL_JDG_WK.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

	/**
	 * SQLKEY(KK_SELECT_211)で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_211(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_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_KK_SELECT_211);
	}

	/**
	 * SQLKEY(KK_SELECT_212)で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_212(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_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_KK_SELECT_212);
	}

	/**
	 * SQLKEY(KK_SELECT_213)で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_213(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_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_KK_SELECT_213);
	}

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

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

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

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

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

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

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

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

	/**
	 * SQLKEY(KK_SELECT_215)で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_215(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_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_KK_SELECT_215);
	}

	/**
	 * 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_SEIKY_KEI_KK_SELECT_051(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_SEIKY_KEI.selectBySqlDefine(paramList, KK_T_SEIKY_KEI_KK_SELECT_051);
	}

	/**
	 * SQLKEY(KK_SELECT_020)で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_020(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_020);
	}

	/**
	 * SQLKEY(KK_SELECT_011)で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_KJNIFDEL_JDG_WK_KK_SELECT_011(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_KJNIFDEL_JDG_WK.selectBySqlDefine(paramList, KK_T_KJNIFDEL_JDG_WK_KK_SELECT_011);
	}

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	サービス契約番号				SVC_KEI_NO
	 *		 	請求契約番号				SEIKY_KEI_NO
	 *		 	ＳＹＳＩＤ				SYSID
	 *		 	サービスコード				SVC_CD
	 *		 	料金グループコード				PRC_GRP_CD
	 *		 	料金コースコード				PCRS_CD
	 *		 	新規申込時申込書番号				NEW_MSKM_JI_MSKMSHO_NO
	 *		 	ＩＳＰ認証ＩＤ				ISP_NINSHO_ID
	 *		 	サービス解約起算年月日				SVC_DSL_KISAN_YMD
	 *		 	サービスキャンセル年月日				SVC_CANCEL_YMD
	 *		 	サービス解約年月日				SVC_DSL_YMD
	 *		 	サービス終了年月日				SVC_ENDYMD
	 *		 	削除処理対象抽出年月日				DEL_TRN_TG_CHSHT_YMD
	 *		 	個人情報削除理由コード				KOJIN_INFO_DEL_RSN_CD
	 *		 	削除判定コード				DEL_JDG_CD
	 *		 	契約最終更新年月日時分秒				KEI_LAST_UPD_DTM
	 *		 	カレントデータ識別コード				CRNT_DATA_SKBT_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_KJNIFDEL_JDG_WK_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("SVC_KEI_NO", setParam[0]);
		setMap.setValue("SEIKY_KEI_NO", setParam[1]);
		setMap.setValue("SYSID", setParam[2]);
		setMap.setValue("SVC_CD", setParam[3]);
		setMap.setValue("PRC_GRP_CD", setParam[4]);
		setMap.setValue("PCRS_CD", setParam[5]);
		setMap.setValue("NEW_MSKM_JI_MSKMSHO_NO", setParam[6]);
		setMap.setValue("ISP_NINSHO_ID", setParam[7]);
		setMap.setValue("SVC_DSL_KISAN_YMD", setParam[8]);
		setMap.setValue("SVC_CANCEL_YMD", setParam[9]);
		setMap.setValue("SVC_DSL_YMD", setParam[10]);
		setMap.setValue("SVC_ENDYMD", setParam[11]);
		setMap.setValue("DEL_TRN_TG_CHSHT_YMD", setParam[12]);
		setMap.setValue("KOJIN_INFO_DEL_RSN_CD", setParam[13]);
		setMap.setValue("DEL_JDG_CD", setParam[14]);
		setMap.setValue("KEI_LAST_UPD_DTM", setParam[15]);
		setMap.setValue("CRNT_DATA_SKBT_CD", setParam[16]);
		setMap.setValue("ADD_DTM", setParam[17]);
		setMap.setValue("ADD_OPEACNT", setParam[18]);
		setMap.setValue("UPD_DTM", setParam[19]);
		setMap.setValue("UPD_OPEACNT", setParam[20]);
		setMap.setValue("DEL_DTM", setParam[21]);
		setMap.setValue("DEL_OPEACNT", setParam[22]);
		setMap.setValue("MK_FLG", setParam[23]);
		setMap.setValue("ADD_UNYO_YMD", setParam[24]);
		setMap.setValue("ADD_TRN_ID", setParam[25]);
		setMap.setValue("UPD_UNYO_YMD", setParam[26]);
		setMap.setValue("UPD_TRN_ID", setParam[27]);
		setMap.setValue("DEL_UNYO_YMD", setParam[28]);
		setMap.setValue("DEL_TRN_ID", setParam[29]);
	
		// DBアクセスを実行します
		//▼▼▼件数取得のため自働生成部を変更▼▼▼
		intInsertCnt += db_KK_T_KJNIFDEL_JDG_WK.insertByPrimaryKeys(setMap);
		//▲▲▲件数取得のため自働生成部を変更▲▲▲
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * 削除対象期間情報抽出処理 <br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.業務パラメータ管理より期間を取得する<br>
	 * 
	 * 2.バッチ運用日をもとに期間算定を行う
	 * </pre>
	 * <p>
	 * @param investDate バッチ運用日
	 * @return 削除対象期間経過情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 * 
	 */
	private String[] getDelOverTerm(String investDate) throws Exception
	{
		super.logPrint.printDebugLog("getDelOverTerm:investDate=" + investDate);
		
		JBSbatCommonDBInterface dbmap = new JBSbatCommonDBInterface();
		
		String compYear = null;
		String compMon = null;
		String compDay = null;
		
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		
		// 期間取得用
		String[] param = new String[3];
		
		// 課金開始後削除対象外期間
		String afDel = null;
		// 課金開始前削除対象外期間
		String bfDel = null;
		// 課金開始前キャンセル削除対象外期間
		String bfcncl = null;
		// 削除対象期間経過情報
		String[] keikaKikan = new String[3];
		
		// 日付を設定
		compYear = investDate.substring(0, 4);
		compMon = investDate.substring(4, 6);
		compDay = investDate.substring(6, 8);
		
		cal.set(Calendar.YEAR, Integer.parseInt(compYear));
		cal.set(Calendar.MONTH, Integer.parseInt(compMon) - 1);
		cal.set(Calendar.DATE, Integer.parseInt(compDay));
		
		// 課金開始後削除対象外期間取得
		// 業務パラメータID
		param[0] = CHRG_AF_DEL_PRD;
		// 業務パラメータ適用開始年月日
		param[1] = investDate;
		// 業務パラメータ適用終了年月日
		param[2] = investDate;
		
		// 業務パラメータよりデータを取得する
		afDel = JKKBatCommon.getWorkParamSetteValue(super.commonItem, CHRG_AF_DEL_PRD);
		if (afDel != null)
		{
			// カレンダーを文字列に変換
			keikaKikan[0] = sdf.format(createDelOverTerm(cal, afDel).getTime());
			super.logPrint.printDebugLog("getDelOverTerm:keikaKikan[0]=" + keikaKikan[0]);
		}
		else
		{
			throw new JBSbatBusinessException("EKKB0740CE", new String[]{"業務パラメータ", "課金開始後削除対象外期間"});
		}
		
		// 課金開始前解約削除対象外期間
		cal.clear();
		cal.set(Calendar.YEAR, Integer.parseInt(compYear));
		cal.set(Calendar.MONTH, Integer.parseInt(compMon) - 1);
		cal.set(Calendar.DATE, Integer.parseInt(compDay));
		
		param[0] = CHRG_BF_DEL_PRD;
		
		// 業務パラメータよりデータを取得する
		bfDel = JKKBatCommon.getWorkParamSetteValue(super.commonItem, CHRG_BF_DEL_PRD);
		if (bfDel != null)
		{
			// カレンダーを文字列に変換
			keikaKikan[1] = sdf.format(createDelOverTerm(cal, bfDel).getTime());
			super.logPrint.printDebugLog("getDelOverTerm:keikaKikan[1]=" + keikaKikan[1]);
		}
		else
		{
			throw new JBSbatBusinessException("EKKB0740CE", new String[]{"業務パラメータ", "課金開始前解約削除対象外期間"});
		}
		
		// 課金開始前キャンセル削除対象外期間
		cal.clear();
		cal.set(Calendar.YEAR, Integer.parseInt(compYear));
		cal.set(Calendar.MONTH, Integer.parseInt(compMon) - 1);
		cal.set(Calendar.DATE, Integer.parseInt(compDay));
		
		param[0] = CHRG_BF_CNCL_PRD;
		
		// 業務パラメータよりデータを取得する
		bfcncl = JKKBatCommon.getWorkParamSetteValue(super.commonItem, CHRG_BF_CNCL_PRD);
		if (dbmap != null)
		{
			// カレンダーを文字列に変換
			keikaKikan[2] = sdf.format(createDelOverTerm(cal, bfcncl).getTime());
			super.logPrint.printDebugLog("getDelOverTerm:keikaKikan[2]=" + keikaKikan[2]);
		}
		else
		{
			throw new JBSbatBusinessException("EKKB0740CE", new String[]{"業務パラメータ", "課金開始前キャンセル削除対象外期間"});
		}
		
		return keikaKikan;
	}
	
	/**
	 * 削除対象期間情報作成処理 <br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * バッチ運用日をもとに期間算定を行う
	 * </pre>
	 * <p>
	 * @param cal バッチ運用日
	 * @param strTerm 保存期間
	 * @return 削除対象期間
	 * @throws Exception 業務サービス内で発生した例外全般。
	 * 
	 */
	private Calendar createDelOverTerm(Calendar cal, String strTerm) throws Exception
	{
		Calendar calRtn = cal;
		int intMar = 2;
		int intEnd = 31;
		int intStart = 1;
		
		if(Integer.parseInt(strTerm.substring(0, 2)) >= 3)
		{
			//保存期間が3年以上の場合、年度単位で区切る
			
			// 処理年判定(年度処理)
			if (calRtn.get(Calendar.MONTH) < 3) 
			{
				// バッチ運用日が１月から３月の場合、課金後期間 + １年を差し引く
				calRtn.add(Calendar.YEAR, -(Integer.parseInt(strTerm.substring(0, 2)) + 1));
				calRtn.add(Calendar.MONTH, -(Integer.parseInt(strTerm.substring(2, 4))));
				
			}
			else 
			{
				
				// バッチ運用日が４月から１２月の場合、課金後期間を差し引く
				calRtn.add(Calendar.YEAR, -(Integer.parseInt(strTerm.substring(0, 2))));
				calRtn.add(Calendar.MONTH, -(Integer.parseInt(strTerm.substring(2, 4))));
				
			}
			
			// 年度末(3月31日)固定
			calRtn.set(Calendar.MONTH, intMar);
			calRtn.set(Calendar.DATE, intEnd);
		}
		else
		{
			//保存期間が3年未満の場合、月単位で区切る
			
			// 処理年判定(年度処理)
			// バッチ運用日から課金前キャンセル削除対象外期間を差し引く
			calRtn.add(Calendar.YEAR, -(Integer.parseInt(strTerm.substring(0, 2))));
			calRtn.add(Calendar.MONTH, -(Integer.parseInt(strTerm.substring(2, 4))));
			
			// 判定月の１日に固定
			calRtn.set(Calendar.DATE, intStart);
		}
		
		return calRtn;
	}
	
	/**
	 * サービス契約より削除対象データの情報(カレント)データを取得する<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * 1.削除対象期間を基にサービス契約よりデータを取得する
	 * 
	 * 2.取得したサービス契約のSYSIDを基に「お客さま」情報を検索する。
	 * 
	 * 3.お客様データの削除対象外フラグが１の場合は削除対象外とする
	 * </p>
	 * @param targetKikan 削除対象期間
	 * @param investDate バッチ運用日
	 * @return targetDelData 削除対象データ(カレント)
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<String[]> getDelData(String[] targetKikan, String investDate) throws Exception
	{
		JBSbatCommonDBInterface dbmap = new JBSbatCommonDBInterface();
		JBSbatCommonDBInterface resultMap = new JBSbatCommonDBInterface();
		
		ArrayList<String[]> targetDelData = new ArrayList<String[]>();
		
		
		// SYSID
		String sysId = null;
		
		
		// 削除対象外フラグ
		String delTrgtGaiFlg = null;
		
		// 削除対象期間(課金開始後削除対象外期間)
		String afKakin = targetKikan[0];
		// 削除対象期間(課金開始前解約削除対象外期間)
		String bfKakin = targetKikan[1];
		// 削除対象期間(課金開始前キャンセル削除対象外期間)
		String bfCancel = targetKikan[2];
		
		// サービス契約ステータス
		// 解約済
		String kaiyakuSumi = "910";
		// キャンセル済
		String cancelSumi = "920";
		
		// サービスコード
		String nonOwner = "99";
		
		String[] paramKakingo = new String[4];
		String[] paramOkyaku = new String[2];
		
		// ■課金後解約データ取得処理
		super.logPrint.printDebugLog("getDelData:■課金後解約データ取得処理");
		// サービス契約ステータス
		paramKakingo[0] = kaiyakuSumi;
		super.logPrint.printDebugLog("getDelData:サービス契約ステータス=" + kaiyakuSumi);
		// サービス終了日
		paramKakingo[1] = afKakin;
		super.logPrint.printDebugLog("getDelData:サービス終了日=" + afKakin);
		// サービスコード
		paramKakingo[2] = nonOwner;
		super.logPrint.printDebugLog("getDelData:サービスコード=" + nonOwner);
		// 予約適用年月日
		paramKakingo[3] = investDate;
		super.logPrint.printDebugLog("getDelData:予約適用年月日=" + investDate);
		
		// サービス契約データ取得
		executeKK_T_SVC_KEI_KK_SELECT_210(paramKakingo);
		
		dbmap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbmap != null) 
		{
			//DB読込件数（カレント）カウントアップ
			intSelectCnt_Crnt++;
			
			// 取得したデータのSYSIDを基に「お客様」情報を検索し、削除対象外フラグを取得する
			sysId = dbmap.getString(JBSbatKK_T_SVC_KEI.SYSID);
			
			paramOkyaku[0] = sysId;
			paramOkyaku[1] = investDate;
			
			// 削除対象外フラグ情報の取得
			executeCK_T_CUST_KK_SELECT_035(paramOkyaku);
			
			resultMap = db_CK_T_CUST.selectNext();
			
			while (resultMap != null)
			{
				// 削除対象外フラグの取得
				delTrgtGaiFlg = resultMap.getString(JBSbatCK_T_CUST.DEL_TRGT_GAI_FLG);
				
				if (delTrgtGaiFlg.compareTo("0") == 0) 
				{
					String[] resultData = new String[16];
					// サービス契約データを取得する
					resultData = getSvcKeiData(dbmap, KAIYAKU_KAKINGO, CRNT_DATA);
					
					targetDelData.add(resultData);
				}
				resultMap = db_CK_T_CUST.selectNext();
			}
			dbmap = db_KK_T_SVC_KEI.selectNext();
		}
		
		// ■課金前解約データ取得処理
		super.logPrint.printDebugLog("getDelData:■課金前解約データ取得処理");
		// サービス契約ステータス
		paramKakingo[0] = kaiyakuSumi;
		super.logPrint.printDebugLog("getDelData:サービス契約ステータス=" + kaiyakuSumi);
		// サービス終了日
		paramKakingo[1] = bfKakin;;
		super.logPrint.printDebugLog("getDelData:サービス終了日=" + bfKakin);
		// サービスコード
		paramKakingo[2] = nonOwner;
		super.logPrint.printDebugLog("getDelData:サービスコード=" + nonOwner);
		// 予約適用年月日
		paramKakingo[3] = investDate;
		super.logPrint.printDebugLog("getDelData:予約適用年月日=" + investDate);
		
		// サービス契約データ取得
		executeKK_T_SVC_KEI_KK_SELECT_211(paramKakingo);
		
		dbmap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbmap != null) 
		{
			//DB読込件数（カレント）カウントアップ
			intSelectCnt_Crnt++;
			
			// 取得したデータのSYSIDを基に「お客様」情報を検索し、削除対象外フラグを取得する
			sysId = dbmap.getString(JBSbatKK_T_SVC_KEI.SYSID);
			
			paramOkyaku[0] = sysId;
			paramOkyaku[1] = investDate;
			
			// 削除対象外フラグ情報の取得
			executeCK_T_CUST_KK_SELECT_035(paramOkyaku);
			
			resultMap = db_CK_T_CUST.selectNext();
			
			while (resultMap != null)
			{
				// 削除対象外フラグの取得
				delTrgtGaiFlg = resultMap.getString(JBSbatCK_T_CUST.DEL_TRGT_GAI_FLG);
				
				if (delTrgtGaiFlg.compareTo("0") == 0) 
				{
					String[] resultData = new String[16];
					// サービス契約データを取得する
					resultData = getSvcKeiData(dbmap, KAIYAKU_KAKINMAE, CRNT_DATA);
					
					targetDelData.add(resultData);
				
				}
				resultMap = db_CK_T_CUST.selectNext();
			}
			dbmap = db_KK_T_SVC_KEI.selectNext();
		}
		
		// ■課金後キャンセルデータ
		super.logPrint.printDebugLog("getDelData:■課金後キャンセルデータ");
		// サービス契約ステータス
		paramKakingo[0] = cancelSumi;
		// サービス終了日
		paramKakingo[1] = afKakin;
		// サービスコード
		paramKakingo[2] = nonOwner;
		// 予約適用年月日
		paramKakingo[3] = investDate;
		
		// サービス契約データ取得
		executeKK_T_SVC_KEI_KK_SELECT_212(paramKakingo);
		
		dbmap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbmap != null) 
		{
			//DB読込件数（カレント）カウントアップ
			intSelectCnt_Crnt++;
			
			// 取得したデータのSYSIDを基に「お客様」情報を検索し、削除対象外フラグを取得する
			sysId = dbmap.getString(JBSbatKK_T_SVC_KEI.SYSID);
			
			paramOkyaku[0] = sysId;
			paramOkyaku[1] = investDate;
			
			// 削除対象外フラグ情報の取得
			executeCK_T_CUST_KK_SELECT_035(paramOkyaku);
			
			resultMap = db_CK_T_CUST.selectNext();
			
			while (resultMap != null)
			{
				// 削除対象外フラグの取得
				delTrgtGaiFlg = resultMap.getString(JBSbatCK_T_CUST.DEL_TRGT_GAI_FLG);
				
				if (delTrgtGaiFlg.compareTo("0") == 0) 
				{
					String[] resultData = new String[16];
					// サービス契約データを取得する
					resultData = getSvcKeiData(dbmap, CANCEL_KAKINGO, CRNT_DATA);
					
					targetDelData.add(resultData);
				
				}
				resultMap = db_CK_T_CUST.selectNext();
			}
			dbmap = db_KK_T_SVC_KEI.selectNext();
		}
		
		// ■課金前キャンセルデータ
		super.logPrint.printDebugLog("getDelData:■課金前キャンセルデータ");
		// サービス契約ステータス
		paramKakingo[0] = cancelSumi;
		// サービス終了日
		paramKakingo[1] = bfCancel;
		// サービスコード
		paramKakingo[2] = nonOwner;
		// 予約適用年月日
		paramKakingo[3] = investDate;
		
		// サービス契約データ取得
		executeKK_T_SVC_KEI_KK_SELECT_213(paramKakingo);
		
		dbmap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbmap != null)
		{
			//DB読込件数（カレント）カウントアップ
			intSelectCnt_Crnt++;
			
			// 取得したデータのSYSIDを基に「お客様」情報を検索し、削除対象外フラグを取得する
			sysId = dbmap.getString(JBSbatKK_T_SVC_KEI.SYSID);
			
			paramOkyaku[0] = sysId;
			paramOkyaku[1] = investDate;
			
			// 削除対象外フラグ情報の取得
			executeCK_T_CUST_KK_SELECT_035(paramOkyaku);
			
			resultMap = db_CK_T_CUST.selectNext();
			
			while (resultMap != null)
			{
				// 削除対象外フラグの取得
				delTrgtGaiFlg = resultMap.getString(JBSbatCK_T_CUST.DEL_TRGT_GAI_FLG);
				
				if (delTrgtGaiFlg.compareTo("0") == 0) 
				{
					String[] resultData = new String[16];
					// サービス契約データを取得する
					resultData = getSvcKeiData(dbmap, CANCEL_KAKINMAE, CRNT_DATA);
					
					targetDelData.add(resultData);
				
				}
				resultMap = db_CK_T_CUST.selectNext();
			}
			dbmap = db_KK_T_SVC_KEI.selectNext();
		}
		
		return targetDelData;
	}

	/**
	 * サービス契約データ取得処理
	 * <p>
	 * </p>
	 * @param dbmap サービス契約より得た情報
	 * @param kjnIfDelRsnCd 個人情報削除理由コード
	 * @param crntData カレントデータ識別コード
	 * @return resultData サービス契約データ
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String[] getSvcKeiData(JBSbatCommonDBInterface dbmap, String kjnIfDelRsnCd, String crntData) throws Exception
	{
		String[] resultData = new String[16];
		
		super.logPrint.printDebugLog("getSvcKeiData:サービス契約番号=" + dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO));
		
		// サービス契約番号
		resultData[0] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO);
		// ＳＹＳＩＤ
		resultData[1] = dbmap.getString(JBSbatKK_T_SVC_KEI.SYSID);
		// サービスコード
		resultData[2] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_CD);
		// 料金グループコード
		resultData[3] = dbmap.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD);
		// 料金コースコード
		resultData[4] = dbmap.getString(JBSbatKK_T_SVC_KEI.PCRS_CD);
		// サービス解約起算年月日
		resultData[5] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_KISAN_YMD);
		// サービスキャンセル年月日
		resultData[6] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_CANCEL_YMD);
		// サービス解約年月日
		resultData[7] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD);
		// サービス終了年月日
		resultData[8] = dbmap.getString(JBSbatKK_T_SVC_KEI.SVC_ENDYMD);
		// 更新年月日時分秒
		resultData[9] = dbmap.getString(JBSbatKK_T_SVC_KEI.UPD_DTM);
		// 予約適用年月日
		resultData[10] = dbmap.getString(JBSbatKK_T_SVC_KEI.RSV_APLY_YMD);
		// 個人情報削除理由コード
		resultData[11] = kjnIfDelRsnCd;
		// カレントデータ識別コード
		resultData[12] = crntData;
		
		return resultData;
	}
	
	/**
	 * サービス契約より削除対象データの情報(履歴)データを取得する<br>
	 * カレントデータと併せて、個人情報削除判定ワークに登録するためのデータに編集する<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * 1.サービス契約情報を基に、カレントのSYSID以外の履歴情報を取得する
	 * 
	 * 2.サービス契約情報を基に、課金先から情報を取得する
	 * 
	 * 3.カレントデータ、および、１．２．の情報を基に登録用データに編集する
	 * </p>
	 * @param lstDelData サービス契約情報(カレント)
	 * @param investDate バッチ運用日
	 * @return lstInsWk 登録用データ 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<String[]> getTorokuDelData(ArrayList<String[]> lstDelData, String investDate) throws Exception
	{
		super.logPrint.printDebugLog("getTorokuDelData:lstDelData.size()=" + lstDelData.size());
		super.logPrint.printDebugLog("getTorokuDelData:investDate=" + investDate);
		
		ArrayList<String[]> lstWk = new ArrayList<String[]>();
		ArrayList<String[]> lstKWk = new ArrayList<String[]>();
		ArrayList<String[]> lstInsWk = new ArrayList<String[]>();
		
		JBSbatCommonDBInterface dbRekimap = new JBSbatCommonDBInterface();
		JBSbatCommonDBInterface dbKakinmap = new JBSbatCommonDBInterface();
		
		// サービス契約番号
		String svcKeiNo = null;
		// SYSID
		String sysId = null;
		// 個人情報削除理由コード
		String kjnIfDelRsnCd = null;
		// 請求契約番号
		String seikyKeiNo = null;
		// 予約適用年月日
		String rsvAplyYmd = null;
		// 比較用予約適用年月日
		String preAplyYmd = null;
		// 課金先適用開始日
		String kakinTstaYmd = null;
		// 課金先適用終了日
		String kakinTendYmd = null;
		
		String[] rekiParam = new String[3];
		String[] kakinParam = new String[1];
		String[] resultData = new String[16];
		String[] rstKakinData = new String[3];
		
		int jdgData = 0;
		
		for (int i = 0; i < lstDelData.size(); i++) 
		{
			// 初期化
			lstWk = new ArrayList<String[]>();
			lstKWk = new ArrayList<String[]>();
			// カレントデータの取得
			lstWk.add(lstDelData.get(i));
			
			// サービス契約番号の取得
			svcKeiNo = lstDelData.get(i)[0];
			// SYSIDの取得
			sysId = lstDelData.get(i)[1];
			// 個人情報削除理由コードの取得
			kjnIfDelRsnCd  = lstDelData.get(i)[11];
			
			// □サービス契約データ(履歴)取得
			// サービス契約番号
			rekiParam[0] = svcKeiNo;
			// SYSID
			rekiParam[1] = sysId;
			
			executeKK_T_SVC_KEI_KK_SELECT_214(rekiParam);
			
			dbRekimap = db_KK_T_SVC_KEI.selectNext();
			
			while (dbRekimap != null) 
			{
			
				//DB読込件数カウントアップ
				intSelectCnt_Rrk++;
				
				// サービス契約データを取得する
				resultData = getSvcKeiData(dbRekimap, kjnIfDelRsnCd, RIREKI_DATA);
				
				lstWk.add(resultData);
				dbRekimap = db_KK_T_SVC_KEI.selectNext();
			}
			
			// □課金先情報の取得
			kakinParam[0] = svcKeiNo;
			
			// 課金先データの取得
			executeKK_T_KAKINS_KK_SELECT_038(kakinParam);
			
			dbKakinmap = db_KK_T_KAKINS.selectNext();
			
			while (dbKakinmap != null) 
			{
				// 課金先データを取得する
				rstKakinData = getKakinData(dbKakinmap);
				
				lstKWk.add(rstKakinData);
				dbKakinmap = db_KK_T_KAKINS.selectNext();
			}
			
			// データ編集処理
			for (int j = 0; j < lstWk.size(); j++) 
			{
				// カレント用のデータ取得処理
				if (j == 0) 
				{
					// ISP認証ID
					String ispID = null;
					// 申込明細番号
					String mskmDtlNo = null;
					// 申込書番号
					String mskmNo = null;
					
					super.logPrint.printDebugLog("getTorokuDelData:サービス契約番号=" + lstWk.get(j)[0]);
					// ISP認証データの取得
					ispID = getIspId(svcKeiNo, investDate);
					// 申込明細番号の取得
					mskmDtlNo = getMskmDtNo(svcKeiNo, investDate);
					if(mskmDtlNo != null)
					{
						// 申込書番号の取得
						mskmNo = getMskmNo(mskmDtlNo);
					}
					
					// ISP認証データ
					lstWk.get(j)[14] = ispID;
					super.logPrint.printDebugLog("getTorokuDelData:ISP認証=" + ispID);
					// 申込書番号の取得
					lstWk.get(j)[15] = mskmNo;
					super.logPrint.printDebugLog("getTorokuDelData:申込書番号=" + mskmNo);
					
				}
				
				// 課金先データが存在しない場合、請求契約番号にALL0設定
				if (lstKWk.size() == 0)
				{
					seikyKeiNo = ALL0;
					lstWk.get(j)[13] = seikyKeiNo;
					super.logPrint.printDebugLog("getTorokuDelData:請求契約番号=" + seikyKeiNo);
					
					boolean addFlg = true;
					for(int l = 0 ; l < lstInsWk.size() ; l++)
					{
						if(lstInsWk.get(l)[0].equals(lstWk.get(j)[0]))
						{
							if(lstInsWk.get(l)[1].equals(lstWk.get(j)[1])
									&& lstInsWk.get(l)[13].equals(lstWk.get(j)[13]))
							{
								addFlg = false;
								break;
							}
						}
					}
					if(addFlg)
					{
						lstInsWk.add(lstWk.get(j));
					}
				}
				else
				{
					
					// 比較用に前データの予約適用年月日前日を取得
					if (j == 0)
					{
						preAplyYmd = "20991231";
						
					}
					else
					{
						
						preAplyYmd = lstWk.get(j - 1)[10];
					}
					// 予約適用年月日(終了)
					preAplyYmd = getcompYmd(preAplyYmd);
					
					// 予約適用年月日の取得
					rsvAplyYmd = lstWk.get(j)[10];
					
					// 課金先データの取得
					for (int k = 0; k < lstKWk.size(); k++)
					{

						// 請求契約番号の取得
						seikyKeiNo = lstKWk.get(k)[0];
						// 課金先適用開始日
						kakinTstaYmd = lstKWk.get(k)[1];
						// 課金先適用終了日
						kakinTendYmd = lstKWk.get(k)[2];
						//現処理サービス契約番号のデータをコピー
						String[] aryWk = lstWk.get(j).clone();
						if(j == 0 && k == 0)
						{
							//カレントデータ
							aryWk[12] = CRNT_DATA;
						}
						else
						{
							//履歴データ
							aryWk[12] = RIREKI_DATA;
						}
						
						// 対象データ編集
						jdgData = getJdgData(rsvAplyYmd, preAplyYmd, kakinTstaYmd, kakinTendYmd);
						
						if (jdgData == 1 || jdgData == 2 || jdgData == 3)
						{
							// 現処理サービス契約データに請求契約番号を設定する
							aryWk[13] = seikyKeiNo;
							super.logPrint.printDebugLog("getTorokuDelData:請求契約番号=" + seikyKeiNo);
							
							boolean addFlg = true;
							for(int l = 0 ; l < lstInsWk.size() ; l++)
							{
								if(lstInsWk.get(l)[0].equals(aryWk[0]))
								{
									if(lstInsWk.get(l)[1].equals(aryWk[1])
											&& lstInsWk.get(l)[13].equals(aryWk[13]))
									{
										addFlg = false;
										break;
									}
								}
							}
							if(addFlg)
							{
								lstInsWk.add(aryWk);
							}
						}
						else
						{
							// 処理対象外
						}
						
					}
				}
			}

		}
		
		return lstInsWk;
	}

	/**
	 * 課金先データを取得する
	 * <p>
	 * </p>
	 * @param dbKakinmap サービス契約番号に紐づく契約番号
	 * @return rstKakinData 課金先情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String[] getKakinData(JBSbatCommonDBInterface dbKakinmap) throws Exception
	{
		String[] rstKakinData = new String[3];
		
		// 請求契約番号
		rstKakinData[0] = dbKakinmap.getString(JBSbatKK_T_KAKINS.SEIKY_KEI_NO);
		// 課金先適用開始年月日
		rstKakinData[1] = dbKakinmap.getString(JBSbatKK_T_KAKINS.KAKINS_TSTAYMD);
		// 課金先適用終了年月日
		rstKakinData[2] = dbKakinmap.getString(JBSbatKK_T_KAKINS.KAKINS_TENDYMD);
		
		return rstKakinData;
	}
	
	/**
	 * ISP認証IDデータを取得する
	 * <p>
	 * </p>
	 * 
	 * @param svcKeiNo サービス契約番号
	 * @param investDate バッチ運用日
	 * @return ispID ISP認証IDを取得する
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getIspId(String svcKeiNo, String investDate) throws Exception
	{
		JBSbatCommonDBInterface dbIspMap = new JBSbatCommonDBInterface();
		
		String ispId = null;
		
		String[] param = new String[2];
		
		// サービス契約番号
		param[0] = svcKeiNo;
		// バッチ運用日
		param[1] = investDate;
		
		executeKK_T_SVKEIUW_EOH_NET_KK_SELECT_008(param);
		
		dbIspMap = db_KK_T_SVKEIUW_EOH_NET.selectNext();
		
		while (dbIspMap != null) 
		{
			ispId = dbIspMap.getString(JBSbatKK_T_SVKEIUW_EOH_NET.ISP_NINSHO_ID);
			dbIspMap = db_KK_T_SVKEIUW_EOH_NET.selectNext();
		}
		
		return ispId;
	}
	
	/**
	 * 申込明細番号を取得する
	 * <p>
	 * </p>
	 * @param svcKeiNo サービス契約番号
	 * @param investDate バッチ運用日
	 * @return mskmDtlNo 申込明細番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getMskmDtNo(String svcKeiNo, String investDate) throws Exception
	{
		JBSbatCommonDBInterface dbMskMap = new JBSbatCommonDBInterface();
		
		String mskmDtlNo = null;
		
		String[] param = new String[4];
		
		// サービス契約番号
		param[0] = svcKeiNo; 
		// 異動区分(新規追加)
		param[1] = NEW_KEI;
		// 異動区分(サービス追加)
		param[2] = ADD_SVC;
		// バッチ運用日
		param[3] = investDate;
		
		executeKK_T_SVC_KEI_KK_SELECT_215(param);
		
		dbMskMap = db_KK_T_SVC_KEI.selectNext();
		
		while (dbMskMap != null) 
		{
			mskmDtlNo = dbMskMap.getString(JBSbatKK_T_SVC_KEI.MSKM_DTL_NO);
			dbMskMap = db_KK_T_SVC_KEI.selectNext();
		}
		
		return mskmDtlNo;
	}
	
	/**
	 * 申込書番号を取得する
	 * <p>
	 * </p>
	 * @param mskmDtlNo 申込明細番号
	 * @return mskmNo 申込書番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getMskmNo(String mskmDtlNo) throws Exception
	{
		JBSbatCommonDBInterface dbMskMap = new JBSbatCommonDBInterface();
		
		String mskmNo = null;
		
		String[] param = new String[1];
		
		// 申込書明細番号	
		param[0] = mskmDtlNo;
		
		executeKK_T_MSKM_DTL_KK_SELECT_020(param);
		
		dbMskMap = db_KK_T_MSKM_DTL.selectNext();
		
		while (dbMskMap != null) 
		{
			mskmNo = dbMskMap.getString(JBSbatKK_T_MSKM_DTL.MSKMSHO_NO);
			dbMskMap = db_KK_T_MSKM_DTL.selectNext();
		}
		
		return mskmNo;
	}
	
	/**
	 * 比較用の適用終了日を取得する
	 * <p>
	 * </p>
	 * @param preAplyYmd １つ前データの予約適用開始日
	 * @return compdate １つ前データの予約適用開始日の前日
	 */
	private String getcompYmd(String preAplyYmd)
	{
		String compYear = null;
		String compMon = null;
		String compDay = null;
		String compdate = null;
		
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		
		compYear = preAplyYmd.substring(0, 4);
		compMon = preAplyYmd.substring(4, 6);
		compDay = preAplyYmd.substring(6, 8);
		
		cal.set(Calendar.YEAR, Integer.parseInt(compYear));
		cal.set(Calendar.MONTH, Integer.parseInt(compMon) - 1);
		cal.set(Calendar.DATE, Integer.parseInt(compDay));
		
		cal.add(Calendar.DATE, -1);
		
		compdate = sdf.format(cal.getTime());
		
		return compdate;
	}
	
	/**
	 * 予約適用日・課金先適用開始年月日・課金先適用終了日を用いて、登録対象データの判定を行う
	 * <p>
	 * </p>
	 * @param rsvAplyYmd 予約適用年月日
	 * @param preAplyYmd 1つ前の予約適用年月日
	 * @param kakinTstaYmd 課金先適用開始年月日
	 * @param kakinTendYmd 課金先適用終了年月日
	 * @return rtnJdg 戻り値
	 */
	private int getJdgData(String rsvAplyYmd, String preAplyYmd, String kakinTstaYmd, String kakinTendYmd)
	{
		super.logPrint.printDebugLog("getJdgData:rsvAplyYmd=" + rsvAplyYmd);
		super.logPrint.printDebugLog("getJdgData:preAplyYmd=" + preAplyYmd);
		super.logPrint.printDebugLog("getJdgData:kakinTstaYmd=" + kakinTstaYmd);
		super.logPrint.printDebugLog("getJdgData:kakinTendYmd=" + kakinTendYmd);
		
		int rtnJdg = 0;
		
		int rsApYmd = 0;
		int preApymd = 0;
		int kaStaYmd = 0;
		int kaEndYmd = 0;
		
		// 予約適用年月日
		rsApYmd = Integer.parseInt(rsvAplyYmd);
		// 1つ前の予約適用年月日
		preApymd = Integer.parseInt(preAplyYmd);
		// 課金先適用開始年月日
		kaStaYmd = Integer.parseInt(kakinTstaYmd);
		// 課金先適用終了年月日
		kaEndYmd = Integer.parseInt(kakinTendYmd);
		
		// 課金先適用終了年月日 < 予約適用年月日の場合
		if (kaEndYmd < rsApYmd)
		{
			//処理対象外
			rtnJdg = 9;
			
		} 
		else if (kaStaYmd == rsApYmd && preApymd == kaEndYmd)
		// 課金先適用開始年月日 = 予約適用年月日 かつ 1つ前の予約適用年月日 = 課金先適用終了年月日の場合
		{
			// 当データ処理
			rtnJdg = 2;
				
		} 
		else if (kaStaYmd <= rsApYmd
					&& rsApYmd <= kaEndYmd
					&& kaEndYmd < preApymd) 
		// 課金先適用開始年月日 <= 予約適用年月日 <=  課金先適用終了年月日かつ
		// 課金先適用終了年月日 < 1つ前の予約適用年月日の場合
		{
			// 前データの請求契約番号にまたがる
			rtnJdg = 1;
			
		} 
		else if (kaStaYmd <= rsApYmd && preApymd < kaEndYmd)
		// 課金先適用開始年月日 <= 予約適用年月日 かつ 1つ前の予約適用年月日 < 課金先適用終了年月日の場合
		{
			// 当データ処理
			rtnJdg = 2;
			
		} 
		else if (rsApYmd < kaStaYmd
					&& kaStaYmd < preApymd
					&& preApymd <= kaEndYmd)
		// 予約適用年月日 < 課金先適用開始年月日 かつ
		// 課金先適用開始年月日 < 1つ前の予約適用年月日 <= 課金先適用終了年月日の場合
		{
			// 次データのはみ出し分処理
			rtnJdg = 3;
			
		} 
		else if (rsApYmd < kaStaYmd && kaEndYmd < preApymd)
		// 予約適用年月日 < 課金先適用開始年月日 かつ 課金先適用終了年月日 < 1つ前の予約適用年月日の場合
		{
			// 当データ処理
			rtnJdg = 2;
			
		} 
		else if (rsApYmd < kaStaYmd)
		// 予約適用年月日 < 課金先適用開始年月日の場合
		{
			//処理対象外
			rtnJdg = 9;
			
		}
		
		return rtnJdg;
	}
	
	/**
	 * 個人情報削除判定ワークにデータを登録する。先に手動にて登録されたデータと重複する場合は、スキップする
	 * <p>
	 * </p>
	 * @param lstInsData 登録用データ
	 * @param investDate バッチ運用日
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void insertDelData(ArrayList<String[]> lstInsData, String investDate) throws Exception
	{
		super.logPrint.printDebugLog("insertDelData:lstInsData.size()=" + lstInsData.size());
		super.logPrint.printDebugLog("insertDelData:investDate=" + investDate);
		
		JBSbatCommonDBInterface dbMap = new JBSbatCommonDBInterface();
		
		// サービス契約番号
		String svcKeiNo = null;
		// 請求契約番号
		String seikyKeiNo = null;
		// SYSID
		String sysId = null;
		// サービスコード
		String svcCD = null;
		// 料金グループコード
		String prcGrpCd = null;
		// 料金コースコード
		String pcrsCd = null;
		// 新規申込時申込書番号
		String mskmshoNo = null;
		// ISP認証ID
		String ispId = null;
		// サービス解約起算年月日
		String kisanYmd = null;
		// サービスキャンセル年月日
		String cancelYmd = null;
		// サービス解約年月日
		String dslYmd = null;
		// サービス終了年月日
		String endYmd = null;
		// 個人情報削除理由コード
		String kjnIfDelRsnCd = null;
		// 契約最終更新年月日時分秒
		String lastUpdDtm = null;
		// カレントデータ識別コード
		String crntData = null;
		
		// 削除判定コード
		// 手動(99)
		String delShudo = "99";
		// 削除対象
		String delTarget = "00";
		
		// 件数判定
		BigDecimal delCnt = BigDecimal.ZERO;
		
		String[] param = new String[4];
		String[] insParam = new String[30];
		
		for (int i = 0; i < lstInsData.size(); i++)
		{
			// サービス契約番号
			svcKeiNo = lstInsData.get(i)[0];
			super.logPrint.printDebugLog("insertDelData:svcKeiNo=" + svcKeiNo);
			// 請求契約番号
			seikyKeiNo = lstInsData.get(i)[13];
			super.logPrint.printDebugLog("insertDelData:seikyKeiNo=" + seikyKeiNo);
			// SYSID
			sysId = lstInsData.get(i)[1];
			super.logPrint.printDebugLog("insertDelData:sysId=" + sysId);
			
			// 手動により既に個人情報削除判定ワークに登録されていないことを確認する
			param[0] = svcKeiNo;
			param[1] = seikyKeiNo;
			param[2] = sysId;
			param[3] = delShudo;
			
			executeKK_T_KJNIFDEL_JDG_WK_KK_SELECT_011(param);
			
			dbMap = db_KK_T_KJNIFDEL_JDG_WK.selectNext();
			
			if (dbMap != null)
			{
				delCnt = dbMap.getBigDecimal("DEL_CNT");
				//dbMap = db_KK_T_KJNIFDEL_JDG_WK.selectNext();
			}
			
			if (delCnt.compareTo(BigDecimal.ZERO) == 0)
			{
				// 個人情報削除判定ワーク登録処理
				// サービス契約
				insParam[0] = svcKeiNo;
				// 請求契約番号
				insParam[1] = seikyKeiNo;
				// SYSID
				insParam[2] = sysId;
				// サービスコード
				svcCD = lstInsData.get(i)[2];
				insParam[3] = svcCD;
				// 料金グループコード
				prcGrpCd = lstInsData.get(i)[3];
				insParam[4] = prcGrpCd;
				// 料金コースコード
				pcrsCd = lstInsData.get(i)[4];
				insParam[5] = pcrsCd;
				// 新規申込時申込書番号
				mskmshoNo = lstInsData.get(i)[15];
				insParam[6] = mskmshoNo;
				// ISP認証ID
				ispId = lstInsData.get(i)[14];
				insParam[7] = ispId;
				// サービス解約起算年月日
				kisanYmd = lstInsData.get(i)[5];
				insParam[8] = kisanYmd;
				// サービスキャンセル年月日
				cancelYmd = lstInsData.get(i)[6];
				insParam[9] = cancelYmd;
				// サービス解約年月日
				dslYmd = lstInsData.get(i)[7];
				insParam[10] = dslYmd;
				// サービス終了年月日
				endYmd = lstInsData.get(i)[8];
				insParam[11] = endYmd;
				// 削除処理対象抽出年月日
				insParam[12] = super.opeDate;
				// 個人情報削除理由コード
				kjnIfDelRsnCd = lstInsData.get(i)[11];
				insParam[13] = kjnIfDelRsnCd;
				// 削除判定コード
				insParam[14] = delTarget;
				// 契約最終更新年月日時分秒
				lastUpdDtm = lstInsData.get(i)[9];
				insParam[15] = lastUpdDtm;
				// カレントデータ識別コード
				crntData = lstInsData.get(i)[12];
				insParam[16] = crntData;
				// 登録年月日時分秒
				insParam[17] = JBSbatDateUtil.getSystemDateTime();
				// 登録オペレータアカウント
				insParam[18] = super.batchUserId;
				// 更新年月日時分秒
				insParam[19] = JBSbatDateUtil.getSystemDateTime();
				// 更新オペレータアカウント
				insParam[20] = super.batchUserId;
				// 削除年月日時分秒
				insParam[21] = "";
				// 削除オペレータアカウント
				insParam[22] = "";
				// 無効フラグ
				insParam[23] = MK_FLG;
				// 登録運用年月日
				insParam[24] = super.opeDate;
				// 登録処理ID
				insParam[25] = super.jobid;
				// 更新運用年月日
				insParam[26] = super.opeDate;
				// 更新処理ID
				insParam[27] = super.jobid;
				// 削除運用年月日
				insParam[28] = "";
				// 削除処理ID
				insParam[29] = "";
				
				// 登録処理の実施。
				executeKK_T_KJNIFDEL_JDG_WK_PKINSERT(insParam);
			}
		}
				
	}
	
}