/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：Futurity
*	モジュール名	：JBSbatCRRrkInfoImport
*	ソースファイル名：JBSbatCRRrkInfoImport.java
*	作成者			：富士通
*	日付			：2011年05月25日
*＜機能概要＞
*	履歴情報インポート共通部品
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/05/25	富士通		新規作成
*				2013/01/17	富士通		ANK-1245-00-00 機種依存文字対応
*	v6.00.00	2013/08/26	FJ斉藤諭	OM-2013-0000796対応
*	v6.00.00	2013/09/06  FJ斉藤諭	OM-2013-0001745対応
*	v6.00.01	2013/11/26  FJ斉藤諭	ANK-1637-00-00対応
*  v16.00.00	2015/10/29	FJ)鯵坂		ST-2015-0000055 対応
*  v39.00.00	2018/08/28	FJ)北村		ANK-3475-00-00 eo顧客：対応履歴（ＣＡＳＥ）ファイル取り込み時に行われる「受付種別チェック仕様」の緩和等
*  v42.00.00	2019/04/01  FJ)前田		ANK-3593-00-00_オペレータ支援対応に伴うeo顧客機能改修（お客さまカルテ）
*  v42.00.00	2019/07/31  FJ)前田		OM-2019-0000866_Web資料受付情報取込処理にて 正常に取込まれるべきところ 存在しない反響可能性フラグエラー処理の対象になりエラーと判断される
**********************************************************************/

package eo.business.common;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
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.JBSbatCK_T_CUST;
import eo.business.util.table.JBSbatCK_T_PROSCST;
import eo.business.util.table.JBSbatCR_M_CTGR;
import eo.business.util.table.JBSbatCR_T_MYBOX;
import eo.business.util.table.JBSbatCR_T_QUE_BOX;
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.JBSbatKK_T_SVC_KEI;
import eo.business.util.table.JBSbatZM_M_AUTHORITY_GRP;
import eo.common.constant.JCRStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.constant.JZM0171Constant;
import eo.common.util.JCRUtilCommon;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.log.JBSbatLogPrintControl;

/**
 * 履歴情報インポート共通部品<p>
 * <BR>
 * @author 富士通
 */
class JBSbatCRRrkInfoImport
{
	/** インデックス:顧客タイプ */
	private static final int IDX_KOKYAKU_TYPE = 0;
	/** インデックス:サービス契約番号 */
	private static final int IDX_SVC_KEI_NO = 1;
	/** インデックス:顧客氏名 */
	private static final int IDX_SHIMEI = 2;
	/** インデックス:顧客氏名(カナ) */
	private static final int IDX_SHIMEI_KANA = 3;
	/** インデックス:電話番号 */
	private static final int IDX_TEL1 = 4;
	/** インデックス:電話番号2 */
	private static final int IDX_TEL2 = 5;
	/** インデックス:郵便番号 */
	private static final int IDX_YUBIN_NO = 6;
	/** インデックス:住所1 */
	private static final int IDX_JUSHO1 = 7;
	/** インデックス:住所2 */
	private static final int IDX_JUSHO2 = 8;
	/** インデックス:住所3 */
	private static final int IDX_JUSHO3 = 9;
	/** インデックス:性別 */
	private static final int IDX_SEIBETSU = 10;
	/** インデックス:生年月日 */
	private static final int IDX_SEINENGAPPI = 11;
	/** インデックス:状態 */
	private static final int IDX_JOTAI = 12;
	/** インデックス:ステータス */
	private static final int IDX_STATUS = 13;
	/** インデックス:作成日時 */
	private static final int IDX_SAKUSEI_DATE = 14;
	/** インデックス:受付者 */
	private static final int IDX_UKETSUKE = 15;
	/** インデックス:担当者 */
	private static final int IDX_TANTO = 16;
	/** インデックス:キューBOX名 */
	private static final int IDX_QUE_NM = 17;
	/** インデックス:受付種別 */
	private static final int IDX_UKETSUKE_SBT = 18;
	/** インデックス:タイトル */
	private static final int IDX_TITLE = 19;
	/** インデックス:カテゴリー1 */
	private static final int IDX_CTGR_01 = 20;
	/** インデックス:カテゴリー2 */
//	private static final int IDX_CTGR_02 = 21;
	/** インデックス:カテゴリー3 */
//	private static final int IDX_CTGR_03 = 22;
	/** インデックス:カテゴリー4 */
//	private static final int IDX_CTGR_04 = 23;
	/** インデックス:カテゴリー5 */
//	private static final int IDX_CTGR_05 = 24;
	/** インデックス:カテゴリー6 */
//	private static final int IDX_CTGR_06 = 25;
	/** インデックス:カテゴリー7 */
//	private static final int IDX_CTGR_07 = 26;
	/** インデックス:カテゴリー8 */
//	private static final int IDX_CTGR_08 = 27;
	/** インデックス:カテゴリー9 */
//	private static final int IDX_CTGR_09 = 28;
	/** インデックス:カテゴリー10 */
//	private static final int IDX_CTGR_10 = 29;
	/** インデックス:カテゴリー11 */
//	private static final int IDX_CTGR_11 = 30;
	/** インデックス:問合せ履歴 */
	private static final int IDX_RIREKI = 31;
	/** インデックス:問合せ客番号 */
	private static final int IDX_TIAWS_KYAKU_NO = 32;
	/** インデックス:eoID */
	private static final int IDX_EOID = 33;
	/** インデックス:申込書番号 */
	private static final int IDX_MUSKM_SHO_NO = 34;
	/** インデックス:コールバック日時 */
	private static final int IDX_CALLBACK_DATE = 35;
	/** インデックス:コールバック時間指定タイプ */
	private static final int IDX_CALLBACK_TYPE = 36;
	/** インデックス:業務個別設定組織コード(CASEファイル) */
	private static final int IDX_WKKBT_ORG_CD_CASE = 37;
	/** インデックス:業務個別設定組織コード(MATEファイル) */
	private static final int IDX_WKKBT_ORG_CD_MATE = 50;
	// ANK-3593-00-00 ADD START
	/** インデックス:反響可能性フラグ */
	private static final int IDX_HANKYO_PSB_FLG = 38;
	/** インデックス:対応部署名 */
	private static final int IDX_TAIO_BUSHO_NM = 39;
	// ANK-3593-00-00 ADD END

	/** エラー有無を取得するキー */
	private static final String KEY_EXIST_ERROR = "KEY_EXIST_ERROR";
	/** ログデータを取得するキー */
	private static final String KEY_LOG_DATA = "KEY_LOG_DATA";
	/** サービス契約番号を取得するキー */
	private static final String KEY_SVC_KEY_NO = "KEY_SVC_KEY_NO";
	/** キューBOX番号を取得するキー */
	private static final String KEY_QUE_BOX_NO = "KEY_QUE_BOX_NO";
	/** MYBOX番号を取得するキー */
	private static final String KEY_MYBOX_NO = "KEY_MYBOX_NO";
	/** 改行コード変換文字を取得するキー */
	static final String KEY_KAIGYO_CD_HENKAN_MOJI = "KEY_KAIGYO_CD_HENKAN_MOJI";
	/** 変換処理後のファイルを取得するキー */
	static final String KEY_HENKANGO_FILE = "KEY_HENKANGO_FILE";
	/** 有効データ件数を取得するキー */
	static final String KEY_COUNT = "KEY_COUNT";

	/** 加入者 */
	private static final String KANYUSHA = "加入者";
	/** 未加入者 */
	private static final String MI_KANYUSHA = "未加入者";
	/** 状態 エスカレーション */
	private static final String JOTAI_OPEN = "オープン";
	/** 状態 エスカレーション */
	private static final String JOTAI_ESCL = "エスカレーション";
	/** コメント文字 */
	private static final String COMMENT = "#";
	/** 終端文字 */
	private static final String END = "[END]";
	/** 改行コード変換文字の囲い文字 */
	private static final char KAKOI = '%';
	/** COUNT()用項目名 */
	static final String CNT = "CNT";

	/** 最大カテゴリーレベル */
	private static final int MAX_TGR_LVL = 11;

	/** サービス契約番号のバイト数 */
	private static final int SVC_KYK_NO_BYTE_SU = 10;
	/** 顧客氏名のバイト数 */
	private static final int NAME_BYTE_SU = 90;
	/** 顧客氏名カナのバイト数 */
	private static final int NAME_KANA_BYTE_SU = 120;
	/** 電話番号のバイト数 */
	private static final int TELNO_BYTE_SU = 11;
	/** 郵便番号のバイト数 */
	private static final int YUBINNO_BYTE_SU = 7;
	/** 住所1のバイト数 */
	private static final int JUSHO1_BYTE_SU = 30;
	/** 住所2のバイト数 */
	private static final int JUSHO2_BYTE_SU = 30;
	/** 住所3のバイト数 */
	private static final int JUSHO3_BYTE_SU = 30;
	/** ユーザーIDのバイト数 */
	private static final int CHK_USERID_BYTE_SU = 20;	// 20バイトまでOKとするが登録は先頭10バイトとする 2011/5/26
	/** ユーザーIDのバイト数 */
	private static final int DB_USERID_BYTE_SU = 10;
	/** キュー名のバイト数 */
	private static final int QUENM_BYTE_SU = 40;
	/** タイトルのバイト数 */
	private static final int TITLE_BYTE_SU = 255;
	/** カテゴリーのバイト数 */
	private static final int CTGRNM_BYTE_SU = 160;
	/** 問合せ履歴のバイト数 */
	private static final int RIREKI_BYTE_SU = 100000;
	/** 問合せ客番号のバイト数 */
	private static final int TIAWS_KYAKU_NO_BYTE_SU = 10;
	/** eoIDのバイト数 */
	private static final int EOID_BYTE_SU = 80;
	/** 申込書番号のバイト数 */
	private static final int MUSKMSHONO_BYTE_SU = 10;
	/** 業務個別設定組織コードのバイト数 */
	private static final int WKKBT_ORG_CD_BYTE_SU = 10;
	/** CASE 1行の項目数 */
//	private static final int CASE_KOUMOKU_SU = 37;
	/** MATE 1行の項目数 */
//	private static final int MATE_KOUMOKU_SU = 50;
	/** 対応記録明細番号 1件目 */
	private static final String FIRST_TAIO_KIROK_DTL_NO = "0000000001";
	/** 対応記録明細番号 2件目 */
	private static final String SECOND_TAIO_KIROK_DTL_NO = "0000000002";
	/** 対応記録明細番号 3件目 */
	private static final String THIRD_TAIO_KIROK_DTL_NO = "0000000003";
	/** 対応記録内訳番号 1件目 */
	private static final String FIRST_TAIO_KIROK_UCWK_NO = "0000000001";
	// ANK-3593-00-00 ADD START
	/** 反響可能性フラグのバイト数 */
	private static final int HANKYO_PSB_FLG_BYTE_SU = 1;
	/** 対応部署名のバイト数 */
	private static final int TAIO_BUSHO_NM_BYTE_SU = 242;
	/** 反響可能性フラグ "チェック有" */
	private static final String HANKYO_PSB_FLG_ON = "1";
	/** 反響可能性フラグ "チェック無" */
	private static final String HANKYO_PSB_FLG_OFF = "0";
	/** 反響可能性フラグ規則 */
	private static final String HANKYO_PSB_FLG_RULE = "｢0｣または｢1｣";
	// ANK-3593-00-00 ADD END

