/*********************************************************************
 *  All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *	システム名			：eo顧客基幹システム
 *	モジュール名		：JBSbatCRCtgrFileCheck
 *	ソースファイル名	：JBSbatCRCtgrFileCheck.java
 *	作成者				：富士通　
 *	作成日				：2011年04月08日
 *＜機能概要＞
 *　問合せカテゴリーファイルチェック処理部品です。
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00.00	2011/04/08   富士通		新規作成
 *********************************************************************/
package eo.business.service;

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_TAIORRK_BATCTRL;
import eo.business.util.table.JBSbatCR_M_TAIORRK_ML_ADBK;
import eo.business.util.table.JBSbatCR_T_CTGR_WK;
import eo.business.util.table.JBSbatCR_T_TORK_EFILE_KNRI;
import eo.common.constant.JCRStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JCRStringUtil;
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.JBSbatStringUtil;

/**
 * 問合せカテゴリーファイルチェック処理
 * <p>
 *<BR>
 * 
 * @author 富士通
 */
public class JBSbatCRCtgrFileCheck extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(対応履歴バッチ制御)*/
	private static final String D_TBL_NAME_CR_M_TAIORRK_BATCTRL = "CR_M_TAIORRK_BATCTRL";

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

	/** テーブル(カテゴリー)*/
	private static final String D_TBL_NAME_CR_M_CTGR = "CR_M_CTGR";

	/** テーブル(対応履歴メールアドレス帳)*/
	private static final String D_TBL_NAME_CR_M_TAIORRK_ML_ADBK = "CR_M_TAIORRK_ML_ADBK";

	/** テーブル(対応履歴電子ファイル管理)*/
	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_T_CTGR_WK = "CR_T_CTGR_WK";

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

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

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

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

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

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

	/** テーブルアクセスクラス(対応履歴バッチ制御)*/
	private JBSbatSQLAccess db_CR_M_TAIORRK_BATCTRL = null;

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

	/** テーブルアクセスクラス(カテゴリー)*/
	private JBSbatSQLAccess db_CR_M_CTGR = null;

	/** テーブルアクセスクラス(対応履歴メールアドレス帳)*/
	private JBSbatSQLAccess db_CR_M_TAIORRK_ML_ADBK = null;

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

	/** テーブルアクセスクラス(カテゴリーワーク)*/
	private JBSbatSQLAccess db_CR_T_CTGR_WK = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/** 処理日付格納用 */
	private String sysDateTime = "";

	/** 初期設定チェックエラー情報 */
	private Map<String, String> initialCheckErrMap = null;

	/**
	 * 対応履歴バッチ制御テーブル更新フラグ
	 * 処理前更新された場合:true
	 */
	private boolean updateBatCtl = false;

	/** メール本文非定型置換文字の最大文字数 */
	private static final int MAX_LENGTH_TEXT_HTK_CKAN_MOJI = 1800;

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

		// DBアクセスクラスを生成します
		db_CR_M_TAIORRK_BATCTRL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_M_TAIORRK_BATCTRL);
		db_ZM_M_WKKBT_ORG = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_WKKBT_ORG);
		db_CR_M_CTGR = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_M_CTGR);
		db_CR_M_TAIORRK_ML_ADBK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_M_TAIORRK_ML_ADBK);
		db_CR_T_TORK_EFILE_KNRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_T_TORK_EFILE_KNRI);
		db_CR_T_CTGR_WK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CR_T_CTGR_WK);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		db_CR_M_TAIORRK_BATCTRL = new JBSbatSQLAccess(commonItem,
				D_TBL_NAME_CR_M_TAIORRK_BATCTRL);

		// 初期処理開始
		// (1) 処理日時取得(共通部品)
		sysDateTime = JCRBatCommon.getSysDateTime();

		try
		{
			// 初期設定チェック処理
			initialCheckErrMap = initialCheck(commonItem);
		}
		catch (Exception e)
		{
			// ECRB0260KW:%1%処理中に予期せぬエラーが発生しました。　%2%
			String[] messageParams = new String[] {"問合せカテゴリーファイルチェック", e.toString()};
			initialCheckErrMap = setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0260KW, messageParams));
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0260KW, messageParams);
			super.logPrint.printDebugLog("例外発生:" + e.toString());
			super.logPrint.printDebugLog("　　　　:" + e.getMessage());
		}

		return;

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

	/**
	 * 初期設定チェック処理
	 * @param commonItem バッチ共通パラメータ電文
	 * @return エラー情報
	 * @throws Exception
	 */
	public Map<String, String> initialCheck(JBSbatCommonItem commonItem) throws Exception
	{
		// システムエラー用置換文字列
		String chikanMoji = "問合せカテゴリー一括更新待ち時間(分)";

		// (2) プロパティファイル情報取得(共通部品)
		// 問合せカテゴリー一括更新待ち時間(分)を取得する。
		String retryInterval = JCRBatCommon.getApplicationConst("CR_CTGR_UPD_WAIT_MIN");
		if (retryInterval == null  || "".equals(retryInterval.trim()))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			return setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {chikanMoji}));
		}

		// 問合せカテゴリー一括更新待ち時間(分)の数値チェック
		if(!JCRBatCommon.isHannkakuSuuji1(retryInterval))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			return setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {chikanMoji}));
		}

		// 問合せカテゴリー一括更新繰返し回数を取得する。
		chikanMoji = "問合せカテゴリー一括更新繰返し回数";
		String retryCount = JCRBatCommon.getApplicationConst("CR_CTGR_UPD_RETRY_COUNT");
		if (retryCount == null || "".equals(retryCount.trim()))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			return setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {chikanMoji}));
		}

		// 問合せカテゴリー一括更新繰返し回数の数値チェック
		if(!JCRBatCommon.isHannkakuSuuji1(retryCount))
		{
			// ECRB0010KW:プロパティーファイルの設定が正しくありません。(項目名:%1%)
			return setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0010KW, new String[] {chikanMoji}));
		}

		// (3) 重複起動チェック
		JBSbatCommonDBInterface batctrlInterface = new JBSbatCommonDBInterface();
		batctrlInterface.setValue(JBSbatCR_M_TAIORRK_BATCTRL.TAIORRK_BATCTRL_NO, JCRStrConst.BATCTRL_CTGR_CHK_START_DTM);

		// 対応履歴バッチ制御テーブルからバッチ制御値の取得を行う。
		JBSbatCommonDBInterface resultInterface = db_CR_M_TAIORRK_BATCTRL.selectByPrimaryKeys(batctrlInterface);

		// 問合せカテゴリー一括更新繰り返し回数をintに変換
		int batRetryCount = Integer.parseInt(retryCount);

		// 制御値がnullでない場合、問合せカテゴリー一括更新待ち時間(分)後に、再びバッチ制御値の取得を行う。
		if (resultInterface.getValue(JBSbatCR_M_TAIORRK_BATCTRL.BATCTRL_VALUE) != null)
		{
			long retryIntervalMiri = Long.parseLong(retryInterval);

			// スリープ処理のため、(分)から(ミリ秒)に変換
			retryIntervalMiri = retryIntervalMiri * JCRStrConst.CONV_MIRIBYO;

			for (int i = 0; i < batRetryCount + 1; i++)
			{
				// 対応履歴バッチ制御テーブルからバッチ制御値の取得を行う。		
				resultInterface = executeCR_M_TAIORRK_BATCTRL_PKSELECT(new String[] {JCRStrConst.BATCTRL_CTGR_CHK_START_DTM});

				if(resultInterface.getValue(JBSbatCR_M_TAIORRK_BATCTRL.BATCTRL_VALUE) == null)
				{
					// 制御値がnullの場合、2.主処理を行う。
					super.logPrint.printDebugLog("問合せカテゴリーファイルチェック処理を開始");
					break;
				}
				else if (i >= batRetryCount)
				{
					// 問合せカテゴリー一括更新繰り返し回数を超えた場合
					super.logPrint.printDebugLog("重複起動で一括更新繰り返し回数を超えたので処理を終了");

					// ECRB0070KW:問合せカテゴリー一括更新繰り返し回数の制限を超えました。
					return setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0070KW));
				}
				else
				{
					// 問合せカテゴリー一括更新待ち時間(分)処理を待つ
					super.logPrint.printDebugLog("別プロセスの問合せカテゴリーファイルチェック起動中");
					Thread.sleep(retryIntervalMiri);	
				}
			}
		}
		// 重複起動が無い場合
		super.logPrint.printDebugLog("重複起動が存在しないため、カテゴリーファイルチェック処理を実行");

		executeCR_M_TAIORRK_BATCTRL_PKUPDATE(new String[] {sysDateTime}, new String[] {JCRStrConst.BATCTRL_CTGR_CHK_START_DTM});

		// 顧客対応履歴情報制御テーブルの更新を行う。
		super.logPrint.printDebugLog("対応履歴バッチ制御テーブルのバッチ制御値を利用中更新");
		super.commit();
		updateBatCtl = true;

		return null;
	}

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

		/** ディレイド処理依頼情報 */
		HashMap<String, Object> shoriIraiInfo = null;

		/** カテゴリー反映年月日 */
		String ctgrHaneiDtm = "";

		/** CSVファイル内展開データ格納用 */
		List<List<String>> ctgrFileList = null;

		/** insert用データ格納用 */
		List<HashMap<String, Object>> instList = new ArrayList<HashMap<String, Object>>();

		/** エラーリスト格納用Map */
		Map<String, String> ctgrErrMap = new HashMap<String, String>();

		/** ディレイド処理結果コード */
		String shoriKekkaCd = "";

		try
		{
			// (1) ディレイド処理依頼確認
			//     (a) 共通部品のディレイド処理を利用し、処理依頼番号と処理対象ファイル名を取得する。
			ArrayList<HashMap<String, Object>> shoriIraiInfoList = JCRBatCommon.getShoriIraiInfo(commonItem, super.jobid);

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

			// (2) (1)で取得した処理依頼番号の件数分(3)〜(15)の処理を行う。取得した件数分すべて処理が終わったら、(16)の処理を行う。
			// エラー退避用リスト
			List<Map<String, String>> ctgrErrList = new ArrayList<Map<String, String>>();
			// 業務個別設定組織コード退避用
			String kijunWorkGroup = "";
			// 入力ファイルパス
			String fileName = "";
			// 入力ファイルパス
			String ctglfilePath = "";

			for (int i = 0; i < shoriIraiInfoList.size(); i++)
			{

				// 処理結果の初期化
				shoriKekkaCd = JCRStrConst.DLYD_SYSTEM_ERR;

				// エラー退避用リスト初期化
				ctgrErrList.clear();

				// 登録データ用リスト初期化
				instList.clear();

				// ディレイド1件分の情報を取得
				shoriIraiInfo = shoriIraiInfoList.get(i);

				// 処理依頼番号取得
				String shoriiraiNo = shoriIraiInfo.get(JBSbatCC_T_DLYD_TRN_REQ.DLYD_TRN_REQ_NO).toString();

				super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " 問合せカテゴリーチェック主処理開始");

				try
				{
					if (initialCheckErrMap != null && initialCheckErrMap.size() > 0)
					{
						// 初期設定チェック処理でエラーがある場合
						ctgrErrList.add(initialCheckErrMap);
					}

					// ディレイド処理依頼テーブルの電子ファイル管理NoのNullチェック
					if(!shoriIraiInfo.containsKey("INPUT_EFILE_KANRI_NO") || shoriIraiInfo.get("INPUT_EFILE_KANRI_NO") == null)
					{
						ctglfilePath = "";
					}
					else
					{
						// (3) カテゴリーファイルの取得と存在チェック
						ctglfilePath = JCRBatCommon.searchDenshiFile(commonItem, shoriIraiInfo.get("INPUT_EFILE_KANRI_NO").toString());
					}

					if(ctglfilePath == null || "".equals(ctglfilePath))
					{
						// ECRB0060KW:処理対象のファイルがありません。
						ctgrErrMap = setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0060KW));
						ctgrErrList.add(ctgrErrMap);
						shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
						super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0060KW);
					}
					else
					{
						// 対応履歴文書管理ファイルテーブルから名取得
						executeCR_T_TORK_EFILE_KNRI_CR_SELECT_002(new Object[]{JCRStrConst.CD_DIV_BUNSHO_SBT_CD_CTGR,
																				shoriIraiInfo.get("INPUT_EFILE_KANRI_NO").toString().trim()});
						fileName = db_CR_T_TORK_EFILE_KNRI.selectNext().getString(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM);

						if (ctgrErrList.size() == 0)
						{
							// 初期設定チェックでエラーがない場合

							super.logPrint.printDebugLog(fileName + " ファイルチェック");
							// カテゴリーファイルの展開を行うメソッドを呼び出す。
							ctgrFileList = eo.common.util.JCRUtilCommon.convCsvFiletoList(ctglfilePath);
							if(ctgrFileList == null || ctgrFileList.size() == 0)
							{
								// ECRB0130KW:問合せカテゴリーファイルのデータが取得できません。
								ctgrErrMap = setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0130KW));
								ctgrErrList.add(ctgrErrMap);
								shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
								super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0330KW, new String[]{fileName});
								super.logPrint.printDebugLog("カテゴリーファイル存在チェックエラー");
							}
							else
							{
								// (4) ファイルの1行目からカテゴリー反映年月日を取得
								List<String> ctgrLineList = ctgrFileList.get(0);
								ctgrHaneiDtm = ctgrLineList.get(0);

								// データ反映日が空白の場合
								if(ctgrHaneiDtm == null || "".equals(ctgrHaneiDtm))
								{
									// システム日付を設定する。
									ctgrHaneiDtm = sysDateTime.substring(0, 8);
								}
								if(!JCRBatCommon.isYearMonthDay1(ctgrHaneiDtm))
								{
									// ECRB0080KW:問合せカテゴリー反映日が取得できません。
									ctgrErrMap = setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0080KW));
									ctgrErrList.add(ctgrErrMap);
									shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
									// ECRB0280KW:問合せカテゴリー反映日が取得できません。（ファイル名:%1%）
									super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0280KW, new String[] {fileName});
								}
								// 正常なデータ反映日が取得できた場合
								// (5) カテゴリーファイルの内容を１行ずつ読み、全ての行を読むまで(5)〜(7)の処理繰り返しを行う。
								for(int j = 1; j < ctgrFileList.size(); j++)
								{
									ctgrLineList = ctgrFileList.get(j);

									// 項目チェックメソッドを呼出す。
									HashMap<String, Object> inputCtglLine = checkCtgrLine(ctgrLineList, Integer.toString(j), ctgrErrList, kijunWorkGroup, fileName);
									if(inputCtglLine == null || inputCtglLine.size() == 0)
									{
										shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
										// エラーが指定件数以上の場合は、登録処理を終了しエラーメールの送信を行う。
										if(ctgrErrList.size() >= JCRStrConst.TOIAWASE_CTGL_ERROR_COUNER)
										{
											return null;
										}
									}
									else
									{
										// エラーで無い場合、登録用リストに追加
										instList.add(inputCtglLine);
									}
								}
							}
							// (8) カテゴリーレベルチェック処理を呼出す
							if(ctgrErrList.size() == 0)
							{
								shoriKekkaCd = ctglLvCheck(instList, ctgrErrList, fileName, shoriKekkaCd);
							}

							// (10) (3)〜(8)の処理でエラーリストにエラー情報が格納されていない場合、(11)〜(15)の処理を行う。
							if(ctgrErrList.size() == 0)
							{
								shoriKekkaCd = insertCtglData(instList, ctgrHaneiDtm, ctgrErrList, fileName, shoriKekkaCd);
							}
						}
					}
					// システムエラー、業務エラーが存在しない場合
					if(ctgrErrList.isEmpty())
					{
						// ディレイド処理結果に正常を示す値を格納
						shoriKekkaCd = JCRStrConst.DLYD_OK;
					}
				}
				catch (JBSbatBusinessException ex)
				{
					// %1%処理中に予期せぬエラーが発生しました。　%2%
					ctgrErrMap = setErrorMap("0",
						JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0260KW, new String[] {"問合せカテゴリーファイルチェック", fileName}));
					ctgrErrList.add(ctgrErrMap);

					// システムエラーフラグを設定する
					shoriKekkaCd = JCRStrConst.DLYD_SYSTEM_ERR;
					super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo);
					super.logPrint.printDebugLog("システムエラー発生:" + ex.toString());
					super.logPrint.printDebugLog("　　　　　　　　　:" + ex.getMessage());
				}
				finally
				{
					// (14) コミット処理を行う。(エラーがない場合)
					if (ctgrErrList.isEmpty() && JCRStrConst.DLYD_OK.equals(shoriKekkaCd))
					{
						super.commit();
						super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " " + fileName + "ファイル コミット実行");
					}
					else
					{
						// ディレイド処理結果コードがシステムエラーでない場合
						if(!JCRStrConst.DLYD_SYSTEM_ERR.equals(shoriKekkaCd))
						{
							// ディレイド処理結果に業務エラーを示す値を格納
							shoriKekkaCd = JCRStrConst.DLYD_GYOMU_ERR;
						}

						// エラーが存在する場合はロールバック
						commonItem.getConnection().rollback();
						super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " " + fileName + "ファイル ロールバック実行");

						// 共通関数のメール送信処理を行う
						sendErrMail(ctgrErrList, fileName);
					}

					// (15) 処理済みテンポラリーファイル削除
					if (ctglfilePath != null && !"".equals(ctglfilePath))
					{
						int index = ctglfilePath.lastIndexOf(JCRStrConst.FILE_KUGIRI);
						String deleteDirPath = ctglfilePath;
						if (index > -1)
						{
							deleteDirPath = ctglfilePath.substring(0, index);
						}
						JCRUtilCommon.deleteDir(deleteDirPath);
					}

					// ディレイド処理依頼結果更新処理部品の呼出し
					JCRBatCommon.updateShoriIraiResult(commonItem, shoriiraiNo, shoriKekkaCd, null);
					super.commit();

					// デバッグ用メッセージ
					String shoriKekka = "";
					if(JCRStrConst.DLYD_OK.equals(shoriKekkaCd))
					{
						shoriKekka = "正常";
					}
					else if(JCRStrConst.DLYD_GYOMU_ERR.equals(shoriKekkaCd))
					{
						shoriKekka = "業務エラー";
					}
					else
					{
						shoriKekka = "システムエラー";

					}
					super.logPrint.printDebugLog("ディレイド処理依頼結果：" + shoriKekka);
					super.logPrint.printDebugLog("処理依頼番号：" + shoriiraiNo + " 問合せカテゴリーチェック主処理終了");
				}
			}
		}
		finally
		{
			if (updateBatCtl == true)
			{
				// (16) 重複起動チェック用データ更新 (対応履歴バッチ制御テーブルのバッチ使用中を解放する)
				// 対応履歴バッチ制御テーブルの値をNullで更新する。
				JBSbatCommonDBInterface where = new JBSbatCommonDBInterface();
				JBSbatCommonDBInterface updateVaule = new JBSbatCommonDBInterface();

				updateVaule.setValue(JBSbatCR_M_TAIORRK_BATCTRL.BATCTRL_VALUE, "");
				where.setValue(JBSbatCR_M_TAIORRK_BATCTRL.TAIORRK_BATCTRL_NO, JCRStrConst.BATCTRL_CTGR_CHK_START_DTM);
				db_CR_M_TAIORRK_BATCTRL.updateByPrimaryKeys(where, updateVaule);
				super.commit();
			}
			super.logPrint.printDebugLog("問合せカテゴリーファイルチェック処理を終了");
		}

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

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

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

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

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

		// DBアクセスを実行します
		db_CR_M_TAIORRK_BATCTRL.updateByPrimaryKeys(whereMap, setMap);
	}

	/**
	 * 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 executeZM_M_WKKBT_ORG_CR_SELECT_001(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_001);
	}

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

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

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

		// DBアクセスを実行します
		db_CR_M_CTGR.selectBySqlDefine(paramList, CR_M_CTGR_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_TAIORRK_ML_ADBK_CR_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

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

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

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

	/**
	 * カテゴリー項目チェック処理
	 * @param oneLineList カテゴリーファイル一行分のデータ
	 * @param line 処理行数
	 * @param ctgrErrList エラー退避用リスト
	 * @param kijunWorkGroup 基準業務個別設定組織コード
	 * @param fileName ファイル名
	 * @return HashMap<String, Object> 項目チェック済みカテゴリーデータ
	 * @throws Exception
	 */
	private HashMap<String, Object> checkCtgrLine(List<String> oneLineList, String line,
			List<Map<String, String>> ctgrErrList, String kijunWorkGroup, String fileName) throws Exception 
	{
		Map<String, String> ctgrErrMap = null;
		HashMap<String, Object> resultMap = new HashMap<String, Object>();

		String tempKijunWorkGroup = kijunWorkGroup;

		// 業務個別設定組織コード取得とチェック
		String workGroup = oneLineList.get(0);

		if(workGroup == null || "".equals(workGroup))
		{
			// ECRB0220KW:問合せカテゴリーファイルの%1%行目の業務個別設定組織コードが存在しません。
			ctgrErrMap = setErrorMap(line, JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0220KW, new String[]{line}));
			ctgrErrList.add(ctgrErrMap);
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0350KW, new String[] {line, fileName});
			return null;
		}

		// (6) カテゴリーファイルの2行目の処理時、または業務個別設定組織コードが直前のデータと異なる場合
		// 業務個別設定組織チェックを実施する
		if(!kijunWorkGroup.equals(workGroup))
		{
			// 業務個別設定組織チェック(業務個別設定組織コードが業務個別設定組織テーブルに存在しない場合)
			executeZM_M_WKKBT_ORG_CR_SELECT_001(new Object[]{workGroup, sysDateTime, sysDateTime });
			String gyoumuSoshikiCount = db_ZM_M_WKKBT_ORG.selectNext().getString("CNT");
			if(gyoumuSoshikiCount == null || "".equals(gyoumuSoshikiCount) || "0".equals(gyoumuSoshikiCount))
			{
				// ECRB0290KW:問合せカテゴリーファイルの%1%行目の業務個別設定組織コード%2%が業務個別設定組織テーブルに存在しません。
				ctgrErrMap = setErrorMap(line, JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0090KW, new String[]{line, workGroup}));
				ctgrErrList.add(ctgrErrMap);
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0290KW, new String[] {line, workGroup, fileName});

				return null;
			}
			// 新しい業務個別設定組織コードを退避
			tempKijunWorkGroup = workGroup;

		}
		
		int ctgrWordCnt = 0;
		// カテゴリー項目チェック
		for (int i = 1; i < oneLineList.size(); i++)
		{
			// 各項目を取得
			String ctglData = oneLineList.get(i);

			// カテゴリー項目に値が格納されている場合のみ処理を行う。
			if (ctglData != null && !"".equals(ctglData))
			{

				// 一行の項目カウント
				if (1 <= ctgrWordCnt)
				{
					// 一行に項目が2つ以上存在する場合、エラーをリストに格納後、次の行の処理へ
					// ECRB0120KW:問合せカテゴリーファイルの%1%行目の項目が2つ以上存在します。
					ctgrErrMap = setErrorMap(line, JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0120KW, new String[]{line}));
					ctgrErrList.add(ctgrErrMap);
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0320KW, new String[] {line, fileName});
					return null;
				}

				// 桁数チェック
				else if(JCRStringUtil.getByteLength(ctglData) > 160)
				{
					// ECRB0110KW:問合せカテゴリーファイルの%1%行目の項目が160バイトを超えています。
					ctgrErrMap = setErrorMap(line, JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0110KW, new String[]{line}));
					ctgrErrList.add(ctgrErrMap);
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0310KW, new String[] {line, fileName});
					return null;

				}
				else
				{
					// カテゴリー項目として正しい場合
					resultMap.put(JBSbatCR_T_CTGR_WK.CTGR_NM, ctglData);
					resultMap.put(JBSbatCR_T_CTGR_WK.CTGR_LV, i);
					resultMap.put(JBSbatCR_T_CTGR_WK.WKKBT_ORG_CD, tempKijunWorkGroup);

					ctgrWordCnt++;
				}

			}
		}
		if(ctgrWordCnt == 0)
		{
			// 業務個別組織設定コードがあり、かつ、カテゴリー項目も存在しない場合は、空行としてDBに登録するため有効とする。
			resultMap.put(JBSbatCR_T_CTGR_WK.CTGR_NM, " ");
			resultMap.put(JBSbatCR_T_CTGR_WK.CTGR_LV, 0);
			resultMap.put(JBSbatCR_T_CTGR_WK.WKKBT_ORG_CD, tempKijunWorkGroup);
		}

		return resultMap;
	}

	/**
	 * カテゴリワークデータ登録処理
	 * @param instList カテゴリーファイルデータ
	 * @param ctgrHaneiDtm カテゴリー反映日
	 * @param ctgrErrList エラー退避用リスト
	 * @param fileName ファイル名
	 * @param shoriKekkaCd ディレイド処理結果コード
	 * @return String ディレイド処理結果コード
	 * @throws Exception 例外
	 */
	private String insertCtglData(List<HashMap<String, Object>> instList,
									String ctgrHaneiDtm,
									List<Map<String, String>> ctgrErrList,
									String fileName,
									String shoriKekkaCd) throws Exception
	{
		HashMap<String, Object> jouiCtgr = new HashMap<String, Object>();
		HashMap<String, Integer> ctglDspJun = new HashMap<String, Integer>();
		String kijunWorkGroup = "";
		int workCtgrLv = 0;
		int intDspJun = 0;

		// 上位カテゴリー番号と、それに紐付くカテゴリー名を格納
		Map<String, List<String>> ctgrNmMap = new HashMap<String, List<String>>();

		// ファイルの行数分処理を行う。
		for (int i = 0; i < instList.size(); i++)
		{
			// カテゴリーワークテーブルに利用するDBアクセス共通インターフェース
			JBSbatCommonDBInterface insertCtglMap = new JBSbatCommonDBInterface();

			HashMap<String, Object> ctglWorkMap = instList.get(i);

			String workGroup = ctglWorkMap.get(JBSbatCR_T_CTGR_WK.WKKBT_ORG_CD).toString();
			int ctgrLv = ((Integer)ctglWorkMap.get(JBSbatCR_T_CTGR_WK.CTGR_LV)).intValue();

			// カテゴリーテーブルNoの採番
			String ctgrNo = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_CTGR_NO, "", 10);

			// カテゴリーテーブルNoを格納
			insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.CTGR_NO, ctgrNo);

			// カテゴリー名を格納
			insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.CTGR_NM, ctglWorkMap.get(JBSbatCR_T_CTGR_WK.CTGR_NM));

			// カテゴリーレベルを格納
			insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.CTGR_LV, JBSbatStringUtil.padNumFormString(Integer.toString(ctgrLv), 3));

			// 業務個別組織設定を格納
			insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.WKKBT_ORG_CD, workGroup);

			// 反映日を格納
			insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.CTGR_HANEI_DTM, ctgrHaneiDtm);

			// カテゴリーファイル2行目の処理時、または業務個別設定組織コードが直前のデータと異なる場合
			if (!kijunWorkGroup.equals(workGroup))
			{
				kijunWorkGroup = workGroup;
				// (11) カテゴリーワークテーブルデータの物理削除
				executeCR_T_CTGR_WK_CR_DELETE_001(new Object[] { workGroup });

				// デバッグログ出力
				super.logPrint.printDebugLog("同一「業務個別設定組織コード」のデータを物理削除：" + workGroup);

				String strDspJun = "";

				// 業務個別設定組織コードが変わる時レベルごとに退避した表示順を初期化する。
				ctglDspJun.clear();
				intDspJun = 1;

				// (12) カテゴリーレベル1の表示順序の取得SQL実行
				executeCR_M_CTGR_CR_SELECT_002(new Object[] { workGroup });
				JBSbatCommonDBInterface sqlResultInterface = db_CR_M_CTGR.selectNext();

				if(sqlResultInterface == null || "".equals(sqlResultInterface. getValue(JBSbatCR_T_CTGR_WK.DSP_JUN)))
				{
					// カテゴリーレベル1の最大表示順取得SQL実行
					executeCR_M_CTGR_CR_SELECT_001(new Object[] {});
					sqlResultInterface = db_CR_M_CTGR.selectNext();
					strDspJun = sqlResultInterface.getString(JBSbatCR_T_CTGR_WK.DSP_JUN);

					if(strDspJun == null || "".equals(strDspJun))
					{
						strDspJun = "1";
						// デバッグログ出力
						super.logPrint.printDebugLog("カテゴリーレベル1の表示順が存在しない");
					}
					else
					{
						// デバッグログ出力
						super.logPrint.printDebugLog("最大表示順取得 表示順：" + strDspJun);
					}
				}
				else
				{
					strDspJun = sqlResultInterface. getValue(JBSbatCR_T_CTGR_WK.DSP_JUN).toString();
					// デバッグログ出力
					super.logPrint.printDebugLog("表示順取得 表示順：" + strDspJun);

				}
				insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.DSP_JUN, Integer.parseInt(strDspJun));
				// 上位カテゴリーに業務個別設定組織コードを格納
				insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.JOI_CTGR_NO, workGroup);

				// 上位カテゴリー用にカテゴリーレベル1のカテゴリー番号を退避させる。
				jouiCtgr.put(JBSbatCR_T_CTGR_WK.CTGR_LV + "_" + ctgrLv, ctgrNo);

				// カテゴリーレベルチェック用カテゴリーレベル退避
				workCtgrLv = ctgrLv;
			}
			// (b) カテゴリーレベル2〜11の場合、退避した前のカテゴリー番号を上位カテゴリー番号に設定する。
			else
			{
				// 上位カテゴリーレベル退避時にすでに同一カテゴリーレベルが退避されている場合
				if (jouiCtgr.containsKey(JBSbatCR_T_CTGR_WK.CTGR_LV + "_" + ctgrLv))
				{
					// 同一カテゴリーNoを削除
					jouiCtgr.remove(JBSbatCR_T_CTGR_WK.CTGR_LV + "_" + ctgrLv);
				}

				// カテゴリーレベルごとに表示順を退避
				if(ctglDspJun.containsKey(Integer.toString(ctgrLv)))
				{
					// 直前行のカテゴリーレベルと同じ場合、カテゴリー表示順に+1をしたものを格納する。
					intDspJun = ((Integer)ctglDspJun.get(Integer.toString(ctgrLv))).intValue();
					intDspJun++;

					if (workCtgrLv < ctgrLv)
					{
						intDspJun = 1;	// 直前のレベルが現在のレベルより上位(小さい)の場合表示順リセット
					}
					// 同じカテゴリーレベルの表示順データが格納されている場合は削除を行い、新しい表示順を格納する。
					ctglDspJun.remove(Integer.toString(ctgrLv));
					ctglDspJun.put(Integer.toString(ctgrLv), intDspJun);
				}
				else
				{
					intDspJun = 1;	// レベル単位で1件目の場合
					ctglDspJun.put(Integer.toString(ctgrLv), intDspJun);
				}

				// 表示順を格納
				insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.DSP_JUN, intDspJun);

				// 上位カテゴリー番号カテゴリー番号を格納
				insertCtglMap.setValue(JBSbatCR_T_CTGR_WK.JOI_CTGR_NO, jouiCtgr.get(JBSbatCR_T_CTGR_WK.CTGR_LV + "_" + (ctgrLv - 1)));

				// 上位カテゴリー番号を設定するために直前行のカテゴリー番号を退避する。
				jouiCtgr.put(JBSbatCR_T_CTGR_WK.CTGR_LV + "_" + ctgrLv, ctgrNo);

				// 上位カテゴリーレベルを取得するため直前のカテゴリー番号を退避する。
				workCtgrLv = ctgrLv;
			}

			// カテゴリー名重複チェック
			String joiCtgrNo = insertCtglMap.getString(JBSbatCR_T_CTGR_WK.JOI_CTGR_NO);		// 上位カテゴリー番号
			String ctgrNm = insertCtglMap.getString(JBSbatCR_T_CTGR_WK.CTGR_NM);			// カテゴリー名
			List<String> ctgrNmList = ctgrNmMap.get(joiCtgrNo);
			if (ctgrNmList == null)
			{
				ctgrNmList = new ArrayList<String>();
				ctgrNmList.add(ctgrNm);
			}
			else
			{
				if (ctgrNmList.contains(ctgrNm))
				{
					// 上位カテゴリーが同じで、カテゴリー名が同じデータが既に存在する場合

					// ECRB0190KW	%1%の内容が正しくありません。（%2%）	1	1	0
					String message = "問合せカテゴリーファイルの" + Integer.toString(i + 1) + "行目のカテゴリー名";
					Map<String, String> ctgrErrMap = setErrorMap(Integer.toString(i + 1),
							JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0190KW, new String[]{message, "カテゴリー名重複"}));
					ctgrErrList.add(ctgrErrMap);
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0190KW,  new String[]{message, "カテゴリー名重複）（ファイル名:" + fileName});
					return JCRStrConst.DLYD_GYOMU_ERR;
				}
				else
				{
					ctgrNmList.add(ctgrNm);
				}
			}
			ctgrNmMap.put(joiCtgrNo, ctgrNmList);

			// 退避されているエラー情報がない場合カテゴリーテーブルに登録を行う。
			if(ctgrErrList.size() == 0)
			{
				// (13) カテゴリーワークテーブル登録
				// カテゴリーワーク登録SQL実行
				db_CR_T_CTGR_WK.insertByPrimaryKeys(insertCtglMap);
				super.logPrint.printDebugLog("カテゴリーワークテーブル " + (i + 1) + " 行目登録：" + insertCtglMap.getString(JBSbatCR_T_CTGR_WK.CTGR_NM));
			}
		}
		return shoriKekkaCd;
	}

	/**
	 * エラーメール送信処理<br>
	 * @param ctgrErrList エラー退避用リスト
	 * @param fileName 	カテゴリーファイル名
	 * @throws Exception
	 *             業務サービス内で発生した例外全般。
	 */
	private void sendErrMail(List<Map<String, String>> ctgrErrList, String fileName) throws Exception
	{
		HashMap<String, Object> sendMailMap = new HashMap<String, Object>();

		// メールに必要な情報

		// 送信パターンに「ディレイド」を設定
		sendMailMap.put("MAIL_SEND_PATTERN_CD", "02");
		// 送信予定年月日時分秒
		sendMailMap.put("MAIL_SEND_RSV_DTM", JCRBatCommon.getSysDateTimeStamp());

		// 送信元(FROM)メールアドレス取得
		executeCR_M_TAIORRK_ML_ADBK_CR_SELECT_001(new Object[] { JCRStrConst.CD_DIV_CTGR_ERR_MAIL_FROM_ADDRESS });
		List<JBSbatCommonDBInterface> fromAddressList = JCRBatCommon.getSelectedDataList(db_CR_M_TAIORRK_ML_ADBK);
		if (fromAddressList != null && fromAddressList.size() > 0)
		{
			String fromAddress = fromAddressList.get(0).getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD);
			String fromAddressNm = fromAddressList.get(0).getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD_NM);
			// 送信元(FROM)メールアドレスを設定
			sendMailMap.put("MLAD_FROM", fromAddress);
			sendMailMap.put("MLAD_FROM_NM", fromAddressNm);
		}

		// 送信先(TO)メールアドレス取得
		executeCR_M_TAIORRK_ML_ADBK_CR_SELECT_001(new Object[] { JCRStrConst.CD_DIV_CTGR_ERR_MAIL_TO_ADDRESS });
		List<JBSbatCommonDBInterface> toAddressList = JCRBatCommon.getSelectedDataList(db_CR_M_TAIORRK_ML_ADBK);
		if(toAddressList == null)
		{
			// ECRB0270KW:エラーメール送信先メールアドレスが取得できません。
			Map<String, String> ctgrErrMap = setErrorMap("0" , JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0270KW));
			ctgrErrList.add(ctgrErrMap);

			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0270KW);
			return;
		}
		String[] toAddress = new String[toAddressList.size()];
		String[] toAddressNm = new String[toAddressList.size()];
		for (int i = 0; i < toAddressList.size(); i++)
		{
			toAddress[i] = toAddressList.get(i).getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD);
			toAddressNm[i] = toAddressList.get(i).getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD_NM);
		}

		// 送信先メールアドレスを設定
		sendMailMap.put("MLAD_TO", toAddress);
		sendMailMap.put("MLAD_TO_NM", toAddressNm);
		String errFileNameMessage = "";
		StringBuilder textCkanMoji = new StringBuilder("");

		// ファイルパスがnullでない場合
		if(fileName != null && !"".equals(fileName))
		{
			// ファイル名を表示するためのメッセージを作成。
			errFileNameMessage = "ファイル名： " + fileName + JCRStrConst.KAIGYO_CD;
		}

		// メールの非定形置換文字作成
		// エラーが指定件数より少ない場合
		if (JCRStrConst.TOIAWASE_CTGL_ERROR_COUNER > ctgrErrList.size())
		{
			textCkanMoji.append("カテゴリーの一括更新用のデータファイルに以下のエラーを検知しました。");
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);
			textCkanMoji.append(errFileNameMessage);
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);

			for (int i = 0; i < ctgrErrList.size(); i++)
			{
				Map<String, String> errMap = ctgrErrList.get(i);
				if(errMap.containsKey("CTGR_ERR_GYOUSU"))
				{
					textCkanMoji.append(errMap.get("CTGR_ERR_GYOUSU"));
					textCkanMoji.append(" 行目" + JCRStrConst.KAIGYO_CD);
				}
				textCkanMoji.append("エラー内容： " + errMap.get("CTGR_ERR_DATA"));
				textCkanMoji.append(JCRStrConst.KAIGYO_CD);

				if (textCkanMoji.length() > MAX_LENGTH_TEXT_HTK_CKAN_MOJI)
				{
					break;
				}
			}
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);
			textCkanMoji.append("ご確認お願い致します。");
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);
		}
		else
		{
			// エラーが指定件数以上の場合
			textCkanMoji.append("カテゴリーの一括更新用のデータファイルに、" + JCRStrConst.TOIAWASE_CTGL_ERROR_COUNER + "件を超えるエラーを検知しました。");
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);
			textCkanMoji.append(errFileNameMessage);
			textCkanMoji.append(JCRStrConst.KAIGYO_CD);
		}
		// 定型文のメールコード
		sendMailMap.put("MAIL_CD", JCRBatCommon.getApplicationConst("CR_MAIL_CD_CTGR_ERR"));

		// 非定形置換文字
		sendMailMap.put("TEXT_HTK_CKAN_MOJI", new String[] { textCkanMoji.toString() });

		// 共通部品メール送信処理
		JCRBatCommon.insertTMailSend(commonItem, sendMailMap);

		return;
	}

	/**
	 * カテゴリーレベルチェック<br>
	 * @param checkCtglList カテゴリーレベルチェック対象リスト
	 * @param ctgrErrList エラー退避用リスト
	 * @param fileName ファイルパス
	 * @param shoriKekkaCd ディレイド処理結果コード
	 * @return String ディレイド処理結果コード
	 * @throws Exception 例外
	 */
	private String ctglLvCheck(List<HashMap<String, Object>> checkCtglList, List<Map<String, String>> ctgrErrList,
														String fileName, String shoriKekkaCd) throws Exception
	{
		int workCtgrLv = 1;
		String kijunWorkGroup = "";

		// カテゴリーレベルチェック
		for(int i = 0; i < checkCtglList.size(); i++)
		{
			HashMap<String, Object> ctglLine = checkCtglList.get(i);
			int ctgrLv = ((Integer)ctglLine.get(JBSbatCR_T_CTGR_WK.CTGR_LV)).intValue();

			// カテゴリーレベル0のデータは空行なのでチェック対象外。
			if(ctgrLv != 0)
			{
				String workGroup = ctglLine.get(JBSbatCR_T_CTGR_WK.WKKBT_ORG_CD).toString();
				// 業務個別設定組織が前行と違う場合
				if (workGroup != null && !kijunWorkGroup.equals(workGroup) && ctgrLv != 1)
				{
					// カテゴリーレベルが1以外の場合はエラー
					// ECRB0140KW:問合せカテゴリーファイルの%1%行目のカテゴリーレベルが正しくありません。
					Map<String, String> ctgrErrMap = setErrorMap(Integer.toString(i + 1),
							JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0140KW, new String[]{Integer.toString(i + 1)}));
					ctgrErrList.add(ctgrErrMap);
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0340KW,  new String[]{Integer.toString(i + 1), fileName});
					return JCRStrConst.DLYD_GYOMU_ERR;
				}

				if(workCtgrLv + 1 < ctgrLv)
				{
					// カテゴリーレベルエラーの場合
					// ECRB0140KW:問合せカテゴリーファイルの%1%行目のカテゴリーレベルが正しくありません。
					Map<String, String> ctgrErrMap = setErrorMap(Integer.toString(i + 1),
							JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0140KW, new String[]{Integer.toString(i + 1)}));
					ctgrErrList.add(ctgrErrMap);
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECRB0340KW,  new String[]{Integer.toString(i + 1), fileName});
					return JCRStrConst.DLYD_GYOMU_ERR;
				}
				// 直前のカテゴリーレベルを退避
				workCtgrLv = ctgrLv;
				kijunWorkGroup = workGroup;
			}
		}
		return shoriKekkaCd;
	}

	/**
	 * エラーメッセージ格納<br>
	 * @param errGyou エラー行数
	 * @param errMessage エラーメッセージ
	 * @return Map<String, String> エラーメッセージ格納後のマップ
	 */
	private Map<String, String> setErrorMap(String errGyou, String errMessage)
	{
		Map<String, String> ctgrErrMap = new HashMap<String, String>();
		ctgrErrMap.put("CTGR_ERR_DATA", errMessage);

		// デバッグログを出力
		if(errGyou == null || "0".equals(errGyou))
		{
			// エラー行が指定されていない場合
			super.logPrint.printDebugLog(errMessage);
		}
		else
		{
			// エラー行が指定されている場合
			ctgrErrMap.put("CTGR_ERR_GYOUSU", errGyou);
			super.logPrint.printDebugLog(errGyou + "行目：" + errMessage);
		}

		return ctgrErrMap;
	}
}