/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JBSbatCRToiawaseShori
*	ソースファイル名：JBSbatCRToiawaseShori.java
*	作成者			：富士通
*	日付			：2011年03月25日
*＜機能概要＞
*	問合せ処理関連共通部品
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/03/25	富士通		新規作成
*	v6.00.00	2013/11/28	富士通		OM-2013-0004744対応
**********************************************************************/

package eo.business.common;

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.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import eo.business.util.table.JBSbatCC_T_TEMP_FILE;
import eo.business.util.table.JBSbatCR_M_KEYWORD;
import eo.business.util.table.JBSbatCR_M_TAIORRK_ML_ADBK;
import eo.business.util.table.JBSbatCR_T_CTGR_TOIAWSMNTW;
import eo.business.util.table.JBSbatCR_T_ESCL_TOIAWSMNTW;
import eo.business.util.table.JBSbatCR_T_MYBOX;
import eo.business.util.table.JBSbatCR_T_QBOX_TOIAWSMNTW;
import eo.business.util.table.JBSbatCR_T_QUE_BOX;
import eo.business.util.table.JBSbatCR_T_SYKK_TOIAWSMNTW;
import eo.business.util.table.JBSbatCR_T_TAIOKRK_DTL;
import eo.business.util.table.JBSbatCR_T_TAIOKRK_UCWK;
import eo.business.util.table.JBSbatCR_T_TAIOKRK_UW_CTGR;
import eo.business.util.table.JBSbatCR_T_TORK_EFILE_KNRI;
import eo.business.util.table.JBSbatCR_T_USER_TOIAWSMNTW;
import eo.business.util.table.JBSbatZM_M_SHYAKK;
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.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.util.JBSbatBusinessFileUtil;

/**
 * 問合せ処理<p>
 * <BR>
 * @author 富士通
 */
class JBSbatCRToiawaseShori
{

	/** テーブル(ユーザー別問合せモニタワーク)*/
	private static final String TBL_NAME_CR_T_USER_TOIAWSMNTW = "CR_T_USER_TOIAWSMNTW";

	/** テーブル(カテゴリー別問合せモニタワーク)*/
	private static final String TBL_NAME_CR_T_CTGR_TOIAWSMNTW = "CR_T_CTGR_TOIAWSMNTW";

	/** テーブル(集約局別問合せモニタワーク)*/
	private static final String TBL_NAME_CR_T_SYKK_TOIAWSMNTW = "CR_T_SYKK_TOIAWSMNTW";

	/** テーブル(キューBOX別問合せモニタワーク)*/
	private static final String TBL_NAME_CR_T_QBOX_TOIAWSMNTW = "CR_T_QBOX_TOIAWSMNTW";

	/** テーブル(エスカレーション先別問合せモニタワーク)*/
	private static final String TBL_NAME_CR_T_ESCL_TOIAWSMNTW = "CR_T_ESCL_TOIAWSMNTW";

	/** テーブル(対応記録内訳抽出ワーク)*/
	private static final String TBL_NAME_CR_T_TIOKR_UW_CST_WK = "CR_T_TIOKR_UW_CST_WK";

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

	/** テーブル(キューBOX)*/
	private static final String TBL_NAME_CR_T_QUE_BOX = "CR_T_QUE_BOX";

	/** テーブル(対応記録)*/
	private static final String TBL_NAME_CR_T_TAIO_KIROK = "CR_T_TAIO_KIROK";

	/** テーブル(対応記録明細)*/
	private static final String TBL_NAME_CR_T_TAIOKRK_DTL = "CR_T_TAIOKRK_DTL";

	/** テーブル(添付ファイル)*/
	private static final String TBL_NAME_CC_T_TEMP_FILE = "CC_T_TEMP_FILE";

	/** テーブル(対応履歴電子ファイル管理)*/
	private static final String TBL_NAME_CR_T_TORK_EFILE_KNRI = "CR_T_TORK_EFILE_KNRI";

	/** テーブル(対応記録内訳)*/
	private static final String TBL_NAME_CR_T_TAIOKRK_UCWK = "CR_T_TAIOKRK_UCWK";

	/** テーブル(対応記録内訳カテゴリー)*/
	private static final String TBL_NAME_CR_T_TAIOKRK_UW_CTGR = "CR_T_TAIOKRK_UW_CTGR";

	/** テーブル(資料送付)*/
	private static final String TBL_NAME_CR_T_ATICLE_SOHU = "CR_T_ATICLE_SOHU";

	/** テーブル(資料送付記録)*/
	private static final String TBL_NAME_CR_T_ATICLE_SOHU_KRK = "CR_T_ATICLE_SOHU_KRK";

	/** テーブル(キーワード)*/
	private static final String TBL_NAME_CR_M_KEYWORD = "CR_M_KEYWORD";

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

	/** テーブル(MYBOX)*/
	private static final String TBL_NAME_CR_T_MYBOX = "CR_T_MYBOX";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/** シーケンス番号の桁数 */
	private static final int SEQ_KETA = 10;

	/** データ種別コード 新規作成 */
	private static final String DATA_SBT_SHINKI = "1";

	/** データ種別コード NGワード */
	private static final String DATA_SBT_NGWORD = "3";

	/** メール送信パターン ディレイド02 */
	private static final String MAIL_SEND_PTN_DELAYD = "02";

	/** 件数取得キー */
	private static final String CNT = "CNT";

	/** 件数ファイル名の後部文字列 */
	private static final String CNT_FILE_POST_FIX = "_CNT.TXT";

	/** フラグファイル名の後部文字列 */
	private static final String FLG_FILE_POST_FIX = "_FTP.FLG";

	/** 権限ファイル名の後部文字列 */
	private static final String AUTHORITY_FILE_POST_FIX = ".ATH";

	/** 件数ファイル情報を取得するキー */
	static final String KEY_KENSU_FILE = "KEY_KENSU_FILE";

	/** フラグファイル情報を取得するキー */
	static final String KEY_FLAG_FILE = "KEY_FLAG_FILE";

	/** 権限ファイル情報を取得するキー */
	static final String KEY_AUTHORITY_FILE = "KEY_AUTHORITY_FILE";

	/** 対応記録内訳番号の初期値 */
	private static final String TAIO_KIROK_UCWK_NO_DEFAULT = "0000000001";

	/**
	 * 問合せモニターデータ登録
	 * 
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分
	 * @param taioKirokNo 対応記録番号
	 * @param userId ユーザーID
	 * @param userNm ユーザー名
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 * 
	 */
	static void entryTiawsMonitorData(JBSbatCommonItem commonItem,
										String shoriKubun,
										String taioKirokNo,
										String userId,
										String userNm,
										String gyomuKbtOrgCd) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("問合せモニターデータ登録");
		commonItem.getLogPrint().printDebugLog("　処理区分:" + shoriKubun);
		commonItem.getLogPrint().printDebugLog("　対応記録番号:" + taioKirokNo);
		commonItem.getLogPrint().printDebugLog("　ユーザーID:" + userId);
		commonItem.getLogPrint().printDebugLog("　ユーザー名:" + userNm);
		commonItem.getLogPrint().printDebugLog("　業務個別設定組織コード:" + gyomuKbtOrgCd);

		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// 対応記録番号、処理区分が空白でない場合

			String wkGyomuKbtOrgCd = gyomuKbtOrgCd;		// 業務個別設定組織コード(ワーク)
			if (wkGyomuKbtOrgCd == null || "".equals(wkGyomuKbtOrgCd))
			{
				wkGyomuKbtOrgCd = " ";
			}

			// NGワード登録済チェック
			if (DATA_SBT_NGWORD.equals(shoriKubun))
			{
				// 処理区分が３(NGワード)の場合
				if (isTourokuZumi(commonItem, taioKirokNo))
				{
					// 同じ対応記録番号でNGワードが既に登録されている場合、処理終了
					return;
				}
			}

			if (userId != null)
			{
				// ユーザーIDがnullでない場合

				String wkUserNm = userNm;					// ユーザー名(ワーク)
				if (wkUserNm == null || "".equals(wkUserNm))
				{
					wkUserNm = " ";
				}
				// ユーザー別問合せモニタワーク登録
				entryUSER_TOIAWSMNTW(commonItem, shoriKubun, taioKirokNo, userId, wkUserNm, wkGyomuKbtOrgCd);
			}