	/** 性別 */
	private static final String[] SEIBETSU_LIST = new String[] {"男性", "女性", "不明"};
	/** 状態 */
	private static final String[] JOTAI_LIST = new String[] {"オープン", "クローズ", "エスカレーション"};
	/** ステータス */
	private static final String[] STATUS_LIST = new String[] {"処理中"};
// ANK-3475-00-00 MOD START
	/** 受付種別 */
//	private static final String[] UKTK_SBT_LIST = new String[] {"他システム", "コール", "EMAIL", "FAX"};
	private static final String[] UKTK_SBT_LIST = new String[] {"着信", "発信", "EMAIL", "他システム", "訪問", "郵便", "FAX", "その他", "SMS",
		 "チャット", "LINE"};
// ANK-3475-00-00 MOD END
	/** テーブル(カテゴリー)*/
	private static final String D_TBL_NAME_CR_M_CTGR = "CR_M_CTGR";
	/** テーブル(サービス契約)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI = "KK_T_SVC_KEI";
	/** テーブル(お客様)*/
	private static final String D_TBL_NAME_CK_T_CUST = "CK_T_CUST";
	/** テーブル(問合せ客)*/
	private static final String D_TBL_NAME_CK_T_PROSCST = "CK_T_PROSCST";
	/** テーブル(キューＢＯＸ)*/
	private static final String D_TBL_NAME_CR_T_QUE_BOX = "CR_T_QUE_BOX";
	/** テーブル(ＭＹＢＯＸ)*/
	private static final String D_TBL_NAME_CR_T_MYBOX = "CR_T_MYBOX";
	/** テーブル(対応記録明細)*/
	private static final String D_TBL_NAME_CR_T_TAIOKRK_DTL = "CR_T_TAIOKRK_DTL";
	/** テーブル(対応記録内訳)*/
	private static final String D_TBL_NAME_CR_T_TAIOKRK_UCWK = "CR_T_TAIOKRK_UCWK";
	/** テーブル(対応記録内訳カテゴリー)*/
	private static final String D_TBL_NAME_CR_T_TAIOKRK_UW_CT = "CR_T_TAIOKRK_UW_CTGR";
	/** テーブル(ユーザー保持権限グループ)*/
	private static final String D_TBL_NAME_ZM_M_USER_HTG_KGGRP = "ZM_M_USER_HTG_KGGRP";
	/** テーブル(業務個別設定組織)*/
	private static final String D_TBL_NAME_ZM_M_WKKBT_ORG = "ZM_M_WKKBT_ORG";

	/** SQL定義キー(CR_SELECT_003)*/
	private static final String CR_M_CTGR_CR_SELECT_003 = "CR_SELECT_003";
	/** SQL定義キー(CR_SELECT_004)*/
	private static final String CR_M_CTGR_CR_SELECT_004 = "CR_SELECT_004";
	/** SQL定義キー(CR_SELECT_001)*/
	private static final String KK_T_SVC_KEI_CR_SELECT_001 = "CR_SELECT_001";
	/** SQL定義キー(CR_SELECT_002)*/
	private static final String KK_T_SVC_KEI_CR_SELECT_002 = "CR_SELECT_002";
	/** SQL定義キー(CR_SELECT_002)*/
	private static final String CK_T_CUST_CR_SELECT_002 = "CR_SELECT_002";
	/** SQL定義キー(CR_SELECT_001)*/
	private static final String CK_T_PROSCST_CR_SELECT_001 = "CR_SELECT_001";
	/** SQL定義キー(CR_SELECT_004)*/
	private static final String CR_T_QUE_BOX_CR_SELECT_004 = "CR_SELECT_004";
	/** SQL定義キー(CR_SELECT_004)*/
	private static final String CR_T_QUE_BOX_CR_SELECT_005 = "CR_SELECT_005";
	/** SQL定義キー(CR_SELECT_001)*/
	private static final String CR_T_MYBOX_CR_SELECT_001 = "CR_SELECT_001";
	/** SQL定義キー(CR_UPDATE_001)*/
	private static final String CR_T_QUE_BOX_CR_UPDATE_001 = "CR_UPDATE_001";
	/** SQL定義キー(CR_UPDATE_001)*/
	private static final String CR_T_MYBOX_CR_UPDATE_001 = "CR_UPDATE_001";
	/** SQL定義キー(CR_SELECT_001)*/
	private static final String ZM_M_USER_HTG_KGGRP_SELECT_001 = "CR_SELECT_001";
	/** SQL定義キー(CR_SELECT_003)*/
	private static final String ZM_M_WKKBT_ORG_CR_SELECT_003 = "CR_SELECT_003";

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

	/**
	 * データチェック(各項目チェック)
	 * @param commonItem 共通情報
	 * @param dataList 1行分のデータ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @param isMate MATEファイル取込の場合はtrue
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	static Map<String, Object> checkTrkmData(JBSbatCommonItem commonItem,
											List<String> dataList,
											int errorRecordCount,
											String chgCRWord,
											boolean isMate) throws Exception
	{

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

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

		Map<String, Object> errInfoMap = null;			// エラー情報

		// 顧客タイプチェック
		String kokyakuTp = dataList.get(IDX_KOKYAKU_TYPE);
		errInfoMap = checkKokyakuType(commonItem, kokyakuTp, errorRecordCount);
		boolean error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// サービス契約番号チェック
		String svcKykNo = dataList.get(IDX_SVC_KEI_NO);
		errInfoMap = checkSvcKykNo(commonItem, svcKykNo, kokyakuTp, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 顧客氏名チェック
		String kokyakuNm = dataList.get(IDX_SHIMEI);
		errInfoMap = checkKokyakuNm(commonItem, kokyakuNm, kokyakuTp, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 顧客氏名(カナ)チェック
		String kokyakuKana = dataList.get(IDX_SHIMEI_KANA);
		errInfoMap = checkKokyakuKana(commonItem, kokyakuKana, kokyakuTp, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 電話番号チェック
		String telNo = dataList.get(IDX_TEL1);
		errInfoMap = checkTelNo(commonItem, telNo, kokyakuTp, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 電話番号2チェック
		String telNo2 = dataList.get(IDX_TEL2);
		errInfoMap = checkTelNo2(commonItem, telNo2, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 郵便番号チェック
		String yubinNo = dataList.get(IDX_YUBIN_NO);
		errInfoMap = checkYubinNo(commonItem, yubinNo, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 住所1チェック
		String jusho1 = dataList.get(IDX_JUSHO1);
		errInfoMap = checkJusho1(commonItem, jusho1, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 住所2チェック
		String jusho2 = dataList.get(IDX_JUSHO2);
		errInfoMap = checkJusho2(commonItem, jusho2, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 住所3チェック
		String jusho3 = dataList.get(IDX_JUSHO3);
		errInfoMap = checkJusho3(commonItem, jusho3, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 性別チェック
		String seibetsu = dataList.get(IDX_SEIBETSU);
		errInfoMap = checkSeibetsu(commonItem, seibetsu, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 生年月日チェック
		String seinengappi = dataList.get(IDX_SEINENGAPPI);
		errInfoMap = checkSeinengappi(commonItem, seinengappi, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 状態チェック
		String jotai = dataList.get(IDX_JOTAI);
		errInfoMap = checkJotai(commonItem, jotai, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// ステータスチェック
		String status = dataList.get(IDX_STATUS);
		errInfoMap = checkStatus(commonItem, status, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 作成日時チェック
		String sakuseiDate = dataList.get(IDX_SAKUSEI_DATE);
		errInfoMap = checkSakuseiDate(commonItem, sakuseiDate, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 受付者チェック
		String uketsukesha = dataList.get(IDX_UKETSUKE);
		errInfoMap = checkUketsukesha(commonItem, uketsukesha, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 担当者チェック
		String tantosha = dataList.get(IDX_TANTO);
		errInfoMap = checkTantosha(commonItem, tantosha, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// キュー名チェック
		String queNm = dataList.get(IDX_QUE_NM);
		errInfoMap = checkQueNm(commonItem, queNm, jotai, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 受付種別チェック
		String uketsukeSbt = dataList.get(IDX_UKETSUKE_SBT);
		errInfoMap = checkUketsukeSbt(commonItem, uketsukeSbt, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// タイトルチェック
		String title = dataList.get(IDX_TITLE);
		errInfoMap = checkTitle(commonItem, title, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// カテゴリーチェック
		boolean existCtgr = false;
		String[] ctgr = new String[MAX_TGR_LVL];
		for (int i = 0; i < ctgr.length; i++)
		{
			ctgr[i] = dataList.get(IDX_CTGR_01 + i);
			if (ctgr[i] != null && !("".equals(ctgr[i].trim())))
			{
				existCtgr = true;
			}
		}
		if (existCtgr)
		{
			errInfoMap = checkCategory(commonItem, ctgr, errorRecordCount);
			error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
			if (error)
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
				existError = true;
			}
		}

		// 問合せ履歴チェック
		String rireki = dataList.get(IDX_RIREKI);
		errInfoMap = checkRireki(commonItem, rireki, chgCRWord, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 問合せ客番号チェック
		String tiawsKyakuNo = dataList.get(IDX_TIAWS_KYAKU_NO);
		errInfoMap = checkTiawsKyakuNo(commonItem, tiawsKyakuNo, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// eoIDチェック
		String eoID = dataList.get(IDX_EOID);
		errInfoMap = checkEoID(commonItem, eoID, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 申込書番号チェック
		String muskmNo = dataList.get(IDX_MUSKM_SHO_NO);
		errInfoMap = checkMuskmshoNo(commonItem, muskmNo, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// コールバック日時チェック
		String callbackDate = dataList.get(IDX_CALLBACK_DATE);
		errInfoMap = checkCallBackDate(commonItem, callbackDate, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// コールバック時間指定タイプチェック
		String callBackTypeNm = dataList.get(IDX_CALLBACK_TYPE);
		errInfoMap = checkCallBackType(commonItem, callBackTypeNm, errorRecordCount);
		error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
		if (error)
		{
			logData.append(errInfoMap.get(KEY_LOG_DATA));
			existError = true;
		}

		// 業務個別設定組織コードチェック
		int wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_CASE;
		if (isMate == true)
		{
			wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_MATE;
		}
		if (dataList.size() > wkkbtOrgCdIdx)
		{
			String wkkbtOrgCd = dataList.get(wkkbtOrgCdIdx);
			errInfoMap = checkWkkbtOrgCd(commonItem, wkkbtOrgCd, errorRecordCount);
			error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
			if (error)
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
				existError = true;
			}
		}

		// OM-2019-0000866 ADD START
		//MATEファイルであれば反響可能性フラグと対応部署名のチェックを行わない
		//CASEファイルであればチェックを行う
		if (isMate == false)
		{
		// OM-2019-0000866 ADD END
			// ANK-3593-00-00 ADD START
			// 反響可能性フラグチェック
			int hankyoPsbFlgIdx = IDX_HANKYO_PSB_FLG;
			if (dataList.size() > hankyoPsbFlgIdx)
			{
				String hankyoPsbFlg = dataList.get(IDX_HANKYO_PSB_FLG);
				errInfoMap = checkHankyoPsbFlg(commonItem, hankyoPsbFlg, errorRecordCount);
				error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
				if (error)
				{
					logData.append(errInfoMap.get(KEY_LOG_DATA));
					existError = true;
				}
			}
			// 対応部署名チェック
			int taioBushoNmIdx = IDX_TAIO_BUSHO_NM;
			if (dataList.size() > taioBushoNmIdx)
			{
				String taioBusho = dataList.get(IDX_TAIO_BUSHO_NM);
				errInfoMap = checkTaioBushoNm(commonItem, taioBusho, errorRecordCount);
				error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
				if (error)
				{
					logData.append(errInfoMap.get(KEY_LOG_DATA));
					existError = true;
				}
			}
			// ANK-3593-00-00 ADD END
		// OM-2019-0000866 ADD START
		}
		// OM-2019-0000866 ADD END

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

		return resMap;
	}

	/**
	 * 顧客タイプチェック
	 * @param commonItem 共通情報
	 * @param kokyakuTp 顧客タイプ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 */
	private static Map<String, Object> checkKokyakuType(JBSbatCommonItem commonItem, String kokyakuTp, int errorRecordCount)
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		// 顧客タイプ

		if (kokyakuTp == null || "".equals(kokyakuTp.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客タイプ"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客タイプ"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else if (!(KANYUSHA.equals(kokyakuTp)) && !(MI_KANYUSHA.equals(kokyakuTp)))
		{
			// 加入者・未加入者でない場合
			// ECRB0190KW	%1%の内容が正しくありません。（%2%）
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0190KW, new String[] {"顧客タイプ", kokyakuTp});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0190KW, new String[] {"顧客タイプ", kokyakuTp}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}

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

		return resMap;
	}

