/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatCRTaioRkFileCheck
*	ソースファイル名	：JBSbatCRTaioRkFileCheck.java
*	作成者				：富士通　
*	作成日				：2011年10月22日
*＜機能概要＞
*　対応履歴ファイルチェック処理部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/10/22   富士通		新規作成
*   v6.00.00    2013/11/07   富士通		同時実行時の不具合対応 OM-2013-0004047
*	v6.00.01	2013/11/26   FJ）斉藤(諭)	ANK-1637-00-00対応
*	v42.00.00	2019/04/01   FJ) 前田	ANK-3593-00-00_オペレータ支援対応に伴うeo顧客機能改修（お客さまカルテ）
*	v48.00.00	2019/12/27   FJ) 張本	ANK-3795-00-00_見込顧客システム構築対応
*********************************************************************/
package eo.business.service;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
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.common.constant.JCRStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JCRUtilCommon;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.log.JBSbatLogPrintControl;
import eo.framework.util.JBSbatBusinessFileUtil;

/**
* 対応履歴ファイルチェック処理 <p>
*<BR>
* @author 富士通
*/
public class JBSbatCRTaioRkFileCheck 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_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_001)*/
	private static final String CR_M_TIOKR_TRKM_CKJK_CR_SELECT_001 = "CR_SELECT_001";

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

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

	// 定数

	/** 問合せ履歴ファイル名キー*/
	private static final String TOIAWASE_FILEPATH = "TOIAWASE_FILEPATH";
	
	/** 問合せ履歴ファイル名を取得するキー */
	private static final String KEY_TOIAWASE_FILENAME = "KEY_TOIAWASE_FILENAME";

	/** 対応履歴電子ファイルの業務個別設定組織コードを取得するキー */
	private static final String KEY_WORK_GROUP = "KEY_WORK_GROUP";
	
	/** ファイル名を示す項目名称取得キー*/
	private static final String FILENAME_KOUMOKU_KEY = "98";

	/** チェック件数を示す項目名称取得キー*/
	private static final String KENSU_KOUMOKU_KEY = "99";

	/** 「と等しい」を 示すチェック条件コード*/
	private static final String JOKEN_CD_HITOSHII = "A1";

	/** 「で始まる」を 示すチェック条件コード*/
	private static final String JOKEN_CD_START = "B3";

	/** 「で終わる」を 示すチェック条件コード*/
	private static final String JOKEN_CD_END = "B4";

	/** 「を含む」を 示すチェック条件コード*/
	private static final String JOKEN_CD_HUKUMU = "B5";
	
	/** 「を含まない」 を判定するための定数 */
	private static final int MOJIHIKAKU_HUKUMANAI = -1;

	
	/** 1行の項目数 */
	private static final int KOUMOKU_SU_START = 37;

	
	/**
	 * 1行の項目数 終了
	 * （反響可能性フラグ、対応部署名、見込顧客番号の追加により39,40,41とも許容する）
	 */
// v48.00.00 ANK-3795-00-00 MOD START
//	// ANK-3593-00-00 MOD START
//	//private static final int KOUMOKU_SU_END = 38;
//	private static final int KOUMOKU_SU_END = 40;
//	// ANK-3593-00-00 MOD END
	private static final int KOUMOKU_SU_END = 41;