			if (DATA_SBT_SHINKI.equals(shoriKubun) || DATA_SBT_NGWORD.equals(shoriKubun))
			{
				// 処理区分が１(新規作成)か、３(NGワード)の場合

				// 集約局別問合せモニタワーク登録

				// 集約局取得
				String sykkCd = "";
				String sykkNm = "";
				Map<String, String> shuyakuKyokuInfo = getShuyakuKyoku(commonItem, taioKirokNo);
				if (shuyakuKyokuInfo != null && shuyakuKyokuInfo.size() >= 2)
				{
					sykkCd = shuyakuKyokuInfo.get(JBSbatZM_M_SHYAKK.SHYAKK_CD);
					sykkNm = shuyakuKyokuInfo.get(JBSbatZM_M_SHYAKK.SHYAKK_NM);

					// 集約局別問合せモニタワーク登録
					entrySYKK_TOIAWSMNTW(commonItem, shoriKubun, taioKirokNo, sykkCd, sykkNm, wkGyomuKbtOrgCd);
				}

				// カテゴリー別問合せモニタワーク登録
				entryCTGR_TOIAWSMNTW(commonItem, shoriKubun, taioKirokNo, wkGyomuKbtOrgCd);
			}
		}
	}

	/**
	 * ユーザー別問合せモニタワーク登録
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分
	 * @param taioKirokNo 対応記録番号
	 * @param userId ユーザーID
	 * @param userNm ユーザー名
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private static void entryUSER_TOIAWSMNTW(JBSbatCommonItem commonItem,
												String shoriKubun,
												String taioKirokNo,
												String userId,
												String userNm,
												String gyomuKbtOrgCd) throws Exception
	{
		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// 対応記録番号、処理区分が空白でない場合

			String wkUserId = userId;					// ユーザーID(ワーク)
			String wkUserNm = userNm;					// ユーザー名(ワーク)
			String wkGyomuKbtOrgCd = gyomuKbtOrgCd;		// 業務個別設定組織コード(ワーク)
			if (wkUserId == null || "".equals(wkUserId))
			{
				wkUserId = " ";
			}
			if (wkUserNm == null || "".equals(wkUserNm))
			{
				wkUserNm = " ";
			}
			if (wkGyomuKbtOrgCd == null || "".equals(wkGyomuKbtOrgCd))
			{
				wkGyomuKbtOrgCd = " ";
			}

			// ユーザー別問合せモニタワーク
			JBSbatSQLAccess db_CR_T_USER_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_USER_TOIAWSMNTW);

			JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

			// ユーザー別問合せモニタワーク番号
			String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_USER_TOIAWSMNTW_NO, "", SEQ_KETA);
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.USER_TOIAWSMNTW_NO, key);
			// 業務個別設定組織コード
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.WKKBT_ORG_CD, wkGyomuKbtOrgCd);
			// ユーザーID
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.USER_ID, wkUserId);
			// ユーザー名
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.USER_NM, wkUserNm);
			// 発生年月日
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.HASSEI_DTM, JCRBatCommon.getSysDateTime());
			// 対応記録番号
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.TAIO_KIROK_NO, taioKirokNo);
			// データ種別コード(1:新規作成、2:クローズ、3:NGワード)
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.DATA_SBT_CD, shoriKubun);
			// データ処理コード(0:未処理、1:処理済)
			inMap.setValue(JBSbatCR_T_USER_TOIAWSMNTW.DATA_TRN_CD, "0");

			// ◆ 登録
			int count = db_CR_T_USER_TOIAWSMNTW.insertByPrimaryKeys(inMap);
			commonItem.getLogPrint().printDebugLog("[ユーザー別問合せモニタワーク] 登録件数:" + count);
		}
	}

	/**
	 * カテゴリー別問合せモニタワーク登録
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分
	 * @param taioKirokNo 対応記録番号
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private static void entryCTGR_TOIAWSMNTW(JBSbatCommonItem commonItem,
												String shoriKubun,
												String taioKirokNo,
												String gyomuKbtOrgCd) throws Exception
	{
		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// 対応記録番号、処理区分が空白でない場合

			String wkGyomuKbtOrgCd = gyomuKbtOrgCd;		// 業務個別設定組織コード(ワーク)
			if (wkGyomuKbtOrgCd == null || "".equals(wkGyomuKbtOrgCd))
			{
				wkGyomuKbtOrgCd = " ";
			}

			// 対応記録内訳カテゴリー
			JBSbatSQLAccess db_CR_T_TAIOKRK_UW_CTGR = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_UW_CTGR);

			// カテゴリー別問合せモニタワーク
			JBSbatSQLAccess db_CR_T_CTGR_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_CTGR_TOIAWSMNTW);

			// 対応記録内訳番号取得
			List<JBSbatCommonDBInterface> ucwkDataList = getTaioKirkUcwkNo(commonItem, taioKirokNo);

			if (ucwkDataList != null)
			{
				commonItem.getLogPrint().printDebugLog("対応記録内訳が存在する場合");

				for (int i = 0; i < ucwkDataList.size(); i++)
				{
					JBSbatCommonDBInterface ucwk = ucwkDataList.get(i);

					// 対応記録内訳のレコードが存在する場合

					String key = null;		// カテゴリー別問合せモニタワーク番号
					// 対応記録内訳番号
					String ucwkNo = ucwk.getString(JBSbatCR_T_TAIOKRK_UCWK.TAIO_KIROK_UCWK_NO);
					// 上位連結カテゴリー名
					StringBuilder joiRnktCtgrNm = new StringBuilder(16);

					// 対応記録内訳カテゴリー取得

					// バイント変数のリストを生成します
					JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
					paramList.setValue(taioKirokNo);
					paramList.setValue(ucwkNo);

					// DBアクセスを実行します
					db_CR_T_TAIOKRK_UW_CTGR.selectBySqlDefine(paramList, CR_T_UW_CTGR_SELECT_001);

					// 対応記録内訳カテゴリー1行分取得
					JBSbatCommonDBInterface ctgr = db_CR_T_TAIOKRK_UW_CTGR.selectNext();

					while (ctgr != null)
					{
						// 対応記録内訳カテゴリーのレコードが存在する場合

						// カテゴリーレベル
						String level = ctgr.getString(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIOKRK_UW_CTGR_LV);
						// カテゴリー名
						String name = ctgr.getString(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIOKRK_UW_CTGR_NM);

						JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

						// カテゴリー別問合せモニタワーク番号(シーケンスから取得)
						key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_CTGR_TOIAWSMNTW_NO, "", SEQ_KETA);
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.CTGR_TOIAWSMNTW_NO, key);

						// 上位連結カテゴリー名
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.JOI_RNKT_CTGR_NM, "".equals(joiRnktCtgrNm.toString()) ? wkGyomuKbtOrgCd: joiRnktCtgrNm.toString());
						// 業務個別設定組織コード
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.WKKBT_ORG_CD, wkGyomuKbtOrgCd);
						// カテゴリーレベル
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.CTGR_LV, level);
						// カテゴリー名
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.CTGR_NM, name);
						// 下位カテゴリー有無　※一旦1(有)をセット
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.KAI_CTGR_UM, "1");
						// 発生年月日
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.HASSEI_DTM, JCRBatCommon.getSysDateTime());
						// 対応記録番号
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.TAIO_KIROK_NO, taioKirokNo);
						// データ種別コード(1:新規作成、3:NGワード)
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.DATA_SBT_CD, shoriKubun);
						// データ処理コード(0:未処理、1:処理済)
						inMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.DATA_TRN_CD, "0");

						// カテゴリー別問合せモニタワーク登録
						int count = db_CR_T_CTGR_TOIAWSMNTW.insertByPrimaryKeys(inMap);
						commonItem.getLogPrint().printDebugLog("[カテゴリー別問合せモニタワーク] 登録件数:" + count);

						// 上位連結カテゴリー名
						// 各カテゴリー名を160バイト固定長で登録
						joiRnktCtgrNm.append(JCRUtilCommon.adjustCharSize(name, 160, true));

						ctgr = db_CR_T_TAIOKRK_UW_CTGR.selectNext();	// 対応記録内訳カテゴリー1行分取得
					}

					if (key != null)
					{
						// 1件でもカテゴリーがあった場合

						// 下位カテゴリー有無の更新

						JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
						whereMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.CTGR_TOIAWSMNTW_NO, key);

						JBSbatCommonDBInterface valueMap = new JBSbatCommonDBInterface();
						// 下位カテゴリー有無　※最後のレコードの下位カテゴリー有無を0(無)に更新
						valueMap.setValue(JBSbatCR_T_CTGR_TOIAWSMNTW.KAI_CTGR_UM, "0");

						// カテゴリー別問合せモニタワーク更新
						int count = db_CR_T_CTGR_TOIAWSMNTW.updateByPrimaryKeys(whereMap, valueMap);
						commonItem.getLogPrint().printDebugLog("[カテゴリー別問合せモニタワーク] 更新件数:" + count);
					}
				}
			}
		}
	}

	/**
	 * 集約局別問合せモニタワーク登録
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分
	 * @param taioKirokNo 対応記録番号
	 * @param sykkCd 集約局コード
	 * @param sykkNm 集約局名
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private static void entrySYKK_TOIAWSMNTW(JBSbatCommonItem commonItem,
												String shoriKubun,
												String taioKirokNo,
												String sykkCd,
												String sykkNm,
												String gyomuKbtOrgCd) throws Exception
	{
		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// 対応記録番号、処理区分が空白でない場合

			String wkSykkCd = sykkCd;					// 集約局コード(ワーク)
			String wkSykkNm = sykkNm;					// 集約局名(ワーク)
			String wkGyomuKbtOrgCd = gyomuKbtOrgCd;		// 業務個別設定組織コード(ワーク)
			if (wkSykkCd == null || "".equals(wkSykkCd))
			{
				wkSykkCd = " ";
			}
			if (wkSykkNm == null || "".equals(wkSykkNm))
			{
				wkSykkNm = " ";
			}
			if (wkGyomuKbtOrgCd == null || "".equals(wkGyomuKbtOrgCd))
			{
				wkGyomuKbtOrgCd = " ";
			}

			// 集約局別問合せモニタワーク
			JBSbatSQLAccess db_CR_T_SYKK_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_SYKK_TOIAWSMNTW);

			JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

			// 集約局別問合せモニタワーク番号
			String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_SYKK_TOIAWSMNTW_NO, "", SEQ_KETA);
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.SYKK_TOIAWSMNTW_NO, key);
			// 業務個別設定組織コード
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.WKKBT_ORG_CD, wkGyomuKbtOrgCd);
			// 集約局コード
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.SHYAKK_CD, wkSykkCd);
			// 集約局名
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.SHYAKK_NM, wkSykkNm);
			// 発生年月日
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.HASSEI_DTM, JCRBatCommon.getSysDateTime());
			// 対応記録番号
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.TAIO_KIROK_NO, taioKirokNo);
			// データ種別コード(1:新規作成、3:NGワード)
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.DATA_SBT_CD, shoriKubun);
			// データ処理コード(0:未処理、1:処理済)
			inMap.setValue(JBSbatCR_T_SYKK_TOIAWSMNTW.DATA_TRN_CD, "0");

			// ◆ 登録
			int count = db_CR_T_SYKK_TOIAWSMNTW.insertByPrimaryKeys(inMap);
			commonItem.getLogPrint().printDebugLog("[集約局別問合せモニタワーク] 登録件数:" + count);
		}
	}

	/**
	 * 対応記録内訳番号を取得する。
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getTaioKirkUcwkNo(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		// 対応記録内訳
		JBSbatSQLAccess db_CR_T_TAIOKRK_UCWK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_UCWK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		db_CR_T_TAIOKRK_UCWK.selectBySqlDefine(paramList, CR_T_TAIOKRK_UCWK_SELECT_001);

		List<JBSbatCommonDBInterface> ucwkDataList = JCRBatCommon.getSelectedDataList(db_CR_T_TAIOKRK_UCWK);

		return ucwkDataList;
	}

	/**
	 * NGワードデータの登録済チェック
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo バイント変数の値配列。
	 * @return チェック結果 登録済:true
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static boolean isTourokuZumi(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		// ユーザー別問合せモニタワーク検索
		JBSbatSQLAccess db_CR_T_USER_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_USER_TOIAWSMNTW);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);						// 対応記録番号
		paramList.setValue(JCRBatCommon.getSysDate());			// 発生日
		paramList.setValue(DATA_SBT_NGWORD);					// データ種別区分

		// DBアクセスを実行します
		db_CR_T_USER_TOIAWSMNTW.selectBySqlDefine(paramList, CR_T_USER_WK_SELECT_001);

		JBSbatCommonDBInterface selectedData = null;			// 取得結果
		selectedData = db_CR_T_USER_TOIAWSMNTW.selectNext();	// 1行分取得
		int count = 0;
		if (selectedData != null)
		{
			count = selectedData.getBigDecimal(CNT).intValue();	// (登録済)件数
		}

		boolean res = false;
		if (count > 0)
		{
			res = true;
		}

		return res;
	}

	/**
	 * 集約局情報を取得する
	 * @param commonItem バッチ共通情報
	 * @param taioKirokNo 対応記録番号
	 * @return 集約局情報Map
	 * 				JBSbatZM_M_SHYAKK.SHYAKK_CD：集約局コード
	 * 				JBSbatZM_M_SHYAKK.SHYAKK_NM：集約局名
	 * @throws Exception 例外
	 */
	private static Map<String, String> getShuyakuKyoku(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		Map<String, String> resMap = new HashMap<String, String>();

		// 対応記録番号から集約局検索
		JBSbatSQLAccess dbTaioKirok = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIO_KIROK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);					// 対応記録番号
		paramList.setValue(JCRBatCommon.getSysDate());		// 回線内訳使用開始年月日
		paramList.setValue(JCRBatCommon.getSysDate());		// 回線内訳使用終了年月日

		// DBアクセスを実行します
		dbTaioKirok.selectBySqlDefine(paramList, CR_T_TAIO_KIROK_CR_SELECT_005);

		JBSbatCommonDBInterface selectedData = null;		// 取得結果
		selectedData = dbTaioKirok.selectNext();			// 1行分取得
		if (selectedData != null)
		{
			String sykkCd = selectedData.getString(JBSbatZM_M_SHYAKK.SHYAKK_CD);	// 集約局コード
			String sykkNm = selectedData.getString(JBSbatZM_M_SHYAKK.SHYAKK_NM);	// 集約局名
			resMap.put(JBSbatZM_M_SHYAKK.SHYAKK_CD, sykkCd);
			resMap.put(JBSbatZM_M_SHYAKK.SHYAKK_NM, sykkNm);
		}

		return resMap;
	}

	/**
	 * 問合せキュー移動データ登録
	 * 
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分
	 * @param taioKirokNo 対応記録番号
	 * @param esclSkQueBoxNo エスカレーション「先」キューBOX番号
	 * @param esclMtWkKbtOrgCd エスカレーション「元」業務個別設定組織コード
	 * @param userId ユーザーID
	 * @throws Exception 例外
	 * 
	 */
	static void entryTiawsMontQueMvData(JBSbatCommonItem commonItem,
										String shoriKubun,
										String taioKirokNo,
										String esclSkQueBoxNo,
										String esclMtWkKbtOrgCd,
										String userId) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("問合せキュー移動データ登録");
		commonItem.getLogPrint().printDebugLog("　処理区分:" + shoriKubun);
		commonItem.getLogPrint().printDebugLog("　対応記録番号:" + taioKirokNo);
		commonItem.getLogPrint().printDebugLog("　エスカレーション「先」キューBOX番号:" + esclSkQueBoxNo);
		commonItem.getLogPrint().printDebugLog("　エスカレーション「元」業務個別設定組織コード:" + esclMtWkKbtOrgCd);
		commonItem.getLogPrint().printDebugLog("　ユーザーID:" + userId);

		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// キューBOX取得
			Map<String, String> queBoxMap = getQueBox(commonItem, esclSkQueBoxNo);

			// キューBOX名
			String queBoxNm = " ";
			// 業務個別設定組織コード(エスカレーション先)
			String esclSkWkKbtOrgCd = " ";

			if (queBoxMap != null && queBoxMap.size() > 0)
			{
				// キューBOX名
				queBoxNm = queBoxMap.get(JBSbatCR_T_QUE_BOX.QUE_BOX_NM);
				// 業務個別設定組織コード(エスカレーション先)
				esclSkWkKbtOrgCd = queBoxMap.get(JBSbatCR_T_QUE_BOX.WKKBT_ORG_CD);
			}

			// キューBOX別問合せモニタワーク登録
			entryQBOX_TOIAWSMNTW(commonItem,
								shoriKubun,
								taioKirokNo,
								esclSkQueBoxNo,
								queBoxNm,
								esclSkWkKbtOrgCd);

			if (JCRStrConst.DATA_SBT_CD_UKETSUKE.equals(shoriKubun))
			{
				// 処理区分が'6'(受付データ)の場合

				// エスカレーション先別問合せモニタワーク登録

				// エスカレーション先業務個別設定組織名取得
				// 業務個別設定組織
				JBSbatSQLAccess db_ZM_M_WKKBT_ORG = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_ZM_M_WKKBT_ORG);

				JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
				whereMap.setValue(JBSbatZM_M_WKKBT_ORG.WKKBT_ORG_CD, esclSkWkKbtOrgCd);
				JBSbatCommonDBInterface resultMap = db_ZM_M_WKKBT_ORG.selectByPrimaryKeys(whereMap);

				String esclSkWkKbtOrgNm = null;
				if (resultMap != null)
				{
					// エスカレーション先業務個別設定組織名
					esclSkWkKbtOrgNm = resultMap.getString(JBSbatZM_M_WKKBT_ORG.WKKBT_ORG_NM);
				}
				if (esclSkWkKbtOrgNm == null)
				{
					esclSkWkKbtOrgNm = " ";
				}
				// エスカレーション先別問合せモニタワーク登録
				entryESCL_TOIAWSMNTW(commonItem,
									taioKirokNo,
									esclMtWkKbtOrgCd,
									esclSkWkKbtOrgCd,
									esclSkWkKbtOrgNm,
									esclSkQueBoxNo,
									queBoxNm);
			}
		}
	}

	/**
	 * キューBOX情報を取得する。
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param esclSkQueBoxNo キューBOX番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static Map<String, String> getQueBox(JBSbatCommonItem commonItem, String esclSkQueBoxNo) throws Exception
	{
		Map<String, String> resMap = new HashMap<String, String>();

		// キューBOX
		JBSbatSQLAccess db_CR_T_QUE_BOX = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_QUE_BOX);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(esclSkQueBoxNo);

		// DBアクセスを実行します
		db_CR_T_QUE_BOX.selectBySqlDefine(paramList, CR_T_QUE_BOX_CR_SELECT_002);
		JBSbatCommonDBInterface queBox = db_CR_T_QUE_BOX.selectNext();	// 1行分取得

		if (queBox != null)
		{
			// キューBOX名
			String queBoxNm = queBox.getString(JBSbatCR_T_QUE_BOX.QUE_BOX_NM);
			// 業務個別設定組織コード(エスカレーション先)
			String wkKbtOrgCd = queBox.getString(JBSbatCR_T_QUE_BOX.WKKBT_ORG_CD);

			resMap.put(JBSbatCR_T_QUE_BOX.QUE_BOX_NM, queBoxNm);
			resMap.put(JBSbatCR_T_QUE_BOX.WKKBT_ORG_CD, wkKbtOrgCd);
		}

		return resMap;
	}

	/**
	 * キューBOX別問合せモニタワーク登録
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriKubun 処理区分(6:受付データ、7:アクセプトデータ)
	 * @param taioKirokNo 対応記録番号
	 * @param qBoxNo キューBOX番号
	 * @param qBoxNm キューBOX名
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private static void entryQBOX_TOIAWSMNTW(JBSbatCommonItem commonItem,
												String shoriKubun,
												String taioKirokNo,
												String qBoxNo,
												String qBoxNm,
												String gyomuKbtOrgCd) throws Exception
	{
		if (taioKirokNo != null && !("".equals(taioKirokNo.trim()))
			&& shoriKubun != null && !("".equals(shoriKubun.trim())))
		{
			// 対応記録番号、処理区分が空白でない場合

			String wkQBoxNo = qBoxNo;					// キューBOX番号(ワーク)
			String wkQBoxNm = qBoxNm;					// キューBOX名(ワーク)
			String wkGyomuKbtOrgCd = gyomuKbtOrgCd;		// 業務個別設定組織コード(ワーク)
			if (wkQBoxNo == null || "".equals(wkQBoxNo))
			{
				wkQBoxNo = " ";
			}
			if (wkQBoxNm == null || "".equals(wkQBoxNm))
			{
				wkQBoxNm = " ";
			}
			if (wkGyomuKbtOrgCd == null || "".equals(wkGyomuKbtOrgCd))
			{
				wkGyomuKbtOrgCd = " ";
			}

			// キューBOX別問合せモニタワーク
			JBSbatSQLAccess db_CR_T_QBOX_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_QBOX_TOIAWSMNTW);

			JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

			// キューBOX別問合せモニタワーク番号
			String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_QBOX_TOIAWSMNTW_NO, "", SEQ_KETA);
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.QBOX_TOIAWSMNTW_NO, key);
			// 業務個別設定組織コード
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.WKKBT_ORG_CD, wkGyomuKbtOrgCd);
			// QBOX番号
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.QUE_BOX_NO, wkQBoxNo);
			// QBOX名
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.QUE_BOX_NM, wkQBoxNm);
			// 発生年月日
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.HASSEI_DTM, JCRBatCommon.getSysDateTime());
			// 対応記録番号
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.TAIO_KIROK_NO, taioKirokNo);
			// データ種別コード(6:受付データ、7:アクセプトデータ)
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.DATA_SBT_CD, shoriKubun);
			// データ処理コード(0:未処理、1:処理済)
			inMap.setValue(JBSbatCR_T_QBOX_TOIAWSMNTW.DATA_TRN_CD, "0");

			// ◆ 登録
			int count = db_CR_T_QBOX_TOIAWSMNTW.insertByPrimaryKeys(inMap);
			commonItem.getLogPrint().printDebugLog("[キューBOX別問合せモニタワーク] 登録件数:" + count);
		}
	}

	/**
	 * エスカレーション先別問合せモニタワーク登録
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param esclMtWkKbtOrgCd エスカレーション元業務個別設定組織コード
	 * @param esclSkWkKbtOrgCd エスカレーション先業務個別設定組織コード
	 * @param esclSkWkKbtOrgNm エスカレーション先業務個別設定組織名
	 * @param qBoxNo エスカレーション先QBOX番号
	 * @param qBoxNm エスカレーション先QBOX名
	 * @throws Exception 例外
	 */
	private static void entryESCL_TOIAWSMNTW(JBSbatCommonItem commonItem,
												String taioKirokNo,
												String esclMtWkKbtOrgCd,
												String esclSkWkKbtOrgCd,
												String esclSkWkKbtOrgNm,
												String qBoxNo,
												String qBoxNm) throws Exception
	{
		if (taioKirokNo != null && !("".equals(taioKirokNo.trim())))
		{
			// 対応記録番号が空白でない場合

			String wkQBoxNo = qBoxNo;						// キューBOX番号(ワーク)
			String wkQBoxNm = qBoxNm;						// キューBOX名(ワーク)
			String wkEsclMtWkKbtOrgCd = esclMtWkKbtOrgCd;	// エスカレーション元業務個別設定組織コード(ワーク)
			String wkEsclSkWkKbtOrgCd = esclSkWkKbtOrgCd;	// エスカレーション先業務個別設定組織コード(ワーク)
			String wkEsclSkWkKbtOrgNm = esclSkWkKbtOrgNm;	// エスカレーション先業務個別設定組織名(ワーク)
			if (wkQBoxNo == null || "".equals(wkQBoxNo))
			{
				wkQBoxNo = " ";
			}
			if (wkQBoxNm == null || "".equals(wkQBoxNm))
			{
				wkQBoxNm = " ";
			}
			if (wkEsclMtWkKbtOrgCd == null || "".equals(wkEsclMtWkKbtOrgCd))
			{
				wkEsclMtWkKbtOrgCd = " ";
			}
			if (wkEsclSkWkKbtOrgCd == null || "".equals(wkEsclSkWkKbtOrgCd))
			{
				wkEsclSkWkKbtOrgCd = " ";
			}
			if (wkEsclSkWkKbtOrgNm == null || "".equals(wkEsclSkWkKbtOrgNm))
			{
				wkEsclSkWkKbtOrgNm = " ";
			}

			// エスカレーション先別問合せモニタワーク
			JBSbatSQLAccess db_CR_T_ESCL_TOIAWSMNTW = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_ESCL_TOIAWSMNTW);

			JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

			// エスカレーション先別問合せモニタワーク番号
			String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_ESCL_TOIAWSMNTW_NO, "", SEQ_KETA);
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCL_TOIAWSMNTW_NO, key);
			// エスカレーション元業務個別設定組織コード
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCLA_MOTO_WKSO_CD, wkEsclMtWkKbtOrgCd);
			// エスカレーション先業務個別設定組織コード
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCLA_SAKI_WKSO_CD, wkEsclSkWkKbtOrgCd);
			// エスカレーション先業務個別設定組織名
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCLA_SAKI_WKSO_NM, wkEsclSkWkKbtOrgNm);
			// エスカレーション先QBOX番号
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCLA_SAKI_QUE_BOX_NO, wkQBoxNo);
			// エスカレーション先QBOX名
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.ESCLA_SAKI_QUE_BOX_NM, wkQBoxNm);
			// 発生年月日
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.HASSEI_DTM, JCRBatCommon.getSysDateTime());
			// 対応記録番号
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.TAIO_KIROK_NO, taioKirokNo);
			// データ処理コード(0:未処理、1:処理済)
			inMap.setValue(JBSbatCR_T_ESCL_TOIAWSMNTW.DATA_TRN_CD, "0");

			// ◆ 登録
			int count = db_CR_T_ESCL_TOIAWSMNTW.insertByPrimaryKeys(inMap);
			commonItem.getLogPrint().printDebugLog("[エスカレーション先別問合せモニタワーク] 登録件数:" + count);
		}
	}

	/**
	 * 対応記録内訳抽出ワーク登録(新規登録時用)
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @throws Exception 例外
	 */
	static void entryTiokrUwCstWkForNew(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		entryTiokrUwCstWk(commonItem, taioKirokNo, TAIO_KIROK_UCWK_NO_DEFAULT);
	}

	/**
	 * 対応記録内訳抽出ワーク登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param taioKirokUcwkNo 対応記録内訳番号
	 * @throws Exception 例外
	 */
	static void entryTiokrUwCstWk(JBSbatCommonItem commonItem, String taioKirokNo, String taioKirokUcwkNo) throws Exception
	{
		String sysDtm = JCRBatCommon.getSysDateTimeStamp();
		String userId = commonItem.getBatchUserId();

		// 応対区分抽出用データ登録
		String[] param = new String[] {
										JCRStrConst.DATA_SBT_CD_TOIAWASE_RSP,
										taioKirokNo,
										taioKirokUcwkNo,
										sysDtm,
										userId,
										sysDtm,
										userId,
										null,
										null,
										"0"
									};
		// 対応記録内訳抽出ワーク登録
		executeCR_T_TIOKR_UW_CST_WK_PKINSERT(commonItem, param);

		// ホットボイス抽出用データ登録
		param = new String[] {
								JCRStrConst.DATA_SBT_CD_HOTVOIC,
								taioKirokNo,
								taioKirokUcwkNo,
								sysDtm,
								userId,
								sysDtm,
								userId,
								null,
								null,
								"0"
							};
		// 対応記録内訳抽出ワーク登録
		executeCR_T_TIOKR_UW_CST_WK_PKINSERT(commonItem, param);
	}

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	抽出データ種別コード		CHSHT_DATA_SBT_CD
	 *		 	対応記録番号				TAIO_KIROK_NO
	 *		 	対応記録内訳番号			TAIO_KIROK_UCWK_NO
	 *		 	登録年月日時分秒			ADD_DTM
	 *		 	登録オペレータアカウント	ADD_OPEACNT
	 *		 	更新年月日時分秒			UPD_DTM
	 *		 	更新オペレータアカウント	UPD_OPEACNT
	 *		 	削除年月日時分秒			DEL_DTM
	 *		 	削除オペレータアカウント	DEL_OPEACNT
	 *		 	無効フラグ					MK_FLG
	 * </pre>
	 * <p>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param setParam 設定項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static void executeCR_T_TIOKR_UW_CST_WK_PKINSERT(JBSbatCommonItem commonItem, String[] setParam) throws Exception
	{
		// 対応記録内訳抽出ワーク
		JBSbatSQLAccess db_CR_T_TIOKR_UW_CST_WK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TIOKR_UW_CST_WK);

		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("CHSHT_DATA_SBT_CD", setParam[0]);
		setMap.setValue("TAIO_KIROK_NO", setParam[1]);
		setMap.setValue("TAIO_KIROK_UCWK_NO", setParam[2]);
		setMap.setValue("ADD_DTM", setParam[3]);
		setMap.setValue("ADD_OPEACNT", setParam[4]);
		setMap.setValue("UPD_DTM", setParam[5]);
		setMap.setValue("UPD_OPEACNT", setParam[6]);
		setMap.setValue("DEL_DTM", setParam[7]);
		setMap.setValue("DEL_OPEACNT", setParam[8]);
		setMap.setValue("MK_FLG", setParam[9]);

		// DBアクセスを実行します
		db_CR_T_TIOKR_UW_CST_WK.insertByPrimaryKeys(setMap);
	}

	/**
	 * NGワードチェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param text 対象文字列
	 * @param userId ユーザーID
	 * @param userNm ユーザー名
	 * @param gyomuKbtOrgCd 業務個別設定組織コード
	 * @return NGワード情報(List)
	 * @throws Exception 例外
	 */
	static List<String> checkNGWord(JBSbatCommonItem commonItem,
									String taioKirokNo,
									String text,
									String userId,
									String userNm,
									String gyomuKbtOrgCd) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("NGワードチェック");
		commonItem.getLogPrint().printDebugLog("　対応記録番号:" + taioKirokNo);
		commonItem.getLogPrint().printDebugLog("　対象文字列:" + text);
		commonItem.getLogPrint().printDebugLog("　ユーザーID:" + userId);
		commonItem.getLogPrint().printDebugLog("　ユーザー名:" + userNm);
		commonItem.getLogPrint().printDebugLog("　業務個別設定組織:" + gyomuKbtOrgCd);

		// 返戻するNGワードのリスト(チェックに該当したNGワードのList)
		List<String> ngWordList = new ArrayList<String>();

		// NGワード取得
		List<String> allNgwordList = getNGWord(commonItem);		// 全NGワードのList

		// NGワードチェック
		for (int i = 0; i < allNgwordList.size(); i++)
		{
			String ngword = allNgwordList.get(i);
			if (text.contains(ngword))
			{
				ngWordList.add(ngword);
			}
		}

		// 問合せモニターデータ登録
		entryTiawsMonitorData(commonItem, DATA_SBT_NGWORD, taioKirokNo, userId, userNm, gyomuKbtOrgCd);

		return ngWordList;
	}

	/**
	 * NGワードチェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param text 対象文字列
	 * @return NGワード情報(List)
	 * @throws Exception 例外
	 */
	static List<String> checkNGWord(JBSbatCommonItem commonItem, String text) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("NGワードチェック");
		commonItem.getLogPrint().printDebugLog("　対象文字列:" + text);

		// 返戻するNGワードのリスト(チェックに該当したNGワードのList)
		List<String> ngWordList = new ArrayList<String>();

		// NGワード取得
		List<String> allNgwordList = getNGWord(commonItem);		// 全NGワードのList

		// NGワードチェック
		for (int i = 0; i < allNgwordList.size(); i++)
		{
			String ngword = allNgwordList.get(i);
			if (text.contains(ngword))
			{
				ngWordList.add(ngword);
			}
		}

		return ngWordList;
	}

	/**
	 * NGワード情報を取得する。
	 * @param commonItem バッチ共通パラメータ電文
	 * @return NGワードのList
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static List<String> getNGWord(JBSbatCommonItem commonItem) throws Exception
	{
		List<String> ngwordList = new ArrayList<String>();

		// キーワード
		JBSbatSQLAccess db_CR_M_KEYWORD = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_M_KEYWORD);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(JCRStrConst.CD_DIV_KEYWORD_SBT_NGWORD);	// キーワード種別コード
		String sysDate = JCRBatCommon.getSysDate();
		paramList.setValue(sysDate);								// キーワード適用開始年月日
		paramList.setValue(sysDate);								// キーワード適用終了年月日

		// DBアクセスを実行します
		db_CR_M_KEYWORD.selectBySqlDefine(paramList, CR_M_KEYWORD_CR_SELECT_001);

		JBSbatCommonDBInterface ngwordData = db_CR_M_KEYWORD.selectNext();		// 1行分取得

		while (ngwordData != null)
		{
			String ngwordNm = ngwordData.getString(JBSbatCR_M_KEYWORD.KEYWORD_NM);	// キーワード名
			ngwordList.add(ngwordNm);

			ngwordData = db_CR_M_KEYWORD.selectNext();		// 1行分取得
		}

		return ngwordList;
	}

	/**
	 * NGワード検知メール送信
	 * 
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param ngWordData NGワード情報
	 * @param userId ユーザーID
	 * @throws Exception 例外
	 * 
	 */
	static void sendNGWordMail(JBSbatCommonItem commonItem,
								Map<String, List<Map<String, String>>> ngWordData,
								String userId) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("NGワード検知メール送信");
		commonItem.getLogPrint().printDebugLog("　NGワード情報:" + ngWordData);
		commonItem.getLogPrint().printDebugLog("　ユーザーID:" + userId);

		if (ngWordData != null && ngWordData.size() > 0)
		{

			// 問合せNGワード検知メール送信「元」メールアドレス取得
			String fromAddress = null;
			String fromAddressNm = null;
			List<JBSbatCommonDBInterface> mladDataList = getMailAddressData(commonItem, JCRStrConst.CD_DIV_NGWORD_MAIL_FROM_ADDRESS);
			if (mladDataList != null && mladDataList.size() > 0)
			{
				JBSbatCommonDBInterface mladData = mladDataList.get(0);
				fromAddress = mladData.getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD);
				fromAddressNm = mladData.getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD_NM);
			}

			// 問合せNGワード検知メール送信「先」メールアドレス取得
			String[] toAddressList = null;
			String[] toAddressNmList = null;
			mladDataList = getMailAddressData(commonItem, JCRStrConst.CD_DIV_NGWORD_MAIL_TO_ADDRESS);

			if (mladDataList != null && mladDataList.size() > 0)
			{
				toAddressList = new String[mladDataList.size()];
				toAddressNmList = new String[mladDataList.size()];
				for (int i = 0; i < mladDataList.size(); i++)
				{
					JBSbatCommonDBInterface mladData = mladDataList.get(i);
					toAddressList[i] = mladData.getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD);
					toAddressNmList[i] = mladData.getString(JBSbatCR_M_TAIORRK_ML_ADBK.MLAD_NM);
				}
			}

			// メール送信登録(共通部品使用)
			HashMap<String, Object> sendMailMap = new HashMap<String, Object>();

			// メールに必要な情報

			// 定型文のメールコード
			sendMailMap.put("MAIL_CD", JCRBatCommon.getApplicationConst("CR_MAIL_CD_NGWD"));
			// 送信予定年月日時分秒
			sendMailMap.put("MAIL_SEND_RSV_DTM", JCRBatCommon.getSysDateTimeStamp());
			sendMailMap.put("MAIL_SEND_PATTERN_CD", MAIL_SEND_PTN_DELAYD);		// 送信パターンに「ディレイド」を設定
			sendMailMap.put("MLAD_FROM", fromAddress);							// Fromメールアドレスを設定
			sendMailMap.put("MLAD_FROM_NM", fromAddressNm);						// Fromメールアドレス名を設定
			sendMailMap.put("MLAD_TO", toAddressList);							// 送信先メールアドレスを設定
			sendMailMap.put("MLAD_TO_NM", toAddressNmList);						// 送信先メールアドレス名を設定

			// メール本文生成
			StringBuilder honbun = new StringBuilder();

			Set<String> ngWordSet = ngWordData.keySet();
			Iterator<String> it = ngWordSet.iterator();
			while (it.hasNext())
			{
				String ngWord = it.next();

				honbun.append(JCRStrConst.KAIGYO_CD);
				honbun.append("NGワード[").append(ngWord).append("]を検知しました。").append(JCRStrConst.KAIGYO_CD);
				honbun.append(JCRStrConst.KAIGYO_CD);

				List<Map<String, String>> ngWordDtlList = ngWordData.get(ngWord);
				if (ngWordDtlList != null)
				{
					for (int i = 0; i < ngWordDtlList.size(); i++)
					{
						Map<String, String> ngWordDtlMap = ngWordDtlList.get(i);
						Set<String> ngWordDtlSet = ngWordDtlMap.keySet();
						Iterator<String> ngWordDtlIt = ngWordDtlSet.iterator();
						while (ngWordDtlIt.hasNext())
						{
							String taioKirkNo = ngWordDtlIt.next();
							String title = ngWordDtlMap.get(taioKirkNo);
							honbun.append("　").append("問合せID：　").append(taioKirkNo).append("　　タイトル：　").append(title);
							honbun.append(JCRStrConst.KAIGYO_CD);
						}
					}
				}
			}

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

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

	/**
	 * メールアドレスを取得する。
	 * @param commonItem バッチ共通パラメータ電文
	 * @param sbtCd メールアドレス種別コード
	 * @return メールアドレス情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getMailAddressData(JBSbatCommonItem commonItem, String sbtCd) throws Exception
	{
		// 対応履歴メールアドレス帳
		JBSbatSQLAccess db_CR_M_TAIORRK_ML_ADBK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_M_TAIORRK_ML_ADBK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(sbtCd);

		// DBアクセスを実行します
		db_CR_M_TAIORRK_ML_ADBK.selectBySqlDefine(paramList, CR_M_TORK_ML_ADBK_SELECT_001);
		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CR_M_TAIORRK_ML_ADBK);

		return dataList;
	}

	/**
	 * 問合せ関連データ削除
	 * 
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param shoriDtm 処理年月日時分秒
	 * @throws Exception 例外
	 * 
	 */
	static void deleteToiawase(JBSbatCommonItem commonItem, String taioKirokNo, String shoriDtm) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("問合せ関連データ削除");
		commonItem.getLogPrint().printDebugLog("　対応記録番号:" + taioKirokNo);
		commonItem.getLogPrint().printDebugLog("　処理年月日時分秒:" + shoriDtm);

		// バッチユーザー取得
		String userId = commonItem.getBatchUserId();

		// 添付ファイル関連データ削除(メール受信番号から)
		deleteTempFile1(commonItem, taioKirokNo, userId, shoriDtm);

		// 添付ファイル関連データ削除(メール送信番号から)
		deleteTempFile2(commonItem, taioKirokNo, userId, shoriDtm);

		// 添付ファイル関連データ削除(対応履歴電子ファイル管理から)
		deleteTempFile3(commonItem, taioKirokNo);

		// 対応記録削除
		deleteTaioKirk(commonItem, shoriDtm, userId, taioKirokNo);

		// 対応記録明細削除
		deleteTaioKrkDtl(commonItem, shoriDtm, userId, taioKirokNo);

		// 対応記録内訳削除
		deleteTaioKrkUcwk(commonItem, shoriDtm, userId, taioKirokNo);

		// 対応記録内訳カテゴリー削除
		deleteTaioKrkUwCtgr(commonItem, shoriDtm, userId, taioKirokNo);

		// 資料送付削除
		deleteSiryosohu(commonItem, shoriDtm, userId, taioKirokNo);

		// 資料送付記録削除
		deleteSiryosohuKirok(commonItem, shoriDtm, userId, taioKirokNo);

		// 対応履歴電子ファイル管理削除
		deleteTaioBunsho(commonItem, shoriDtm, userId, taioKirokNo);

	}

	/**
	 * 添付ファイル関連データ削除
	 * (メール受信番号から)
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param userId ユーザーID
	 * @param shoriDtm 処理年月日時分秒
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static void deleteTempFile1(JBSbatCommonItem commonItem, String taioKirokNo, String userId, String shoriDtm) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("電子ファイル管理削除(メール受信番号から)");

		// メール受信番号取得
		List<JBSbatCommonDBInterface> mailDataList = getMailRcvNo(commonItem, taioKirokNo);

		if (mailDataList != null)
		{
			for (int i = 0; i < mailDataList.size(); i++)
			{
				// 対応記録明細取得結果
				JBSbatCommonDBInterface taioKrkDtl = mailDataList.get(i);

				String mailRcvNo = taioKrkDtl.getString(JBSbatCR_T_TAIOKRK_DTL.MAIL_RCV_NO);	// メール受信番号

				// 電子ファイル管理番号取得
				List<JBSbatCommonDBInterface> tempFileDataList = getEFileNoByMailRcvNo(commonItem, mailRcvNo);

				if (tempFileDataList != null)
				{
					for (int j = 0; j < tempFileDataList.size(); j++)
					{
						// 添付ファイル取得結果
						JBSbatCommonDBInterface tempFile = tempFileDataList.get(j);

						String eFileNo = tempFile.getString(JBSbatCC_T_TEMP_FILE.EFILE_KANRI_NO);	// 電子ファイル管理番号

						// 電子ファイル管理削除
						JCRBatCommon.deleteDenshiFile(commonItem, eFileNo);

						commonItem.getLogPrint().printDebugLog("[共通部品(電子ファイル管理削除)呼出] 電子ファイル管理番号:" + eFileNo);

					}
				}
				// 添付ファイル削除(メール受信番号から)
				deleteTempFileByMailRcvNo(commonItem, shoriDtm, userId, mailRcvNo);
			}
		}
	}

	/**
	 * 添付ファイル関連データ削除
	 * (メール送信番号から)
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param userId ユーザーID
	 * @param shoriDtm 処理年月日時分秒
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static void deleteTempFile2(JBSbatCommonItem commonItem, String taioKirokNo, String userId, String shoriDtm) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("電子ファイル管理削除(メール送信番号から)");

		// メール送信番号取得
		List<JBSbatCommonDBInterface> mailDataList = getMailSendNo(commonItem, taioKirokNo);

		if (mailDataList != null)
		{
			for (int i = 0; i < mailDataList.size(); i++)
			{
				// 対応記録明細取得結果
				JBSbatCommonDBInterface taioKrkDtl = mailDataList.get(i);		// 1行分取得

				String mailSendNo = taioKrkDtl.getString(JBSbatCR_T_TAIOKRK_DTL.MAIL_SEND_NO);	// メール受信番号

				// 電子ファイル管理番号取得
				List<JBSbatCommonDBInterface> tempFileDataList = getEFileNoByMailSendNo(commonItem, mailSendNo);

				if (tempFileDataList != null)
				{
					for (int j = 0; j < tempFileDataList.size(); j++)
					{

						// 添付ファイル取得結果
						JBSbatCommonDBInterface tempFile = tempFileDataList.get(j);

						String eFileNo = tempFile.getString(JBSbatCC_T_TEMP_FILE.EFILE_KANRI_NO);	// 電子ファイル管理番号

						// 電子ファイル管理削除
						JCRBatCommon.deleteDenshiFile(commonItem, eFileNo);

						commonItem.getLogPrint().printDebugLog("[共通部品(電子ファイル管理削除)呼出] 電子ファイル管理番号:" + eFileNo);

					}
				}
				// 添付ファイル削除(メール送信番号から)
				deleteTempFileByMailSendNo(commonItem, shoriDtm, userId, mailSendNo);
			}
		}
	}

	/**
	 * 対応履歴電子ファイル管理関連データ削除
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @param userId ユーザーID
	 * @param shoriDtm 処理年月日時分秒
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static void deleteTempFile3(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		commonItem.getLogPrint().printDebugLog("対応履歴電子ファイル管理関連データ削除");

		// 対応履歴電子ファイル管理取得
		List<JBSbatCommonDBInterface> bunshoDataList = getTaioBunsho(commonItem, taioKirokNo);

		if (bunshoDataList != null)
		{
			for (int i = 0; i <  bunshoDataList.size(); i++)
			{
				// 対応履歴電子ファイル管理取得結果
				JBSbatCommonDBInterface taioBunsho = bunshoDataList.get(i);		// 1行分取得

				String eFileNo = taioBunsho.getString(JBSbatCR_T_TORK_EFILE_KNRI.EFILE_KANRI_NO);	// 電子ファイル管理番号

				// 電子ファイル管理削除
				JCRBatCommon.deleteDenshiFile(commonItem, eFileNo);

				commonItem.getLogPrint().printDebugLog("[共通部品(電子ファイル管理削除)呼出] 電子ファイル管理番号:" + eFileNo);
			}
		}
	}

	/**
	 * メール受信番号を取得する。
	 * (対応記録明細から)
	 * SQLKEY(CR_SELECT_01)でDBアクセスを行います。<br>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getMailRcvNo(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		// 対応記録明細
		JBSbatSQLAccess db_CR_T_TAIOKRK_DTL = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_DTL);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		db_CR_T_TAIOKRK_DTL.selectBySqlDefine(paramList, CR_T_TAIOKRK_DTL_CR_SELECT_001);

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CR_T_TAIOKRK_DTL);

		return dataList;
	}

	/**
	 * 電子ファイル管理番号を取得する。
	 * (メール受信番号から)
	 * SQLKEY(CR_SELECT_01)でDBアクセスを行います。<br>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param mailRcvNo メール受信番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getEFileNoByMailRcvNo(JBSbatCommonItem commonItem, String mailRcvNo) throws Exception
	{
		// 添付ファイルテーブル
		JBSbatSQLAccess db_CC_T_TEMP_FILE = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CC_T_TEMP_FILE);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(mailRcvNo);

		// DBアクセスを実行します
		db_CC_T_TEMP_FILE.selectBySqlDefine(paramList, CC_T_TEMP_FILE_CR_SELECT_001);

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CC_T_TEMP_FILE);

		return dataList;
	}

	/**
	 * メール送信番号を取得する。
	 * (対応記録明細から)
	 * SQLKEY(CR_SELECT_02)でDBアクセスを行います。<br>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getMailSendNo(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		// 対応記録明細
		JBSbatSQLAccess db_CR_T_TAIOKRK_DTL = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_DTL);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		db_CR_T_TAIOKRK_DTL.selectBySqlDefine(paramList, CR_T_TAIOKRK_DTL_CR_SELECT_002);

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CR_T_TAIOKRK_DTL);

		return dataList;
	}

	/**
	 * 電子ファイル管理番号を取得する。
	 * (メール送信番号から)
	 * SQLKEY(CR_SELECT_02)でDBアクセスを行います。<br>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param mailSendNo メール送信番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getEFileNoByMailSendNo(JBSbatCommonItem commonItem, String mailSendNo) throws Exception
	{
		// 添付ファイルテーブル
		JBSbatSQLAccess db_CC_T_TEMP_FILE = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CC_T_TEMP_FILE);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(mailSendNo);

		// DBアクセスを実行します
		db_CC_T_TEMP_FILE.selectBySqlDefine(paramList, CC_T_TEMP_FILE_CR_SELECT_002);

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CC_T_TEMP_FILE);

		return dataList;
	}

	/**
	 * 対応履歴電子ファイル管理から電子ファイル管理番号を取得する。
	 * SQLKEY(CR_SELECT_01)でDBアクセスを行います。<br>
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirokNo 対応記録番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getTaioBunsho(JBSbatCommonItem commonItem, String taioKirokNo) throws Exception
	{
		// 対応履歴電子ファイル管理
		JBSbatSQLAccess db_CR_T_TORK_EFILE_KNRI = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TORK_EFILE_KNRI);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(taioKirokNo);

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

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CR_T_TORK_EFILE_KNRI);

		return dataList;
	}

	/**
	 * 添付ファイルを論理削除する。
	 * (メール受信番号から)
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param mailRcvNo メール受信番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTempFileByMailRcvNo(JBSbatCommonItem commonItem,
												String shoriDtm,
												String userId,
												String mailRcvNo) throws Exception
	{
		// 添付ファイルテーブル
		JBSbatSQLAccess db_CC_T_TEMP_FILE = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CC_T_TEMP_FILE);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(mailRcvNo);

		// DBアクセスを実行します
		int count = db_CC_T_TEMP_FILE.executeBySqlDefine(paramList, CC_T_TEMP_FILE_CR_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[添付ファイル] 論理削除(メール受信番号から)件数:" + count);

		return count;
	}

	/**
	 * 添付ファイルを論理削除する。
	 * (メール送信番号から)
	 * SQLKEY(CR_UPDATE_02)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param mailSendNo メール送信番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTempFileByMailSendNo(JBSbatCommonItem commonItem,
													String shoriDtm,
													String userId,
													String mailSendNo) throws Exception
	{
		// 添付ファイルテーブル
		JBSbatSQLAccess db_CC_T_TEMP_FILE = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CC_T_TEMP_FILE);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(mailSendNo);

		// DBアクセスを実行します
		int count = db_CC_T_TEMP_FILE.executeBySqlDefine(paramList, CC_T_TEMP_FILE_CR_UPDATE_002);

		commonItem.getLogPrint().printDebugLog("[添付ファイル] 論理削除(メール送信番号から)件数:" + count);

		return count;
	}

	/**
	 * 対応記録論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTaioKirk(JBSbatCommonItem commonItem,
										String shoriDtm,
										String userId,
										String taioKirokNo) throws Exception
	{
		// 対応記録
		JBSbatSQLAccess db_CR_T_TAIO_KIROK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIO_KIROK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_TAIO_KIROK.executeBySqlDefine(paramList, CR_T_TAIO_KIROK_CR_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[対応記録] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 対応記録明細論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTaioKrkDtl(JBSbatCommonItem commonItem,
											String shoriDtm,
											String userId,
											String taioKirokNo) throws Exception
	{
		// 対応記録明細
		JBSbatSQLAccess db_CR_T_TAIOKRK_DTL = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_DTL);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_TAIOKRK_DTL.executeBySqlDefine(paramList, CR_T_TAIOKRK_DTL_CR_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[対応記録明細] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 対応記録内訳論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTaioKrkUcwk(JBSbatCommonItem commonItem,
											String shoriDtm,
											String userId,
											String taioKirokNo) throws Exception
	{
		// 対応記録内訳
		JBSbatSQLAccess db_CR_T_TAIOKRK_UCWK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_UCWK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_TAIOKRK_UCWK.executeBySqlDefine(paramList, CR_T_TAIOKRK_UCWK_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[対応記録内訳] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 対応記録内訳カテゴリー論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteTaioKrkUwCtgr(JBSbatCommonItem commonItem,
											String shoriDtm,
											String userId,
											String taioKirokNo) throws Exception
	{
		// 対応記録内訳カテゴリー
		JBSbatSQLAccess db_CR_T_TAIOKRK_UW_CTGR = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TAIOKRK_UW_CTGR);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_TAIOKRK_UW_CTGR.executeBySqlDefine(paramList, CR_T_UW_CTGR_CR_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[対応記録内訳カテゴリー] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 資料送付論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteSiryosohu(JBSbatCommonItem commonItem,
										String shoriDtm,
										String userId,
										String taioKirokNo) throws Exception
	{
		// 資料送付
		JBSbatSQLAccess db_CR_T_ATICLE_SOHU = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_ATICLE_SOHU);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_ATICLE_SOHU.executeBySqlDefine(paramList, CR_T_ATICLE_SOHU_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[資料送付] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 資料送付記録論理削除
	 * SQLKEY(CR_UPDATE_01)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int deleteSiryosohuKirok(JBSbatCommonItem commonItem,
											String shoriDtm,
											String userId,
											String taioKirokNo) throws Exception
	{
		// 資料送付記録
		JBSbatSQLAccess db_CR_T_ATICLE_SOHU_KRK = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_ATICLE_SOHU_KRK);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_ATICLE_SOHU_KRK.executeBySqlDefine(paramList, CR_T_ATICLE_SH_KRK_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[資料送付記録] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 対応履歴電子ファイル検索
	 * (ファイル名から)
	 * SQLKEY(CR_SELECT_004)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param fileName ファイル名
	 * @param sbtCd 対応記録番号
	 * @return 対応履歴電子ファイル情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static List<JBSbatCommonDBInterface> getTaioBunshoByName(JBSbatCommonItem commonItem,
															String fileName,
															String sbtCd) throws Exception
	{
		// 対応履歴電子ファイル管理
		JBSbatSQLAccess db_CR_T_TORK_EFILE_KNRI = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TORK_EFILE_KNRI);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(fileName);
		paramList.setValue(sbtCd);

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

		List<JBSbatCommonDBInterface> dataList = JCRBatCommon.getSelectedDataList(db_CR_T_TORK_EFILE_KNRI);

		return dataList;
	}

	/**
	 * 対応履歴電子ファイル管理論理削除
	 * SQLKEY(CR_UPDATE_001)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param shoriDtm 処理日時
	 * @param userId ユーザーID
	 * @param taioKirokNo 対応記録番号
	 * @return 論理削除件数
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static int deleteTaioBunsho(JBSbatCommonItem commonItem,
								String shoriDtm,
								String userId,
								String taioKirokNo) throws Exception
	{
		// 対応履歴電子ファイル管理
		JBSbatSQLAccess db_CR_T_TORK_EFILE_KNRI = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TORK_EFILE_KNRI);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(shoriDtm);
		paramList.setValue(userId);
		paramList.setValue(taioKirokNo);

		// DBアクセスを実行します
		int count = db_CR_T_TORK_EFILE_KNRI.executeBySqlDefine(paramList, CR_T_TORK_EFILE_CR_UPDATE_001);

		commonItem.getLogPrint().printDebugLog("[対応履歴電子ファイル管理] 論理削除件数:" + count);

		return count;
	}

	/**
	 * 対応履歴電子ファイル管理登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param dataMap 対応履歴電子ファイル管理登録データのMap
	 * 			キーは、JBSbatCR_T_TAIO_BUNSHOクラスの定数
	 * @return 対応履歴電子ファイル管理番号
	 * @throws Exception 例外
	 */
	static String entryTaioBunsho(JBSbatCommonItem commonItem, Map<String, String> dataMap) throws Exception
	{
		// 対応履歴電子ファイル管理
		JBSbatSQLAccess dbCrTTaioBunsho = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_TORK_EFILE_KNRI);

		JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

		// 対応履歴電子ファイル管理番号
		String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_TORK_EFILE_KNRI_NO, "", SEQ_KETA);
		inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.TORK_EFILE_KNRI_NO, key);

		// 文書種別コード
		String sbtCd = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.BUNSHO_SBT_CD);
		inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.BUNSHO_SBT_CD, sbtCd);

		// 対応記録番号
		String taioKirkNo = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.TAIO_KIROK_NO);
		if (taioKirkNo != null)
		{
			inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.TAIO_KIROK_NO, taioKirkNo);
		}

		// 対応記録明細番号
		String taioKirkDtlNo = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.TAIO_KIROK_DTL_NO);
		if (taioKirkDtlNo != null)
		{
			inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.TAIO_KIROK_DTL_NO, taioKirkDtlNo);
		}

		// クエリ番号
		String queryNo = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.QUERY_NO);
		if (queryNo != null)
		{
			inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.QUERY_NO, queryNo);
		}

		// 電子ファイル管理番号
		String eFileNo = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.EFILE_KANRI_NO);
		inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.EFILE_KANRI_NO, eFileNo);

		// 対応履歴文書ファイル名
		String fileNm = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM);
		inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM, fileNm);

		// 対応履歴文書作成年月日時分秒
		inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_SAKSEI_DTM, JCRBatCommon.getSysDateTimeStamp());

		// 業務個別設定組織コード
		String soshikiCd = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_ORG_CD);
		if (soshikiCd != null)
		{
			inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_ORG_CD, soshikiCd);
		}

		// 業務個別設定立場コード
		String tachibaCd = dataMap.get(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_POSITION_CD);
		if (tachibaCd != null)
		{
			inMap.setValue(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_POSITION_CD, tachibaCd);
		}

		// ◆ 登録
		int count = dbCrTTaioBunsho.insertByPrimaryKeys(inMap);
		commonItem.getLogPrint().printDebugLog("[対応履歴電子ファイル管理登録] 登録件数:" + count);

		return key;
	}

	/**
	 * 付属ファイル取得
	 * @param commonItem 共通情報
	 * @param targetFile 対象ファイル情報
	 * @param targetFileDirPath 対象ファイルパス(ディレクトリまで)
	 * @return 付属ファイルMap
	 * 			キー
	 * 			KEY_KENSU_FILE		件数ファイル情報
	 * 			KEY_FLAG_FILE		フラグファイル情報
	 * 			KEY_AUTHORITY_FILE	権限ファイル情報
	 * 		(件数ファイル、フラグファイルのいずれかが存在しない場合は0件のMapを返す)
	 */
	static Map<String, File> getHuzokuFile(JBSbatCommonItem commonItem, File targetFile, File targetFileDirPath)
	{
		Map<String, File> resMap = new HashMap<String, File>();

		// ファイル名から拡張子を省いた部分
		String fileNameOmitExt = targetFile.getName().substring(0, targetFile.getName().length() - JCRStrConst.EXT_CSV.length());

		File countFile = null;
		File flgFile = null;
		File athFile = null;

		File[] files = targetFileDirPath.listFiles();	// 対象ディレクトリ内のファイルリスト取得

		if (files != null)
		{
			for (int i = 0; i < files.length; i++)
			{
				if (files[i].isFile())
				{
					String fileName = files[i].getName();	// 対象ディレクトリ内のファイルのファイル名

					if (fileName.startsWith(fileNameOmitExt))
					{
						// ファイル名が、ファイル名から拡張子(.CSV)を省いた部分で始まっている場合
						if (fileName.toUpperCase().equals(fileNameOmitExt.toUpperCase() + CNT_FILE_POST_FIX))
						{
							// 件数ファイル
							countFile = files[i];
							commonItem.getLogPrint().printDebugLog("件数ファイルあり:" + countFile);
						}
						else if (fileName.toUpperCase().equals(fileNameOmitExt.toUpperCase() + FLG_FILE_POST_FIX))
						{
							// フラグファイル
							flgFile = files[i];
							commonItem.getLogPrint().printDebugLog("フラグファイルあり:" + flgFile);
						}
						else if (fileName.toUpperCase().equals(fileNameOmitExt.toUpperCase() + AUTHORITY_FILE_POST_FIX))
						{
							// 権限ファイル
							athFile = files[i];
							commonItem.getLogPrint().printDebugLog("権限ファイルあり:" + athFile);
						}
						
					}
					if (countFile != null && flgFile != null && athFile != null)
					{
						// 件数ファイル、フラグファイル、権限ファイルが見つかった場合
						break;
					}
				}
			}
			if (countFile != null && flgFile != null)
			{
				// 件数ファイル、フラグファイルが見つかった場合
				resMap.put(KEY_KENSU_FILE, countFile);
				resMap.put(KEY_FLAG_FILE, flgFile);
				if (athFile != null)
				{
					// 権限ファイルが見つかった場合
					resMap.put(KEY_AUTHORITY_FILE, athFile);
				}
			}
		}

		return resMap;
	}

	/**
	 * 付属ファイル取得（ファイルタイプ指定）
	 * @param commonItem 共通情報
	 * @param targetFile 対象ファイル情報
	 * @param targetFileDirPath 対象ファイルパス(ディレクトリまで)
	 * @param huzokuFileType 付属ファイルタイプ（{拡張子, 付属ファイル種別名}）
	 * @return 付属ファイルMap
	 * 		(存在しない場合は0件のMapを返す)
	 */
	static Map<String, File> getHuzokuFileTypeShitei(JBSbatCommonItem commonItem, File targetFile, File targetFileDirPath, String[][] huzokuFileType)
	{
		Map<String, File> resMap = new HashMap<String, File>();

		// ファイル名から拡張子を省いた部分
		String fileNameOmitExt = targetFile.getName().substring(0, targetFile.getName().length() - JCRStrConst.EXT_CSV.length());

		File huzokuFile = null;

		File[] files = targetFileDirPath.listFiles();	// 対象ディレクトリ内のファイルリスト取得
		int fileCnt = 0;

		if (files != null)
		{
			for (int i = 0; i < files.length; i++)
			{
				if (files[i].isFile())
				{
					String fileName = files[i].getName();	// 対象ディレクトリ内のファイルのファイル名

					if (fileName.startsWith(fileNameOmitExt))
					{
						for (int j = 0; j < huzokuFileType.length; j++)
						{
							String[] husokuFile = huzokuFileType[j];

							// ファイル名が、ファイル名から拡張子を省いた部分で始まっている場合
							if (fileName.toUpperCase().equals(fileNameOmitExt.toUpperCase() + husokuFile[0]))
							{
								huzokuFile = files[i];
								resMap.put(husokuFile[1], huzokuFile);
								commonItem.getLogPrint().printDebugLog(husokuFile[1] + "あり:" + huzokuFile);
								fileCnt++;
							}
						}
					}
					if (huzokuFileType.length == fileCnt)
					{
						// 付属ファイルが見つかった場合
						break;
					}
				}
			}
			if (huzokuFileType.length != fileCnt)
			{
				// 付属ファイルが見つからなかった場合
				return new HashMap<String, File>();
			}
		}

		return resMap;
	}

	/**
	 * 件数ファイルチェック
	 * @param commonItem 共通情報
	 * @param targetFile 対象ファイル情報
	 * @param dataCount データ件数
	 * @param countFile 件数ファイル情報
	 * @return チェック結果
	 */
	static boolean isCountFileCheckOK(JBSbatCommonItem commonItem, File targetFile, int dataCount, File countFile)
	{
		boolean res = true;

		BufferedReader br = null;
		try
		{
			// 件数チェック
			br = new BufferedReader(new InputStreamReader(new FileInputStream(countFile), JCRStrConst.DEFAULT_ENCODE));

			String countFileData = br.readLine();

			if (countFileData != null)
			{
				// ダブルクォート除去
				countFileData = countFileData.replaceAll("\"", "");
			}

			if (countFileData == null || "".equals(countFileData.trim()))
			{
				// 件数ファイルの内容が空白の場合

				// ECRB0170KW データ件数が件数ファイルの件数と一致しません。（%1%）
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0170KW, new String[] {targetFile.getName()});
				res = false;
			}
			else if (!(JCRBatCommon.isHannkakuSuuji1(countFileData)))
			{
				// 件数ファイルの内容が数字でない場合

				// ECRB0230TW	%1%の属性が正しくありません。（属性:%2% 値:%3%）
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"件数ファイル", "半角数字", countFileData});
				res = false;
			}
			else if (Integer.parseInt(countFileData) != dataCount)
			{
				// 件数が一致しない場合

				// ECRB0170KW データ件数が件数ファイルの件数と一致しません。（%1%）
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0170KW, new String[] {targetFile.getName()});
				res = false;
			}
		}
		catch (IOException ioe)
		{
			// ECRB0260KW	%1%処理中に予期せぬエラーが発生しました。　%2%
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0260KW, new String[] {"件数ファイルチェック", ioe.getMessage()});
			res = false;
		}
		finally
		{
			if (br != null)
			{
				try
				{
					br.close();
				}
				catch (IOException ioe)
				{
					commonItem.getLogPrint().printDebugLog("br close error");
				}
			}
		}
		return res;
	}

	/**
	 * エラーファイル電子ファイル管理登録
	 * @param commonItem 共通情報
	 * @param errFilePath エラーファイルパス情報
	 * @param errListData エラー情報リスト
	 * @throws Exception 例外
	 */
	static void entryErrFileData(JBSbatCommonItem commonItem, String errFilePath, List<String> errListData) throws Exception
	{
		// エラーファイル作成
		JBSbatBusinessFileUtil errFileObj =
			JCRBatCommon.createBusinessFileUtil(errFilePath, JCRStrConst.DEFAULT_ENCODE, JCRStrConst.KAIGYO_CD, "");
		commonItem.getLogPrint().printDebugLog("エラーファイル作成:" + errFilePath);
		
		for(int i = 0; i < errListData.size(); i++)
		{
			// ファイルにエラー情報を書き込む
			JCRBatCommon.printBusinessFileUtil(errFileObj, errListData.get(i));
		}
		// ファイルオブジェクトのクローズ
		JCRBatCommon.closeBusinessFileUtil(errFileObj);
		commonItem.getLogPrint().printDebugLog("エラーファイルオブジェクトクローズ処理実行");
		return;
	}

	/**
	 * トータル処理時間計算<br>
	 * <br>
	 * 開始時刻(例:対応開始年月日時分秒(14桁))から終了時刻(例:システム日時(14桁))
	 * までの時間を分として換算した値を返す。
	 * (オンラインの
	 * eo.ejb.common.edit.JCRejbCalcDifferenceTimeクラス(koptModel)の
	 * getDifferenceTime()メソッドと同内容のメソッドをバッチ用に作成)
	 *
	 * @param startTime 開始時刻(String yyyyMMddHHmiss)
	 * @param endTime 終了時刻(String yyyyMMddHHmiss)
	 * @return 分に換算した値
	 */
	static String calcTotalTranTime(String startTime, String endTime)
	{
		int dtmLength = 14;
		long retMinutes = 0;

		if (startTime != null && startTime.length() == dtmLength && endTime != null && endTime.length() == dtmLength)
		{
			// 開始の日付
			String startDate = startTime.substring(0, 8);
			// 終了の日付
			String endDate = endTime.substring(0, 8);

			// 開始の時間
			int startHour = Integer.parseInt(startTime.substring(8, 10));

			// 終了の時間
			int endHour = Integer.parseInt(endTime.substring(8, 10));

			// 開始の分
			int startMinutes = Integer.parseInt(startTime.substring(10, 12));

			// 終了の分
			int endMinutes = Integer.parseInt(endTime.substring(10, 12));

			// 日の差分を取得
			int difDay = JCRUtilCommon.subtractDay(endDate, startDate);

			// 日の差分を分に換算
			long difMinutes = difDay * 24 * 60;

			retMinutes = difMinutes + (endHour * 60 + endMinutes) - (startHour * 60 + startMinutes);
		}
		return String.valueOf(retMinutes);
	}

	/**
	 * 処理件数ログ出力
	 * @param commonItem 共通情報
	 * @param title タイトル　例：ディレイド処理件数
	 * @param count 件数
	 */
	static void printShoriCountLog(JBSbatCommonItem commonItem, String title, int count)
	{
		// 処理件数出力
		commonItem.getLogPrint().printLogMsg(JPCBatchMessageConstant.ECRB0400AI, title, count);
	}

	/**
	 * キューBOXの現在格納数を対応記録から算出して更新する
	 * SQLKEY(CR_UPDATE_005)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param queBoxNo キューBOX番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static void updateQueNowKaknoCnt(JBSbatCommonItem commonItem, String queBoxNo) throws Exception
	{
		// キューBOX
		JBSbatSQLAccess db_CR_T_QUE_BOX = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_QUE_BOX);

		// バイント変数のリストを生成（SELECT用）
//		JBSbatCommonDBInterface paramList1 = new JBSbatCommonDBInterface();
//		paramList1.setValue(queBoxNo);
//		// 行ロックのためSELECT発行
//		db_CR_T_QUE_BOX.selectBySqlDefine(paramList1, CR_T_QUE_BOX_CR_SELECT_008);
//		JBSbatCommonDBInterface queBox = db_CR_T_QUE_BOX.selectNext();
//		if (queBox == null)
//		{
//			commonItem.getLogPrint().printDebugLog("キューBOX未登録：" + queBoxNo);
//		}

		String sysDtm = JCRBatCommon.getSysDateTimeStamp();
		// バイント変数のリストを生成（UPDATE用）
		JBSbatCommonDBInterface paramList2 = new JBSbatCommonDBInterface();
		paramList2.setValue(queBoxNo);
		paramList2.setValue(sysDtm);
		paramList2.setValue(sysDtm);
		paramList2.setValue(commonItem.getBatchUserId());
		paramList2.setValue(queBoxNo);

		// DBアクセスを実行します
		int count = db_CR_T_QUE_BOX.executeBySqlDefine(paramList2, CR_T_QUE_BOX_CR_UPDATE_005);

		commonItem.getLogPrint().printDebugLog("[キューBOX] 更新件数:" + count);
	}

	/**
	 * ユーザーIDからMYBOXの現在格納数を対応記録から算出して更新する
	 * SQLKEY(CR_UPDATE_004)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param userId ユーザーID
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static void updateMyBoxNowKaknoCntByUserId(JBSbatCommonItem commonItem, String userId) throws Exception
	{
		// MYBOX
		JBSbatSQLAccess db_CR_T_MYBOX = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_MYBOX);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(userId);

		// DBアクセスを実行します
		db_CR_T_MYBOX.selectBySqlDefine(paramList, CR_T_MYBOX_SELECT_001);

		List<JBSbatCommonDBInterface> myBoxDataList = JCRBatCommon.getSelectedDataList(db_CR_T_MYBOX);

		if (myBoxDataList != null)
		{
			for (int i = 0; i < myBoxDataList.size(); i++)
			{
				JBSbatCommonDBInterface myBoxData = myBoxDataList.get(i);
				String myBoxNo = myBoxData.getString(JBSbatCR_T_MYBOX.MYBOX_NO);
				updateMyBoxNowKaknoCnt(commonItem, myBoxNo);
			}
		}
	}

	/**
	 * MYBOXの現在格納数を対応記録から算出して更新する
	 * SQLKEY(CR_UPDATE_004)でDBアクセスを行います。<br>
	 * @param commonItem　バッチ共通パラメータ電文
	 * @param myBoxNo キューBOX番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	static void updateMyBoxNowKaknoCnt(JBSbatCommonItem commonItem, String myBoxNo) throws Exception
	{
		// MYBOX
		JBSbatSQLAccess db_CR_T_MYBOX = JCRBatCommon.getDataAccessObj(commonItem, TBL_NAME_CR_T_MYBOX);

		// バイント変数のリストを生成（SELECT用）
//		JBSbatCommonDBInterface paramList1 = new JBSbatCommonDBInterface();
//		paramList1.setValue(myBoxNo);
//		// 行ロックのためSELECT発行
//		db_CR_T_MYBOX.selectBySqlDefine(paramList1, CR_T_MYBOX_SELECT_002);
//		JBSbatCommonDBInterface myBox = db_CR_T_MYBOX.selectNext();
//		if (myBox == null)
//		{
//			commonItem.getLogPrint().printDebugLog("MYBOX未登録：" + myBoxNo);
//		}

		String sysDtm = JCRBatCommon.getSysDateTimeStamp();
		// バイント変数のリストを生成（UPDATE用）
		JBSbatCommonDBInterface paramList2 = new JBSbatCommonDBInterface();
		paramList2.setValue(myBoxNo);
		paramList2.setValue(sysDtm);
		paramList2.setValue(sysDtm);
		paramList2.setValue(commonItem.getBatchUserId());
		paramList2.setValue(myBoxNo);

		// DBアクセスを実行します
		int count = db_CR_T_MYBOX.executeBySqlDefine(paramList2, CR_T_MYBOX_CR_UPDATE_004);

		commonItem.getLogPrint().printDebugLog("[MYBOX] 更新件数:" + count);
	}
}