	/**
	 * サービス契約番号チェック
	 * @param commonItem 共通情報
	 * @param svcKykNo サービス契約番号
	 * @param kokyakuTp 顧客タイプ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkSvcKykNo(JBSbatCommonItem commonItem, String svcKykNo, String kokyakuTp, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		// サービス契約番号
		String komokuNm = "お客さまID";

		if (KANYUSHA.equals(kokyakuTp))
		{
			// 顧客タイプが「加入者」の場合

			if (svcKykNo == null || "".equals(svcKykNo.trim()))
			{
				// 必須チェック
				// エラーログ
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {komokuNm});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {komokuNm}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

		if (svcKykNo != null && !("".equals(svcKykNo.trim())))
		{
			int byteLength = JCRUtilCommon.getByteLength(svcKykNo);
			if (byteLength != SVC_KYK_NO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {komokuNm, SVC_KYK_NO_BYTE_SU + "byte", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {komokuNm, SVC_KYK_NO_BYTE_SU + "byte", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 顧客氏名チェック
	 * @param commonItem 共通情報
	 * @param kokyakuNm 顧客氏名
	 * @param kokyakuTp 顧客タイプ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkKokyakuNm(JBSbatCommonItem commonItem, String kokyakuNm, String kokyakuTp, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (MI_KANYUSHA.equals(kokyakuTp))
		{
			// 顧客タイプが「未加入者」の場合

			if (kokyakuNm == null || "".equals(kokyakuNm.trim()))
			{
				// 必須チェック
				// エラーログ
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客氏名"});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客氏名"}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

		if (kokyakuNm != null && !("".equals(kokyakuNm.trim())))
		{
			if (!(JCRBatCommon.isKisyuIzonNmAd(kokyakuNm)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"顧客氏名", "機種依存_氏名/住所", kokyakuNm});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"顧客氏名", "機種依存_氏名/住所", kokyakuNm}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(kokyakuNm);
			if (byteLength > NAME_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"顧客氏名", NAME_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"顧客氏名", NAME_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 顧客氏名(カナ)チェック
	 * @param commonItem 共通情報
	 * @param kokyakuKana 顧客氏名(カナ)
	 * @param kokyakuTp 顧客タイプ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkKokyakuKana(JBSbatCommonItem commonItem, String kokyakuKana, String kokyakuTp, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (MI_KANYUSHA.equals(kokyakuTp))
		{
			// 顧客タイプが「未加入者」の場合

			if (kokyakuKana == null || "".equals(kokyakuKana.trim()))
			{
				// 必須チェック
				// エラーログ
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客氏名(カナ)"});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"顧客氏名(カナ)"}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

		if (kokyakuKana != null && !("".equals(kokyakuKana.trim())))
		{
			if (!(JCRBatCommon.isZenkakuESuujiKana(kokyakuKana)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"顧客氏名(カナ)", "全角英数字カナ", kokyakuKana});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW,
																new String[] {"顧客氏名(カナ)", "全角英数字カナ", kokyakuKana}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(kokyakuKana);
			if (byteLength > NAME_KANA_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"顧客氏名(カナ)", NAME_KANA_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"顧客氏名(カナ)", NAME_KANA_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 電話番号チェック
	 * @param commonItem 共通情報
	 * @param telNo 電話番号
	 * @param kokyakuTp 顧客タイプ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTelNo(JBSbatCommonItem commonItem, String telNo, String kokyakuTp, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (MI_KANYUSHA.equals(kokyakuTp))
		{
			// 顧客タイプが「未加入者」の場合

			if (telNo == null || "".equals(telNo.trim()))
			{
				// 必須チェック
				// エラーログ
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"電話番号"});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"電話番号"}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

		if (telNo != null && !("".equals(telNo.trim())))
		{
			// ハイフン除去
			String telNoWork = JCRBatCommon.formatTelNoDel(telNo);
			int byteLength = JCRUtilCommon.getByteLength(telNoWork);
			if (byteLength > TELNO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"電話番号", TELNO_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"電話番号", TELNO_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 電話番号2チェック
	 * @param commonItem 共通情報
	 * @param telNo2 電話番号2
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTelNo2(JBSbatCommonItem commonItem, String telNo2, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (telNo2 != null && !("".equals(telNo2.trim())))
		{
			// ハイフン除去
			String telNoWork = JCRBatCommon.formatTelNoDel(telNo2);
			int byteLength = JCRUtilCommon.getByteLength(telNoWork);
			if (byteLength > TELNO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"電話番号２", TELNO_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"電話番号２", TELNO_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 郵便番号チェック
	 * @param commonItem 共通情報
	 * @param yubinNo 郵便番号
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkYubinNo(JBSbatCommonItem commonItem, String yubinNo, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (yubinNo != null && !("".equals(yubinNo.trim())))
		{
			// ハイフン除去
			String yubinNoWork = yubinNo.replaceAll("-", "");

			if (!(JCRBatCommon.isHannkakuSuuji1(yubinNoWork)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"郵便番号", "半角数字、'-'", yubinNo});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"郵便番号", "半角数字、'-'", yubinNo}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(yubinNoWork);
			if (byteLength > YUBINNO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"郵便番号", YUBINNO_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"郵便番号", YUBINNO_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 住所1チェック
	 * @param commonItem 共通情報
	 * @param jusho1 住所1
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkJusho1(JBSbatCommonItem commonItem, String jusho1, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (jusho1 != null && !("".equals(jusho1.trim())))
		{
			if (!(JCRBatCommon.isKisyuIzonNmAd(jusho1)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所1", "機種依存_氏名/住所", jusho1});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所1", "機種依存_氏名/住所", jusho1}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(jusho1);
			if (byteLength > JUSHO1_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所1", JUSHO1_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所1", JUSHO1_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 住所2チェック
	 * @param commonItem 共通情報
	 * @param jusho2 住所2
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkJusho2(JBSbatCommonItem commonItem, String jusho2, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (jusho2 != null && !("".equals(jusho2.trim())))
		{
			if (!(JCRBatCommon.isKisyuIzonNmAd(jusho2)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所2", "機種依存_氏名/住所", jusho2});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所2", "機種依存_氏名/住所", jusho2}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(jusho2);
			if (byteLength > JUSHO2_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所2", JUSHO2_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所2", JUSHO2_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 住所3チェック
	 * @param commonItem 共通情報
	 * @param jusho3 住所3
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkJusho3(JBSbatCommonItem commonItem, String jusho3, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (jusho3 != null && !("".equals(jusho3.trim())))
		{
			if (!(JCRBatCommon.isKisyuIzonNmAd(jusho3)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所3", "機種依存_氏名/住所", jusho3});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"住所3", "機種依存_氏名/住所", jusho3}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(jusho3);
			if (byteLength > JUSHO3_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所3", JUSHO3_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"住所3", JUSHO3_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 性別チェック
	 * @param commonItem 共通情報
	 * @param seibetsu 性別
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkSeibetsu(JBSbatCommonItem commonItem, String seibetsu, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (seibetsu != null && !("".equals(seibetsu.trim())))
		{

			boolean exist = false;
			StringBuilder seibetsuList = new StringBuilder();
			for (int i = 0; i < SEIBETSU_LIST.length; i++)
			{
				if (SEIBETSU_LIST[i].equals(seibetsu))
				{
					exist = true;
				}
				if (i != 0)
				{
					seibetsuList.append(",");
				}
				seibetsuList.append(SEIBETSU_LIST[i]);
			}
			if (!(exist))
			{
				// 値チェック
				// ECRB0390TW	%1%の値チェックエラー。（%2%を入力）値：%3%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0390TW,
																new String[] {"性別", seibetsuList.toString(), seibetsu});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0390TW,
																new String[] {"性別", seibetsuList.toString(), seibetsu}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 生年月日チェック
	 * @param commonItem 共通情報
	 * @param seinengappi 生年月日
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkSeinengappi(JBSbatCommonItem commonItem, String seinengappi, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (seinengappi != null && !("".equals(seinengappi.trim())))
		{
			if (!(JCRBatCommon.isHannkakuSuuji1(seinengappi)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"生年月日", "半角数字", seinengappi});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"生年月日", "半角数字", seinengappi}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			if (!(existError))
			{
				if (!(JCRBatCommon.isYearMonthDay1(seinengappi)))
				{
					// 日付チェック
					// ECRB0380TW	%1%の日付チェックエラー。（ yyyyMMdd もしくは yyyy/MM/dd の形式）値：%2%
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0380TW, new String[] {"生年月日", seinengappi});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0380TW, new String[] {"生年月日", seinengappi}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
				}
			}
		}

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

		return resMap;
	}

	/**
	 * 状態チェック
	 * @param commonItem 共通情報
	 * @param jotai 状態
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkJotai(JBSbatCommonItem commonItem, String jotai, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (jotai == null || "".equals(jotai.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"状態"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"状態"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else
		{
			boolean exist = false;
			StringBuilder jotaiList = new StringBuilder();
			for (int i = 0; i < JOTAI_LIST.length; i++)
			{
				if (JOTAI_LIST[i].equals(jotai))
				{
					exist = true;
				}
				if (i != 0)
				{
					jotaiList.append(",");
				}
				jotaiList.append(JOTAI_LIST[i]);
			}
			if (!(exist))
			{
				// 値チェック
				// ECRB0390TW	%1%の値チェックエラー。（%2%を入力）値：%3%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0390TW, new String[] {"状態", jotaiList.toString(), jotai});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0390TW, new String[] {"状態", jotaiList.toString(), jotai}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * ステータスチェック
	 * @param commonItem 共通情報
	 * @param status ステータス
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkStatus(JBSbatCommonItem commonItem, String status, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (status == null || "".equals(status.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"ステータス"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"ステータス"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else
		{
			boolean exist = false;
			StringBuilder statusList = new StringBuilder();
			for (int i = 0; i < STATUS_LIST.length; i++)
			{
				if (STATUS_LIST[i].equals(status))
				{
					exist = true;
				}
				if (i != 0)
				{
					statusList.append(",");
				}
				statusList.append(STATUS_LIST[i]);
			}
			if (!(exist))
			{
				// 値チェック
				// ECRB0390TW	%1%の値チェックエラー。（%2%を入力）値：%3%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0390TW, new String[] {"ステータス", statusList.toString(), status});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0390TW, new String[] {"ステータス", statusList.toString(), status}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 作成日時チェック
	 * @param commonItem 共通情報
	 * @param sakuseiDate 作成日時
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkSakuseiDate(JBSbatCommonItem commonItem, String sakuseiDate, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (sakuseiDate == null || "".equals(sakuseiDate.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"作成日時"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"作成日時"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else
		{
			if (!(JCRBatCommon.isDayHour4(sakuseiDate)))
			{
				// 日付チェック
				// ECRB0240TW	%1%の日付チェックエラー。（yyyy/MM/dd HH:MI:SSの形式）値：%2%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0240TW, new String[] {"作成日時", sakuseiDate});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0240TW, new String[] {"作成日時", sakuseiDate}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 受付者チェック
	 * @param commonItem 共通情報
	 * @param uketsukesha 受付者
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkUketsukesha(JBSbatCommonItem commonItem, String uketsukesha, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (uketsukesha == null || "".equals(uketsukesha.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"受付者"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"受付者"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else
		{
			int byteLength = JCRUtilCommon.getByteLength(uketsukesha);
			if (byteLength > CHK_USERID_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"受付者", CHK_USERID_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"受付者", CHK_USERID_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 担当者チェック
	 * @param commonItem 共通情報
	 * @param tantosha 担当者
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTantosha(JBSbatCommonItem commonItem, String tantosha, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (tantosha == null || "".equals(tantosha.trim()))
		{
			// 必須チェック
			// エラーログ
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"担当者"});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"担当者"}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}
		else
		{
			int byteLength = JCRUtilCommon.getByteLength(tantosha);
			if (byteLength > CHK_USERID_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"担当者", CHK_USERID_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"担当者", CHK_USERID_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * キュー名チェック
	 * @param commonItem 共通情報
	 * @param queNm キュー名
	 * @param jotai 状態
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkQueNm(JBSbatCommonItem commonItem, String queNm, String jotai, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (JOTAI_ESCL.equals(jotai))
		{
			// 状態がエスカレーションの場合
			if (queNm == null || "".equals(queNm.trim()))
			{
				// 必須チェック
				// エラーログ
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0370TW, new String[] {"キュー名"});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0370TW, new String[] {"キュー名"}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}
		if (queNm != null && !("".equals(queNm.trim())))
		{
			int byteLength = JCRUtilCommon.getByteLength(queNm);
			if (byteLength > QUENM_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"キュー名", QUENM_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"キュー名", QUENM_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 受付種別チェック
	 * @param commonItem 共通情報
	 * @param uketsukeSbt 受付種別
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkUketsukeSbt(JBSbatCommonItem commonItem, String uketsukeSbt, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (uketsukeSbt != null && !("".equals(uketsukeSbt.trim())))
		{
			boolean exist = false;
			StringBuilder jotaiList = new StringBuilder();
			for (int i = 0; i < UKTK_SBT_LIST.length; i++)
			{
				if (UKTK_SBT_LIST[i].equals(uketsukeSbt))
				{
					exist = true;
				}
				if (i != 0)
				{
					jotaiList.append(",");
				}
				jotaiList.append(UKTK_SBT_LIST[i]);
			}
			if (!(exist))
			{
				// 値チェック
				// ECRB0390TW	%1%の値チェックエラー。（%2%を入力）値：%3%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0390TW, new String[] {"受付種別", jotaiList.toString(), uketsukeSbt});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0390TW,
																new String[] {"受付種別", jotaiList.toString(), uketsukeSbt}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * タイトルチェック
	 * @param commonItem 共通情報
	 * @param title タイトル
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTitle(JBSbatCommonItem commonItem, String title, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (title != null && !("".equals(title.trim())))
		{
			if (!(JCRBatCommon.isMailTitle(title)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"タイトル", "メールタイトル", title});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"タイトル", "メールタイトル", title}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(title);
			if (byteLength > TITLE_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"タイトル", TITLE_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"タイトル", TITLE_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * カテゴリーチェック
	 * @param commonItem 共通情報
	 * @param ctgr カテゴリー名配列
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkCategory(JBSbatCommonItem commonItem, String[] ctgr, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		boolean isDataNull = false;					// データ空フラグ（データが空のときtrue）

		for (int i = 0; i < ctgr.length; i++)
		{
			String ctgrNm = ctgr[i];

			if (isDataNull == true)
			{
				// 上位レベルに空のカテゴリーがある場合
				if (ctgrNm != null && !("".equals(ctgrNm.trim())))
				{
					// カテゴリーの組合せ不正
					// ECRB0190KW	%1%の内容が正しくありません。（%2%）
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0190KW, new String[] {"カテゴリー名", "組合せ不正"});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0190KW, new String[] {"カテゴリー名", "組合せ不正"}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
					break;
				}
			}

			if (ctgrNm == null || ("".equals(ctgrNm.trim())))
			{
				// カテゴリー名が空の場合
				isDataNull = true;
			}
		}

		for (int i = 0; i < ctgr.length; i++)
		{
			String ctgrNm = ctgr[i];

			if (ctgrNm != null && !("".equals(ctgrNm.trim())))
			{
				if (!(JCRBatCommon.isMIX(ctgrNm)))
				{
					// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"カテゴリー名(" + (i + 1) + ")", "MIX", ctgrNm});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"カテゴリー名(" + (i + 1) + ")", "MIX", ctgrNm}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
				}

				int byteLength = JCRUtilCommon.getByteLength(ctgrNm);
				if (byteLength > CTGRNM_BYTE_SU)
				{
					// 桁数チェック
					// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"カテゴリー名(" + (i + 1) + ")", CTGRNM_BYTE_SU + "byte以内", String.valueOf(byteLength)});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"カテゴリー名(" + (i + 1) + ")", CTGRNM_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
				}
			}
		}

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

		return resMap;
	}

	/**
	 * カテゴリーチェック
	 * @param commonItem 共通情報
	 * @param ctgr カテゴリー名配列
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkCategory2(JBSbatCommonItem commonItem, String[] ctgr, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		String joiCtgrNo = null;

		for (int i = 0; i < ctgr.length; i++)
		{
			String ctgrNm = ctgr[i];

			if (ctgrNm != null && !("".equals(ctgrNm.trim())))
			{
				Object[] params = null;

				if (i == 0)
				{
					params = new Object[2];
					params[0] = ctgrNm;
					params[1] = JCRBatCommon.fillZero(Integer.toString(i + 1), 3, false);
				}
				else
				{
					params = new Object[3];
					params[0] = ctgrNm;
					params[1] = JCRBatCommon.fillZero(Integer.toString(i + 1), 3, false);
					params[2] = joiCtgrNo;
				}
				commonItem.getLogPrint().printDebugLog("カテゴリー名(" + (i + 1) + "):" + ctgrNm);

				// カテゴリーテーブル検索
				List<JBSbatCommonDBInterface> ctgrDataList = getCategoryInfo(commonItem, params);

				if (ctgrDataList == null || ctgrDataList.size() == 0)
				{
					// ECRB0250KW:データが登録されていません。(%1%)
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {"カテゴリーテーブル;カテゴリー名:" + ctgrNm});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, new String[] {"カテゴリーテーブル;カテゴリー名:" + ctgrNm}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
					break;
				}

				JBSbatCommonDBInterface ctgrData = ctgrDataList.get(0);
				joiCtgrNo = ctgrData.getString(JBSbatCR_M_CTGR.CTGR_NO);		// カテゴリー番号
			}
			else
			{
				joiCtgrNo = null;
			}
		}

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

		return resMap;
	}

	/**
	 * 問合せ履歴チェック
	 * @param commonItem 共通情報
	 * @param rireki 問合せ履歴
	 * @param chgCRWord 改行コード変換文字
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkRireki(JBSbatCommonItem commonItem,
													String rireki,
													String chgCRWord,
													int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		String wkRireki = "";
		if (rireki != null && !("".equals(rireki.trim())))
		{
			// 改行コード復元
			wkRireki = rireki.replaceAll(chgCRWord, JCRStrConst.KAIGYO_CD);

			if (!(JCRBatCommon.isMailText(wkRireki)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"問合せ履歴", "メール本文", wkRireki});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"問合せ履歴", "メール本文", wkRireki}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(wkRireki);
			if (byteLength > RIREKI_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"問合せ履歴", RIREKI_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"問合せ履歴", RIREKI_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 問合せ客番号チェック
	 * @param commonItem 共通情報
	 * @param tiawsKyakuNo 問合せ客番号
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTiawsKyakuNo(JBSbatCommonItem commonItem, String tiawsKyakuNo, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (tiawsKyakuNo != null && !("".equals(tiawsKyakuNo.trim())))
		{
			if (!(JCRBatCommon.isHannkakuSuuji1(tiawsKyakuNo)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"問合せ客番号", "半角数字", tiawsKyakuNo});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"問合せ客番号", "半角数字", tiawsKyakuNo}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(tiawsKyakuNo);
			if (byteLength > TIAWS_KYAKU_NO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"問合せ客番号", TIAWS_KYAKU_NO_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"問合せ客番号", TIAWS_KYAKU_NO_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * eoIDチェック
	 * @param commonItem 共通情報
	 * @param eoID eoID
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkEoID(JBSbatCommonItem commonItem, String eoID, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (eoID != null && !("".equals(eoID.trim())))
		{
			if (!(JCRBatCommon.isHannkakuESuuji2(eoID)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"eoID", "半角英数字", eoID});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"eoID", "半角英数字", eoID}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(eoID);
			if (byteLength > EOID_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"eoID", EOID_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"eoID", EOID_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 申込書番号チェック
	 * @param commonItem 共通情報
	 * @param muskmshoNo 申込書番号
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkMuskmshoNo(JBSbatCommonItem commonItem, String muskmshoNo, int errorRecordCount)
	throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (muskmshoNo != null && !("".equals(muskmshoNo.trim())))
		{
			if (!(JCRBatCommon.isHannkakuESuuji8(muskmshoNo)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW,
																new String[] {"受付番号", "半角英数字(英小文字不可)", muskmshoNo});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW,
																new String[] {"受付番号", "半角英数字(英小文字不可)", muskmshoNo}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			int byteLength = JCRUtilCommon.getByteLength(muskmshoNo);
			if (byteLength > MUSKMSHONO_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"受付番号", MUSKMSHONO_BYTE_SU + "byte以内", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"受付番号", MUSKMSHONO_BYTE_SU + "byte以内", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * コールバック日時チェック
	 * @param commonItem 共通情報
	 * @param callBackDate コールバック日時
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkCallBackDate(JBSbatCommonItem commonItem, String callBackDate, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (callBackDate != null && !("".equals(callBackDate.trim())))
		{
			if (!(JCRBatCommon.isDayHour4(callBackDate)))
			{
				// 日付チェック
				// ECRB0240TW	%1%の日付チェックエラー。（yyyy/MM/dd HH:MI:SSの形式）値：%2%
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0240TW, new String[] {"コールバック日時", callBackDate});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0240TW, new String[] {"コールバック日時", callBackDate}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * コールバック時間指定タイプチェック
	 * @param commonItem 共通情報
	 * @param callBackTypeNm コールバック時間指定タイプ名
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkCallBackType(JBSbatCommonItem commonItem, String callBackTypeNm, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (callBackTypeNm != null && !("".equals(callBackTypeNm.trim())))
		{
			// コード名称管理検索
			String codeKbn = JCRBatCommon.getCodeKbn(commonItem, JZM0171Constant.CD00457, callBackTypeNm);

			if (codeKbn == null || "".equals(codeKbn))
			{
				// ECRB0250KW:データが登録されていません。(%1%)
				String param = "コード名称管理テーブル;コールバック時間指定タイプ名:" + callBackTypeNm;
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {param});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, new String[] {param}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	/**
	 * 業務個別設定組織コードチェック
	 * @param commonItem 共通情報
	 * @param wkkbtOrgCd 業務個別設定組織コード
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkWkkbtOrgCd(JBSbatCommonItem commonItem, String wkkbtOrgCd, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (wkkbtOrgCd != null && !("".equals(wkkbtOrgCd.trim())))
		{
			int byteLength = JCRUtilCommon.getByteLength(wkkbtOrgCd);
			if (byteLength != WKKBT_ORG_CD_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"業務個別設定組織コード", WKKBT_ORG_CD_BYTE_SU + "byte", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"業務個別設定組織コード", WKKBT_ORG_CD_BYTE_SU + "byte", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}
		}

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

		return resMap;
	}

	// ANK-3593-00-00 ADD START
	/**
	 * 反響可能性フラグチェック
	 * @param commonItem 共通情報
	 * @param hankyoPsbFlg 反響可能性フラグ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkHankyoPsbFlg(JBSbatCommonItem commonItem, String hankyoPsbFlg, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (hankyoPsbFlg != null && !("".equals(hankyoPsbFlg.trim())))
		{
			// byte桁数チェック
			int byteLength = JCRUtilCommon.getByteLength(hankyoPsbFlg);
			if (byteLength != HANKYO_PSB_FLG_BYTE_SU)
			{
				// 桁数チェック
				// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"反響可能性フラグ", HANKYO_PSB_FLG_BYTE_SU + "byte", String.valueOf(byteLength)});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
															new String[] {"反響可能性フラグ", HANKYO_PSB_FLG_BYTE_SU + "byte", String.valueOf(byteLength)}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			if (!(existError))
			{
				// 反響可能性フラグの値が0または1以外の場合
				if(!HANKYO_PSB_FLG_ON.equals(hankyoPsbFlg) && !HANKYO_PSB_FLG_OFF.equals(hankyoPsbFlg)){
					
						// 値チェック
						// ECRB0390TW	%1%の値チェックエラー。（%2%を入力）値：%3%
						commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0390TW, new String[] {"反響可能性フラグ", HANKYO_PSB_FLG_RULE, hankyoPsbFlg});
						logData.append(String.valueOf(errorRecordCount) + "レコード目:");
						logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0390TW,
																		new String[] {"反響可能性フラグ", HANKYO_PSB_FLG_RULE, hankyoPsbFlg}));
						logData.append(JCRStrConst.KAIGYO_CD);
	
						existError = true;
				}
			}	
		}

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

		return resMap;
	}
	
	/**
	 * 対応部署名チェック
	 * @param commonItem 共通情報
	 * @param taioBusho 対応部署名
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkTaioBushoNm(JBSbatCommonItem commonItem, String taioBusho, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		if (taioBusho != null && !("".equals(taioBusho.trim())))
		{
			if (!(JCRBatCommon.isZenkaku(taioBusho)))
			{
				// ECRB0230TW	%1%の属性が正しくありません。(属性:%2% 値:%3%)
				commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0230TW, new String[] {"対応部署名", "全角", taioBusho});
				logData.append(String.valueOf(errorRecordCount) + "レコード目:");
				logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0230TW, new String[] {"対応部署名", "全角", taioBusho}));
				logData.append(JCRStrConst.KAIGYO_CD);

				existError = true;
			}

			if (!(existError))
			{
				// byte桁数チェック
				int byteLength = JCRUtilCommon.getByteLength(taioBusho);
				if (byteLength > TAIO_BUSHO_NM_BYTE_SU)
				{
					// 桁数チェック
					// ECRB0200TW	%1%のバイト数が正しくありません。(条件:%2% 値:%3%)
					commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"対応部署名", TAIO_BUSHO_NM_BYTE_SU + "byte", String.valueOf(byteLength)});
					logData.append(String.valueOf(errorRecordCount) + "レコード目:");
					logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0200TW,
																new String[] {"対応部署名", TAIO_BUSHO_NM_BYTE_SU + "byte", String.valueOf(byteLength)}));
					logData.append(JCRStrConst.KAIGYO_CD);

					existError = true;
				}
			}
		}

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

		return resMap;
	}
	// ANK-3593-00-00 ADD END
	/**
	 * カテゴリー情報を取得する。
	 * @param commonItem バッチ共通パラメータ電文
	 * @param param バイント変数の値配列。
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static List<JBSbatCommonDBInterface> getCategoryInfo(JBSbatCommonItem commonItem, Object[] param) throws Exception
	{
		// カテゴリー
		JBSbatSQLAccess dbCrMCtgr = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_M_CTGR);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());	// カテゴリー名
		paramList.setValue(param[1].toString());	// カテゴリーレベル

		if (param.length == 2)
		{
			// DBアクセスを実行します
			dbCrMCtgr.selectBySqlDefine(paramList, CR_M_CTGR_CR_SELECT_003);
		}
		else
		{
			paramList.setValue(param[2].toString());	// 上位カテゴリー番号
			// DBアクセスを実行します
			dbCrMCtgr.selectBySqlDefine(paramList, CR_M_CTGR_CR_SELECT_004);
		}

		List<JBSbatCommonDBInterface> ctgrDataList = JCRBatCommon.getSelectedDataList(dbCrMCtgr);

		return ctgrDataList;
	}

	/**
	 * テーブルデータチェック処理
	 * @param commonItem 共通情報
	 * @param dataList 1行分のデータ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_SVC_KEY_NO		サービス契約番号
	 * 			KEY_QUE_BOX_NO		キューBOX番号(取得できた場合)
	 * 			KEY_MYBOX_NO		MYBOX番号(取得できた場合)
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 */
	static Map<String, Object> checkTableData(JBSbatCommonItem commonItem,
									List<String> dataList,
									int errorRecordCount,
									String chgCRWord) throws Exception
	{
		return checkTableData(commonItem, dataList, errorRecordCount, chgCRWord, false);
	}

