/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatCRTaioRkCheckDataUpdate
*	ソースファイル名	：JBSbatCRTaioRkCheckDataUpdate.java
*	作成者				：富士通　
*	作成日				：2011年10月03日
*＜機能概要＞
*　対応履歴チェック情報更新処理部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/10/03   富士通		新規作成
*	v6.00.00	2013/11/26   FJ）斉藤(諭)	ANK-1637-00-00対応
*********************************************************************/
package eo.business.service;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCRBatCommon;
import eo.business.util.table.JBSbatCC_T_DLYD_TRN_REQ;
import eo.business.util.table.JBSbatCR_M_TIOKR_TRKM_CKJK;
import eo.business.util.table.JBSbatCR_T_TORK_EFILE_KNRI;
import eo.business.util.table.JBSbatZM_M_CD_NM_KANRI;
import eo.business.util.table.JBSbatZM_M_WKKBT_ORG;
import eo.common.constant.JCRStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JCRUtilCommon;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.log.JBSbatLogPrintControl;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;

/**
* 対応履歴チェック情報更新処理 <p>
*<BR>
* @author 富士通
*/
public class JBSbatCRTaioRkCheckDataUpdate extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(対応履歴電子ファイル管理)*/
	private static final String D_TBL_NAME_CR_T_TORK_EFILE_KNRI = "CR_T_TORK_EFILE_KNRI";

	/** テーブル(業務個別設定組織)*/
	private static final String D_TBL_NAME_ZM_M_WKKBT_ORG = "ZM_M_WKKBT_ORG";

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

	/** テーブル(対応記録取込チェック条件)*/
	private static final String D_TBL_NAME_CR_M_TIOKR_TRKM_CKJK = "CR_M_TIOKR_TRKM_CKJK";

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

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

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

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

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

	/** テーブルアクセスクラス(対応履歴電子ファイル管理)*/
	private JBSbatSQLAccess db_CR_T_TORK_EFILE_KNRI = null;

	/** テーブルアクセスクラス(業務個別設定組織)*/
	private JBSbatSQLAccess db_ZM_M_WKKBT_ORG = null;

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

	/** テーブルアクセスクラス(対応記録取込チェック条件)*/
	private JBSbatSQLAccess db_CR_M_TIOKR_TRKM_CKJK = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	// 定数定義
	/** チェック項目名称取得キー*/
	private static final String CR_CASEFILE_KOUMOKUMEI = "CR_CASEFILE_KOUMOKUMEI_";

	/** CASEファイルMAX項目数*/
	private static final int CASEFILE_KOUMOKUSU_MAX = 38;
	
	/** ファイル名を示す項目名称取得キー*/
	private static final String FILEMEI_KOUMOKU_KEY = "98";

	/** チェック件数を示す項目名称取得キー*/
	private static final String KENSU_KOUMOKU_KEY = "99";
	
	/** チェック条件ファイルパス取得キー*/
	private static final String JOKEN_FILEPATH = "JOKEN_FILEPATH";

	/** チェック条件ファイル名キー*/
	private static final String JOKEN_FILENAME = "JOKEN_FILENAME";
	
	/** チェック条件の「以下」を表す定数*/
	private static final String JOKEN_IKA = "以下";

	/** チェック条件リストの添え字 0 */
	private static final int PARAMNO_ZERO   = 0;
	/** チェック条件リストの添え字 1 */
	private static final int PARAMNO_ONE    = 1;
	/** チェック条件リストの添え字 2 */
	private static final int PARAMNO_TWO    = 2;
	/** チェック条件リストの添え字 3 */
	private static final int PARAMNO_THREE  = 3;
	/** チェック条件リストの添え字 4 */
	private static final int PARAMNO_FOUR   = 4;

	// 変数定義
	/** 処理日付格納用 */
	private String sysDateTime = null;
	
	/** 対応履歴一時ファイル保存先パス */
	private String tempFilePath = null;
	
	/** チェック項目名称格納用Map */
	private Map<String, String> chkJokenKmkNmMap = null;

	/** チェック条件称格納用Map */
	private Map<String, String> chkJokenNmMap = null;

	/** 初期処理エラーメッセージ */
	private String initErrMessage = null;

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

		// DBアクセスクラスを生成します
		db_CR_T_TORK_EFILE_KNRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_T_TORK_EFILE_KNRI);
		db_ZM_M_WKKBT_ORG = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_WKKBT_ORG);
		db_ZM_M_CD_NM_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_CD_NM_KANRI);
		db_CR_M_TIOKR_TRKM_CKJK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_M_TIOKR_TRKM_CKJK);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/

		// 初期処理開始
		
		// システム日付取得
		sysDateTime = JCRBatCommon.getSysDateTime();
		
		try
		{
			// プロパティーファイルチェックと情報取得
			checkApplicationProperty();
		}
		catch (Exception e)
		{
			// ECRB0260KW:%1%処理中に予期せぬエラーが発生しました。　%2%
			initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0260KW, new String[] {"対応履歴チェック情報更新", e.toString()});
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0260KW, new String[] {"対応履歴チェック情報更新", e.toString()});
			super.logPrint.printDebugLog("例外発生:" + e.toString());
			super.logPrint.printDebugLog("　　　　:" + e.getMessage());
		}
		
		/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}
	
	/**
	 * プロパティ情報設定とチェック<br>
	 * 初期処理でプロパティ情報を取得し設定します<br>
	 * @throws Exception 例外
	 */
	private void checkApplicationProperty() throws Exception
	{
		// 対応履歴一時ファイル保存パスチェック＆取得
		tempFilePath = checkTempFilePath();

		if (initErrMessage == null)
		{
			// チェック項目名称取得
			chkJokenKmkNmMap = getChkJokenKmkNm();
		}
	}

	/**
	 * 一時ファイル保存先パス取得とチェック<br>
	 * @return 一時保存先のパス
	 * @throws Exception 例外
	 */
	private String checkTempFilePath() throws Exception
	{
		boolean existError = false;

		// 抽出ファイル保存先パスを取得
		String hozonPath = JCRBatCommon.getApplicationConst("CR_TEMP_FILE_DIR");
		if (null == hozonPath || "".equals(hozonPath.trim()))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {"対応履歴一時ファイル保存先パス"});
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0010KW, new String[] {"対応履歴一時ファイル保存先パス"});
			existError = true;
		}
		else
		{
			File csvPath = JCRUtilCommon.checkDirExist(hozonPath);
			if (null == csvPath)
			{
				// 存在しない場合
				// ECRB0160KW:指定されたパスが存在しません。(%1%)
				String[] messageParams = new String[] {"プロパティ:CR_TEMP_FILE_DIR:" + hozonPath};
				initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0160KW, messageParams);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0160KW, messageParams);
				existError = true;
			}
			super.logPrint.printDebugLog("対応履歴一時ファイル保存先パス取得:" + csvPath);
		}
		if (existError == true)
		{
			hozonPath = null;
		}
		
		return hozonPath;
	}

	/**
	 * チェック条件項目名称取得<br>
	 * @return チェック条件項目名Map
	 * @throws Exception 例外
	 */
	private Map<String, String> getChkJokenKmkNm() throws Exception
	{
		// 戻り値格納用
		HashMap<String, String> checkJokenKmkNmMap = new HashMap<String, String>();

		boolean existError = false;

		// チェック条件項目名
		String checkjokenkmkNm = null;
		
		// CASEファイルの1〜38のチェック項目名をプロパティから取得
		for(int i = 0; i < CASEFILE_KOUMOKUSU_MAX; i++)
		{
			// チェック条件項目名Mapのキー
			String constKey = "";
			if(i < 9)
			{
				constKey = "0";
			}
			constKey = constKey + Integer.toString(i + 1);
			checkjokenkmkNm = JCRBatCommon.getApplicationConst(CR_CASEFILE_KOUMOKUMEI + constKey);

			// 取得項目がNULLまたは、空文字でなければMapに格納
			if(null == checkjokenkmkNm || "".equals(checkjokenkmkNm))
			{
				// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
				String[] messageParams = new String[] {"チェック項目番号:" + CR_CASEFILE_KOUMOKUMEI + constKey};
				initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				existError = true;
				break;
			}
			checkJokenKmkNmMap.put(checkjokenkmkNm, constKey);
		}

		if (existError == false)
		{
			// CASEファイルのファイル名を示すチェック項目名をプロパティから取得
			checkjokenkmkNm = JCRBatCommon.getApplicationConst(CR_CASEFILE_KOUMOKUMEI + FILEMEI_KOUMOKU_KEY);
			if(null == checkjokenkmkNm || "".equals(checkjokenkmkNm.trim()))
			{
				// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
				String[] messageParams = new String[] {"チェック項目番号:" + CR_CASEFILE_KOUMOKUMEI + FILEMEI_KOUMOKU_KEY};
				initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				existError = true;
			}
			else
			{
				checkJokenKmkNmMap.put(checkjokenkmkNm, FILEMEI_KOUMOKU_KEY);
			}
		}

		if (existError == false)
		{
			// CASEファイルのチェック件数を示す項目名をプロパティから取得
			checkjokenkmkNm = JCRBatCommon.getApplicationConst(CR_CASEFILE_KOUMOKUMEI + KENSU_KOUMOKU_KEY);
			if(null == checkjokenkmkNm || "".equals(checkjokenkmkNm.trim()))
			{
				// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
				String[] messageParams = new String[] {"チェック項目番号:" + CR_CASEFILE_KOUMOKUMEI + KENSU_KOUMOKU_KEY};
				initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0010KW, messageParams);
				existError = true;
			}
			else
			{
				checkJokenKmkNmMap.put(checkjokenkmkNm, KENSU_KOUMOKU_KEY);
			}
		}
		
		return checkJokenKmkNmMap;
	}

	/**
	 * チェック条件名称取得<br>
	 * @return チェック条件名称Map
	 * @throws Exception 例外
	 */
	private Map<String, String> getChkJokenNm() throws Exception
	{
		Map<String, String> resultMap = new HashMap<String, String>();

		// チェック条件名称取得(SQL定義キー:コード名称管理テーブルCR_SELECT_003)
		executeZM_M_CD_NM_KANRI_CR_SELECT_003(new Object[]{});
		List<JBSbatCommonDBInterface> codeNmList =  JCRBatCommon.getSelectedDataList(db_ZM_M_CD_NM_KANRI);
		
		// 取得できたレコードの数だけMapに格納
		if(null != codeNmList && 0 != codeNmList.size())
		{
			for(int i = 0; i < codeNmList.size(); i++)
			{
				// チェック条件名称が正しく取得できたものをMapに格納
				JBSbatCommonDBInterface selectData = codeNmList.get(i);
				if(null != selectData.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV_NM) &&
					!"".equals(selectData.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV_NM)))
				{
					resultMap.put(selectData.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV_NM),
					selectData.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV));
				}
			}
		}
		return resultMap;
	}
	
	/**
	 * 主処理
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/

		// (1)(a) ディレイド処理依頼情報取得
		ArrayList<HashMap<String, Object>> shoriIraiInfoList = JCRBatCommon.getShoriIraiInfo(commonItem, super.jobid);
		
		// ディレイド存在チェック
		if (null == shoriIraiInfoList || 0 == shoriIraiInfoList.size())
		{
			// 処理依頼が0件の場合、処理依頼が存在しないため処理を終了する。
			JCRBatCommon.printShoriCountLog(commonItem, "ディレイド処理依頼件数", 0);
			super.logPrint.printDebugLog("ディレイド処理依頼は存在しません。");
			return null;
		}
		// 処理件数ログ出力
		JCRBatCommon.printShoriCountLog(commonItem, "ディレイド処理依頼件数", shoriIraiInfoList.size());

		// (b) チェック条件名称取得
		chkJokenNmMap = getChkJokenNm();

		
		// (2) ディレイド処理依頼の件数実行
		for (int i = 0; i < shoriIraiInfoList.size(); i++)
		{
			List<Map<String, Object>> insertDataList = new ArrayList<Map<String, Object>>();
			List<String> errList = new ArrayList<String>();

			// 処理結果の初期化
			// ディレイド処理結果コード
			String shoriKekkaCd = JCRStrConst.DLYD_SYSTEM_ERR;

			// エラーファイルパス
			String errFile = null;
			
			Map<String, String> jokenFileMap = null;

			// チェック条件ファイルパス
			String checkJokenFilePath = null;

			// (3) ディレイド処理依頼情報1件読込
			// ディレイド処理依頼情報
			HashMap<String, Object> shoriIraiInfo = shoriIraiInfoList.get(i);
			
			// 処理依頼番号取得
			String shoriiraiNo = (String)shoriIraiInfo.get(JBSbatCC_T_DLYD_TRN_REQ.DLYD_TRN_REQ_NO);
			
			String eFileKanriNo = (String)shoriIraiInfo.get("INPUT_EFILE_KANRI_NO");

			super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " 対応履歴チェック条件更新処理主処理開始");
			super.logPrint.printDebugLog("電子ファイル管理番号：" + eFileKanriNo);

			try
			{

				// (4) 対応履歴チェック条件ファイルの取得
				jokenFileMap  = checkFilePath(eFileKanriNo);
				checkJokenFilePath = jokenFileMap.get(JOKEN_FILEPATH);

				if (initErrMessage == null)
				{
					// (4)(d)(e) チェック条件ファイルのデータを1行ずつリストに格納
					List<List<String>> chkJokenDataList = eo.common.util.JCRUtilCommon.convCsvFiletoList(jokenFileMap.get(JOKEN_FILEPATH));
					if(null == chkJokenDataList || chkJokenDataList.size() == 0)
					{
						// ECRB0190KW			%1%の内容が正しくありません。（%2%）
						String[] chikanMoji = {"対応履歴チェック条件ファイル", "ファイルフォーマットエラー"};
						setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji, errList);

						// 処理件数ログ出力
						JCRBatCommon.printShoriCountLog(commonItem, "チェック条件ファイル行数", 0);
					}
					else
					{
						// 処理件数ログ出力
						JCRBatCommon.printShoriCountLog(commonItem, "チェック条件ファイル行数", chkJokenDataList.size());

						// (5) 対応履歴チェック条件ファイルチェックを行う。
						insertDataList = checkJoken(chkJokenDataList, errList);

						// (6) 対応履歴チェック条件テーブル登録
						if(null == errList || 0 == errList.size())
						{
							// (a) 対応記録取込チェック条件テーブル全件物理削除
							executeCR_M_TIOKR_TRKM_CKJK_CR_DELETE_001(new Object[]{});
							super.logPrint.printDebugLog("対応記録取込チェック条件テーブル全件物理削除");

							// (b) チェック条件テーブル登録
							insertCheckJoken(insertDataList);
							super.logPrint.printDebugLog("対応記録取込チェック条件テーブル登録");

							// (7) 処理済ファイル更新
							// 対応履歴電子ファイル管理テーブル更新
							upDateTaioBunsho(eFileKanriNo);
							
						}
					}
					
					// エラー情報がない場合
					if(null == errList || 0 == errList.size())
					{
						// ディレイド処理バッチが正常の場合
						shoriKekkaCd = JCRStrConst.DLYD_OK;
					}
					// エラー情報が有る場合
					else
					{
						// ディレイド処理バッチが業務エラーの場合
						shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
					}
				}
				else
				{
					// 初期処理チェックでエラーがある場合
					if (tempFilePath != null && !("".equals(tempFilePath.trim())))
					{
						// 対応履歴一時ファイル保存先パスの設定が正しい場合
						errList = new ArrayList<String>();		// 画面に返すエラー情報を保持
						errList.add(initErrMessage);
						shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
					}
				}
			}
			catch (JBSbatBusinessException ex)
			{	
				// システムエラーフラグを設定する
				shoriKekkaCd = JCRStrConst.DLYD_SYSTEM_ERR;
				super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo);
				super.logPrint.printDebugLog("システムエラー発生:" + ex.toString());
				super.logPrint.printDebugLog("　　　　　　　　　:" + ex.getMessage());
			}
			finally
			{
				
				// 正常終了の場合
				if (JCRStrConst.DLYD_OK.equals(shoriKekkaCd))
				{
					super.commit();
					super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " コミット実行");

					// (9) ディレイド処理依頼結果更新処理(処理結果：正常)
					JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, null);
					super.logPrint.printDebugLog("ディレイド処理依頼結果： 正常");
				}
				// エラーが存在する場合
				else
				{
					// ロールバック
					commonItem.getConnection().rollback();
					super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + "  ロールバック実行");
					
					// 業務エラーの場合
					if(JCRStrConst.DLYD_GYOMU_ERR.equals(shoriKekkaCd))
					{
						// (8) エラーファイル作成
						errFile = tempFilePath + JCRStrConst.FILE_KUGIRI + jokenFileMap.get(JOKEN_FILENAME);
						String errFilePath = entryErrFile(errFile, errList);

						// (9) ディレイド処理依頼結果更新処理(処理結果：業務エラー)
						HashMap<String, String> shoriKekkaMap =
							JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, errFilePath);
						super.logPrint.printDebugLog("ディレイド処理依頼結果： 業務エラー");
						super.logPrint.printDebugLog("エラー電子ファイル管理番号： " + shoriKekkaMap.get("EFILE_KAMRI_NO"));

						// エラーファイルの一時ファイル物理削除
						JCRUtilCommon.deleteTempFile(errFilePath);
						super.logPrint.printDebugLog("エラーファイル物理削除： " + errFilePath);

					}
					// システムエラーが発生した場合
					else
					{
						// (9) ディレイド処理依頼結果更新処理(処理結果：システムエラー)
						JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, null);
						super.logPrint.printDebugLog("ディレイド処理依頼結果： システムエラー");
					}

				}
				
				// (9)(b) ディレイド処理結果コミット
				super.commit();
				super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " コミット実行");

				// (10) 終了処理
				// チェック条件ファイルの一時ファイル物理削除
				if (null != checkJokenFilePath && !"".equals(checkJokenFilePath))
				{
					int index = checkJokenFilePath.lastIndexOf(JCRStrConst.FILE_KUGIRI);
					checkJokenFilePath = checkJokenFilePath.substring(0, index);
					JCRUtilCommon.deleteDir(checkJokenFilePath);
					super.logPrint.printDebugLog("一時ファイル物理削除： " + checkJokenFilePath);
				}
				
				// ログ出力処理
				super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " 対応履歴チェック情報更新主処理終了");
			}
		}
		return null;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * チェック条ファイルパスとファイル名取得<br>
	 * @param eKanriFileNo 電子ファイル管理番号
	 * @return チェック条件ファイル情報Map
	 * @throws Exception 例外
	 */
	private Map<String, String> checkFilePath(String eKanriFileNo) throws Exception
	{
		// チェック条件ファイル情報Map
		Map<String, String> resultMap = new HashMap<String, String>();
	
		// チェック条件ファイル取得
		String filePath = getFilePath(eKanriFileNo);
		resultMap.put(JOKEN_FILEPATH, filePath);
		
		// (4)(c) チェック条件ファイル名取得
		executeCR_T_TORK_EFILE_KNRI_CR_SELECT_002(new Object[]{JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_CHK , eKanriFileNo});
		JBSbatCommonDBInterface selectedData = db_CR_T_TORK_EFILE_KNRI.selectNext();
		if(null == selectedData)
		{
			// ファイル名が取得できない場合
			String[] chikanMoji = {"対応履歴電子ファイル管理テーブル"};
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
			super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, chikanMoji));
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
		}

		resultMap.put(JOKEN_FILENAME, selectedData.getString(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM));

		return resultMap;
	}

	/**
	 * チェック条件ファイルパス取得処理<br>
	 * @param eKanriFileNo 電子ファイル番号
	 * @return チェック条件ファイルパス
	 * @throws Exception 例外
	 */
	private String getFilePath(String eKanriFileNo) throws Exception
	{
		// (4)(a) ファイルパス取得
		String filePath = JCRBatCommon.searchDenshiFile(commonItem, eKanriFileNo);
		// (4)(b) ファイルパスの存在チェック
		if(null == filePath || "".equals(filePath))
		{
			// ファイルパスが取得できない場合
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0060KW, new String[] {""});
			super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0060KW, new String[] {""}));
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECRB0060KW, new String[] {""});
		}

		return filePath;
	}

	/**
	 * チェック条件処理<br>
	 * @param chkJokenDataList チェック対象条件データ
	 * @param errList エラーファイルリスト
	 * @return チェック条件登録データリスト
	 * @throws Exception 例外
	 */
	private List<Map<String, Object>> checkJoken(List<List<String>> chkJokenDataList, List<String> errList) throws Exception
	{

		// 対応履歴チェック条件テーブル格納用List
		List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();

		// チェック条件ファイルの行数分処理を行う
		for(int i = 0; i < chkJokenDataList.size(); i++)
		{
			// 対応履歴チェック条件テーブル格納用Map
			Map<String, Object> insertMap = new HashMap<String, Object>();

			// チェック条件ファイルの一行分のデータ取得
			List<String> chkjokenLineData = chkJokenDataList.get(i);
			int line = i + 1;

			// (a) 項目数チェック
			if(null == chkjokenLineData || 5 != chkjokenLineData.size())
			{
				// エラー
				// ECRB0180KW 項目数が正しくありません。（%1%）
				int komokusu = 0;
				if (chkjokenLineData != null)
				{
					komokusu = chkjokenLineData.size();
				}
				String[] chikanMoji = {"項目数:" + komokusu};
				setErrMsg(line, JPCBatchMessageConstant.ECRB0180KW, chikanMoji, errList);
			}
			else
			{
				// チェック条件リストの変数
				String wkkbtNm = chkjokenLineData.get(PARAMNO_ZERO);		// 業務個別設定組織名
				String chkKenmei = chkjokenLineData.get(PARAMNO_ONE);		// チェック件名
				String chkJokenKmkNm = chkjokenLineData.get(PARAMNO_TWO);	// チェック条件項目名
				String chkValueData = chkjokenLineData.get(PARAMNO_THREE);	// チェック値
				String chkJokenNm = chkjokenLineData.get(PARAMNO_FOUR);		// チェック条件名

				// (b) 業務個別設定組織名存在チェック
				String wkkbtCd = checkWkkbt(wkkbtNm, errList, line);
				if(null != wkkbtCd && !"".equals(wkkbtCd))
				{
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.WKKBT_ORG_CD, wkkbtCd);
				}
				
				// (c) チェック件名妥当性チェック
				String kenmei = checkKenmei(wkkbtNm, chkKenmei, errList, line);
				if(null != kenmei && !"".equals(kenmei))
				{
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI, kenmei);
				}
				
				// (d) チェック条件項目名存在チェック
				String jokenKmkNo = checkJokenKmkmei(chkJokenKmkNm, errList, line);
				if(null != jokenKmkNo && !"".equals(jokenKmkNo))
				{
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NM, chkJokenKmkNm);
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NO, jokenKmkNo);
				}
				
				// (e) チェック値の妥当性チェック
				String chkValue = checkValueData(chkValueData, chkJokenKmkNm, chkJokenNm, errList, line);
				if(null !=  chkValue && !"".equals(chkValue))
				{
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_VALUE, chkValue);
				}
				
				// (f) チェック条件チェック
				String chkJokenCd = checkJokenCd(chkJokenNm, errList, line);
				if(null !=  chkJokenCd && !"".equals(chkJokenCd))
				{
					insertMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_CD, chkJokenCd);
				}

				resultList.add(insertMap);
			}
		}
		
		super.logPrint.printDebugLog("対応記録取込チェック条件チェック完了");

		return resultList;
	}
	
	/**
	 * 業務個別設定組織名存在チェック
	 * @param wkkbtNm	業務個別設定組織名
	 * @param errList	エラーリスト
	 * @param line	対象行数
	 * @return	業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private String checkWkkbt(String wkkbtNm, List<String> errList, int line) throws Exception
	{
		// 必須チェック
		if(null == wkkbtNm || "".equals(wkkbtNm))
		{
			// ECRB0370TW			%1%の必須チェックエラー
			String[] chikanMoji = {"業務個別設定組織名"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0370TW, chikanMoji, errList);
			return null;
		}

		// 業務個別設定組織テーブル内検索
		executeZM_M_WKKBT_ORG_CR_SELECT_002(new Object[]{wkkbtNm, sysDateTime, sysDateTime});
		JBSbatCommonDBInterface selectedData = db_ZM_M_WKKBT_ORG.selectNext();
		if(null == selectedData)
		{
			// ECRB0250KW			データが登録されていません。（%1%）
			String[] chikanMoji = {"業務個別設定組織テーブル：" + wkkbtNm};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0250KW, chikanMoji, errList);
			return null;
		}
		
		return selectedData.getString(JBSbatZM_M_WKKBT_ORG.WKKBT_ORG_CD);
	}

	/**
	 * チェック件名妥当性チェック
	 * @param wkkbtNm	業務個別設定組織名
	 * @param chkKenmei		チェック件名
	 * @param errList	エラーリスト
	 * @param line	対象行数
	 * @return	チェック件名
	 * @throws Exception 例外
	 */
	private String checkKenmei(String wkkbtNm, String chkKenmei, List<String> errList, int line) throws Exception
	{
		// 必須チェック
		if(null == chkKenmei || "".equals(chkKenmei))
		{
			// ECRB0370TW			%1%の必須チェックエラー
			String[] chikanMoji = {"チェック件名"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0370TW, chikanMoji, errList);
			return null;
		}

		// バイト数チェック
		if (200 < chkKenmei.getBytes(JCRStrConst.MOJI_CD_MS932).length)
		{
			// ECRB0200TW %1%のバイト数が正しくありません。（条件:%2% 値:%3%)
			String[] chikanMoji = { "チェック件名", "200バイト以内",
					chkKenmei.getBytes(JCRStrConst.MOJI_CD_MS932).length + "バイト" };
			setErrMsg(line, JPCBatchMessageConstant.ECRB0200TW, chikanMoji, errList);
		}

		// 内容チェック
		if(!chkKenmei.startsWith(wkkbtNm + "　"))
		{
			// ECRB0190KW		%1%の内容が正しくありません。（%2%）
			String[] chikanMoji = {"チェック件名", "「業務個別設定組織名＋全角空白」で始まっていません"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0190KW, chikanMoji, errList);
		}

		return chkKenmei;
	}

	/**
	 * チェック条件項目名存在チェック
	 * @param chkKmkMei		チェック項目名
	 * @param errList	エラーリスト
	 * @param line 	対象行数
	 * @return	チェック項目名
	 * @throws Exception 例外
	 */
	private String checkJokenKmkmei(String chkKmkMei, List<String> errList, int line)  throws Exception
	{
		// 必須チェック
		if(null == chkKmkMei || "".equals(chkKmkMei))
		{
			// ECRB0370TW			%1%の必須チェックエラー
			String[] chikanMoji = {"チェック項目名"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0370TW, chikanMoji, errList);
			return null;
		}
		
		// チェック条件項目名存在チェック
		if(!chkJokenKmkNmMap.containsKey(chkKmkMei))
		{
			// ECRB0250KW			データが登録されていません。（%1%）
			String[] chikanMoji = {"プロパティファイル：チェック条件項目名称"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0250KW, chikanMoji, errList);
			return null;
		}
		
		return chkJokenKmkNmMap.get(chkKmkMei);
	}

	/**
	 * チェック値の妥当性チェック
	 * @param chkValueData 	チェック値
	 * @param chkKmkMei チェック項目名
	 * @param chkJokenNm チェック条件
	 * @param errList	エラーリスト
	 * @param line	対象行数
	 * @return	チェック値
	 * @throws Exception	例外
	 */
	private String checkValueData(String chkValueData, String chkKmkMei, String chkJokenNm, List<String> errList, int line)  throws Exception
	{
		// 必須チェック
		if(null == chkValueData || "".equals(chkValueData))
		{
			// ECRB0370TW			%1%の必須チェックエラー
			String[] chikanMoji = {"チェック値"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0370TW, chikanMoji, errList);
			return null;
		}

		// 読込行の「チェック条件」が「件数」の場合
		if(KENSU_KOUMOKU_KEY.equals(chkJokenKmkNmMap.get(chkKmkMei)))
		{
			
			// バイト数チェック
			if(6 < chkValueData.getBytes(JCRStrConst.MOJI_CD_MS932).length)
			{
				// ECRB0200TW		%1%のバイト数が正しくありません。（条件:%2% 値:%3%)
				String[] chikanMoji = {"チェック値", "6バイト以内", chkValueData.getBytes(JCRStrConst.MOJI_CD_MS932).length + "バイト"};
				setErrMsg(line, JPCBatchMessageConstant.ECRB0200TW, chikanMoji, errList);
				
			}
			
			// 属性チェック
			if(!JCRBatCommon.isHannkakuSuuji1(chkValueData))
			{
				// ECRB0230TW			「%1%の属性が正しくありません。（属性:%2% 値:%3%）」
				String[] chikanMoji = {"チェック値", "半角数字", chkValueData};
				setErrMsg(line, JPCBatchMessageConstant.ECRB0230TW, chikanMoji, errList);
			}
			
			// チェック条件が'以下'でない場合はエラー
			if(!JOKEN_IKA.equals(chkJokenNm))
			{
				
				// ECRB0190KW			「%1%の内容が正しくありません。（%2%）」
				String[] chikanMoji = {"チェック条件", "チェック項目名が'件数'の場合、チェック条件は'以下'のみ指定できます。"};
				setErrMsg(line, JPCBatchMessageConstant.ECRB0190KW, chikanMoji, errList);
			}
		}
		else
		{
			// 読込行の「チェック条件」が「件数」でない場合、
			// バイト数チェック
			if (200 < chkValueData.getBytes(JCRStrConst.MOJI_CD_MS932).length)
			{
				// ECRB0200TW %1%のバイト数が正しくありません。（条件:%2% 値:%3%)
				String[] chikanMoji = { "チェック値", "200バイト以内", chkValueData.getBytes(JCRStrConst.MOJI_CD_MS932).length + "バイト" };
				setErrMsg(line, JPCBatchMessageConstant.ECRB0200TW, chikanMoji, errList);
			}
			
			// チェック条件が'以下'の場合はエラー
			if(JOKEN_IKA.equals(chkJokenNm))
			{
				
				// ECRB0190KW			「%1%の内容が正しくありません。（%2%）」
				String[] chikanMoji = {"チェック条件", "チェック項目名が'件数'以外の場合、チェック条件は'以下'を指定することはできません。"};
				setErrMsg(line, JPCBatchMessageConstant.ECRB0190KW, chikanMoji, errList);
			}

		}

		return chkValueData;
	}
	
	/**
	 * チェック条件チェック
	 * @param chkJoken	チェック条件
	 * @param errList	エラーリスト
	 * @param line	対象行数
	 * @return チェック条件項目番号
	 * @throws Exception 例外
	 */
	private String checkJokenCd(String chkJoken, List<String> errList, int line)  throws Exception
	{
		// 必須チェック
		if(null == chkJoken || "".equals(chkJoken))
		{
			// ECRB0370TW			%1%の必須チェックエラー
			String[] chikanMoji = {"チェック条件"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0370TW, chikanMoji, errList);
			return null;
		}
		
		// チェック条件項目名存在チェック
		if(!chkJokenNmMap.containsKey(chkJoken))
		{
			// ECRB0250KW			データが登録されていません。（%1%）
			String[] chikanMoji = {"コード名称管理テーブル：クエリ条件コード"};
			setErrMsg(line, JPCBatchMessageConstant.ECRB0250KW, chikanMoji, errList);
		}
		
		return chkJokenNmMap.get(chkJoken);
	}

	/**
	 * チェック条件登録処理
	 * @param insertDataList	チェック条件登録データリスト
	 * @throws Exception 例外
	 */
	private void insertCheckJoken(List<Map<String, Object>> insertDataList) throws Exception
	{
		// チェック条件順用データ格納Map
		Map<String, Integer> chkJokenJunMap = new HashMap<String, Integer>();
		
		for(int i = 0; i < insertDataList.size(); i++)
		{
			Map<String, Object> insertDataMap = insertDataList.get(i);
			if(null != insertDataMap)
			{
				// チェック条件順を設定
				if(chkJokenJunMap.containsKey(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI)))
				{
					Integer count = chkJokenJunMap.get(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI));
					count++;
					insertDataMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_JUN, count.toString());
					chkJokenJunMap.remove(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI));
					chkJokenJunMap.put(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI).toString(), count);

				}
				else
				{
					chkJokenJunMap.put(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI).toString(), 1);
					insertDataMap.put(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_JUN, 1);
				}
				
				// 対応記録取込チェック条件テーブル登録処理
				entryTIOKR_TRKM_CKJK(insertDataMap);
			}
		}
	}
	
	/**
	 * エラーファイル作成
	 * @param checkJokenFilePath	対応履歴チェック条件ファイルパス
	 * @param errList	エラーリスト
	 * @return エラーファイル名
	 * @throws Exception 例外
	 */
	private String entryErrFile(String checkJokenFilePath, List<String> errList) throws Exception
	{
		String errFileName = checkJokenFilePath;
		
		// ファイル名の拡張子変更
		int index = checkJokenFilePath.lastIndexOf(".");
		if (-1 < index)
		{
			errFileName = checkJokenFilePath.substring(0, index);
		}
		errFileName = errFileName  + "_ERR.TXT";
		
		JCRBatCommon.entryErrFileData(commonItem, errFileName, errList);

		return errFileName;
	}
	
	/**
	 * 対応記録取込チェック条件登録
	 * @param insertDataMap		チェック条件登録データMap
	 * @throws Exception 例外
	 */
	private void entryTIOKR_TRKM_CKJK(Map<String, Object> insertDataMap) throws Exception
	{
		String sysDtm = JCRBatCommon.getSysDateTimeStamp();
		String userId = commonItem.getBatchUserId();

		// 登録データ設定
		String[] insertData = new String[15];
		
		insertData[0] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.WKKBT_ORG_CD);			// (1)業務個別設定組織コード
		insertData[1] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_KENMEI);			// (2)チェック件名
		insertData[2] = insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_JUN).toString();	// (3)チェック条件項目順序
		insertData[3] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NO);		// (4)チェック条件項目番号
		insertData[4] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NM);		// (5)チェック条件項目名

		// チェック条件名が「件数」でない場合
		if(!KENSU_KOUMOKU_KEY.equals(insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NO)))
		{
			insertData[5] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_VALUE);		// (6)チェック値
		}
		else
		{
			insertData[7] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_VALUE);		// (8)チェック対象データ最大件数
		}
		insertData[6] = (String)insertDataMap.get(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_CD);			// (7)チェック条件コード
		insertData[8] = sysDtm;																		// (9)登録年月日時分秒
		insertData[9] = userId;																		// (10)登録オペレータアカウント
		insertData[10] = sysDtm;																	// (11)更新年月日時分秒
		insertData[11] = userId;																	// (12)更新オペレータアカウント
		insertData[12] = null;																		// (13)削除年月日時分秒
		insertData[13] = null;																		// (14)削除オペレータアカウント
		insertData[14] = "0";																		// (15)無効フラグ
		
		// 対応記録取込チェック条件テーブル登録
		executeCR_M_TIOKR_TRKM_CKJK_PKINSERT(insertData);
	}

	/**
	 * 対応履歴電子ファイル管理更新
	 * @param denshiKanriNo		更新対象の電子管理ファイル番号
	 * @throws Exception 例外
	 */
	private void upDateTaioBunsho(String denshiKanriNo)  throws Exception
	{
		String sysDtm = JCRBatCommon.getSysDateTimeStamp();
		String userId = commonItem.getBatchUserId();
		
		// 文書種別コード更新
		executeCR_T_TORK_EFILE_KNRI_CR_UPDATE_003(new Object[]{JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_CHKZUMI, sysDtm, userId, denshiKanriNo});
		super.logPrint.printDebugLog("対応履歴電子ファイル管理テーブル文書種別コード更新:" + JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_CHKZUMI);
	}
	
	/**
	 * エラーメッセージリスト格納処理(行数有り)
	 * @param line	エラー行数
	 * @param msgId		メッセージID
	 * @param chikanMoji	置換文字列
	 * @param errList	エラーリスト
	 * @throws Exception 例外
	 */
	private void setErrMsg(int line, String msgId, String[] chikanMoji, List<String> errList) throws Exception
	{

		// エラーメッセージ作成
		String lineMsg = line + "行目";
		String errMsg = JBSbatLogPrintControl.getMessage(msgId, chikanMoji);
		errList.add(lineMsg + errMsg);
		
		super.logPrint.printBusinessErrorLog(msgId, chikanMoji);
		super.logPrint.printDebugLog(lineMsg + errMsg);
	}
	

	/**
	 * エラーメッセージリスト格納処理(行数なし)
	 * @param msgId		メッセージID
	 * @param chikanMoji	置換文字列
	 * @param errList	エラーリスト
	 * @throws Exception 例外
	 */
	private void setErrMsg(String msgId, String[] chikanMoji, List<String> errList) throws Exception
	{
		// エラーメッセージ作成
		String errMsg = JBSbatLogPrintControl.getMessage(msgId, chikanMoji);
		errList.add(errMsg);

		super.logPrint.printBusinessErrorLog(msgId, chikanMoji);
		super.logPrint.printDebugLog(errMsg);

	}

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

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

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

	/**
	 * SQLKEY(CR_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 executeZM_M_WKKBT_ORG_CR_SELECT_002(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_ZM_M_WKKBT_ORG.selectBySqlDefine(paramList, ZM_M_WKKBT_ORG_CR_SELECT_002);
	}

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

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

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

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

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	業務個別設定組織コード				WKKBT_ORG_CD
	 *		 	チェック件名				CHK_KENMEI
	 *		 	チェック条件項目順序				CHK_JOKEN_KMK_JUN
	 *		 	チェック条件項目番号				CHK_JOKEN_KMK_NO
	 *		 	チェック条件項目名				CHK_JOKEN_KMK_NM
	 *		 	チェック値				CHK_VALUE
	 *		 	チェック条件コード				CHK_JOKEN_CD
	 *		 	チェック対象データ最大件数				CHK_TG_DATA_MAX_CNT
	 *		 	登録年月日時分秒				ADD_DTM
	 *		 	登録オペレータアカウント				ADD_OPEACNT
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	削除年月日時分秒				DEL_DTM
	 *		 	削除オペレータアカウント				DEL_OPEACNT
	 *		 	無効フラグ				MK_FLG
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeCR_M_TIOKR_TRKM_CKJK_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("WKKBT_ORG_CD", setParam[0]);
		setMap.setValue("CHK_KENMEI", setParam[1]);
		setMap.setValue("CHK_JOKEN_KMK_JUN", setParam[2]);
		setMap.setValue("CHK_JOKEN_KMK_NO", setParam[3]);
		setMap.setValue("CHK_JOKEN_KMK_NM", setParam[4]);
		setMap.setValue("CHK_VALUE", setParam[5]);
		setMap.setValue("CHK_JOKEN_CD", setParam[6]);
		setMap.setValue("CHK_TG_DATA_MAX_CNT", setParam[7]);
		setMap.setValue("ADD_DTM", setParam[8]);
		setMap.setValue("ADD_OPEACNT", setParam[9]);
		setMap.setValue("UPD_DTM", setParam[10]);
		setMap.setValue("UPD_OPEACNT", setParam[11]);
		setMap.setValue("DEL_DTM", setParam[12]);
		setMap.setValue("DEL_OPEACNT", setParam[13]);
		setMap.setValue("MK_FLG", setParam[14]);
	
		// DBアクセスを実行します
		db_CR_M_TIOKR_TRKM_CKJK.insertByPrimaryKeys(setMap);
	}

	/**
	 * SQLKEY(CR_UPDATE_003)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	文書種別コード
	 *		 	更新オペレータアカウント
	 *		 	更新年月日時分秒
	 *		 	電子ファイル管理番号
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeCR_T_TORK_EFILE_KNRI_CR_UPDATE_003(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());
		paramList.setValue(param[3].toString());

		// DBアクセスを実行します
		db_CR_T_TORK_EFILE_KNRI.executeBySqlDefine(paramList, CR_T_TORK_EFILE_KNRI_CR_UPDATE_003);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
}