// v48.00.00 ANK-3795-00-00 MOD START

	/** エラー有無を取得するキー */
	private static final String KEY_EXIST_ERROR = "KEY_EXIST_ERROR";
	/** ログデータを取得するキー */
	private static final String KEY_LOG_DATA = "KEY_LOG_DATA";
	/** 問合せ履歴データを取得するキー */
	private static final String KEY_TOIAWASE_DATA = "KEY_TOIAWASE_DATA";
	/** 改行コード変換文字を取得するキー */
	public static final String KEY_KAIGYO_CD_HENKAN_MOJI = "KEY_KAIGYO_CD_HENKAN_MOJI";
	/** 変換処理後のファイルを取得するキー */
	static final String KEY_HENKANGO_FILE = "KEY_HENKANGO_FILE";
	
	/** 項目数エラー有無を取得するキー */
	private static final String KEY_EXIST_KOUMOKUSU_ERROR = "KEY_EXIST_KOUMOKUSU_ERROR";

	
	// 変数定義
	/** チェック済みCSVファイルディレクトリ */
	private String toiawaseOutputPath = null;
	
	/** 問合せ履歴一時ファイルを配置する */
	private String toiawaseTempFilePath = null;
	
	/** 対応履歴一時ファイル保存先パス */
	private String tempFilePath = 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_CR_M_TIOKR_TRKM_CKJK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_M_TIOKR_TRKM_CKJK);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		// 初期処理開始

		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)
		{
			// チェック済みCSVファイルディレクトリ取得＆チェック
			toiawaseOutputPath = checkToiawaseFilePath();
		}

		if (initErrMessage == null)
		{
			// 問合せ履歴一時ファイルディレクトリ取得＆チェック
			toiawaseTempFilePath = checkToiawaseTempFilePath();
		}
	}

	/**
	 * チェック済みCSVファイルディレクトリ取得とチェック<br>
	 * @return チェック済みCSVファイルディレクトリ
	 * @throws Exception 例外
	 */
	private String checkToiawaseFilePath() throws Exception
	{
		boolean existError = false;

		// チェック済みCSVファイルディレクトリを取得
		String hozonPath = JCRBatCommon.getApplicationConst("CR_TWS_RK_FILE_DIR");
		if (hozonPath == null || "".equals(hozonPath.trim()))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {"チェック済みCSVファイルディレクトリ"});
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0010KW, new String[] {"チェック済みCSVファイルディレクトリ"});
			existError = true;
		}
		else
		{
			File csvPath = JCRUtilCommon.checkDirExist(hozonPath);
			if (csvPath == null)
			{
				// ECRB0160KW:指定されたパスが存在しません。(%1%)
				String[] messageParams = new String[] {"プロパティ:CR_TWS_RK_FILE_DIR:" + hozonPath};
				initErrMessage = JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0160KW, messageParams);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0160KW, messageParams);
				existError = true;
			}
			super.logPrint.printDebugLog("チェック済みCSVファイルディレクトリ取得:" + csvPath);
		}
		if (existError == true)
		{
			hozonPath = null;
		}

		return hozonPath;
	}

	/**
	 * 問合せ履歴一時ファイルディレクトリ取得とチェック<br>
	 * @return 問合せ履歴一時ファイルディレクトリ
	 * @throws Exception 例外
	 */
	private String checkToiawaseTempFilePath() throws Exception
	{
		boolean existError = false;

		// 問合せ履歴一時ファイルディレクトリを取得
		String hozonPath = JCRBatCommon.getApplicationConst("CR_TWS_RK_TMP_FILE_DIR");
		if (hozonPath == null || "".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 (csvPath == null)
			{
				// 存在しない場合
				// ECRB0160KW:指定されたパスが存在しません。(%1%)
				String[] messageParams = new String[] {"プロパティ:CR_TWS_RK_TMP_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 対応履歴一時ファイル保存先パス
	 * @throws Exception 例外
	 */
	private String checkTempFilePath() throws Exception
	{
		boolean existError = false;

		// 対応履歴一時ファイル保存先パスを取得
		String hozonPath = JCRBatCommon.getApplicationConst("CR_TEMP_FILE_DIR");
		if (hozonPath == null || "".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 (csvPath == null)
			{
				// 存在しない場合
				// 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;
	}

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

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

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

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

			// 問合せ履歴一時ファイルパス
			File toiawaseTmpFile = null;

			// エラーファイルパス
			String errFilePath = null;

			// 問合せ履歴ファイルパス
			String toiawaseFilePath = 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(JBSbatCC_T_DLYD_TRN_REQ.INPUT_EFILE_KANRI_NO);

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

			try
			{
				// (4) 問合せ履歴ファイルの取得
				Map<String, String> toiawaseFileInfoMap  = checkFilePath(eFileKanriNo);
				String fileName = toiawaseFileInfoMap.get(KEY_TOIAWASE_FILENAME);
				String workGroupCd = toiawaseFileInfoMap.get(KEY_WORK_GROUP);

				if (initErrMessage == null)
				{
					// 初期処理チェックでエラーがない場合

					errFilePath = tempFilePath + JCRStrConst.FILE_KUGIRI + fileName;
					String outputPath = toiawaseOutputPath + JCRStrConst.FILE_KUGIRI + fileName;

					// 問合せ履歴一時ディレクトリ取得
					toiawaseFilePath = toiawaseFileInfoMap.get(TOIAWASE_FILEPATH);
					File toiawaseFile = new File(JCRUtilCommon.inspection(toiawaseFilePath));
					File toiawaseTempFile = new File(JCRUtilCommon.inspection(toiawaseTempFilePath));
					
					// (5) CSV一般化処理(1レコード1行に変換:問合せ履歴一時ディレクトリ)
					Map<String, Object> tmpFileMap = JCRBatCommon.chgToOneRowForCsv(commonItem, toiawaseFile, toiawaseTempFile);
					String chgCRWord = (String)tmpFileMap.get(JCRBatCommon.KEY_KAIGYO_CD_HENKAN_MOJI);	// 改行コード変換文字
					File tmpFile = (File)tmpFileMap.get(JCRBatCommon.KEY_HENKANGO_FILE);				// 変換後一時ファイル
					int dataCount = ((Integer)tmpFileMap.get(JCRBatCommon.KEY_COUNT)).intValue();		// レコード件数

					// 最初の一行目はチェック件名のため省く。(件数から-1を行う)
					dataCount = dataCount - 1;
					toiawaseTmpFile = (File)tmpFileMap.get(KEY_HENKANGO_FILE);

					super.logPrint.printDebugLog("改行コード変換文字:" + chgCRWord);
					super.logPrint.printDebugLog("一時ファイル名:" + tmpFile.getName());
					super.logPrint.printDebugLog("データ件数:" + dataCount);

					// 処理件数ログ出力
					JCRBatCommon.printShoriCountLog(commonItem, "データ件数", dataCount);

					boolean isErrorFile = false;

					// 問合せ履歴ファイルチェックを行う。
					// 変換後ファイル読込処理
					Map<String, Object> checkInfoMap = checkToiawaseFile(commonItem, tmpFile, dataCount, fileName, chgCRWord);

					isErrorFile = (Boolean)checkInfoMap.get(KEY_EXIST_ERROR);

					// エラーが存在する場合、ログに出力する
					if(isErrorFile)
					{
						String logData = (String)checkInfoMap.get(KEY_LOG_DATA);
						errList.add(logData);
					}

					// ファイル出力処理
					if(errList == null || errList.size() == 0)
					{
						// 問合せ履歴チェック済みデータ取得
						List<String> toiawaseDataList = (ArrayList<String>)checkInfoMap.get(KEY_TOIAWASE_DATA);

						// (8) 問合せ履歴ファイル出力
						createFile(outputPath, workGroupCd, toiawaseDataList, chgCRWord);

						// ディレイド処理バッチが正常の場合
						shoriKekkaCd = JCRStrConst.DLYD_OK;
					}
					// エラー情報が有る場合
					else
					{
						// ディレイド処理バッチが業務エラーの場合
						shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
					}
				}
				else
				{
					// 初期処理チェックでエラーがある場合
					if (tempFilePath != null && !("".equals(tempFilePath.trim())))
					{
						// 対応履歴一時ファイル保存先パスの設定が正しい場合
						errFilePath = tempFilePath + JCRStrConst.FILE_KUGIRI + fileName;
						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))
				{
					// (10) ディレイド処理依頼結果更新処理(処理結果：正常)
					JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, null);
					super.logPrint.printDebugLog("ディレイド処理依頼結果： 正常");
				}
				// エラーが存在する場合
				else
				{
					// 業務エラーの場合
					if(JCRStrConst.DLYD_GYOMU_ERR.equals(shoriKekkaCd))
					{
						// (9) エラーファイル作成
						String errFile = entryErrFile(errFilePath, errList);

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

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

					// システムエラーが発生した場合
					else
					{
						// (10) ディレイド処理依頼結果更新処理(処理結果：システムエラー)
						JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, null);
						super.logPrint.printDebugLog("ディレイド処理依頼結果： システムエラー");
					}
				}
				
				// (10)(b) ディレイド処理結果コミット
				super.commit();
				super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " コミット実行");

				//(11) 終了処理
				// 問合せ履歴ファイルの一時ファイル物理削除
				if (toiawaseFilePath != null && !"".equals(toiawaseFilePath))
				{
					int index = toiawaseFilePath.lastIndexOf(JCRStrConst.FILE_KUGIRI);
					toiawaseFilePath = toiawaseFilePath.substring(0, index);
					JCRUtilCommon.deleteDir(toiawaseFilePath);
					super.logPrint.printDebugLog("一時ファイル物理削除： " + toiawaseFilePath);
				}
				if (toiawaseTmpFile != null)
				{
					JCRUtilCommon.deleteTempFile(toiawaseTmpFile.getPath());
					super.logPrint.printDebugLog("一時ファイル物理削除： " + toiawaseTmpFile.getPath());
				}
				// ログ出力処理
				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(TOIAWASE_FILEPATH, filePath);
		
		// (4)(c) 対応履歴ファイル取込ディレイド処理用ファイル名取得
		executeCR_T_TORK_EFILE_KNRI_CR_SELECT_002(new Object[]{JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_DYLD , eKanriFileNo});
		JBSbatCommonDBInterface selectedData = db_CR_T_TORK_EFILE_KNRI.selectNext();
		if(selectedData == null)
		{
			// ファイル名が取得できない場合
			String[] chikanMoji = {"対応履歴電子ファイル管理テーブル"};
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
			super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, chikanMoji));
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
		}

		resultMap.put(KEY_TOIAWASE_FILENAME, selectedData.getString(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM));
		resultMap.put(KEY_WORK_GROUP, selectedData.getString(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_ORG_CD));

		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(filePath == null || "".equals(filePath))
		{
			// 電子ファイル管理テーブルの電子ファイルレコードが取得できない場合
			String[] chikanMoji = {"電子ファイル管理テーブル 電子ファイル管理番号:" + eKanriFileNo};
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
			super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, chikanMoji));
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECRB0250KW, chikanMoji);
		}
		
		return filePath;
	}
	

	/**
	 * 問合せ履歴ファイルチェック処理
	 * @param commonItem 共通情報
	 * @param tmpFile 一時ファイル
	 * @param dataCount 問合せ履歴ファイル件数
	 * @param fileName 問合せ履歴ファイル名
	 * @param chgCRWord 改行コード変換文字
	 * @return 処理結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_TOIAWASE_DATA	問合せ履歴情報
	 * 			KEY_ERR_DATA		エラー行データ
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 */
	private Map<String, Object> checkToiawaseFile(JBSbatCommonItem commonItem, File tmpFile,
			int dataCount, String fileName, String chgCRWord) throws Exception
	{

		Map<String, Object> resMap = new HashMap<String, Object>();

		boolean isErrorFile = false;					// エラー有無判定用(1件でもエラーがあればtrue)

		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納
		StringBuilder errData = new StringBuilder();	// エラー行格納

		// 一時ファイル読込み処理
		BufferedReader br = null;
		try
		{
			// 一時ファイル(変換後)
			br = new BufferedReader(new InputStreamReader(new FileInputStream(tmpFile), JCRStrConst.DEFAULT_ENCODE));

			int errorRecordCount = 1;

			List<String>  toiawaseDataList = new ArrayList<String>();
			List<JBSbatCommonDBInterface> checkAllJokenList = null;
			
			String data = br.readLine();		// 1行目読込み

			// 読込みデータList化
			List<String> dataList = JCRUtilCommon.convStringToList(data);

			// (6)-1 チェック件名とチェック条件取得
			// (a) チェック条件必須チェックと妥当性チェック
			if(dataList == null || dataList.size() != 1)
			{
				// チェック件名取得エラー
				isErrorFile = true;

				// ECRB0370TW			%1%の必須チェックエラー
				String[] chikanMoji = {"チェック件名"};
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, chikanMoji));
				logData.append(JCRStrConst.KAIGYO_CD);
				super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, chikanMoji));

				resMap.put(KEY_LOG_DATA, logData.toString());
				resMap.put(KEY_EXIST_ERROR, isErrorFile);
				
				return resMap;
			}

			// (b) 対応記録取込チェック条件存在チェック
			checkAllJokenList = checkJokenData(dataList.get(0));
			if(checkAllJokenList == null)
			{
				// 存在しない場合、後続のチェック処理を行わない。
				// チェック件名取得エラー
				isErrorFile = true;

				String[] chikanMoji = {"対応記録取込チェック条件テーブル"};
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, chikanMoji));
				logData.append(JCRStrConst.KAIGYO_CD);
				super.logPrint.printDebugLog(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, chikanMoji));
				
				resMap.put(KEY_LOG_DATA, logData.toString());
				resMap.put(KEY_EXIST_ERROR, isErrorFile);
				return resMap;
			}
			
			// 対応履歴チェック条件の分割
			List<JBSbatCommonDBInterface> checkKensuList = new ArrayList<JBSbatCommonDBInterface>();		// ファイル件数チェックリスト
			List<JBSbatCommonDBInterface> checkFileNameList = new ArrayList<JBSbatCommonDBInterface>();		// ファイル名チェックリスト
			List<JBSbatCommonDBInterface> checkJokenList = new ArrayList<JBSbatCommonDBInterface>();		// チェック条件リスト
			for(int i = 0; i < checkAllJokenList.size(); i++)
			{
				JBSbatCommonDBInterface checkJoken = checkAllJokenList.get(i);
				String jokenKmkNo = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NO);

				// チェック項目番号が件数を示す"99"の場合
				if(KENSU_KOUMOKU_KEY.equals(jokenKmkNo))
				{
					checkKensuList.add(checkJoken);
				}
				// チェック項目番号がファイル名を示す"98"の場合
				else if(FILENAME_KOUMOKU_KEY.equals(jokenKmkNo))
				{
					checkFileNameList.add(checkJoken);
					
				}
				// チェック項目番号が上記以外の場合
				else
				{
					checkJokenList.add(checkJoken);
					
				}
			}
			
			boolean existError = false;
			// 存在する場合、各種チェックを行う。
			data = br.readLine();		// 2行目読込み
			while (data != null)
			{
				// 対応履歴行データを確認
				toiawaseDataList.add(data);

				// 読込みデータList化
				dataList = JCRUtilCommon.convStringToList(data);

				if (dataList == null)
				{
					dataList = new ArrayList<String>();
				}

				// (6)-2 問合せ履歴ファイルチェック
				Map<String, Object> checkInfoMap = check(commonItem, dataList, errorRecordCount, chgCRWord);
				existError = (Boolean)checkInfoMap.get(KEY_EXIST_ERROR);	// 1行中のエラー有無
				if (existError)
				{
					// エラー行を退避
					errData.append(JCRStrConst.KAIGYO_CD);
					logData.append(checkInfoMap.get(KEY_LOG_DATA));

					isErrorFile = true;
				}
				boolean koumokusuError = (Boolean)checkInfoMap.get(KEY_EXIST_KOUMOKUSU_ERROR);

				if (!(koumokusuError))
				{
					// 項目数エラーが無かった場合
					// (6)-3 問合せ履歴チェック条件チェック
					if(checkJokenList != null && checkJokenList.size() != 0)
					{
						Map<String, Object> checkToiawaseMap = checkToiawaseJoken(dataList, checkJokenList,
								errorRecordCount);
						existError = (Boolean)checkToiawaseMap.get(KEY_EXIST_ERROR);	// 1行中のエラー有無
		
						if(existError)
						{
							// エラー行を退避
							logData.append(checkToiawaseMap.get(KEY_LOG_DATA));
							isErrorFile = true;
						}
					}
				}

				errorRecordCount++;
				data = br.readLine();		// 1行読込み
			}
			
			// (7)-1 ファイル名チェックが存在する場合
			if(checkFileNameList != null && checkFileNameList.size() != 0)
			{
				String taioRkFileName = convFileName(fileName);
				
				Map<String, Object> checkFileNameMap = checkFileName(taioRkFileName, checkFileNameList);
				existError = (Boolean)checkFileNameMap.get(KEY_EXIST_ERROR);	// 1行中のエラー有無
				if(existError)
				{
					logData.append(checkFileNameMap.get(KEY_LOG_DATA));
					isErrorFile = true;
				}
			}

			// (7)-2 件数チェックが存在する場合
			if(checkKensuList != null && checkKensuList.size() != 0)
			{
				Map<String, Object> checkToiawaseKensuMap = checkToiawaseKensu(dataCount, checkKensuList);
				existError = (Boolean)checkToiawaseKensuMap.get(KEY_EXIST_ERROR);	// 1行中のエラー有無
				if(existError)
				{
					logData.append(checkToiawaseKensuMap.get(KEY_LOG_DATA));
					isErrorFile = true;
				}
			}
			
			resMap.put(KEY_EXIST_ERROR, isErrorFile);
			resMap.put(KEY_TOIAWASE_DATA, toiawaseDataList);
			resMap.put(KEY_LOG_DATA, logData.toString());

			return resMap;

		}
		finally
		{
			if (br != null)
			{
				try
				{
					br.close();
				}
				catch (IOException ioe)
				{
					super.logPrint.printDebugLog("br close error");
				}
			}
		}
	}
	
	/**
	 * チェック条件データ取得処理
	 * @param checkKenmei		チェック件名
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @return 取得した対応記録取込チェック条件レコード
	 * @throws Exception 例外
	 */
	private List<JBSbatCommonDBInterface> checkJokenData(String checkKenmei)  throws Exception
	{
		// チェック条件情報リスト
		List<JBSbatCommonDBInterface> resultList = new ArrayList<JBSbatCommonDBInterface>();
			
		// (6)(b) 対応記録取込チェック条件テーブルから条件情報を取得する。
		executeCR_M_TIOKR_TRKM_CKJK_CR_SELECT_001(new Object[]{checkKenmei});
		resultList = JCRBatCommon.getSelectedDataList(db_CR_M_TIOKR_TRKM_CKJK);
		
		return resultList;

	}
	
	/**
	 * チェック処理
	 * @param commonItem 共通情報
	 * @param dataList 1行分のデータ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 */
	private Map<String, Object> check(JBSbatCommonItem commonItem, List<String> dataList,
			int errorRecordCount, String chgCRWord) throws Exception
	{

		Map<String, Object> resMap = new HashMap<String, Object>();

		boolean existError = false;

		Map<String, Object> errInfoMap = null;			// エラー情報
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納

		// 読込データチェック
		errInfoMap = checkData(dataList, errorRecordCount, chgCRWord);
		boolean error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}
		boolean koumokusuError = (Boolean)errInfoMap.get(KEY_EXIST_KOUMOKUSU_ERROR);
		if (!(koumokusuError))
		{
			// 項目数エラーが無かった場合
			// テーブルチェック
			errInfoMap = JCRBatCommon.checkTableData(commonItem, dataList, errorRecordCount, chgCRWord);
			error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
			if (error)
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
				existError = true;
			}
		}

		resMap.put(KEY_EXIST_KOUMOKUSU_ERROR, koumokusuError);
		resMap.put(KEY_EXIST_ERROR, existError);
		resMap.put(KEY_LOG_DATA, logData.toString());

		return resMap;
	}
	
	/**
	 * データチェック
	 * @param dataList 1行分のデータ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private Map<String, Object> checkData(List<String> dataList,
			int errorRecordCount, String chgCRWord) throws Exception
	{

		Map<String, Object> resMap = new HashMap<String, Object>();

		boolean existError = false;
		boolean existKoumokusuError = false;
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納

		if (dataList.size() < KOUMOKU_SU_START || dataList.size() > KOUMOKU_SU_END)
		{
			// エラーログ 項目数が正しくありません。(%1%)
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0180KW, new String[] {String.valueOf(errorRecordCount) + "レコード目"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0180KW, new String[] {"CASEファイル"}));
			logData.append(JCRStrConst.KAIGYO_CD);
			existError = true;
			existKoumokusuError = true;
		}

		if (!(existError))
		{
			// 項目数が正しい場合

			// 項目チェック
			Map<String, Object> errInfoMap = JCRBatCommon.checkTrkmData(commonItem, dataList, errorRecordCount, chgCRWord);
			existError = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
			if (existError)
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
			}
		}

		resMap.put(KEY_EXIST_ERROR, existError);						// エラー有無
		resMap.put(KEY_EXIST_KOUMOKUSU_ERROR, existKoumokusuError);		// 項目数エラー有無
		resMap.put(KEY_LOG_DATA, logData.toString());					// ログ用データ

		return resMap;
	}
	
	/**
	 * 問合せ履歴条件チェック
	 * @param dataList 1行分のデータ
	 * @param checkJokenList チェック条件リスト
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 * */
	private Map<String, Object> checkToiawaseJoken(List<String> dataList, List<JBSbatCommonDBInterface> checkJokenList,
			int errorRecordCount) throws Exception
	{
	
		Map<String, Object> resultMap = new HashMap<String, Object>();

		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納
		boolean existError = false;					// エラーフラグ

		
		// チェック条件リストから一行読込む
		for(int i = 0; i < checkJokenList.size(); i++)
		{
			JBSbatCommonDBInterface checkJokenData = checkJokenList.get(i);
			Map<String, Object> errInfoMap = checkJoken(dataList, checkJokenData, errorRecordCount);
			
			if ((Boolean)errInfoMap.get(KEY_EXIST_ERROR))
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
				existError = true;
			}
		}
		
		resultMap.put(KEY_EXIST_ERROR, existError);					// エラー有無
		resultMap.put(KEY_LOG_DATA, logData.toString());			// ログ用データ

		return resultMap;
	}

	/**
	 * 問合せ履歴条件チェック
	 * @param dataList 1行分のデータ
	 * @param checkJoken チェック条件データ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 * */
	private Map<String, Object> checkJoken(List<String> dataList, JBSbatCommonDBInterface checkJoken,
			int errorRecordCount) throws Exception
	{
		// チェック項目名、チェック条件項目番号、チェック値、チェック条件コード、チェック対象データ最大件数をMapから取得
		String jokenKmkName = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NM);
		String jokenKmkNo = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NO);
		String jokenValue = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_VALUE);
		String jokenCd = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_CD);

		// 問合せ履歴データからチェック対象項目を求める。(リストの添え字を示すため-1を行う)
		int koumokuNo = Integer.parseInt(jokenKmkNo) - 1;

		// 問合せ履歴情報リストから一行読込む
		String targetData = "";
		if (koumokuNo < dataList.size())
		{
			targetData = dataList.get(koumokuNo);
		}
		super.logPrint.printDebugLog("条件項目No." + (koumokuNo + 1) + " は、条件項目「" + jokenKmkName  + "」です。");
		Map<String, Object> resultMap = checkJokenMain(targetData, errorRecordCount, jokenValue, jokenCd, jokenKmkName);

		return resultMap;
	}

	/**
	 * 問合せ履歴条件チェック
	 * @param targetData チェック対象データ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param jokenValue チェック条件値
	 * @param jokenCd チェック条件コード
	 * @param jokenKmkName チェック条件項目名
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 * */
	private Map<String, Object> checkJokenMain(String targetData, int errorRecordCount,
			String jokenValue, String jokenCd, String jokenKmkName) throws Exception
	{
		Map<String, Object> resultMap = new HashMap<String, Object>();
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納
		boolean existError = false;					// エラーフラグ

		// チェック条件コードごとに問合せ履歴データをチェックする。
		if(JOKEN_CD_HITOSHII.equals(jokenCd))
		{
			if(!targetData.equals(jokenValue))
			{
				// 対象文字がチェック値と等しくない場合
				existError = true;
				
				// ECRB0190KW %1%の内容が正しくありません。（%2%）
				String[] chikanMoji = {jokenKmkName, jokenKmkName + "が\'" + jokenValue + "\'と等しくありません。　値：\'" + targetData + "\'"};

				// 行数指定が無い場合
				if(errorRecordCount == 0)
				{
					logData.append(setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
	
				// 行数指定が有る場合
				else
				{
					logData.append(setErrMsg(errorRecordCount, JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
			}
			else
			{
				// ログ表示
				String chikanMoji = "チェック条件判定 OK:" +  jokenKmkName + "が\'" + jokenValue + "\'と等しい。　値：\'" + targetData + "\'";
				super.logPrint.printDebugLog(chikanMoji);
				
			}
		}
		else if(JOKEN_CD_START.equals(jokenCd))
		{
			if(!targetData.startsWith(jokenValue))
			{
				existError = true;

				// 対象文字がチェック値で開始しないもの
				// ECRB0190KW %1%の内容が正しくありません。（%2%）
				String[] chikanMoji = {jokenKmkName, jokenKmkName + "が\'" + jokenValue + "\'で始まりません。　値：\'" + targetData + "\'"};

				// 行数指定が無い場合
				if(errorRecordCount == 0)
				{
					logData.append(setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
				// 行数指定が有る場合
				else
				{
					logData.append(setErrMsg(errorRecordCount, JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
			}
			else
			{
				// ログ表示
				String chikanMoji = "チェック条件判定 OK:" +  jokenKmkName + "が\'" + jokenValue + "\'で始まる。　値：\'" + targetData + "\'";
				super.logPrint.printDebugLog(chikanMoji);
				
			}

		}
		else if(JOKEN_CD_END.equals(jokenCd))
		{
			if(!targetData.endsWith(jokenValue))
			{
				// 対象文字がチェック値で終了しないもの
				existError = true;

				// ECRB0190KW %1%の内容が正しくありません。（%2%）
				String[] chikanMoji = {	jokenKmkName, jokenKmkName + "が\'" + jokenValue + "\'で終わりません。　値：\'" + targetData + "\'"};
				
				// 行数指定が無い場合
				if(errorRecordCount == 0)
				{
					logData.append(setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
				// 行数指定が有る場合
				else
				{
					logData.append(setErrMsg(errorRecordCount, JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
			}
			else
			{
				// ログ表示
				String chikanMoji = "チェック条件判定 OK:" +  jokenKmkName + "が\'" + jokenValue + "\'で終わる。　値：\'" + targetData + "\'";
				super.logPrint.printDebugLog(chikanMoji);
				
			}

		}
		else if(JOKEN_CD_HUKUMU.equals(jokenCd))
		{
			if(targetData.indexOf(jokenValue) == MOJIHIKAKU_HUKUMANAI)
			{
				// 対象文字がチェック値を含まない場合
				existError = true;

				// ECRB0190KW %1%の内容が正しくありません。（%2%）
				String[] chikanMoji = {jokenKmkName, jokenKmkName + "が\'" + jokenValue + "\'を含みません。　値：\'" + targetData + "\'"};
				// 行数指定が無い場合
				if(errorRecordCount == 0)
				{
					logData.append(setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
				// 行数指定が有る場合
				else
				{
					logData.append(setErrMsg(errorRecordCount, JPCBatchMessageConstant.ECRB0190KW, chikanMoji));
				}
			}
			else
			{
				// ログ表示
				String chikanMoji = "チェック条件判定 OK:" +  jokenKmkName + "が\'" + jokenValue + "\'を含む。　値：\'" + targetData + "\'";
				super.logPrint.printDebugLog(chikanMoji);
			}

		}
		// 戻り値を設定
		resultMap.put(KEY_EXIST_ERROR, existError);				// エラー有無
		resultMap.put(KEY_LOG_DATA, logData.toString());		// ログ用データ
		
		return resultMap;
	}

	/**
	 * 問合せ履歴ファイル名チェック
	 * @param dataCount 問合せ履歴行数
	 * @param checkJokenList チェック条件データ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 * */
	private Map<String, Object> checkToiawaseKensu(int dataCount, List<JBSbatCommonDBInterface>  checkJokenList) throws Exception
	{
		Map<String, Object> resultMap = new HashMap<String, Object>();
		boolean existError = false;					// エラーフラグ
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納
		int kensuuCountMin = 0;
		JBSbatCommonDBInterface checkJokenMin = null;

		
		// 件数リストの中でチェック値が最も小さい件数でチェックを実施する
		for(int i = 0; i < checkJokenList.size(); i++)
		{
			JBSbatCommonDBInterface checkJoken = checkJokenList.get(i);
			
			String jokenMaxCnt = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_TG_DATA_MAX_CNT);

			int jokenCnt = Integer.parseInt(jokenMaxCnt);

			// 1件目はチェック値を格納
			if(i == 0)
			{
				kensuuCountMin = jokenCnt;
				checkJokenMin = checkJoken;
			}
			else
			{
				// 2件目以降はチェック値の大きさ比較
				if(kensuuCountMin > jokenCnt)
				{
					kensuuCountMin = jokenCnt;
					checkJokenMin = checkJoken;
				}

			}
		}
		
		// 項目名を取得
		String jokenKmkName = checkJokenMin.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NM);
		// 問合せ履歴データの件数とチェック条件の件数を比較
		if(dataCount  > kensuuCountMin)
		{
			super.logPrint.printDebugLog("件数チェック(条件：" + kensuuCountMin + " 以下  件数：" + dataCount + ")");

			// ECRB0190KW %1%の内容が正しくありません。（%2%）

			String[] chikanMoji = {jokenKmkName, jokenKmkName + "が\'" + kensuuCountMin + "\'以下ではありません。　件数：\'" + dataCount + "\'件"};
			logData.append(setErrMsg(JPCBatchMessageConstant.ECRB0190KW, chikanMoji));

			existError = true;
		}
		else
		{
			// ログ表示
			String chikanMoji = "チェック条件判定 OK:" +  jokenKmkName + "が\'" + kensuuCountMin + "\'以下です。　件数：\'" + dataCount + "\'件";

			super.logPrint.printDebugLog(chikanMoji);
		}
		
		resultMap.put(KEY_EXIST_ERROR, existError);					// エラー有無
		resultMap.put(KEY_LOG_DATA, logData.toString());			// ログ用データ

		return resultMap;
	}

	
	/**
	 * 問合せ履歴ファイル名チェック
	 * @param fileName 問合せ履歴ファイル名
	 * @param checkJokenList チェック条件リスト
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 * */
	private Map<String, Object> checkFileName(String fileName, List<JBSbatCommonDBInterface> checkJokenList) throws Exception
	{
		Map<String, Object> resultMap = new HashMap<String, Object>();
		boolean existError = false;					// エラーフラグ
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納

		for(int i = 0; i < checkJokenList.size(); i++)
		{
			JBSbatCommonDBInterface checkJoken = checkJokenList.get(i);

			// チェック値、チェック条件コードをMapから取得
			String jokenValue = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_VALUE);
			String jokenCd = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_CD);
			String jokenKmkName = checkJoken.getString(JBSbatCR_M_TIOKR_TRKM_CKJK.CHK_JOKEN_KMK_NM);
	
			Map<String, Object> errInfoMap = checkJokenMain(fileName, 0, jokenValue, jokenCd, jokenKmkName);
			
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			if((Boolean)errInfoMap.get(KEY_EXIST_ERROR))
			{
				existError = true;
			}
		}

		resultMap.put(KEY_EXIST_ERROR, existError);				// エラー有無
		resultMap.put(KEY_LOG_DATA, logData.toString());		// ログ用データ
		return resultMap;
	}

	/**
	 * ファイル名変更処理
	 * 拡張子を除いたファイル名に付随するログインIDとシステム日付(YYYYMMDD)を取り除いた
	 * ファイル名を返す処理
	 * @param fileName		問合せ履歴ファイル名
	 * @return 変換後ファイル名
	 * @throws Exception 例外
	 */
	private String convFileName(String fileName) throws Exception
	{
		// ファイル名の拡張子のみを抽出
		String kakuchoushi = fileName.substring(fileName.lastIndexOf("."), fileName.length());
		int sysDateIndex = fileName.lastIndexOf("_");

		// ファイル名のシステム日付を省いたものを抽出
		String workFileName = fileName.substring(0, sysDateIndex);
		
		int loginUserIndex = workFileName.lastIndexOf("_");

		// ファイル名のユーザーIDを省いたものと拡張子を結合
		String resultFileName = workFileName.substring(0, loginUserIndex) + kakuchoushi;
		return resultFileName;
	}
	
	/**
	 * ファイル出力
	 * @param toiawaseFilePath		問合せ履歴ファイルディレクトリ
	 * @param workGroupCd			業務個別設定組織コード
	 * @param dataList				問合せ履歴チェック対応データ
	 * @param henkanMoji			変換文字
	 * @return エラーファイル名
	 * @throws Exception 例外
	 */
	private void createFile(String toiawaseFilePath, String workGroupCd, List<String> dataList, String henkanMoji) throws Exception
	{

		// 問合せ履歴ファイル出力
		int count = createToiawaseFile(toiawaseFilePath, dataList, henkanMoji);
		
		// 件数ファイル出力
		createCountFile(toiawaseFilePath, count);

		// 業務個別設定組織コードの値がnullまたは空文字で無い場合、権限ファイルを作成
		if(workGroupCd != null && !"".equals(workGroupCd))
		{
			// 権限ファイル出力
			createAuthrityFile(toiawaseFilePath, workGroupCd);
		}
		
		// フラグファイル出力
		createFlgFile(toiawaseFilePath);
		
		return;
	}
	
	/**
	 * 問合せ履歴ファイル出力
	 * @param toiawaseFilePath		問合せ履歴ファイルディレクトリ
	 * @param dataList				問合せ履歴チェック対応データ
	 * @param henkanMoji			変換文字
	 * @return 問合せ出力行数
	 * @throws Exception 例外
	 */
	private int createToiawaseFile(String toiawaseFilePath, List<String> dataList, String henkanMoji) throws Exception
	{

		// 問合せ履歴ファイル作成
		JBSbatBusinessFileUtil toiawaseFileObj =
			JCRBatCommon.createBusinessFileUtil(toiawaseFilePath, JCRStrConst.MOJI_CD_MS932, JCRStrConst.KAIGYO_CD, "");

		try
		{
			super.logPrint.printDebugLog("問合せ履歴ファイル作成:" + toiawaseFilePath);
			// 出力データ作成
			for(int i = 0; i < dataList.size(); i++)
			{	
				// CSV一般化を戻す
				String toiawaseData =  dataList.get(i).replaceAll(henkanMoji, JCRStrConst.KAIGYO_CD);
				
				// 問合せ履歴ファイルに問合せ履歴データ書き込む
				JCRBatCommon.printBusinessFileUtil(toiawaseFileObj, toiawaseData);
			}
		}
		finally
		{
			// ファイルオブジェクトのクローズ
			JCRBatCommon.closeBusinessFileUtil(toiawaseFileObj);
			super.logPrint.printDebugLog("問合せ履歴ファイルオブジェクトクローズ処理実行");
		}

		return dataList.size();
	}

	/**
	 * 問合せ履歴件数ファイル出力
	 * @param toiawaseFilePath		問合せ履歴ファイルディレクトリ
	 * @param count					問合せ履歴件数
	 * @throws Exception 例外
	 */
	private void createCountFile(String toiawaseFilePath, int count) throws Exception
	{

		String toiawaseFileName = toiawaseFilePath;	

		// ファイル名の拡張子変更
		int index = toiawaseFileName.lastIndexOf(".");
		if (-1 < index)
		{
			toiawaseFileName = toiawaseFileName.substring(0, index);
		}
		String countFile = toiawaseFileName  + "_CNT.TXT";
		
		// 件数ファイル作成
		JBSbatBusinessFileUtil toiawaseFileObj =
			JCRBatCommon.createBusinessFileUtil(countFile, JCRStrConst.MOJI_CD_MS932, JCRStrConst.KAIGYO_CD, "");
		try
		{
			super.logPrint.printDebugLog("問合せ履歴件数ファイル作成:" + countFile);	
	
			JCRBatCommon.printBusinessFileUtil(toiawaseFileObj, Integer.toString(count));
		}
		finally
		{
			// ファイルオブジェクトのクローズ
			JCRBatCommon.closeBusinessFileUtil(toiawaseFileObj);
			super.logPrint.printDebugLog("問合せ履歴件数ファイルオブジェクトクローズ処理実行");
		}
		return;
	}
	
	/**
	 * 権限ファイル出力
	 * @param toiawaseFilePath		問合せ履歴ファイルディレクトリ
	 * @param workGroupCd			業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private void createAuthrityFile(String toiawaseFilePath, String workGroupCd) throws Exception
	{

		String toiawaseFileName = toiawaseFilePath;
		String outPutWorkGroupCd = "\"" + workGroupCd + "\"";

		// ファイル名の拡張子変更
		int index = toiawaseFileName.lastIndexOf(".");
		if (-1 < index)
		{
			toiawaseFileName = toiawaseFileName.substring(0, index);
		}
		String authrityFile = toiawaseFileName  + ".ATH";
		
		// 権限ファイル作成
		JBSbatBusinessFileUtil toiawaseFileObj =
			JCRBatCommon.createBusinessFileUtil(authrityFile, JCRStrConst.MOJI_CD_MS932, JCRStrConst.KAIGYO_CD, "");
		try
		{
			super.logPrint.printDebugLog("権限ファイル作成:" + authrityFile);	
			JCRBatCommon.printBusinessFileUtil(toiawaseFileObj, outPutWorkGroupCd);
		}
		finally
		{
			// ファイルオブジェクトのクローズ
			JCRBatCommon.closeBusinessFileUtil(toiawaseFileObj);
			super.logPrint.printDebugLog("権限ファイルオブジェクトクローズ処理実行");
		}
		return;
	}

	/**
	 * 問合せ履歴フラグファイル出力
	 * @param toiawaseFilePath		問合せ履歴ファイルディレクトリ
	 * @throws Exception 例外
	 */
	private void createFlgFile(String toiawaseFilePath) throws Exception
	{

		String toiawaseFileName = toiawaseFilePath;	

		// ファイル名の拡張子変更
		int index = toiawaseFileName.lastIndexOf(".");
		if (-1 < index)
		{
			toiawaseFileName = toiawaseFileName.substring(0, index);
		}
		String countFile = toiawaseFileName  + "_FTP.FLG";

		// フラグファイル作成
		JBSbatBusinessFileUtil toiawaseFileObj =
			JCRBatCommon.createBusinessFileUtil(countFile, JCRStrConst.MOJI_CD_MS932, JCRStrConst.KAIGYO_CD, "");
		try
		{
			super.logPrint.printDebugLog("問合せ履歴フラグファイル作成:" + countFile);
		}
		finally
		{
			// ファイルオブジェクトのクローズ
			JCRBatCommon.closeBusinessFileUtil(toiawaseFileObj);
			super.logPrint.printDebugLog("問合せ履歴フラグファイルオブジェクトクローズ処理実行");
		}

		return;
	}

	
	/**
	 * エラーファイル作成
	 * @param toiawaseFilePath	問合せ履歴ファイルディレクトリ
	 * @param errList	エラーリスト
	 * @return エラーファイル名
	 * @throws Exception 例外
	 */
	private String entryErrFile(String toiawaseFilePath, List<String> errList) throws Exception
	{
		String errFileName = toiawaseFilePath;
		
		// ファイル名の拡張子変更
		int index = toiawaseFilePath.lastIndexOf(".");
		if (-1 < index)
		{
			errFileName = toiawaseFilePath.substring(0, index);
		}
		errFileName = errFileName  + "_ERR.TXT";
		
		JCRBatCommon.entryErrFileData(commonItem, errFileName, errList);

		return errFileName;
	}
	
	/**
	 * エラーメッセージ作成処理(行数有り)
	 * @param line	エラー行数
	 * @param msgId		メッセージID
	 * @param chikanMoji	置換文字列
	 * @return エラーメッセージ
	 * @throws Exception 例外
	 */
	private String setErrMsg(int line, String msgId, String[] chikanMoji) throws Exception
	{

		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納
		
		// エラーメッセージ作成
		String lineMsg = line + "レコード目:";
		String errMsg = JBSbatLogPrintControl.getMessage(msgId, chikanMoji);

		super.logPrint.printBusinessErrorLog(msgId, chikanMoji);
		super.logPrint.printDebugLog(lineMsg + errMsg);
		logData.append(lineMsg);
		logData.append(errMsg);
		logData.append(JCRStrConst.KAIGYO_CD);

		return logData.toString();
	}
	
	/**
	 * エラーメッセージ作成処理(行数なし)
	 * @param msgId		メッセージID
	 * @param chikanMoji	置換文字列
	 * @return エラーメッセージ
	 * @throws Exception 例外
	 */
	private String setErrMsg(String msgId, String[] chikanMoji) throws Exception
	{
		StringBuilder logData = new StringBuilder();	// 取込処理ログファイル出力内容格納

		// エラーメッセージ作成
		String errMsg = JBSbatLogPrintControl.getMessage(msgId, chikanMoji);

		super.logPrint.printBusinessErrorLog(msgId, chikanMoji);
		super.logPrint.printDebugLog(errMsg);
		logData.append(errMsg);
		logData.append(JCRStrConst.KAIGYO_CD);
		
		return logData.toString();
	}

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

		// データアクセスオブジェクトクローズ
		JCRBatCommon.closeDataAccessObj(commonItem);

	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

}