	/**
	 * テーブルデータチェック処理
	 * @param commonItem 共通情報
	 * @param dataList 1行分のデータ
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @param chgCRWord 改行コード変換文字
	 * @param isMate MATEファイルの場合true
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_SVC_KEY_NO		サービス契約番号
	 * 			KEY_QUE_BOX_NO		キューBOX番号(取得できた場合)
	 * 			KEY_MYBOX_NO		MYBOX番号(取得できた場合)
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 */
	static Map<String, Object> checkTableData(JBSbatCommonItem commonItem,
									List<String> dataList,
									int errorRecordCount,
									String chgCRWord,
									boolean isMate) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

		boolean existError = false;
		boolean error = false;

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

		String kokyakuTp = dataList.get(IDX_KOKYAKU_TYPE);

		if (!(MI_KANYUSHA.equals(kokyakuTp)))
		{
			// 加入者の場合

			// お客様存在チェック
			String svcKeiNo = dataList.get(IDX_SVC_KEI_NO);
			String eoID = dataList.get(IDX_EOID);
			errInfoMap = checkOkyakusama(commonItem, svcKeiNo, eoID, errorRecordCount);
			error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
			if (!(error))
			{
				String wkSvcKeiNo = (String)errInfoMap.get(KEY_SVC_KEY_NO);
				if (wkSvcKeiNo != null && !("".equals(wkSvcKeiNo.trim())))
				{
					// eoIDからサービス契約番号が取得できた場合
					resMap.put(KEY_SVC_KEY_NO, wkSvcKeiNo);
				}
			}
			else
			{
				logData.append(errInfoMap.get(KEY_LOG_DATA));
				existError = true;
			}
		}

