/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatKKMakeKjnIfdelWk
*	ソースファイル名	：JBSbatKKMakeKjnIfdelWk.java
*	作成者				：富士通　
*	作成日				：2012年09月19日
*＜機能概要＞
*　個人情報削除ワーク作成処理部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2012/09/19   富士通		新規作成
*   v28.00.00   2017/01/24  FJ)原田    【ANK-3141-00-00】契約削除バッチの１日複数回走行対応
*********************************************************************/
package eo.business.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JKKBatCommon;
import eo.business.util.table.JBSbatKK_T_KJNIFDEL_WK;
import eo.business.util.table.JBSbatKK_T_KOJIN_INFO_DEL;
import eo.common.constant.JACStrConst;
import eo.common.util.JPCEditString;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatOutputFileUtil;
import eo.framework.util.JBSbatDateUtil;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatKKMakeKjnIfdelWk extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(個人情報削除)*/
	private static final String D_TBL_NAME_KK_T_KOJIN_INFO_DEL = "KK_T_KOJIN_INFO_DEL";

	/** テーブル(個人情報削除ワーク)*/
	private static final String D_TBL_NAME_KK_T_KJNIFDEL_WK = "KK_T_KJNIFDEL_WK";

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

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

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

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

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

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

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

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

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

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

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

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

	/** テーブルアクセスクラス(個人情報削除)*/
	private JBSbatSQLAccess db_KK_T_KOJIN_INFO_DEL = null;

	/** テーブルアクセスクラス(個人情報削除ワーク)*/
	private JBSbatSQLAccess db_KK_T_KJNIFDEL_WK = null;
	
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/** 削除処理制限数*/
	private static final String KK_DEL_TRN_LMT_CNT = "KK_DEL_TRN_LMT_CNT";
	
	/** 削除処理多重数*/
	// ANK-3141-00-00 MOD START
	//private static final String KK_DEL_TRAN_TAJU_CNT = "KK_DEL_TRAN_TAJU_CNT";
	private static final String KK_DEL_TRN_TAJU_CNT = "KK_DEL_TRN_TAJU_CNT";
	// ANK-3141-00-00 MOD END
	
	/** 文字コード */
	private static final String UTF  = "UTF-8";

	/** 改行コード */
	private static final String LF  = "LF";

	/** 件数ファイル括り文字 */
	private static final String SCOPE  = "\"";
	
	/** 削除実施中*/
	private static final String DEL_OPERATION = "030";

	/** 削除未実施*/
	private static final String DIS_DEL_OPERATION = "010";
	
	/** 削除可*/
	private static final String DEL_JDG_CD = "00";
	
	/** 定数0*/
	private static final int ZERO = 0;

	/** 定数1*/
	private static final int ONE = 1;

	/** 請求契約番号・SYSID ALL0 */
	private static final String ALL_0 = "0000000000";
	
	/** 中間ファイルパス*/
	private String strFilePath = "";
	
	// ANK-3141-00-00 ADD START
	/** 第2引数（走行回数）の値*/
	private String runCnt = "";
	// ANK-3141-00-00 ADD END
	
	/** DB読込件数 */
	private int intSelectCnt = 0;
	
	/** DB更新件数 */
	private int intUpdateCnt = 0;
	
	/** DB登録件数 */
	private int intInsertCnt = 0;
	
	/** 削除データリスト */
	private ArrayList<String[]> delList;
	
	/** 削除データリスト処理件数 */
	private int delListCnt = 0;
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_KK_T_KOJIN_INFO_DEL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KOJIN_INFO_DEL);
		db_KK_T_KJNIFDEL_WK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KJNIFDEL_WK);
		
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/

		// 中間ファイル出力先の取得
		// ANK-3141-00-00 MOD START
		//strFilePath = super.freeItem;
		String free[] = super.freeItem.split(JACStrConst.SEMI_COLON);
		strFilePath = free[0];
		
		// フリー項目の第2引数（走行回数）が設定されていたら取得する
		if (1 < free.length)
		{
			runCnt = free[1];
		}
		// ANK-3141-00-00 MOD END
		
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
		
	}

	/**
	 * 主処理
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		super.logPrint.printDebugLog("execute_START");
		
		// 多重起動処理情報
		String[] tajuSeigyo = new String[2];
		
		// 業務パラメータ管理より1.削除処理制限数、2.削除処理多重数を取得する
		tajuSeigyo = getTajuShori();
		
		// 中間ファイルの作成
		createFile(tajuSeigyo[1]);
		
		// ■個人情報削除ワーク作成処理
		this.createKjnDelWK(tajuSeigyo);
		
		super.logPrint.printDebugLog("execute_END");
		
		return null;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		//DB読込件数ログ出力
		super.logPrint.printBusinessErrorLog("EKKB0770AI", new String[]{"個人情報削除", Integer.toString(intSelectCnt)});
		//DB更新件数ログ出力
		super.logPrint.printBusinessErrorLog("EKKB0800AI", new String[]{"個人情報削除", Integer.toString(intUpdateCnt)});
		//DB登録件数ログ出力
		super.logPrint.printBusinessErrorLog("EKKB0790AI", new String[]{"個人情報削除ワーク", Integer.toString(intInsertCnt)});
		
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_KK_T_KOJIN_INFO_DEL.close();
		db_KK_T_KJNIFDEL_WK.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

	/**
	 * 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
	 *		 	多重起動処理番号				TAJU_KIDOU_TRAN_NO
	 *		 	多重起動処理枝番				TAJU_KIDOU_TRAN_SEQ
	 *		 	サービスコード				SVC_CD
	 *		 	料金グループコード				PRC_GRP_CD
	 *		 	料金コースコード				PCRS_CD
	 *		 	ＩＳＰ認証ＩＤ				ISP_NINSHO_ID
	 *		 	サービスキャンセル年月日				SVC_CANCEL_YMD
	 *		 	サービス解約年月日				SVC_DSL_YMD
	 *		 	削除処理対象抽出年月日				DEL_TRN_TG_CHSHT_YMD
	 *		 	個人情報削除理由コード				KOJIN_INFO_DEL_RSN_CD
	 *		 	契約最終更新年月日時分秒				KEI_LAST_UPD_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_KJNIFDEL_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("TAJU_KIDOU_TRAN_NO", setParam[3]);
		setMap.setValue("TAJU_KIDOU_TRAN_SEQ", setParam[4]);
		setMap.setValue("SVC_CD", setParam[5]);
		setMap.setValue("PRC_GRP_CD", setParam[6]);
		setMap.setValue("PCRS_CD", setParam[7]);
		setMap.setValue("ISP_NINSHO_ID", setParam[8]);
		setMap.setValue("SVC_CANCEL_YMD", setParam[9]);
		setMap.setValue("SVC_DSL_YMD", setParam[10]);
		setMap.setValue("DEL_TRN_TG_CHSHT_YMD", setParam[11]);
		setMap.setValue("KOJIN_INFO_DEL_RSN_CD", setParam[12]);
		setMap.setValue("KEI_LAST_UPD_DTM", setParam[13]);
		setMap.setValue("ADD_DTM", setParam[14]);
		setMap.setValue("ADD_OPEACNT", setParam[15]);
		setMap.setValue("UPD_DTM", setParam[16]);
		setMap.setValue("UPD_OPEACNT", setParam[17]);
		setMap.setValue("DEL_DTM", setParam[18]);
		setMap.setValue("DEL_OPEACNT", setParam[19]);
		setMap.setValue("MK_FLG", setParam[20]);
		setMap.setValue("ADD_UNYO_YMD", setParam[21]);
		setMap.setValue("ADD_TRN_ID", setParam[22]);
		setMap.setValue("UPD_UNYO_YMD", setParam[23]);
		setMap.setValue("UPD_TRN_ID", setParam[24]);
		setMap.setValue("DEL_UNYO_YMD", setParam[25]);
		setMap.setValue("DEL_TRN_ID", setParam[26]);
	
		// DBアクセスを実行します
		//▼▼▼件数取得のため自働生成部を変更▼▼▼
		intInsertCnt += db_KK_T_KJNIFDEL_WK.insertByPrimaryKeys(setMap);
		//▲▲▲件数取得のため自働生成部を変更▲▲▲
	}

	/**
	 * PK(ＰＫ　更新)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.引数で条件マップを作ります。<br>
	 *
	 * 3.DBアクセスを実行します。<br>
	 * 
	 * 4.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	個人情報削除ステータス				KOJIN_INFO_DEL_STAT
	 *		 	削除実施年月日				DEL_JSSI_YMD
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	更新運用年月日				UPD_UNYO_YMD
	 *		 	更新処理ＩＤ				UPD_TRN_ID
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	SVC_KEI_NO
	 *		 	SEIKY_KEI_NO
	 *		 	SYSID
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @param whereParam 条件項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_KOJIN_INFO_DEL_PKUPDATE(Object[] setParam, Object[] whereParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("KOJIN_INFO_DEL_STAT", setParam[0]);
		setMap.setValue("DEL_JSSI_YMD", setParam[1]);
		setMap.setValue("UPD_DTM", setParam[2]);
		setMap.setValue("UPD_OPEACNT", setParam[3]);
		setMap.setValue("UPD_UNYO_YMD", setParam[4]);
		setMap.setValue("UPD_TRN_ID", setParam[5]);
	
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("SEIKY_KEI_NO", whereParam[1]);
		whereMap.setValue("SYSID", whereParam[2]);

		// DBアクセスを実行します
		//▼▼▼件数取得のため自働生成部を変更▼▼▼
		intUpdateCnt += db_KK_T_KOJIN_INFO_DEL.updateByPrimaryKeys(whereMap, setMap);
		//▲▲▲件数取得のため自働生成部を変更▲▲▲
	}

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

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

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

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

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

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

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

		// DBアクセスを実行します
		db_KK_T_KOJIN_INFO_DEL.selectBySqlDefine(paramList, KK_T_KOJIN_INFO_DEL_KK_SELECT_022);
	}
	
	/**
	 * SQLKEY(KK_SELECT_024)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	サービス契約番号
	 *		 	請求契約番号
	 *		 	SYSID
	 *		 	個人情報削除ステータス
	 *		 	削除判定コード
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_KOJIN_INFO_DEL_KK_SELECT_024(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_KOJIN_INFO_DEL.selectBySqlDefine(paramList, KK_T_KOJIN_INFO_DEL_KK_SELECT_024);
	}

	/**
	 * PK(ＰＫ　削除)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で条件マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	SVC_KEI_NO
	 *		 	SEIKY_KEI_NO
	 *		 	SYSID
	 * </pre>
	 * <p>
	 * @param whereParam 条件項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_KOJIN_INFO_DEL_PKDELETE(Object[] whereParam) throws Exception
	{
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("SEIKY_KEI_NO", whereParam[1]);
		whereMap.setValue("SYSID", whereParam[2]);

		// DBアクセスを実行します
		db_KK_T_KOJIN_INFO_DEL.deleteByPrimaryKeys(whereMap);
	}

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

		// DBアクセスを実行します
		db_KK_T_KJNIFDEL_WK.executeBySqlDefine(paramList, KK_T_KJNIFDEL_WK_KK_DELETE_001);
	}

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

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

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

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

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

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

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

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

	/**
	 * 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_KJNIFDEL_WK_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_KJNIFDEL_WK.selectBySqlDefine(paramList, KK_T_KJNIFDEL_WK_KK_SELECT_008);
	}

	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * 業務パラメータ管理より、削除処理制限数と削除処理多重数を取得する
	 * <p>
	 * <p>
	 * @return tajuData 1.削除処理制限数、2.削除処理多重数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String[] getTajuShori() throws Exception
	{
		
		String[] tajuData = new String[2];
		
		// 削除処理制限数の取得
		// ANK-3141-00-00 MOD START
		//tajuData[0] = JKKBatCommon.getWorkParamSetteValue(super.commonItem, KK_DEL_TRN_LMT_CNT);
		tajuData[0] = JKKBatCommon.getWorkParamSetteValue(super.commonItem, KK_DEL_TRN_LMT_CNT + runCnt);
		// ANK-3141-00-00 MOD END
		if (tajuData[0] == null)
		{
			throw new JBSbatBusinessException("EKKB0740CE", new String[]{"業務パラメータ", "削除処理制限数"});
		}
		super.logPrint.printBusinessErrorLog("EKKB0810AI", new String[]{tajuData[0]});
		
		// 削除処理多重数の取得
		// ANK-3141-00-00 MOD START
		//tajuData[1] = JKKBatCommon.getWorkParamSetteValue(super.commonItem, KK_DEL_TRAN_TAJU_CNT);
		tajuData[1] = JKKBatCommon.getWorkParamSetteValue(super.commonItem, KK_DEL_TRN_TAJU_CNT + runCnt);
		// ANK-3141-00-00 MOD END
		if (tajuData[1] == null)
		{
			throw new JBSbatBusinessException("EKKB0740CE", new String[]{"業務パラメータ", "削除処理多重数"});
		}
		
		if(tajuData[1].compareTo("0") == 0)
		{
			//削除処理多重数が0の場合はエラー
			throw new JBSbatBusinessException("EKKB0090TE", new String[]{"削除処理多重数:" + tajuData[1]});
		}
		
		return tajuData;
	}
	
	/**
	 * 削除処理多重数情報の中間ファイルを作成
	 * <p>
	 * </p>
	 * @param strTajuCnt 削除処理多重数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void createFile(String strTajuCnt) throws Exception
	{
		JBSbatOutputFileUtil cntFile = new JBSbatOutputFileUtil(this.strFilePath);
		
		cntFile.setEncode(UTF);
		cntFile.setLine(LF);
		cntFile.createWriter();
		StringBuffer sb = new StringBuffer();
		sb.append(strTajuCnt);
		cntFile.write(sb.toString());
		cntFile.close();
		
	}
	
	/**
	 * 個人情報ワーク作成処理
	 * <p>
	 * 1.「個人情報削除」より未処理データを抽出する
	 * 2.多重起動処理番号ごとに削除処理制限数だけ個人情報削除ワークへ登録する
	 * 3.個人情報削除の個人情報削除ステータスを削除実施中(030)に設定する
	 * </p>
	 * @param tajuSeigyo 1.削除処理制限数、2.削除処理多重数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void createKjnDelWK(String[] tajuSeigyo) throws Exception
	{
		// 削除処理制限数(最大値)
		int limtDealCnt = Integer.parseInt(tajuSeigyo[0]);
		super.logPrint.printDebugLog("createKjnDelWK:limtDealCnt=" + limtDealCnt);
		// 登録済み件数
		int totalSyoriCnt = 0;
		// 削除処理多重数(最大値)
		int maxMultiCnt = Integer.parseInt(tajuSeigyo[1]);
		super.logPrint.printDebugLog("createKjnDelWK:maxMultiCnt=" + maxMultiCnt);
		// 多重数管理用変数
		int multiCnt = 0;
		// 多重枝番管理用変数
		int[] branchCnt = new int[maxMultiCnt];
		
		// 処理対象となる個人情報削除データの総件数用変数
		int totalTagtCnt = 0;
		
		// 件数用変数
		int cnt = 0;
		int edaCant = 0;
		
		ArrayList<String[]> insDelData = new ArrayList<String[]>();
		
		// □処理対象となる個人情報削除データの総件数を取得する
		totalTagtCnt = getTotalCount();
		super.logPrint.printDebugLog("createKjnDelWK:totalTagtCnt=" + totalTagtCnt);
		
		// □処理対象となる個人情報削除データを取得する
		delListCnt = 0;
		delList = getAllOlderDelData();
		
		// 削除対象の件数が０件、または削除処理制限数が０件の場合は処理しない
		if (totalTagtCnt != 0 && limtDealCnt != 0)
		{
			// ■処理対象となるデータの総件数に達するまたは削除処理制限数(最大値)を超えたら終了
			while (totalSyoriCnt < totalTagtCnt && totalSyoriCnt < limtDealCnt)
			{
				// 請求契約初期化グループ削除時の多重カウント制御フラグ
				boolean cntFlg = true;
				
				// 請求契約初期化存在チェック
				if (multiCnt != 0)
				{
					// 前ループ処理が請求契約初期化存在グループかの検索
					JBSbatCommonDBInterface seikeiChk = new JBSbatCommonDBInterface();
					// 前ループ処理の多重カウントにてワークを検索
					String[] skParam = new String[2];
					skParam[0] = JPCEditString.fillZero(multiCnt + "", 2, false);
					skParam[1] = JPCEditString.fillZero(branchCnt[multiCnt - ONE] + "", 6, false);
					executeKK_T_KJNIFDEL_WK_KK_SELECT_008(skParam);
					seikeiChk = db_KK_T_KJNIFDEL_WK.selectNext();
					
					if (seikeiChk != null)
					{
						// 前ループ処理が請求契約初期化存在グループの場合、ワークから登録データを取得
						JBSbatCommonDBInterface chkDelList = new JBSbatCommonDBInterface();
						executeKK_T_KJNIFDEL_WK_KK_SELECT_002(skParam);
						chkDelList = db_KK_T_KJNIFDEL_WK.selectNext();
						
						// ワーク登録データのキーを取得し、個人情報削除より対象データを削除する。
						while(chkDelList != null)
						{
							String[] kjnDelParam = new String[3];
							kjnDelParam[0] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SVC_KEI_NO);
							kjnDelParam[1] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SEIKY_KEI_NO);
							kjnDelParam[2] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SYSID);
							// 個人情報削除のデータを削除
							executeKK_T_KOJIN_INFO_DEL_PKDELETE(kjnDelParam);
							
							// 現時点の処理件数と処理対象件数より削除データ分のカウントダウンを行う。
							totalSyoriCnt = totalSyoriCnt - 1;
							totalTagtCnt = totalTagtCnt - 1;
							chkDelList = db_KK_T_KJNIFDEL_WK.selectNext();
						}
						
						// 個人情報削除ワークのデータを削除
						executeKK_T_KJNIFDEL_WK_KK_DELETE_001(skParam);
						// 多重カウントを上げないようにする
						cntFlg = false;
					}
				}
				
				// □最古の未処理データを出力する
				insDelData = getOlderDelData();
				super.logPrint.printDebugLog("createKjnDelWK:insDelData.size=" + insDelData.size());
				// 登録済み件数のカウントアップ
				totalSyoriCnt = totalSyoriCnt + ONE;
				super.logPrint.printDebugLog("createKjnDelWK:totalSyoriCnt=" + totalSyoriCnt);
				
				// □多重数関連の処理
				// 初回の場合、多重数、多重枝番に「1」を設定する。
				if (multiCnt == 0)
				{
					// 多重数
					multiCnt = ONE;
					// 多重枝番
					branchCnt[0] = ONE;
					
				}
				else
				{
					if (cntFlg)
					{
						// 多重数管理用変数 = 削除処理多重数(最大値)の場合、多重数を「1」に設定する
						if (multiCnt == maxMultiCnt)
						{
							multiCnt = ONE;
							
						} 
						// 多重数管理用変数 != 削除処理多重数(最大値)の場合、「多重数 + 1」に設定する
						else
						{
							
							multiCnt = multiCnt + ONE;
							
						}
						
						// 多重枝番は、多重数単位で連番になるよう設定する
						edaCant = branchCnt[multiCnt - ONE];
						branchCnt[multiCnt - ONE] = edaCant + ONE;
					}
				}
				
				// □個人情報削除ワークにデータを登録する。また、個人情報削除の個人情報削除ステータスを「削除実施中(030)」に更新する
				this.crtDelData(insDelData, multiCnt, branchCnt[multiCnt - ONE]);
				
				// □個人情報削除ワークから同一の多重数、多重枝番に紐づくデータを取得し編集する。
				
				cnt = crtDelKjinDataWk(multiCnt, branchCnt[multiCnt - ONE]);
				
				// □カウントアップ
				totalSyoriCnt = totalSyoriCnt + cnt;
			}
			
			// 最終グループに請求契約初期化が存在する場合の処理
			if (multiCnt != 0)
			{
				// 前ループ処理が請求契約初期化存在グループかの検索
				JBSbatCommonDBInterface seikeiChk = new JBSbatCommonDBInterface();
				// 前ループ処理の多重カウントにてワークを検索
				String[] skParam = new String[2];
				skParam[0] = JPCEditString.fillZero(multiCnt + "", 2, false);
				skParam[1] = JPCEditString.fillZero(branchCnt[multiCnt - ONE] + "", 6, false);
				executeKK_T_KJNIFDEL_WK_KK_SELECT_008(skParam);
				seikeiChk = db_KK_T_KJNIFDEL_WK.selectNext();
				
				if (seikeiChk != null)
				{
					// 前ループ処理が請求契約初期化存在グループの場合、ワークから登録データを取得
					JBSbatCommonDBInterface chkDelList = new JBSbatCommonDBInterface();
					executeKK_T_KJNIFDEL_WK_KK_SELECT_002(skParam);
					chkDelList = db_KK_T_KJNIFDEL_WK.selectNext();
					
					// ワーク登録データのキーを取得し、個人情報削除より対象データを削除する。
					while(chkDelList != null)
					{
						String[] kjnDelParam = new String[3];
						kjnDelParam[0] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SVC_KEI_NO);
						kjnDelParam[1] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SEIKY_KEI_NO);
						kjnDelParam[2] = chkDelList.getString(JBSbatKK_T_KJNIFDEL_WK.SYSID);
						// 個人情報削除のデータを削除
						executeKK_T_KOJIN_INFO_DEL_PKDELETE(kjnDelParam);
						
						// 現時点の処理件数と処理対象件数より削除データ分のカウントダウンを行う。
						totalSyoriCnt = totalSyoriCnt - 1;
						totalTagtCnt = totalTagtCnt - 1;
						chkDelList = db_KK_T_KJNIFDEL_WK.selectNext();
					}
					
					// 個人情報削除ワークのデータを削除
					executeKK_T_KJNIFDEL_WK_KK_DELETE_001(skParam);
					
				}
			}
			
			//DB読込件数取得
			intSelectCnt = totalSyoriCnt;
			if(limtDealCnt < totalTagtCnt)
			{
				//制限数超過で終了時ログ出力
				super.logPrint.printBusinessErrorLog("EKKB0830AI", new String[]{limtDealCnt + ""});
			}
		}
	}

	/**
	 * 処理対象となる個人情報削除データの総件数を取得する
	 * <p>
	 * </p>
	 * @return totalTagtCnt 総件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private int getTotalCount() throws Exception
	{
		JBSbatCommonDBInterface dbmapCnt = new JBSbatCommonDBInterface();
		
		BigDecimal tragetCnt = BigDecimal.ZERO;
		
		int totalTagtCnt = 0;
		
		String[] paramCnt = new String[2];
		
		// 個人情報削除ステータス
		paramCnt[0] = DIS_DEL_OPERATION;
		// 削除判定コード
		paramCnt[1] = DEL_JDG_CD;
		
		executeKK_T_KOJIN_INFO_DEL_KK_SELECT_022(paramCnt);
		
		dbmapCnt = db_KK_T_KOJIN_INFO_DEL.selectNext();
		
		if (dbmapCnt != null)
		{
			tragetCnt = dbmapCnt.getBigDecimal("CNT");
		}
		
		totalTagtCnt = tragetCnt.intValue();
		
		return totalTagtCnt;
	}
	
	/**
	 * 削除対象データの中で最も古いデータから順にデータ抽出する
	 * <p>
	 * </p>
	 * @return rtnData 個人情報削除データ
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<String[]> getAllOlderDelData() throws Exception
	{
		JBSbatCommonDBInterface dbmap = new JBSbatCommonDBInterface();
		
		String[] param = new String[2];
		
		ArrayList<String[]> rtnData = new ArrayList<String[]>();
		
		// 個人情報削除ステータス
		param[0] = DIS_DEL_OPERATION;
		// 削除判定コード
		param[1] = DEL_JDG_CD;
		
		executeKK_T_KOJIN_INFO_DEL_KK_SELECT_013(param);
		
		dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
		
		while (dbmap != null)
		{
			String[] lstData = new String[3];
			// サービス契約番号
			lstData[0] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_KEI_NO);
			// 請求契約番号
			lstData[1] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SEIKY_KEI_NO);
			// SYSID
			lstData[2] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SYSID);
			
			rtnData.add(lstData);
			
			dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
		}
		
		return rtnData;
	}
	
	/**
	 * 削除対象データの中で最も古いデータを抽出する
	 * <p>
	 * </p>
	 * @return rtnData 個人情報削除データ
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<String[]> getOlderDelData() throws Exception
	{
		
		JBSbatCommonDBInterface dbmap = new JBSbatCommonDBInterface();
		
		String[] param = new String[5];
		String[] lstData = null;
		
		ArrayList<String[]> rtnData = new ArrayList<String[]>();
		
		while(lstData == null && delListCnt < delList.size())
		{
			//サービス契約番号
			param[0] = delList.get(delListCnt)[0];
			//請求契約番号
			param[1] = delList.get(delListCnt)[1];
			//SYSID
			param[2] = delList.get(delListCnt)[2];
			// 個人情報削除ステータス
			param[3] = DIS_DEL_OPERATION;
			// 削除判定コード
			param[4] = DEL_JDG_CD;
			
			executeKK_T_KOJIN_INFO_DEL_KK_SELECT_024(param);
			
			dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
			
			if(dbmap != null)
			{
				lstData = new String[12];
				// サービス契約番号
				lstData[0] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_KEI_NO);
				// 請求契約番号
				lstData[1] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SEIKY_KEI_NO);
				// SYSID
				lstData[2] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SYSID);
				// サービスコード
				lstData[3] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_CD);
				// 料金グループコード
				lstData[4] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.PRC_GRP_CD);
				// 料金コースコード
				lstData[5] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.PCRS_CD);
				// ISP認証ID
				lstData[6] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.ISP_NINSHO_ID);
				// サービスキャンセル年月日
				lstData[7] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_CANCEL_YMD);
				// サービス解約年月日
				lstData[8] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_DSL_YMD);
				// 削除処理対象抽出年月日
				lstData[9] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.DEL_TRN_TG_CHSHT_YMD);
				// 個人情報削除理由コード
				lstData[10] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.KOJIN_INFO_DEL_RSN_CD);
				// 契約最終更新年月日時分秒
				lstData[11] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.KEI_LAST_UPD_DTM);
			}
			//削除データリスト処理件数カウントアップ
			delListCnt++;
			super.logPrint.printDebugLog("getOlderDelData:delListCnt=" + delListCnt);
		}
		
		rtnData.add(lstData);
		
		return rtnData;
	}
	
	/**
	 * 個人情報削除ワーク登録処理。
	 * <p>
	 * 1.個人情報削除ワークにデータを登録する<br>
	 * 2.個人情報削除の個人情報削除ステータスを「削除実施中("030")」に更新する<br>
	 * </p>
	 * @param insDelData 個人情報削除のデータ
	 * @param multiCnt 多重数
	 * @param branchCnt 多重枝番
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void crtDelData(ArrayList<String[]> insDelData, int multiCnt, int branchCnt) throws Exception
	{
		super.logPrint.printDebugLog("crtDelData:insDelData.size()=" + insDelData.size());
		super.logPrint.printDebugLog("crtDelData:multiCnt=" + multiCnt);
		super.logPrint.printDebugLog("crtDelData:branchCnt=" + branchCnt);
		
		String[] paramIns = new String[27];
		
		// サービス契約番号
		String svcKeiNo = null;
		// 請求契約番号
		String seiKyNo = null;
		// SYSID
		String sysID = null;
		
		// 個人情報削除ワークにデータを登録する
		// サービス契約番号
		paramIns[0] = insDelData.get(ZERO)[0];
		// 請求契約番号
		paramIns[1] = insDelData.get(ZERO)[1];
		// SYSID
		paramIns[2] = insDelData.get(ZERO)[2];
		// 多重起動処理番号
		paramIns[3] = JPCEditString.fillZero(String.valueOf(multiCnt),2,false);
		// 多重処理枝番
		paramIns[4] = JPCEditString.fillZero(String.valueOf(branchCnt),6,false);
		// サービスコード
		paramIns[5] = insDelData.get(ZERO)[3];
		// 料金グループコード
		paramIns[6] = insDelData.get(ZERO)[4];
		// 料金コースコード
		paramIns[7] = insDelData.get(ZERO)[5];
		// ISP認証ID
		paramIns[8] = insDelData.get(ZERO)[6];
		// サービスキャンセル年月日
		paramIns[9] = insDelData.get(ZERO)[7];
		// サービス解約年月日
		paramIns[10] = insDelData.get(ZERO)[8];
		// 削除処理対象抽出年月日
		paramIns[11] = insDelData.get(ZERO)[9];
		// 個人情報削除理由コード
		paramIns[12] = insDelData.get(ZERO)[10];
		// 契約最終更新年月日時分秒
		paramIns[13] = insDelData.get(ZERO)[11];
		// 登録年月日時分秒
		paramIns[14] = JBSbatDateUtil.getSystemDateTime();
		// 登録オペレータアカウント
		paramIns[15] = super.batchUserId;
		// 更新年月日時分秒
		paramIns[16] = JBSbatDateUtil.getSystemDateTime();
		// 更新オペレータアカウント
		paramIns[17] = super.batchUserId;
		// 削除年月日時分秒
		paramIns[18] = "";
		// 削除オペレータアカウント
		paramIns[19] = "";
		// 無効フラグ
		paramIns[20] = String.valueOf(ZERO);
		// 登録運用年月日
		paramIns[21] = super.opeDate;
		// 登録処理ID
		paramIns[22] = super.jobid;
		// 更新運用年月日
		paramIns[23] = super.opeDate;
		// 更新処理ID
		paramIns[24] = super.jobid;
		// 削除運用年月日
		paramIns[25] = "";
		// 削除処理ID
		paramIns[26] = "";
		
		executeKK_T_KJNIFDEL_WK_PKINSERT(paramIns);
		
		// 個人情報削除ステータスを「削除実施中(030)」に更新する
		// サービス契約番号
		svcKeiNo = insDelData.get(ZERO)[0];
		// 請求契約番号
		seiKyNo = insDelData.get(ZERO)[1];
		// SYSID
		sysID = insDelData.get(ZERO)[2];

		super.logPrint.printDebugLog("insDelData:svcKeiNo=" + svcKeiNo);
		super.logPrint.printDebugLog("insDelData:seiKyNo=" + seiKyNo);
		super.logPrint.printDebugLog("insDelData:sysID=" + sysID);
		
		this.updKjnIfDel(svcKeiNo, seiKyNo, sysID);
		
		
	}

	/**
	 * 個人情報削除ステータス更新処理
	 * <p>
	 * </p>
	 * @param svcKeiNo サービス契約番号
	 * @param seiKyNo 請求契約番号
	 * @param sysID SYSID
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void updKjnIfDel(String svcKeiNo, String seiKyNo, String sysID) throws Exception
	{
		String[] setParam = new String[6];
		String[] whereParam = new String[3];
		
		// SET句の設定
		// 個人情報削除ステータス
		setParam[0] = DEL_OPERATION;
		// 削除実施年月日
		setParam[1] = super.opeDate;
		// 更新年月日時分秒
		setParam[2] = JBSbatDateUtil.getSystemDateTime();
		// 更新オペレータアカウント
		setParam[3] = super.batchUserId;
		// 更新運用年月日
		setParam[4] = super.opeDate;
		// 更新処理ID
		setParam[5] = super.jobid;
		
		// WHERE句の設定
		// サービス契約番号
		whereParam[0] = svcKeiNo;
		// 請求契約番号
		whereParam[1] = seiKyNo;
		// SYSID
		whereParam[2] = sysID;
		
		executeKK_T_KOJIN_INFO_DEL_PKUPDATE(setParam, whereParam);
		
		
	}
	
	/**
	 * 個人情報削除ワークの多重数と多重枝番に紐づくデータを個人情報削除から取得し、登録する
	 * <p>
	 * </p>
	 * @param multiCnt 多重数
	 * @param branchCnt 多重枝番
	 * @return delCnt 総件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private int crtDelKjinDataWk(int multiCnt, int branchCnt) throws Exception
	{
		super.logPrint.printDebugLog("crtDelKjinDataWk:multiCnt=" + multiCnt);
		super.logPrint.printDebugLog("crtDelKjinDataWk:branchCnt=" + branchCnt);
		JBSbatCommonDBInterface dbmapSvc = new JBSbatCommonDBInterface();
		JBSbatCommonDBInterface dbmapSei = new JBSbatCommonDBInterface();
		JBSbatCommonDBInterface dbmapSys = new JBSbatCommonDBInterface();
		
		// 登録処理件数(合計)
		int delCnt = 0;
		// 登録処理件数(サービス契約番号)
		int svcCnt = 0;
		// 登録処理件数(請求契約番号);
		int seiCnt = 0;
		// 登録処理件数(SYSID)
		int sysCnt = 0;
		
		// パラメータ用変数
		String[] selectWk = new String[2];

		// サービス契約番号用変数
		ArrayList<String[]> arySvcKeiNo = new ArrayList<String[]>();
		// 請求契約番号用変数
		ArrayList<String[]> arySeiKeiNo = new ArrayList<String[]>();
		// SYSID用変数
		ArrayList<String[]> arySysId = new ArrayList<String[]>();
		
		// 登録処理判定用フラグ
		boolean blnDelFlg = true;
		// 処理分岐用フラグ(1:サービス契約番号、2:請求契約番号、3.SYSID)
		int branchFlg = 0;
		
		while (blnDelFlg)
		{
			
			// 多重数
			selectWk[0] = JPCEditString.fillZero(String.valueOf(multiCnt), 2, false) ;
			// 多重数枝番
			selectWk[1] = JPCEditString.fillZero(String.valueOf(branchCnt), 6, false);
			
			// ●関連するデータの抽出(サービス契約番号)
			dbmapSvc = new JBSbatCommonDBInterface();
			arySvcKeiNo = new ArrayList<String[]>();
			svcCnt = 0;
			
			executeKK_T_KJNIFDEL_WK_KK_SELECT_004(selectWk);
			
			dbmapSvc = db_KK_T_KJNIFDEL_WK.selectNext();
			
			while (dbmapSvc != null)
			{
				// サービス契約番号用変数
				String[] strSVC = new String[1];
				strSVC[0] = dbmapSvc.getString(JBSbatKK_T_KJNIFDEL_WK.SVC_KEI_NO);
				super.logPrint.printDebugLog("crtDelKjinDataWk:strSVC[0]=" + strSVC[0]);
				
				arySvcKeiNo.add(strSVC);
				
				dbmapSvc = db_KK_T_KJNIFDEL_WK.selectNext();
			}
			
			// 抽出したデータの情報処理
			if (arySvcKeiNo.size() > 0)
			{
				branchFlg = 1;
				svcCnt = getDataInf(arySvcKeiNo, branchFlg, multiCnt, branchCnt);
				
				delCnt = delCnt + svcCnt;
			}

			
			// ●関連するデータの抽出(請求契約番号)
			dbmapSei = new JBSbatCommonDBInterface();
			arySeiKeiNo = new ArrayList<String[]>();
			seiCnt = 0;
			
			executeKK_T_KJNIFDEL_WK_KK_SELECT_005(selectWk);
			
			dbmapSei = db_KK_T_KJNIFDEL_WK.selectNext();
			
			while (dbmapSei != null)
			{
				// 請求契約番号用変数
				String[] strSei = new String[1];
				strSei[0] = dbmapSei.getString(JBSbatKK_T_KJNIFDEL_WK.SEIKY_KEI_NO);
				super.logPrint.printDebugLog("crtDelKjinDataWk:strSei[0]=" + strSei[0]);
				
				arySeiKeiNo.add(strSei);
				
				dbmapSei = db_KK_T_KJNIFDEL_WK.selectNext();
				
			}
			
			// 抽出したデータの情報処理
			if (arySeiKeiNo.size() > 0)
			{
				branchFlg = 2;
				seiCnt = getDataInf(arySeiKeiNo, branchFlg, multiCnt, branchCnt);
				
				delCnt = delCnt + seiCnt;
				
			}
			
			// ●関連するデータの抽出(SYSID)
			dbmapSys = new JBSbatCommonDBInterface();
			arySysId = new ArrayList<String[]>();
			sysCnt = 0;
			
			executeKK_T_KJNIFDEL_WK_KK_SELECT_006(selectWk);
			
			dbmapSys = db_KK_T_KJNIFDEL_WK.selectNext();
			
			while (dbmapSys != null)
			{
				// SYSID用変数
				String[] strSys = new String[1];
				strSys[0] = dbmapSys.getString(JBSbatKK_T_KJNIFDEL_WK.SYSID);
				super.logPrint.printDebugLog("crtDelKjinDataWk:strSys[0]=" + strSys[0]);
				
				arySysId.add(strSys);
				
				dbmapSys = db_KK_T_KJNIFDEL_WK.selectNext();
				
			}
			
			// 抽出したデータの情報処理
			if (arySysId.size() > 0)
			{
				branchFlg = 3;
				sysCnt = getDataInf(arySysId, branchFlg, multiCnt, branchCnt);
				
				delCnt = delCnt + sysCnt;
			}
			
			if (svcCnt == ZERO && seiCnt == ZERO && sysCnt == 0)
			{
				// 全関連データの処理が終わったら処理を抜ける
				blnDelFlg = false;
			}
		}
		
		return delCnt;
	}

	/**
	 * 個人情報削除ワーク登録処理
	 * <p>
	 * 個人情報削除ワークから抽出したキー情報をもとに個人情報のデータを取得し、登録する
	 * また、登録データについて、個人情報削除の個人情報削除ステータスを削除実施中に更新する
	 * </p>
	 * @param aryData 抽出したデータ
	 * @param branchFlg 取得キーデータ判定用フラグ(1:サービス契約番号、2:請求契約番号、3.SYSID) 
	 * @param multiCnt 多重数
	 * @param branchCnt 多重枝番 
	 * @return 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private int getDataInf(ArrayList<String[]> aryData, int branchFlg, int multiCnt, int branchCnt) throws Exception
	{
		
		super.logPrint.printDebugLog("getDataInf:aryData.size()=" + aryData.size());
		
		ArrayList<String[]> lstKey = new ArrayList<String[]>();
		
		String[] param = new String[3];
		
		int cnt = 0;
		
		for (int i = 0; i < aryData.size(); i++)
		{
			super.logPrint.printDebugLog("getDataInf:aryData.get(" + i + ")[0]=" + aryData.get(i)[0]);
		
			JBSbatCommonDBInterface dbmap = null;
			// 個人情報削除のデータ検索
			// キー情報
			System.arraycopy(aryData.get(i), 0, param, ZERO, ONE);
			// 個人情報削除ステータス
			param[1] = DIS_DEL_OPERATION;
			// 削除判定コード
			param[2] = DEL_JDG_CD;
			
			lstKey = new ArrayList<String[]>();
			
			switch (branchFlg) 
			{
				
				case 1:
				// サービス契約番号の場合
					executeKK_T_KOJIN_INFO_DEL_KK_SELECT_019(param);
					dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
					
					break;
					
				case 2:
				// 請求契約番号の場合
					//ALL0の場合は検索しない
					if(param[0].compareTo(ALL_0) != 0)
					{
						executeKK_T_KOJIN_INFO_DEL_KK_SELECT_020(param);
						dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
					}
					break;
					
				case 3:
				// SYSIDの場合
					//ALL0の場合は検索しない
					if(param[0].compareTo(ALL_0) != 0)
					{
						executeKK_T_KOJIN_INFO_DEL_KK_SELECT_021(param);
						dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
					}
					break;
					
				default:
					break;
				
			}
			
			//dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
			
			while (dbmap != null)
			{
				String[] paramIns = new String[12];
				// サービス契約番号
				paramIns[0] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_KEI_NO);
				// 請求契約番号
				paramIns[1] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SEIKY_KEI_NO);
				// SYSID
				paramIns[2] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SYSID);
				// サービスコード
				paramIns[3] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_CD);
				// 料金グループコード
				paramIns[4] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.PRC_GRP_CD);
				// 料金コースコード
				paramIns[5] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.PCRS_CD);
				// ISP認証ID
				paramIns[6] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.ISP_NINSHO_ID);
				// サービスキャンセル年月日
				paramIns[7] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_CANCEL_YMD);
				// サービス解約年月日
				paramIns[8] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.SVC_DSL_YMD);
				// 削除処理対象抽出年月日
				paramIns[9] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.DEL_TRN_TG_CHSHT_YMD);
				// 個人情報削除理由コード
				paramIns[10] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.KOJIN_INFO_DEL_RSN_CD);
				// 契約最終更新年月日時分秒
				paramIns[11] = dbmap.getString(JBSbatKK_T_KOJIN_INFO_DEL.KEI_LAST_UPD_DTM);
				
				lstKey.add(paramIns);
				
				dbmap = db_KK_T_KOJIN_INFO_DEL.selectNext();
			}
			
			if (lstKey.size() > 0)
			{
				// 個人情報削除ワークにデータ登録
				this.kanrenDelIfData(lstKey, multiCnt, branchCnt);
				
				// カウント
				cnt = cnt + lstKey.size();
			}
		}
		
		return cnt;
	}

	/**
	 * 個人情報削除ワーク登録処理
	 * <p>
	 * 1.個人上削除ワークにデータを登録する<br>
	 * 2.個人情報の個人情報削除ステータスを「削除実施中(030)に更新する
	 * </p>
	 * @param lstKey 個人情報削除データ
	 * @param multiCnt 多重起動処理数
	 * @param branchCnt 多重起動枝番
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void kanrenDelIfData(ArrayList<String[]> lstKey, int multiCnt, int branchCnt) throws Exception
	{
		String[] paramIns = new String[27];
		
		// サービス契約番号
		String svcKeiNo = null;
		// 請求契約番号
		String seiKyNo = null;
		// SYSID
		String sysID = null;
		
		for (int i = 0; i < lstKey.size(); i++)
		{
			// 個人情報削除ワークにデータを登録する
			// サービス契約番号
			// 請求契約番号
			// SYSID
			System.arraycopy(lstKey.get(i), ZERO, paramIns, ZERO, 3);
			// 多重起動処理番号
			paramIns[3] = JPCEditString.fillZero(String.valueOf(multiCnt),2,false);
			// 多重処理枝番
			paramIns[4] = JPCEditString.fillZero(String.valueOf(branchCnt),6,false);
			// サービスコード
			// 料金グループコード
			// 料金コースコード
			// ISP認証ID
			// サービスキャンセル年月日
			// サービス解約年月日
			// 削除処理対象抽出年月日
			// 個人情報削除理由コード
			// 契約最終更新年月日時分秒
			System.arraycopy(lstKey.get(i), 3, paramIns, 5, 9);
			// 登録年月日時分秒
			paramIns[14] = JBSbatDateUtil.getSystemDateTime();
			// 登録オペレータアカウント
			paramIns[15] = super.batchUserId;
			// 更新年月日時分秒
			paramIns[16] = JBSbatDateUtil.getSystemDateTime();
			// 更新オペレータアカウント
			paramIns[17] = super.batchUserId;
			// 削除年月日時分秒
			paramIns[18] = "";
			// 削除オペレータアカウント
			paramIns[19] = "";
			// 無効フラグ
			paramIns[20] = String.valueOf(i);
			// 登録運用年月日
			paramIns[21] = super.opeDate;
			// 登録処理ID
			paramIns[22] = super.jobid;
			// 更新運用年月日
			paramIns[23] = super.opeDate;
			// 更新処理ID
			paramIns[24] = super.jobid;
			// 削除運用年月日
			paramIns[25] = "";
			// 削除処理ID
			paramIns[26] = "";
			
			executeKK_T_KJNIFDEL_WK_PKINSERT(paramIns);
			
			// 個人情報削除ステータスを「削除実施中(030)」に更新する
			// サービス契約番号
			svcKeiNo = lstKey.get(i)[0];
			// 請求契約番号
			seiKyNo = lstKey.get(i)[1];
			// SYSID
			sysID = lstKey.get(i)[2];
			
			this.updKjnIfDel(svcKeiNo, seiKyNo, sysID);
		}
		
	}
}