		if (!(existError))
		{
			if (MI_KANYUSHA.equals(kokyakuTp))
			{
				// 未加入者の場合

				// 問合せ客存在チェック
				String tiawsKyakuNo = dataList.get(IDX_TIAWS_KYAKU_NO);
				if (tiawsKyakuNo != null && !("".equals(tiawsKyakuNo.trim())))
				{
					// 読込ファイルの問合せ客番号が空白でない場合

					errInfoMap = checkTiawsKyaku(commonItem, tiawsKyakuNo, errorRecordCount);
					error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
					if (error)
					{
						logData.append(errInfoMap.get(KEY_LOG_DATA));
						existError = true;
					}
				}
			}
		}

		String jotai = dataList.get(IDX_JOTAI);
		if (!(existError))
		{
			if (JOTAI_ESCL.equals(jotai))
			{
				// 読込ファイルの「状態」がエスカレーションの場合

				// キューBOX存在チェック
				String queNm = dataList.get(IDX_QUE_NM);
				String queBoxNo = "";
				// キューBOX存在チェック処理
				errInfoMap = checkQueBox(commonItem, queNm, errorRecordCount);
				error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
				if (!(error))
				{
					queBoxNo = (String)errInfoMap.get(KEY_QUE_BOX_NO);
					resMap.put(KEY_QUE_BOX_NO, queBoxNo);
				}
				else
				{
					logData.append(errInfoMap.get(KEY_LOG_DATA));
					existError = true;
				}
			}
		}

		if (!(existError))
		{
			if (JOTAI_OPEN.equals(jotai))
			{
				// 読込ファイルの「状態」がオープンの場合

				// MYBOX存在チェック
				String myboxNo = "";
				// MYBOX存在チェック処理
				errInfoMap = checkMybox(commonItem, dataList.get(IDX_TANTO), errorRecordCount);
				error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
				if (!(error))
				{
					myboxNo = (String)errInfoMap.get(KEY_MYBOX_NO);
					resMap.put(KEY_MYBOX_NO, myboxNo);
				}
				else
				{
					logData.append(errInfoMap.get(KEY_LOG_DATA));
					existError = true;
				}
			}
		}

		if (!(existError))
		{
			// 業務個別設定組織コードチェック
			int wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_CASE;
			if (isMate == true)
			{
				wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_MATE;
			}
			if (dataList.size() > wkkbtOrgCdIdx)
			{
				String wkkbtOrgCd = dataList.get(wkkbtOrgCdIdx);
				if (wkkbtOrgCd != null && !("".equals(wkkbtOrgCd.trim())))
				{
					// 業務個別設定組織コード存在チェック処理
					errInfoMap = checkWkkbtOrg(commonItem, wkkbtOrgCd, errorRecordCount);
					error = (Boolean)errInfoMap.get(KEY_EXIST_ERROR);
					if (error)
					{
						logData.append(errInfoMap.get(KEY_LOG_DATA));
						existError = true;
					}
				}
			}
		}

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

		return resMap;
	}

	/**
	 * お客様存在チェック
	 * @param commonItem 共通情報
	 * @param svcKeiNo サービス契約番号
	 * @param eoID eoID
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_SVC_KEY_NO		サービス契約番号(取得できた場合)
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 例外
	 */
	private static Map<String, Object> checkOkyakusama(JBSbatCommonItem commonItem,
														String svcKeiNo,
														String eoID,
														int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		int count = 0;

		if (svcKeiNo != null && !("".equals(svcKeiNo)))
		{
			// 読込ファイルに「サービス契約番号」の設定がある場合

			// お客さまデータ件数取得
			count = getOkyakusamaDataCount(commonItem, svcKeiNo);
			if (count == 0)
			{
				existError = true;
			}
		}

		if (count == 0)
		{
			// お客様データが取得できなかった場合
			wkSvcKeiNo = null;

			if (eoID != null && !("".equals(eoID)))
			{
				// 読込ファイルに「eoID」の設定がある場合
				existError = false;
				wkSvcKeiNo = getSvcKeiNo(commonItem, eoID);
				if (wkSvcKeiNo == null || "".equals(wkSvcKeiNo.trim()))
				{
					existError = true;
				}
			}
		}

		if (existError)
		{
			// ECRB0250KW:データが登録されていません。(%1%)
			String[] params = new String[] {"お客様テーブル;お客さまID:" + svcKeiNo + ";eoID:" + eoID};
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, params);
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, params));
			logData.append(JCRStrConst.KAIGYO_CD);
		}

		resMap.put(KEY_EXIST_ERROR, existError);
		resMap.put(KEY_SVC_KEY_NO, wkSvcKeiNo);
		resMap.put(KEY_LOG_DATA, logData.toString());

		return resMap;
	}

	/**
	 * お客様データ件数を取得する。
	 * @param commonItem バッチ共通パラメータ電文
	 * @param svcKeiNo サービス契約番号
	 * @return 取得データ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static int getOkyakusamaDataCount(JBSbatCommonItem commonItem, String svcKeiNo) throws Exception
	{
		// サービス契約
		JBSbatSQLAccess dbKkTSvcKei = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_KK_T_SVC_KEI);

		// ▼▼ ST-2015-0000055 MOD START ▼▼
//		String sysDate = JCRBatCommon.getSysDate();
		String opeDate = commonItem.getOpeDate();
		// ▲▲ ST-2015-0000055  MOD  END ▲▲

		int count = 0;

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(svcKeiNo);		// サービス契約番号
		// ▼▼ ST-2015-0000055 MOD START ▼▼
//		paramList.setValue(sysDate);		// 予約適用年月日
//		paramList.setValue(sysDate);		// 予約適用年月日
		paramList.setValue(opeDate);		// 運用年月日
		paramList.setValue(opeDate);		// 運用年月日
		// ▲▲ ST-2015-0000055  MOD  END ▲▲

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

		JBSbatCommonDBInterface selectedData = dbKkTSvcKei.selectNext();

		if (selectedData != null)
		{
			BigDecimal cnt = selectedData.getBigDecimal(CNT);
			if (cnt != null)
			{
				count = cnt.intValue();
			}
		}
		return count;
	}

	/**
	 * サービス契約番号を取得する。
	 * @param commonItem バッチ共通パラメータ電文
	 * @param eoID eoID
	 * @return サービス契約番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static String getSvcKeiNo(JBSbatCommonItem commonItem, String eoID) throws Exception
	{
		String svcKeiNo = "";		// サービス契約番号
		// ▼▼ ST-2015-0000055 MOD START ▼▼
//		String sysDate = JCRBatCommon.getSysDate();
		String opeDate = commonItem.getOpeDate();
		// ▲▲ ST-2015-0000055  MOD  END ▲▲

		// お客様
		JBSbatSQLAccess dbCkTCust = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CK_T_CUST);

		String sysId = "";

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(eoID);
		// ▼▼ ST-2015-0000055 MOD START ▼▼
//		paramList.setValue(sysDate);
		paramList.setValue(opeDate);		// 運用年月日
		// ▲▲ ST-2015-0000055  MOD  END ▲▲

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

		JBSbatCommonDBInterface selectedData = dbCkTCust.selectNext();

		if (selectedData != null)
		{
			sysId = selectedData.getString(JBSbatCK_T_CUST.SYSID);
		}

		if (sysId != null && !("".equals(sysId)))
		{
			// サービス契約
			JBSbatSQLAccess dbKkTSvcKei = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_KK_T_SVC_KEI);

			// バイント変数のリストを生成します
			paramList = new JBSbatCommonDBInterface();
			paramList.setValue(sysId);
			// ▼▼ ST-2015-0000055 MOD START ▼▼
//			paramList.setValue(sysDate);
			paramList.setValue(opeDate);		// 運用年月日
			// ▲▲ ST-2015-0000055  MOD  END ▲▲

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

			selectedData = dbKkTSvcKei.selectNext();

			if (selectedData != null)
			{
				svcKeiNo = selectedData.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO);
			}
		}
		return svcKeiNo;
	}

	/**
	 * 問合せ客存在チェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param tiawsKyakuNo 問合せ客番号
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return エラー情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static Map<String, Object> checkTiawsKyaku(JBSbatCommonItem commonItem, String tiawsKyakuNo, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		// 問合せ客
		JBSbatSQLAccess dbCkTProscst = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CK_T_PROSCST);

		int count = 0;

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(JCRBatCommon.fillZero(tiawsKyakuNo, TIAWS_KYAKU_NO_BYTE_SU, false));		// 問合せ客番号

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

		JBSbatCommonDBInterface selectedData = dbCkTProscst.selectNext();

		if (selectedData != null)
		{
			BigDecimal cnt = selectedData.getBigDecimal(CNT);
			if (cnt != null)
			{
				count = cnt.intValue();
			}
		}

		if (count == 0)
		{
			// ECRB0250KW:データが登録されていません。(%1%)
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {"問合せ客テーブル;問合せ客番号:" + tiawsKyakuNo});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW,
															new String[] {"問合せ客テーブル;問合せ客番号:" + tiawsKyakuNo}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}

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

		return resMap;
	}

	/**
	 * キューBOX存在チェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param queBoxNm キューBOX名
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_QUE_BOX_NO		キューBOX番号(取得できた場合)
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static Map<String, Object> checkQueBox(JBSbatCommonItem commonItem, String queBoxNm, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		String queBoxNo = "";

		// キューBOX
		JBSbatSQLAccess dbCrTQueBox = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_QUE_BOX);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(queBoxNm);		// キューBOX名

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

		JBSbatCommonDBInterface selectedData = dbCrTQueBox.selectNext();

		if (selectedData != null)
		{
			queBoxNo = selectedData.getString(JBSbatCR_T_QUE_BOX.QUE_BOX_NO);
		}
		else
		{
			// ECRB0250KW:データが登録されていません。(%1%)
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {"キューBOXテーブル;キューBOX名:" + queBoxNm});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, new String[] {"キューBOXテーブル;キューBOX名:" + queBoxNm}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}

		resMap.put(KEY_EXIST_ERROR, existError);
		resMap.put(KEY_QUE_BOX_NO, queBoxNo);
		resMap.put(KEY_LOG_DATA, logData.toString());

		return resMap;
	}

	/**
	 * MYBOX存在チェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param userId ユーザーID
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_MYBOX_NO		MYBOX番号(取得できた場合)
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static Map<String, Object> checkMybox(JBSbatCommonItem commonItem, String userId, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

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

		String myboxNo = "";

		// MYBOX
		JBSbatSQLAccess dbCrTMybox = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_MYBOX);

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

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

		JBSbatCommonDBInterface selectedData = dbCrTMybox.selectNext();

		if (selectedData != null)
		{
			myboxNo = selectedData.getString(JBSbatCR_T_MYBOX.MYBOX_NO);
		}
		else
		{
			// ECRB0250KW:データが登録されていません。(%1%)
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {"MYBOXテーブル;ユーザーID:" + userId});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, new String[] {"MYBOXテーブル;ユーザーID:" + userId}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}

		resMap.put(KEY_EXIST_ERROR, existError);
		resMap.put(KEY_MYBOX_NO, myboxNo);
		resMap.put(KEY_LOG_DATA, logData.toString());

		return resMap;
	}

	/**
	 * 業務個別設定組織コード存在チェック
	 * @param commonItem バッチ共通パラメータ電文
	 * @param wkkbtOrgCd 業務個別設定組織コード
	 * @param errorRecordCount エラーが存在したレコードの件数番号
	 * @return チェック結果のMap
	 * 			キー
	 * 			KEY_EXIST_ERROR		エラーが有る場合はtrue
	 * 			KEY_LOG_DATA		ログ情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private static Map<String, Object> checkWkkbtOrg(JBSbatCommonItem commonItem, String wkkbtOrgCd, int errorRecordCount) throws Exception
	{
		Map<String, Object> resMap = new HashMap<String, Object>();
		String sysDate = JCRBatCommon.getSysDate();

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

		// 業務個別設定組織
		JBSbatSQLAccess dbZmMWkkbtOrg = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_ZM_M_WKKBT_ORG);

		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(wkkbtOrgCd);		// 業務個別設定組織コード
		paramList.setValue(sysDate);
		paramList.setValue(sysDate);

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

		JBSbatCommonDBInterface selectedData = dbZmMWkkbtOrg.selectNext();

		if (selectedData == null)
		{
			// ECRB0250KW:データが登録されていません。(%1%)
			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECRB0250KW, new String[] {"業務個別設定組織テーブル;業務個別設定組織コード:" + wkkbtOrgCd});
			logData.append(String.valueOf(errorRecordCount) + "レコード目:");
			logData.append(JBSbatLogPrintControl.getMessage(JPCBatchMessageConstant.ECRB0250KW, new String[] {"業務個別設定組織テーブル;業務個別設定組織コード:" + wkkbtOrgCd}));
			logData.append(JCRStrConst.KAIGYO_CD);

			existError = true;
		}

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

		return resMap;
	}

	/**
	 * 問合せ客登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param dataList 対象データ(1行分)
	 * @return 問合せ客番号
	 * @throws Exception 例外
	 */
	static String entryTiawsKyaku(JBSbatCommonItem commonItem, List<String> dataList) throws Exception
	{
		// 問合せ客
		JBSbatSQLAccess dbCkTproscst = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CK_T_PROSCST);

		JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

		// 問合せ客番号
		String key = JCRBatCommon.getFormatedNextSeq(commonItem, JCRStrConst.SEQ_PROSCST_NO, "", TIAWS_KYAKU_NO_BYTE_SU);
		inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_NO, key);
		// 問合せ客名
		inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_NM, dataList.get(IDX_SHIMEI));
		// 問合せ客カナ名
		inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_KANA, dataList.get(IDX_SHIMEI_KANA));

		// 問合せ客電話番号
		String tel1 = dataList.get(IDX_TEL1).replaceAll("-", "");
		inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_TELNO, tel1);

		// 問合せ客携帯電話番号
		String tel2 = dataList.get(IDX_TEL2);
		if (tel2 != null && !("".equals(tel2.trim())))
		{
			tel2 = tel2.replaceAll("-", "");
			inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_KTAI_TELNO, tel2);
		}

		// 問合せ客郵便番号
		String yubinNo = dataList.get(IDX_YUBIN_NO);
		if (yubinNo != null && !("".equals(yubinNo.trim())))
		{
			yubinNo = yubinNo.replaceAll("-", "");
			inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_PCD, yubinNo);
		}

		// 問合せ客住所
		String jusho = dataList.get(IDX_JUSHO1) + dataList.get(IDX_JUSHO2) + dataList.get(IDX_JUSHO3);
		if (jusho != null && !("".equals(jusho.trim())))
		{
			inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_BNCHIGO, jusho.trim());
		}

		// 問合せ客性別コード
		String seibetsu = dataList.get(IDX_SEIBETSU);
		if (seibetsu != null && !("".equals(seibetsu.trim())))
		{
			// コード名称管理検索
			String seibetsuCd = JCRBatCommon.getCodeKbn(commonItem, JZM0171Constant.CD00245, seibetsu);
			if (seibetsuCd != null)
			{
				inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_SEX_CD, seibetsuCd);
			}
		}

		// 問合せ客生年月日
		String seinenGappi = dataList.get(IDX_SEINENGAPPI);
		if (seinenGappi != null && !("".equals(seinenGappi.trim())))
		{
			inMap.setValue(JBSbatCK_T_PROSCST.PROSCST_BIRTHD, seinenGappi);
		}

		// 削除対象外フラグ
		inMap.setValue(JBSbatCK_T_PROSCST.DEL_TRGT_GAI_FLG, JCRStrConst.CD_DIV_DEL_TAISHO);

		// お客様特定用申込書番号
		String muskmNo = dataList.get(IDX_MUSKM_SHO_NO);
		if (muskmNo != null && !("".equals(muskmNo.trim())))
		{
			inMap.setValue(JBSbatCK_T_PROSCST.CUST_TOKUT_MSKMSHO_NO, muskmNo);
		}

		// ◆ 登録
		int count = dbCkTproscst.insertByPrimaryKeys(inMap);
		commonItem.getLogPrint().printDebugLog("[問合せ客登録] 登録件数:" + count);

		return key;
	}

	/**
	 * 対応記録明細登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param dataList 対象データ(1行分)
	 * @param taioKirkNo 対応記録番号
	 * @param jotaiCd 問合せ状態コード
	 * @throws Exception 例外
	 */
	static void entryTaiokirkDtl(JBSbatCommonItem commonItem, List<String> dataList, String taioKirkNo, String jotaiCd)
	throws Exception
	{
		entryTaiokirkDtl(commonItem, dataList, taioKirkNo, jotaiCd, false);
	}

	/**
	 * 対応記録明細登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param dataList 対象データ(1行分)
	 * @param taioKirkNo 対応記録番号
	 * @param jotaiCd 問合せ状態コード
	 * @param isMATE MATE取込の場合true
	 * @throws Exception 例外
	 */
	static void entryTaiokirkDtl(JBSbatCommonItem commonItem, List<String> dataList, String taioKirkNo, String jotaiCd, boolean isMATE)
	throws Exception
	{
		// 作成日時
		String sakuseiDate = getNoDateSignString(dataList.get(IDX_SAKUSEI_DATE));
		// 対応ユーザーID
		String taioUserId = JCRUtilCommon.adjustCharSize(dataList.get(IDX_TANTO), DB_USERID_BYTE_SU, "").trim();
		// 業務個別設定組織コード
		String wkkbtOrgCd = null;

		// 業務個別設定組織コードのインデックス
		int wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_CASE;

		if (isMATE)
		{
			// MATEの場合

			wkkbtOrgCdIdx = IDX_WKKBT_ORG_CD_MATE;
			if (dataList.size() > wkkbtOrgCdIdx)
			{
				wkkbtOrgCd = dataList.get(wkkbtOrgCdIdx);
			}

			// 新規作成
			entryTaiokirkDtl(commonItem,
							taioKirkNo,
							FIRST_TAIO_KIROK_DTL_NO,
							JCRStrConst.CD_DIV_ACTION_TYPE_CD_SHINKI,
							sakuseiDate,
							taioUserId,
							wkkbtOrgCd);

			// 資料送付
			entryTaiokirkDtl(commonItem,
							taioKirkNo,
							SECOND_TAIO_KIROK_DTL_NO,
							JCRStrConst.CD_DIV_ACTION_TYPE_CD_SHIRYO,
							sakuseiDate,
							taioUserId,
							wkkbtOrgCd);

			// アクションタイプコード
			if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_CLOSE.equals(jotaiCd))
			{
				// クローズ
				entryTaiokirkDtl(commonItem,
								taioKirkNo,
								THIRD_TAIO_KIROK_DTL_NO,
								JCRStrConst.CD_DIV_ACTION_TYPE_CD_CLOSE,
								sakuseiDate,
								taioUserId,
								wkkbtOrgCd);
			}
			else if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_ESCL.equals(jotaiCd))
			{
				// エスカレーション
				entryTaiokirkDtl(commonItem,
								taioKirkNo,
								THIRD_TAIO_KIROK_DTL_NO,
								JCRStrConst.CD_DIV_ACTION_TYPE_CD_ESCL,
								sakuseiDate,
								taioUserId,
								wkkbtOrgCd);
			}
		}
		else
		{
			if (dataList.size() > wkkbtOrgCdIdx)
			{
				wkkbtOrgCd = dataList.get(wkkbtOrgCdIdx);
			}

			// 新規作成
			entryTaiokirkDtl(commonItem,
							taioKirkNo,
							FIRST_TAIO_KIROK_DTL_NO,
							JCRStrConst.CD_DIV_ACTION_TYPE_CD_SHINKI,
							sakuseiDate,
							taioUserId,
							wkkbtOrgCd);

			// アクションタイプコード
			if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_CLOSE.equals(jotaiCd))
			{
				// クローズ
				entryTaiokirkDtl(commonItem,
								taioKirkNo,
								SECOND_TAIO_KIROK_DTL_NO,
								JCRStrConst.CD_DIV_ACTION_TYPE_CD_CLOSE,
								sakuseiDate,
								taioUserId,
								wkkbtOrgCd);
			}
			else if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_ESCL.equals(jotaiCd))
			{
				// エスカレーション
				entryTaiokirkDtl(commonItem,
								taioKirkNo,
								SECOND_TAIO_KIROK_DTL_NO,
								JCRStrConst.CD_DIV_ACTION_TYPE_CD_ESCL,
								sakuseiDate,
								taioUserId,
								wkkbtOrgCd);
			}
		}
	}

	/**
	 * 対応記録明細登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirkNo 対応記録番号
	 * @param taioKirkDtlNo 対応記録明細番号
	 * @param actionTp アクションタイプコード
	 * @param sakuseiDate 作成日時
	 * @param taioUserId 対応ユーザーID
	 * @param wkkbtOrgCd 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	private static void entryTaiokirkDtl(JBSbatCommonItem commonItem,
										String taioKirkNo,
										String taioKirkDtlNo,
										String actionTp,
										String sakuseiDate,
										String taioUserId,
										String wkkbtOrgCd)
	throws Exception
	{
		// 対応記録明細
		JBSbatSQLAccess dbCrTaiokirkDtl = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_TAIOKRK_DTL);

		JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

		// 対応記録番号
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.TAIO_KIROK_NO, taioKirkNo);

		// 対応記録明細番号
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.TAIO_KIROK_DTL_NO, taioKirkDtlNo);

		// アクションタイプコード
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.ACTION_TYPE_CD, actionTp);

		// アクション開始年月日時分秒
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.ACTION_STA_DTM, sakuseiDate);

		// アクション完了年月日時分秒
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.ACTION_FIN_DTM, sakuseiDate);

		// 対応ユーザーID
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.TAIO_USER_ID, taioUserId);

		// 編集状態フラグ
		inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.HENSHU_STAT_FLG, JCRStrConst.CD_DIV_HENSHU_STAT_FLG_KANRYO);

		// 業務個別設定組織コード
		if (wkkbtOrgCd != null && !("".equals(wkkbtOrgCd)))
		{
			inMap.setValue(JBSbatCR_T_TAIOKRK_DTL.WKKBT_ORG_CD, wkkbtOrgCd);
		}

		// ◆ 登録
		dbCrTaiokirkDtl.insertByPrimaryKeys(inMap);
	}

	/**
	 * 日付記号を除去した文字列を取得する。
	 * @param target 対象文字列
	 * @return 日付記号を除去した文字列
	 */
	private static String getNoDateSignString(String target)
	{
		String res = target;
		res = res.replaceAll("/", "");
		res = res.replaceAll(":", "");
		res = res.replaceAll("\\.", "");
		res = res.replaceAll(" ", "");
		return res;
	}

	/**
	 * 対応記録内訳登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param taioKirkNo 対応記録番号
	 * @throws Exception 例外
	 */
	static void entryTaiokirkUcwk(JBSbatCommonItem commonItem, String taioKirkNo) throws Exception
	{
		// 対応記録内訳
		JBSbatSQLAccess dbCrTaiokirkUcwk = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_TAIOKRK_UCWK);

		JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

		// 対応記録番号
		inMap.setValue(JBSbatCR_T_TAIOKRK_UCWK.TAIO_KIROK_NO, taioKirkNo);

		// 対応記録内訳番号
		inMap.setValue(JBSbatCR_T_TAIOKRK_UCWK.TAIO_KIROK_UCWK_NO, FIRST_TAIO_KIROK_UCWK_NO);

		// 問合せ応対区分
		inMap.setValue(JBSbatCR_T_TAIOKRK_UCWK.TOIAWASE_RSP_DIV, JCRStrConst.CD_DIV_TIAWS_OUTAI_TIAWS);

		// 表示順序
		inMap.setValue(JBSbatCR_T_TAIOKRK_UCWK.DSP_JUN, 1);

		// ◆ 登録
		int count = dbCrTaiokirkUcwk.insertByPrimaryKeys(inMap);
		commonItem.getLogPrint().printDebugLog("[対応記録内訳登録] 登録件数:" + count);
	}

	/**
	 * 対応記録内訳カテゴリー登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param ctgrs カテゴリー配列
	 * @param taioKirkNo 対応記録番号
	 * @throws Exception 例外
	 */
	static void entryTaiokirkUwCtgr(JBSbatCommonItem commonItem,
									String[] ctgrs,
									String taioKirkNo) throws Exception
	{
		// 対応記録内訳カテゴリー
		JBSbatSQLAccess dbCrTaiokirkUwCtgr = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_TAIOKRK_UW_CT);

		for (int i = 0; i < ctgrs.length; i++)
		{
			// カテゴリー
			String ctgr = ctgrs[i];

			if (ctgr == null || "".equals(ctgr.trim()))
			{
				break;
			}
			else
			{
				JBSbatCommonDBInterface inMap = new JBSbatCommonDBInterface();

				// 対応記録番号
				inMap.setValue(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIO_KIROK_NO, taioKirkNo);

				// 対応記録内訳番号
				inMap.setValue(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIO_KIROK_UCWK_NO, FIRST_TAIO_KIROK_UCWK_NO);

				// 対応記録内訳カテゴリーレベル
				inMap.setValue(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIOKRK_UW_CTGR_LV, JCRBatCommon.fillZero(Integer.toString(i + 1), 3, false));

				// 対応記録内訳カテゴリー名
				inMap.setValue(JBSbatCR_T_TAIOKRK_UW_CTGR.TAIOKRK_UW_CTGR_NM, ctgr);

				// ◆ 登録
				int count = dbCrTaiokirkUwCtgr.insertByPrimaryKeys(inMap);
				commonItem.getLogPrint().printDebugLog("[対応記録内訳カテゴリー登録] 登録件数:" + count);
			}
		}
	}

	/**
	 * NGワードチェック（NGワードチェック条件がnullやサイズ0の場合は無条件に実施する）
	 * @param commonItem バッチ共通パラメータ電文
	 * @param jokenList NGワードチェック条件のList
	 * @param dataList 対象データ(1行分)
	 * @return NGワードエラー情報
	 * @throws Exception 例外
	 */
	static List<String> checkRrkInfoInportNGWord(JBSbatCommonItem commonItem,
												String[] jokenList,
												List<String> dataList) throws Exception
	{
		boolean needNgWordCheck = false;

		if (jokenList == null || jokenList.length == 0)
		{
			needNgWordCheck = true;
		}
		else
		{
			String index = null;
			String naiyo = null;
			String joken = null;

			// NGワードチェックを行うかどうかの条件チェック
			for (int i = 0; i < jokenList.length; i++)
			{
				if ((i % 2) == 0)
				{
					index = jokenList[i].trim();
					naiyo = dataList.get(Integer.parseInt(index) - 1);
				}
				else
				{
					joken = jokenList[i].trim();
					if (joken.equals(naiyo))
					{
						needNgWordCheck = true;
						break;
					}
					index = null;
					naiyo = null;
					joken = null;
				}
			}
		}
			
		List<String> ngWordInfo = null;

		if (needNgWordCheck)
		{
			String title = dataList.get(IDX_TITLE);				// タイトル
			String rireki = dataList.get(IDX_RIREKI);			// 対応記録履歴

			ngWordInfo = JCRBatCommon.checkNGWord(commonItem, title + rireki);
		}
		return ngWordInfo;
	}

	/**
	 * 業務個別設定組織コード(ワークグループ)取得
	 * @param commonItem バッチ共通パラメータ電文
	 * @param userId ユーザーID
	 * @param queBoxNo キューBOX番号
	 * @return 業務個別設定組織コード
	 * @throws Exception 例外
	 */
	static String getWorkGroupCd(JBSbatCommonItem commonItem, String userId, String queBoxNo) throws Exception
	{
		String wgCd = null;

		if (queBoxNo != null && !("".equals(queBoxNo)))
		{
			// キューBOX番号が空白でない場合

			// キューBOX
			JBSbatSQLAccess dbCrTQueBox = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_QUE_BOX);

			// バイント変数のリストを生成します
			JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
			paramList.setValue(queBoxNo);		// キューBOX番号

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

			JBSbatCommonDBInterface selectedData = dbCrTQueBox.selectNext();

			if (selectedData != null)
			{
				wgCd = selectedData.getString(JBSbatCR_T_QUE_BOX.WKKBT_ORG_CD);
			}
		}
		else
		{
			// ユーザー保持対象権限グループ
			JBSbatSQLAccess dbUserKengen = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_ZM_M_USER_HTG_KGGRP);

			String sysDate = JCRBatCommon.getSysDate();
			// バイント変数のリストを生成します
			JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
			paramList.setValue(userId);		// ユーザーID
			paramList.setValue(sysDate);	// システム年月日
			paramList.setValue(sysDate);	// システム年月日

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

			JBSbatCommonDBInterface selectedData = dbUserKengen.selectNext();

			if (selectedData != null)
			{
				wgCd = selectedData.getString(JBSbatZM_M_AUTHORITY_GRP.WKKBT_ORG_CD);
			}
		}

		if (wgCd == null)
		{
			wgCd = " ";
		}

		return wgCd;
	}

	/**
	 * 問合せモニター集計用データ登録
	 * @param commonItem バッチ共通パラメータ電文
	 * @param queBoxNo キューBOX番号
	 * @param jotaiCd 状態コード
	 * @param taioKirkNo 対応記録番号
	 * @param userId ユーザーID
	 * @param workGroupCd 業務個別設定組織コード
	 * @param existNGWord NGワードが存在する場合true
	 * @throws Exception 例外
	 */
	static void entryTiawsMonitorData(JBSbatCommonItem commonItem,
									String queBoxNo,
									String jotaiCd,
									String taioKirkNo,
									String userId,
									String workGroupCd,
									boolean existNGWord) throws Exception
	{
		String userNm = JCRBatCommon.getUserNm(commonItem, userId);

		// 問合せモニター集計用データ登録
		if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_OPEN.equals(jotaiCd))
		{
			// オープンの場合
			// 問合せモニターデータ登録
			JCRBatCommon.entryTiawsMonitorData(commonItem, JCRStrConst.DATA_SBT_CD_NEW, taioKirkNo, userId, userNm, workGroupCd);
		}
		else if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_CLOSE.equals(jotaiCd))
		{
			// クローズの場合
			// 問合せモニターデータ登録
			JCRBatCommon.entryTiawsMonitorData(commonItem, JCRStrConst.DATA_SBT_CD_CLOSE, taioKirkNo, userId, userNm, workGroupCd);
		}
		else if (JCRStrConst.CD_DIV_TOIAWASE_STAT_CD_ESCL.equals(jotaiCd))
		{
			// エスカレーションの場合
			// 問合せモニターデータ登録
			JCRBatCommon.entryTiawsMonitorData(commonItem, JCRStrConst.DATA_SBT_CD_NEW, taioKirkNo, userId, userNm, workGroupCd);
			// 問合せキュー移動データ登録
			JCRBatCommon.entryTiawsMontQueMvData(commonItem, JCRStrConst.DATA_SBT_CD_UKETSUKE, taioKirkNo, queBoxNo, workGroupCd, userId);
		}

		if (existNGWord)
		{
			// NGワードありの場合
			// 問合せモニターデータ登録
			JCRBatCommon.entryTiawsMonitorData(commonItem, JCRStrConst.DATA_SBT_CD_NGWORD, taioKirkNo, userId, userNm, workGroupCd);
		}
	}

	/**
	 * キューBOXの現在格納数更新
	 * @param commonItem バッチ共通パラメータ電文
	 * @param queBoxMap キューBOX更新情報
	 * @throws Exception 例外
	 */
	static void updateQueBox(JBSbatCommonItem commonItem, Map<String, Integer> queBoxMap) throws Exception
	{
		// キューBOX
		JBSbatSQLAccess dbCrTQueBox = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_QUE_BOX);

		Set<String> keySet = queBoxMap.keySet();
		Iterator<String> it = keySet.iterator();
		while (it.hasNext())
		{
			String queBoxNo = it.next();
			int count = queBoxMap.get(queBoxNo);

			String sysDtms = JCRBatCommon.getSysDateTimeStamp();
			JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
			paramList.setValue(count);
			paramList.setValue(sysDtms);
			paramList.setValue(sysDtms);
			paramList.setValue(commonItem.getBatchUserId());
			paramList.setValue(queBoxNo);

			dbCrTQueBox.executeBySqlDefine(paramList, CR_T_QUE_BOX_CR_UPDATE_001);
		}
	}

	/**
	 * MYBOXの現在格納数更新
	 * @param commonItem バッチ共通パラメータ電文
	 * @param myboxMap MYBOX更新情報
	 * @throws Exception 例外
	 */
	static void updateMybox(JBSbatCommonItem commonItem, Map<String, Integer> myboxMap) throws Exception
	{
		// キューBOX
		JBSbatSQLAccess dbCrTMybox = JCRBatCommon.getDataAccessObj(commonItem, D_TBL_NAME_CR_T_MYBOX);

		Set<String> keySet = myboxMap.keySet();
		Iterator<String> it = keySet.iterator();
		while (it.hasNext())
		{
			String myboxNo = it.next();
			int count = myboxMap.get(myboxNo);

			String sysDtms = JCRBatCommon.getSysDateTimeStamp();
			JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
			paramList.setValue(count);
			paramList.setValue(sysDtms);
			paramList.setValue(sysDtms);
			paramList.setValue(commonItem.getBatchUserId());
			paramList.setValue(myboxNo);

			dbCrTMybox.executeBySqlDefine(paramList, CR_T_MYBOX_CR_UPDATE_001);
		}
	}

	/**
	 * エラーファイル登録
	 * @param commonItem 共通情報
	 * @param wkkbtOrgCd 業務個別設定組織コード
	 * @param outputFilePath 一時ファイルパス
	 * @param errData エラー行データ
	 * @param logData ログデータ
	 * @param csvFile 対象CSVファイル
	 * @param targetFilePreFix 対象ファイル名のプレフィックス
	 * @param errorFilePreFix エラーファイル名のプレフィックス
	 * @param chgCRWord 改行コード変換文字
	 * @throws Exception 例外
	 */
	static void entryErrorFile(JBSbatCommonItem commonItem,
								String wkkbtOrgCd,
								File outputFilePath,
								String errData,
								String logData,
								File csvFile,
								String targetFilePreFix,
								String errorFilePreFix,
								String chgCRWord) throws Exception
	{
		String csvFileName = csvFile.getName();
		// ログファイル名
		String logFileName = csvFileName.substring(0, csvFileName.length() - JCRStrConst.EXT_CSV.length()) + JCRStrConst.EXT_LOG;
		// エラーファイル名
		String defaultErrFileName = csvFileName.replaceFirst(targetFilePreFix, errorFilePreFix);
		int extIndex = defaultErrFileName.lastIndexOf(".");	// 拡張子開始位置検索
		String errorFileName = defaultErrFileName;

		boolean needCheck = true;				// ファイル名チェックが必要な場合true
		boolean existSameNameFile = false;		// 同名のファイルが存在した場合true
		int fileNameIndex = 0;					// ファイル名変更時に付加する数字

		while (needCheck)
		{
			existSameNameFile = false;

			// 同名ファイル存在チェック(ログファイル)
			List<JBSbatCommonDBInterface> efileDataList = JCRBatCommon.getTaioBunshoByName(commonItem, logFileName, JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_ERR);

			if (efileDataList != null && efileDataList.size() > 0)
			{
				// 同名のファイルが存在した場合
				existSameNameFile = true;
			}
			else
			{
				// 同名ファイル存在チェック(エラーファイル)
				efileDataList = JCRBatCommon.getTaioBunshoByName(commonItem, errorFileName, JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM);
				if (efileDataList != null && efileDataList.size() > 0)
				{
					// 同名のファイルが存在した場合
					existSameNameFile = true;
				}
			}

			if (existSameNameFile == true)
			{
				// 同名ファイルが存在した場合
				++fileNameIndex;
				// ファイル名変更
				logFileName = csvFileName.substring(0, csvFileName.length() - JCRStrConst.EXT_CSV.length()) + "_" + fileNameIndex + JCRStrConst.EXT_LOG;

				if (extIndex == -1)
				{
					// 拡張子なしの場合
					errorFileName = defaultErrFileName +  "_" + fileNameIndex;
				}
				else
				{
					// 拡張子前に番号付加
					errorFileName = defaultErrFileName.substring(0, extIndex) +  "_" + fileNameIndex + defaultErrFileName.substring(extIndex);
				}
			}
			else
			{
				// 同名のファイルが存在しなかった場合
				needCheck = false;
			}
		}

		BufferedOutputStream errorFileStream = null;
		BufferedOutputStream logFileStream = null;
		try
		{
			if (logData != null)
			{
				// ログデータ出力
				File logFile = new File(JCRUtilCommon.inspection(outputFilePath.getPath() + File.separator + logFileName));
				logFileStream = new BufferedOutputStream(new FileOutputStream(logFile));
				logFileStream.write(logData.getBytes(JCRStrConst.DEFAULT_ENCODE));
				logFileStream.flush();

				// 電子ファイル管理登録
				String[] denshiFileInfo = JCRBatCommon.createDenshiFile(commonItem, null, logFile.getPath(), null);

				// 対応履歴電子ファイル管理登録
				Map<String, String> dataMap = new HashMap<String, String>();
				dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.BUNSHO_SBT_CD, JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM_ERR);	// 文書種別コード
				dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.EFILE_KANRI_NO, denshiFileInfo[0]);		// 電子ファイル管理番号
				dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM, logFileName);	// 対応履歴文書ファイル名
				if (wkkbtOrgCd != null)
				{
					dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_ORG_CD, wkkbtOrgCd);			// 業務個別設定組織コード
				}
				JCRBatCommon.entryTaioBunsho(commonItem, dataMap);

				// ログデータファイル削除
				logFile.delete();
			}

			String outputErrData = errData;
			if (outputErrData == null)
			{
				BufferedReader br = null;

				try
				{
					br = new BufferedReader(new InputStreamReader(new FileInputStream(csvFile), JCRStrConst.DEFAULT_ENCODE));
					String data = br.readLine();				// 1行読込み
					StringBuilder sb = new StringBuilder();		// 読込みファイル内容保持用

					while (data != null)
					{
						sb.append(data);
						sb.append(JCRStrConst.KAIGYO_CD);		// 改行コードLFを付加
						data = br.readLine();					// 1行読込み
					}
					outputErrData = sb.toString();
				}
				finally
				{
					if (br != null)
					{
						try
						{
							br.close();
						}
						catch (IOException ioe)
						{
							commonItem.getLogPrint().printDebugLog("errorFileStream close error");
						}
					}
				}
			}

			if (outputErrData == null)
			{
				outputErrData = "";
			}

			// エラーデータ出力
			File errorFile = new File(JCRUtilCommon.inspection(outputFilePath.getPath() + File.separator + errorFileName));
			errorFileStream = new BufferedOutputStream(new FileOutputStream(errorFile));
			errorFileStream.write(outputErrData.replaceAll(chgCRWord, JCRStrConst.KAIGYO_CD).getBytes(JCRStrConst.DEFAULT_ENCODE));
			errorFileStream.flush();

			// 電子ファイル管理登録
			String[] denshiFileInfo = JCRBatCommon.createDenshiFile(commonItem, null, errorFile.getPath(), null);

			// 対応履歴電子ファイル管理登録
			Map<String, String> dataMap = new HashMap<String, String>();
			dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.BUNSHO_SBT_CD, JCRStrConst.CD_DIV_BUNSHO_SBT_CD_TRKM);	// 文書種別コード
			dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.EFILE_KANRI_NO, denshiFileInfo[0]);		// 電子ファイル管理番号
			dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.TAIORRKI_BUNSHO_FILE_NM, errorFileName);	// 対応履歴文書ファイル名
			if (wkkbtOrgCd != null)
			{
				dataMap.put(JBSbatCR_T_TORK_EFILE_KNRI.WKKBT_ORG_CD, wkkbtOrgCd);			// 業務個別設定組織コード
			}
			JCRBatCommon.entryTaioBunsho(commonItem, dataMap);

			// エラーデータファイル削除
			errorFile.delete();
		}
		finally
		{
			if (errorFileStream != null)
			{
				try
				{
					errorFileStream.close();
				}
				catch (IOException ioe)
				{
					commonItem.getLogPrint().printDebugLog("errorFileStream close error");
				}
			}
			if (logFileStream != null)
			{
				try
				{
					logFileStream.close();
				}
				catch (IOException ioe)
				{
					commonItem.getLogPrint().printDebugLog("logFileStream close error");
				}
			}
		}
	}

	/**
	 * CSV1レコード1行化<P>
	 * ダブルクォートに囲まれた項目内に改行があるCSVファイルをの1レコードを
	 * 1行に変換して一時ファイルに出力する。
	 * 改行コードは別の文字に変換する。
	 * @param commonItem 共通情報
	 * @param file 変換対象ファイル
	 * @param henkangoPath 変換後のファイルを出力するディレクトリーのパス
	 * @return 変換情報のMap
	 * 				キー						内容
	 * 				KEY_KAIGYO_CD_HENKAN_MOJI	改行コード変換文字列(String)
	 * 				KEY_HENKANGO_FILE			出力ファイル(File)
	 * 				KEY_COUNT					件数(Integer)
	 * @throws IOException 例外
	 */
	static Map<String, Object> chgToOneRowForCsv(JBSbatCommonItem commonItem, File file, File henkangoPath) throws IOException
	{
		Map<String, Object> resMap = new HashMap<String, Object>();

		int dataCount = 0;			// データ件数

		BufferedReader br = null;
		BufferedWriter bw = null;

		try
		{
			// 読込みファイル
			br = new BufferedReader(new InputStreamReader(new FileInputStream(file), JCRStrConst.DEFAULT_ENCODE));

			// 書込みファイル
			File outputFile = new File(JCRUtilCommon.inspection(henkangoPath.getAbsolutePath() + File.separator + file.getName() + "_TMP"));
			bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile), JCRStrConst.DEFAULT_ENCODE));

			// ファイル内容を全行読込

			String data = br.readLine();				// 1行読込み
			StringBuilder sb = new StringBuilder();		// 読込みファイル内容保持用

			while (data != null)
			{
				sb.append(data);
				sb.append(JCRStrConst.KAIGYO_CD);		// 改行コードLFを付加

				data = br.readLine();					// 1行読込み
			}

			// 改行コード変換文字設定
			int index = 0;
			int i = 0;
			String chgWordLF = "";						// 改行コード変換文字
			while (index > -1)
			{
				// 変換に使用するための文字が存在した場合は別の文字を設定する
				chgWordLF = KAKOI + "LF" + i++ + KAKOI;
				index = sb.indexOf(chgWordLF);
			}

			// 全内容を1行化
			String fileContents = sb.toString().replaceAll(JCRStrConst.KAIGYO_CD, chgWordLF);

			StringBuilder buff = new StringBuilder();

			int quoteCount = 0;
			for (int j = 0; j < fileContents.length(); j++)
			{
				char chr = fileContents.charAt(j);
				buff.append(chr);

				if (chr == '\"')
				{
					quoteCount++;
				}

				if (chr == KAKOI)
				{
					if (quoteCount % 2 == 0)
					{
						// "の出現回数が偶数の場合
						String tmp = buff.toString();
						if (tmp.endsWith(chgWordLF))
						{
							// 改行変換文字で終わっている場合
							// 1行出力
							buff.delete(buff.length() - chgWordLF.length(), buff.length());

							String work = buff.toString().trim();
							if (work.startsWith(END))
							{
								// 先頭が終端文字の場合は以降の処理を行わない
								break;
							}
							if (!("".equals(work)) && !(work.startsWith(COMMENT)))
							{
								// 空白行でなくコメント行でない場合、ファイル出力
								bw.append(buff);
								bw.append(JCRStrConst.KAIGYO_CD);
								dataCount++;
							}

							buff.delete(0, buff.length());	// クリア
							quoteCount = 0;
						}
					}
				}
			}

			resMap.put(KEY_KAIGYO_CD_HENKAN_MOJI, chgWordLF);
			resMap.put(KEY_HENKANGO_FILE, outputFile);
			resMap.put(KEY_COUNT, dataCount);

			return resMap;

		}
		catch (IOException ioe)
		{
			commonItem.getLogPrint().printDebugLog(ioe.getMessage());
			throw ioe;
		}
		finally
		{
			// 読込みファイルクローズ
			if (br != null)
			{
				try
				{
					br.close();
				}
				catch (IOException ioe)
				{
					commonItem.getLogPrint().printDebugLog("br close error");
				}
			}
			// 書込みファイルクローズ
			if (bw != null)
			{
				try
				{
					bw.flush();
					bw.close();
				}
				catch (IOException ioe)
				{
					commonItem.getLogPrint().printDebugLog("bw close error");
				}
			}
		}
	}

}