/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *	システム名		：eo顧客基幹システム
 *	モジュール名	：JKKejbKK1071Edit
 *	ソースファイル名：JKKejbKK1071Edit.java
 *	作成者			：富士通
 *	日付			：2011年07月15日
 *＜機能概要＞
 *	審査のチェック処理を行う部品
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00.00	2011/07/14	富士通		新規作成
 *	v4.00.01	2013/01/29	FJ）藤本	ST3-2013-0000169
 *	v5.00.00	2013/03/07	FJ）寺園	IT1-2013-0000395
 *	v5.00.01	2013/04/03	FJ）清藤	IT1-2013-0000551
 *	v5.00.02	2013/04/08	FJ）沖田	IT1-2013-0000551
 *	v5.00.03	2013/04/12	FJ）清藤	IT1-2013-0000878
 *  v5.00.04    2013/06/25  FJ）寺本    LT-2013-0000091
 *  v5.00.05	2013/06/27	FJ) 沖田	IT1-2013-0001288
 *  v5.00.06	2013/06/30	FJ) 竹内	LT-2013-0000147
 *  v5.00.07	2013/07/05	FJ) 砂川	LT-2013-0000282
 *  v51.00.00	2020/10/20	FJ) 吉村	【ANK-3949-00-00】Netflix導入対応（STEP1）
 *  v59.00.00	2022/06/06	FJ) 西窪	【ANK-4296-00-00】成人年齢引き下げに伴うバックヤード改修対応
 *  v71.00.00	2024/05/22	FJ) 渋谷	【ANK-4468-00-00】eo光ネット「シンプルプラン」追加対応
 **********************************************************************/

package eo.ejb.common.edit;

import java.util.ArrayList;
import java.util.HashMap;

import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.model.base.CAANException;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.base.CAANRuntimeException;

import eo.common.util.JPCAdCommonCheckUtil;
import eo.common.util.JPCDateUtil;
import eo.common.util.JPCUtilCommon;
import eo.common.util.JZMCreditcardValid;
import eo.ejb.cbm.entity.CH0231ETMsg;
import eo.ejb.cbm.entity.CH0231LE;
import eo.ejb.cbm.entity.CH0501ETMsg;
import eo.ejb.cbm.entity.CH0501LE;
import eo.ejb.cbm.entity.KK0021ETMsg;
import eo.ejb.cbm.entity.KK0021LE;
import eo.ejb.cbm.entity.KK0081ETMsg;
import eo.ejb.cbm.entity.KK0081LE;
import eo.ejb.cbm.entity.KK0241ETMsg;
import eo.ejb.cbm.entity.KK0241LE;
import eo.ejb.cbm.entity.KK0251ETMsg;
import eo.ejb.cbm.entity.KK0251LE;
import eo.ejb.cbm.entity.KK0491ETMsg;
import eo.ejb.cbm.entity.KK0771ETMsg;
import eo.ejb.cbm.entity.KK0771LE;
import eo.ejb.cbm.entity.KK0801ETMsg;
import eo.ejb.cbm.entity.KK0801LE;
import eo.ejb.cbm.entity.KK0841ETMsg;
import eo.ejb.cbm.entity.KK1831ETMsg;
import eo.ejb.cbm.entity.KK1831LE;
import eo.ejb.cbm.entity.KK1981ETMsg;
import eo.ejb.cbm.entity.KK1981LE;
import eo.ejb.cbm.entity.ZM0081ETMsg;
import eo.ejb.cbm.entity.ZM0091ETMsg;
import eo.ejb.cbm.entity.ZM0121ETMsg;
import eo.ejb.cbm.entity.ZM0121LE;
import eo.ejb.cbm.entity.ZM0301ETMsg;
import eo.ejb.cbm.entity.ZM0301LE;
import eo.ejb.cbs.cbsmsg.EKK1071C021CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C021CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKK1071C041CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C081CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg3List;
import eo.ejb.common.JKKModelCommon;
import eo.ejb.common.JKKModelConst;
import eo.ejb.common.JKKejbMapPkgCall;
import eo.ejb.common.db.JKKejbDBAUtil;
import eo.ejb.common.db.JKKejbKK0021DBABase;
import eo.ejb.common.db.JKKejbKK0081DBABase;
import eo.ejb.common.db.JKKejbKK0251DBABase;
import eo.ejb.common.db.JKKejbKK0491DBABase;
import eo.ejb.common.db.JKKejbKK0801DBABase;
import eo.ejb.common.db.JKKejbKK0841DBABase;
import eo.ejb.common.db.JKKejbZM0081DBABase;
import eo.ejb.common.db.JKKejbZM0091DBABase;
import eo.ejb.common.db.JKKejbZM0321DBAccess;
import java.sql.Connection;
import com.fujitsu.futurity.model.ejb.common.JSYejbConnection;
import com.fujitsu.futurity.model.base.CAANConnectionMgr;

/**
 * <p>
 * 審査のチェック処理を行う。
 * </p>
 * @author 富士通
 */
public class JKKejbKK1071Edit
{

	/** 業務パラメータ */
	private static final String PARAM_ID = "KK_JDG_MSKM_PRD";
	
	/** メッセージ埋込み文字 申込,面開発案件以外 */
	private static final String UMKMMOJI = "申込,面開発案件以外,";

	/** ALL0判定用 */
	private static final char ZERO = '0';

	/** 料金スケジュール定義イベントコード (請求処理日)*/
	private static final String EVENT_CD_SEIKYU_DAY = "04";

	/** 料金スケジュール定義イベントコード (口座振替日)*/
	private static final String EVENT_CD_KOZAHURIKAE_DAY = "15";

	/** 自動照査機能(09) */
	private static final String SRVID_AUTO_SYOSA = "09";

	/** エリアチェック判定用(外部インターフェイスチェック結果) */
	private static final String[][] AREA_CHK_MTX = {{"02", "A03", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"02", "A04", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"02", "A06", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"02", "A08", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"02", "A09", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"02", "A07", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"}, {"02", "A11", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"},
		{"02", "A05", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"02", "A10", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		{"03", "A03", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"03", "A04", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"03", "A06", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"03", "A08", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"03", "A09", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"03", "A07", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"},
		{"03", "A11", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"}, {"03", "A05", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		{"03", "A10", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"04", "A03", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"04", "A04", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"04", "A06", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"04", "A08", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"}, {"04", "A09", "AreaEoNet", "1", "AreaEoNetDtl", "1,2,3"},
		{"04", "A07", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"}, {"04", "A11", "AreaEoNet", "1", "AreaEoNetDtl", "2,3"},
		{"04", "A05", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"04", "A10", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		{"11", "", "AreaEoTv", "1", "AreaEoTvDtl", "1,2"}, {"12", "", "AreaEoTv", "1", "AreaEoTvDtl", "2"}, {"10", "", "AreaEoTel", "1", "", ""},
		//ANK-3949-00-00 MOD START
	//	{"13", "", "AreaEoTv", "1", "AreaEoTvDtl", "1,2"}};
		{"13", "", "AreaEoTv", "1", "AreaEoTvDtl", "1,2"},
		{"02", "A91", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"02", "A92", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		{"03", "A91", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"03", "A92", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		{"04", "A91", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"04", "A92", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		// ANK-4468-00-00 ADD START
		{"02", "A97", "AreaEoNet", "1", "AreaEoNetDtl", "3"}, {"02", "A99", "AreaEoNet", "1", "AreaEoNetDtl", "3"},
		// ANK-4468-00-00 ADD END
		};
		//ANK-3949-00-00 MOD END


	/** 処理結果OK */
	private static final String RETURN_OK = "00";

	/** 処理結果NG */
	private static final String RETURN_NG = "01";

	/** 処理結果警告 */
	private static final String RETURN_WN = "02";

	/** 実施要否（要） */
	private static final String JUDGE_JSSI_YH_YO = "1";
	
	/** 住所不備チェック内部エラーコード(住所コード存在判定エラー) */
	private static final String NG_ADCD = "01";
	
	/** 住所不備チェック内部エラーコード(郵便番号存在判定エラー) */
	private static final String NG_PCD = "02";

	/** 住所不備チェック内部エラーコード(住所名称一致判定エラー) */
	private static final String NG_MEISHO = "03";

	/** 住所不備チェック内部エラーコード(都道府県名判定エラー) */
	private static final String NG_STATE = "030";
	
	/** 住所不備チェック内部エラーコード(市区町村名一致判定エラー) */
	private static final String NG_CITY = "031";
	
	/** 住所不備チェック内部エラーコード(番地号一致判定エラー) */
	private static final String NG_BNCHIGO = "032";
	
	/** 親権者情報不備チェック内部エラーコード(未来日チェック) */
	private static final String NG_MIRAI = "10";

	/** 親権者情報不備チェック内部エラーコード(未成年チェック) */
	private static final String NG_MISEINEN = "20";
	
	/** 法人格入力不備チェック内部エラーコード(法人格前後指定コード未入力) */
	private static final String NG_HOUJINZENGO = "10";

	/** 法人格入力不備チェック内部エラーコード(法人格種別コード未入力) */
	private static final String NG_HOUJINSBT = "20";

	/** 同一部屋番号未存在チェック実施不要回線コード用MAP */
	private static final HashMap<String, String> SAME_ROOM_NOCHK_MAP = new HashMap<String, String>();

	static
	{
		SAME_ROOM_NOCHK_MAP.put(JKKModelConst.KAISEN_CD_PHS, JKKModelConst.KAISEN_CD_PHS);
		SAME_ROOM_NOCHK_MAP.put(JKKModelConst.KAISEN_CD_MBL, JKKModelConst.KAISEN_CD_MBL);
		SAME_ROOM_NOCHK_MAP.put(JKKModelConst.KAISEN_CD_MBL_EM, JKKModelConst.KAISEN_CD_MBL_EM);
		SAME_ROOM_NOCHK_MAP.put(JKKModelConst.KAISEN_CD_MBL_UQ_WIMAX, JKKModelConst.KAISEN_CD_MBL_UQ_WIMAX);
	}

	/** 同一部屋番号未存在チェック各回線コード許容回線コード用MAP */
	private static final HashMap<String, String[]> SAME_ROOM_KAINO_MAP = new HashMap<String, String[]>();

	/** 光回線許容配列 */
	private static final String[] LINE_VALID = {JKKModelConst.KAISEN_CD_HIKARI, JKKModelConst.KAISEN_CD_HIKARI_MANS_VDSL, JKKModelConst.KAISEN_CD_HIKARI_MANS_ENET, JKKModelConst.KAISEN_CD_HIKARI_MANS_HHISN};
	/** 光回線(マンションVDSL)許容配列 */
	private static final String[] VDSL_VALID = {JKKModelConst.KAISEN_CD_HIKARI, JKKModelConst.KAISEN_CD_HIKARI_MANS_VDSL, JKKModelConst.KAISEN_CD_HIKARI_MANS_ENET, JKKModelConst.KAISEN_CD_HIKARI_MANS_HHISN};
	/** 光回線(マンションイーサネット)許容配列 */
	private static final String[] INSR_VALID = {JKKModelConst.KAISEN_CD_HIKARI, JKKModelConst.KAISEN_CD_HIKARI_MANS_VDSL, JKKModelConst.KAISEN_CD_HIKARI_MANS_ENET, JKKModelConst.KAISEN_CD_HIKARI_MANS_HHISN};
	/** 光回線(マンション光配線)許容配列 */
	private static final String[] HAIS_VALID = {JKKModelConst.KAISEN_CD_HIKARI, JKKModelConst.KAISEN_CD_HIKARI_MANS_VDSL, JKKModelConst.KAISEN_CD_HIKARI_MANS_ENET, JKKModelConst.KAISEN_CD_HIKARI_MANS_HHISN};
	/** ADSL回線(eAccess)許容配列 */
	private static final String[] EAC_VALID = {JKKModelConst.KAISEN_CD_ADSL_EACCESS, JKKModelConst.KAISEN_CD_ADSL_NTT_WEST};
	/** ADSL回線(NTT西日本)許容配列 */
	private static final String[] NTT_VALID = {JKKModelConst.KAISEN_CD_ADSL_EACCESS, JKKModelConst.KAISEN_CD_ADSL_NTT_WEST};


	static
	{		
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_HIKARI, LINE_VALID);
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_HIKARI_MANS_VDSL, VDSL_VALID);
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_HIKARI_MANS_ENET, INSR_VALID);
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_HIKARI_MANS_HHISN, HAIS_VALID);
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_ADSL_EACCESS, EAC_VALID);
		SAME_ROOM_KAINO_MAP.put(JKKModelConst.KAISEN_CD_ADSL_NTT_WEST, NTT_VALID);
	}

	/**
	 * コンストラクタです。
	 */
	public JKKejbKK1071Edit()
	{
	}

	/**
	 * <p>
	 * 住所不備チェックを行います。
	 * </p>
	 * @param inMsg  処理対象のメッセージキャリア
	 * @param adcd     住所コード
	 * @param pcd      郵便番号
	 * @param stateNm  都道府県名
	 * @param cityNm   市区町村名
	 * @param oaztsuNm 大字通称名
	 * @param azchoNm  字丁目名
	 * @param banchiGo 番地号
	 * @return チェック結果(OK:"00",NG(住所コード存在判定):"01",NG(郵便番号存在判定):"02",
	 * 						 NG(住所名称一致判定):"03")
	 */
	public Object adHbiCheck(CAANMsg inMsg, String adcd, String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm, String banchiGo)
	{
		// パラメータチェックを行う
		if (!isParamCheck(adcd))
		{
			return NG_ADCD;
		}

		// 住所コードのALL0判定を行う。
		if (!isCodeCheck(adcd))
		{
			return NG_ADCD;
		}

		// 住所情報の入力チェックを行う
		Object resultInput = adInfoInputCheck(pcd, stateNm, cityNm, banchiGo);

		if(!RETURN_OK.equals(resultInput))
		{
			return resultInput;
		}

		// 住所マスタの検索を行う
		CAANMsg otETMsg = zM0081CurrentSearch(inMsg, adcd);

		if (otETMsg == null)
		{
			return NG_ADCD;
		}

		// 検索結果とパラメータの比較を行う
		Object result = getAdressAgreeCheckRslt(otETMsg, pcd, stateNm, cityNm, oaztsuNm, azchoNm, adcd);

		if (!RETURN_OK.equals(result))
		{
			return result;
		}

		return RETURN_OK;
	}

	/**
	 * <p>
	 * 住所情報の入力チェックを行います。
	 * </p>
	 * @param pcd      郵便番号
	 * @param stateNm  都道府県名
	 * @param cityNm   市区町村名
	 * @param banchiGo 番地号
	 * @return チェック結果(OK:"00",NG(郵便番号存在判定):"02",NG(都道府県存在判定):"030",NG(市区町村存在判定):"031",NG(番地号存在判定):"032",NG(住所名称一致判定):"03"))
	 */
	private Object adInfoInputCheck(String pcd, String stateNm, String cityNm, String banchiGo)
	{
		// 郵便番号が未設定の場合、NG(郵便番号存在判定)を返却
		if (!isParamCheck(pcd))
		{
			return NG_PCD;
		}

		// 都道府県名が未設定の場合、NG(住所名称一致判定)を返却
		if (!isParamCheck(stateNm))
		{
			return NG_STATE;
		}

		// 市区町村名が未設定の場合、NG(住所名称一致判定)を返却
		if (!isParamCheck(cityNm))
		{
			return NG_CITY;
		}

		// 番地号が未設定の場合、NG(住所名称一致判定)を返却
		if (!isParamCheck(banchiGo))
		{
			return NG_BNCHIGO;
		}
		
		return RETURN_OK;
	}

	/**
	 * <p>
	 * 申込日チェックを行います。
	 * </p>
	 * @param inMsg   処理対象のメッセージキャリア
	 * @param mskmYmd 申込年月日
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object mskmYmdCheck(CAANMsg inMsg, String mskmYmd)
	{
		// パラメータチェック
		if (!isParamCheck(mskmYmd))
		{
			return RETURN_OK;
		}

		JKKejbZM0321DBAccess jKKejbZM0321DBAccessIns = new JKKejbZM0321DBAccess();

		// 以下のパラメータを設定しgetParamEの呼び出しを行い業務パラメータの値取得を行う。
		String value = jKKejbZM0321DBAccessIns.getParamE(PARAM_ID);

		// 日付を編集する
		String yyyymmdd = JPCDateUtil.addDay(JKKModelCommon.getOpeDate(inMsg), -Integer.parseInt(value));

		// 申込年月日と取得した値で比較をおこなう。
		int ymd = JPCDateUtil.subtractDay(yyyymmdd, mskmYmd);

		// 差が0未満の場合エラーを返却する
		if (ymd >= 0)
		{
			return RETURN_NG;

		}

		return RETURN_OK;

	}

	/**
	 * <p>
	 * 申込書番号未存在チェックを行います。
	 * </p>
	 * @param mskmNo     申込番号
	 * @param mskmshoNo  申込書番号
	 * @param inContext Agentから渡されたAgentDispatchContext
	 * @param svcKeiNo 検索対象のサービス契約番号
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object mskmshoNoCheck(String mskmNo, String mskmshoNo)
	{

		if(!isParamCheck(mskmshoNo))
		{
			return RETURN_OK;
		}
		// 申込明細の一覧検索を行う
		CAANMsg[] otETMsg = kK0021Search(mskmshoNo);

		if (otETMsg.length == 0)
		{
			return RETURN_OK;
		}

		if(!isParamCheck(mskmNo))
		{
			return RETURN_OK;
		}
		for(int i = 0; i < otETMsg.length; i++)
		{
			String mskmNoRet = otETMsg[i].getString(KK0021ETMsg.MSKM_NO);
			if(!mskmNo.equals(mskmNoRet))
			{
				return RETURN_NG;
			}
		}

		return RETURN_OK;

	}

	/**
	 * <p>
	 * 同一部屋番号未存在チェックを行います。
	 * </p>
	 * @param inMsg             処理対象のメッセージキャリア
	 * @param svcKaiNo          サービス回線契約内訳番号
	 * @param pcd               郵便番号
	 * @param staNm             都道府県名
	 * @param cityNm            市区町村名
	 * @param oaztsuNm          大字通称名
	 * @param azchoNm           字丁目
	 * @param bnchigo           番地号
	 * @param adrttm            住所補記・建物名
	 * @param adrrm             住所補記・部屋番号
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object sameRoomNoCheck(CAANMsg inMsg, String svcKaiNo, String pcd, String staNm, String cityNm, String oaztsuNm, String azchoNm,
			String bnchigo, String adrttm, String adrrm)
	{

		// 郵便番号〜住所補記・建物名の
		// すべての項目がnullの場合は実施しない
		if (null == pcd && null == staNm)
		{
			if (null == cityNm && null == oaztsuNm && null == azchoNm)
			{
				if (null == bnchigo && null == adrttm)
				{
					return RETURN_OK;
				}
			}
		}
		// 住所補記・部屋番号がnullの場合は実施しない
		if (null == adrrm)
		{
			return RETURN_OK;
		}
		
		// サービス契約回線番号のカレントレコードの取得を行う。
		CAANMsg retKK0251Cur = kK0251CurrentSearch(svcKaiNo);

		// カレントレコードが存在しない場合はOKとする
		if (null == retKK0251Cur)
		{
			return RETURN_OK;
		}

		// 入力値のサービス契約回線内訳番号に紐付く回線コードを取得
		String kaisenCdWithIn = retKK0251Cur.getString(KK0251ETMsg.KAISEN_CD);

		// チェック不要回線コードの配列に存在する場合はチェックを行わない
		if (SAME_ROOM_NOCHK_MAP.containsKey(kaisenCdWithIn))
		{
			return RETURN_OK;
		}
		
		// サービス契約回線内訳の一覧検索を行う
		CAANMsg[] otMsgs = kK0251Search(pcd, staNm, cityNm, oaztsuNm, azchoNm, bnchigo, adrttm, adrrm);

		ArrayList<String> arraySvcKeiKaisenUcwkNo = new ArrayList<String>();

		// サービス回線内訳の検索結果の件数分繰り返す
		for (int i = 0; i < otMsgs.length; i++)
		{
			if (!arraySvcKeiKaisenUcwkNo.contains(otMsgs[i].getString(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO)))
			{
				arraySvcKeiKaisenUcwkNo.add(otMsgs[i].getString(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO));
			}
		}

		// 格納したリストのサイズ分繰り返す
		for (int i = 0; i < arraySvcKeiKaisenUcwkNo.size(); i++)
		{
			// 検索結果のサービス契約回線内訳番号をキーにサービス契約回線内訳のカレント検索を行う
			CAANMsg otMsg = kK0251CurrentSearch(arraySvcKeiKaisenUcwkNo.get(i));

			if (otMsg == null)
			{
				return RETURN_NG;
			}

			// 入力値のサービス契約回線内訳番号に対する回線コードと、リストの回線コードが競合していないかのチェックを行う
			if (!SAME_ROOM_KAINO_MAP.containsKey(kaisenCdWithIn))
			{
				continue;
			}

			String[] validCds = SAME_ROOM_KAINO_MAP.get(kaisenCdWithIn);
			boolean kyogoFlg = false;

			for (int j = 0; j < validCds.length; j++)
			{
				// 競合配列内に該当の回線コードが存在した場合はフラグオン
				if(validCds[j].equals(otMsg.getString(KK0251ETMsg.KAISEN_CD)))
				{
					kyogoFlg = true;
				}
			}

			// 競合していなければ次の明細へ
			if (!kyogoFlg)
			{
				continue;
			}

			// サービス契約回線内訳のカレント検索の結果とパラメータとの比較を行う
			if (!isKK0251Cehck(otMsg, svcKaiNo, pcd, staNm, cityNm, oaztsuNm, azchoNm, bnchigo, adrttm, adrrm))
			{
				return RETURN_NG;
			}
		}

		return RETURN_OK;
	}

	/**
	 * <p>
	 * 強制解約者の同一チェックを行います。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param pcd        郵便番号
	 * @param stateNm    都道府県名
	 * @param cityNm     市区町村名
	 * @param oaztsuNm   大字通称名
	 * @param azchoNm    字丁目
	 * @param bnchigo    番地号
	 * @param adrttm     住所補記・建物名
	 * @param adrrm      住所補記・部屋番号
	 * @param sysidList  SYSIDリスト
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object ksiDslCheck(CAANMsg inMsg, String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm, String bnchigo,
			String adrttm, String adrrm, CAANMsg[] sysidList)
	{
		// null対応
		if (null == sysidList)
		{
			return RETURN_OK;
		}

		for (int i = 0; i < sysidList.length; i++)
		{
			// サービス契約の検索を行う
			CAANMsg[] oETKK0081Msgs = kK0081Search(sysidList[i].getString(EKK1071C041CBSMsg1List.SYSID));


			// 同一のサービス契約番号で検索しないためにリストにキー項目を設定する
			ArrayList<String> arraySvckeino = new ArrayList<String>();

			for (int k = 0; k < oETKK0081Msgs.length; k++)
			{

				if (!arraySvckeino.contains(oETKK0081Msgs[k].getString(KK0081ETMsg.SVC_KEI_NO)))
				{
					arraySvckeino.add(oETKK0081Msgs[k].getString(KK0081ETMsg.SVC_KEI_NO));
				}
			}

			// 格納したリストの要素数分繰り返す
			for (int j = 0; j < arraySvckeino.size(); j++)
			{
				// サービス契約のカレント検索を行う
				CAANMsg otETMsg = kK0081CurrentSearch(inMsg, arraySvckeino.get(j));

				if (otETMsg == null)
				{
					return RETURN_NG;
				}

				// サービス契約のカレントレコードのチェックを行う
				if (isSysidAgreeCheck(oETKK0081Msgs[j].getString(KK0081ETMsg.SYSID), otETMsg))
				{
					// 回線対象サービス契約の検索を行う
					CAANMsg[] otETKK0241Msgs = kK0241Search(otETMsg.getString(KK0081ETMsg.SVC_KEI_NO));

					if (otETKK0241Msgs.length > 0)
					{
						// サービス契約回線内訳のチェックを行う
						if (isAdreesDisCodeCheck(otETKK0241Msgs, pcd, stateNm, cityNm, oaztsuNm, azchoNm, bnchigo, adrttm, adrrm))
						{
							return RETURN_NG;
						}
					}
				}
			}
		}

		return RETURN_OK;
	}

	/**
	 * <p>
	 * クレジットカード番号体系チェックを行います。
	 * </p>
	 * @param inMsg          処理対象のメッセージキャリア
	 * @param crecardCompCd  クレジットカード会社コード
	 * @param crecardJigyoCd クレジットカード事業コード
	 * @param crecardNo      クレジットカード番号
	 * @param seikyukeiNo    請求契約番号
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object creditCardNoCheck(CAANMsg inMsg, String crecardCompCd, String crecardJigyoCd, String crecardNo, String seikyukeiNo)
	{
		if (crecardCompCd == null)
		{
			return RETURN_OK;
		}
		if (crecardJigyoCd == null)
		{
			return RETURN_OK;
		}
		if (crecardNo == null)
		{
			return RETURN_OK;
		}

		// 請求契約を検索する
		CAANMsg otETKK0491 = kk0491CurrentSearch(inMsg, seikyukeiNo);
		if (otETKK0491 == null)
		{
			return RETURN_NG;
		}

		if (!JKKModelConst.SEIKY_WAY_CD_CREDIT.equals(otETKK0491.getString(KK0491ETMsg.SEIKY_WAY_CD)))
		{
			return RETURN_OK;
		}

		// クレジットカード番号チェックを行う
		if (!JZMCreditcardValid.isCreditcardValid(crecardCompCd, crecardNo))
		{
			return RETURN_NG;
		}

		return RETURN_OK;
	}

	/**
	 * <p>
	 * 督促状態チェックを行います。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param seikyKeiNo 請求契約番号
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object tokusokuStatCheck(CAANMsg inMsg, String seikyKeiNo)
	{
		// 請求契約番号が未設定の場合は処理を行わない
		if (seikyKeiNo == null)
		{
			return RETURN_OK;
		}

		// 督促の検索を行う
		CAANMsg[] oETMsgs = cH0231Search(seikyKeiNo);

		if (oETMsgs.length == 0)
		{
			return RETURN_OK;
		}

		// 検索結果の督促ステータスを確認する
		if (isStateCheck(inMsg, oETMsgs))
		{
			return RETURN_NG;
		}

		return RETURN_OK;
	}

	/**
	 * <p>
	 * 緊急連絡先チェックを行います
	 * </p>
	 * @param inMsg              処理対象のメッセージキャリア
	 * @param eKK1071C081CBSMsgs 記載不備電話番号情報審査明細
	 * @return チェックエラーが発生した配列の番号（エラーがなかった場合は-1）
	 */
	public int emgRrskCheck(CAANMsg inMsg, CAANMsg[] eKK1071C081CBSMsgs)
	{
		for (int i = 0; i < eKK1071C081CBSMsgs.length; i++)
		{
			// 記載不備電話番号情報審査明細の住所コードをチェックする
			if (!isParamCheck(eKK1071C081CBSMsgs[i].getString(EKK1071C081CBSMsg1List.EMG_AD_CD)))
			{
				return i;
			}

			if (!isCodeCheck(eKK1071C081CBSMsgs[i].getString(EKK1071C081CBSMsg1List.EMG_AD_CD)))
			{
				return i;
			}
		}

		return -1;
	}

	/**
	 * <p>
	 * エリアチェックを行います。
	 * </p>
	 * @param prcGrpCd 料金グループコード
	 * @param pcrsCd 料金コースコード
	 * @param lgtd 経度
	 * @param lttd 緯度
	 * @return チェック結果(OK:"00",NG:"01")
	 * @throws Exception
	 */
	public boolean isAreaCheck(String prcGrpCd, String pcrsCd, String lgtd, String lttd) throws Exception
	{
		// エリアチェック(外部パッケージ呼出)を実行する。
		HashMap<String, String> resultMap = new JKKejbMapPkgCall().areaCheck(SRVID_AUTO_SYOSA, lgtd, lttd);

		// エリアチェック結果判定MAPの検索処理
		if (!isContaintsMap(resultMap, prcGrpCd, pcrsCd))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * エリアチェック結果判定MAPの検索処理を行います
	 * </p>
	 * @param resultMap           エリアチェック結果(外部パッケージ戻り値)
	 * @param prcGrpCd            料金グループコード
	 * @param pcrsCd              料金コースコード
	 * @return エリアチェック結果判定MAPの内容とチェック結果が一致する場合true、それ以外はfalse
	 */
	private boolean isContaintsMap(HashMap<String, String> resultMap, String prcGrpCd, String pcrsCd)
	{
		// エリアチェック判定用MAPの件数分判定する
		for (int i = 0; i < AREA_CHK_MTX.length; i++)
		{

			// 料金グループコード判定
			if (!AREA_CHK_MTX[i][0].equals(prcGrpCd))
			{
				continue;
			}

			// 料金コースコード判定
			if (!"".equals(AREA_CHK_MTX[i][1]) && !AREA_CHK_MTX[i][1].equals(pcrsCd))
			{
				continue;
			}

			// 判定結果１判定
			if (!resultMap.get(AREA_CHK_MTX[i][2]).equals(AREA_CHK_MTX[i][3]))
			{
				continue;
			}

			// 判定結果２判定
			if (!"".equals(AREA_CHK_MTX[i][4]))
			{
				String[] areaChkDtl = AREA_CHK_MTX[i][5].split(",");

				for (int j = 0; j < areaChkDtl.length; j++)
				{
					if (resultMap.get(AREA_CHK_MTX[i][4]).equals(areaChkDtl[j]))
					{
						return true;
					}
				}
			}
			// 判定結果２判定(判定不要の場合)
			else
			{
				return true;
			}

		}
		return false;
	}

	/**
	 * <p>
	 * 面開発対象チェックを行います。
	 * </p>
	 * @param inMsg            処理対象のメッセージキャリア
	 * @param list             割引サービスコードの配列
	 * @param menkaihatAnkenNo 面開発案件番号
	 * @return 割引サービス名
	 */
	public String mnkhtTgtCheck(CAANMsg inMsg, CAANMsg[] list, String menkaihatAnkenNo)
	{
		
		for (int i = 0; i < list.length; i++)
		{
			// 割引サービスの検索を行う
			CAANMsg kK0841Msg = kK0841CurrentSearch(inMsg, list[i].getString(EKK1071C021CBSMsg2List.WRIB_SVC_CD));

			if (kK0841Msg == null)
			{
				return null;
			}

			// 割引タイプコードが「キャンペーン割引(面開発用)」であるかチェックする
			if (JKKModelConst.WRIB_TYPE_CD_CMP_MNKHT.equals(kK0841Msg.getString(KK0841ETMsg.WRIB_TYPE_CD)))
			{
				// パラメータチェックを行う
				if (!isParamCheck(menkaihatAnkenNo) || "".equals(menkaihatAnkenNo.trim()))
				{
					return UMKMMOJI + kK0841Msg.getString(KK0841ETMsg.WRIB_SVC_NM);
				}
			}
		}
		return null;
	}

	/**
	 * <p>
	 * 住所コード最下層チェックを行います。
	 * </p>
	 * @param inMsg 処理対象のメッセージキャリア
	 * @param adcd  住所コード
	 * @param pcd   郵便番号
	 * @return チェック結果(OK:"00",WG:"02")
	 */
	public String adCdMostBottom(CAANMsg inMsg, String adcd, String pcd)
	{
		// 住所コードおよび郵便番号が未設定の場合
		if (adcd == null || pcd == null)
		{
			return RETURN_OK;
		}

		// コネクション
		Connection con = JSYejbConnection.getConnection(ZM0081ETMsg.getTableName());

		try
		{
			// 住所最下層チェックを実施する
			boolean bol = JPCAdCommonCheckUtil.adMaxKaiChk(con, adcd, pcd, JKKModelCommon.getOpeDate(inMsg));

			// 結果がfalseの場合、ワーニングを返却する
			if (!bol)
			{
				return RETURN_WN;
			}
		}
		catch (Exception e)
		{
			throw new CAANRuntimeException("住所最下層チェックでエラーが発生しました。");
		}
		finally
		{
			if(con != null)
			{
				CAANConnectionMgr.getInstance().close(con);
			}
		}
		return RETURN_OK;
	}

	/**
	 * <p>
	 * 割引サービスのカレント検索を行います。
	 * </p>
	 * @param  inMsg   処理対象のメッセージキャリア
	 * @param  wrsvcCd 配列から取り出した割引サービスコード
	 * @return レコードが取得できた場合true、それ以外false
	 */
	private CAANMsg kK0841CurrentSearch(CAANMsg inMsg, String wrsvcCd)
	{
		// カレント検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0841ETMsg.class.getName());
		inETMsg.set(KK0841ETMsg.WRIB_SVC_CD, wrsvcCd);
		inETMsg.set(KK0841ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(inMsg));

		// 作成したメッセージを使用して検索を行う
		CAANMsg otETMsg = new JKKejbKK0841DBABase().findByCurrent(inETMsg);

		return otETMsg;
	}

	/**
	 * <p>
	 * 住所マスタの検索を行います。
	 * </p>
	 * @param  inMsg 処理対象のメッセージキャリア
	 * @param  adcd  住所コード
	 * @return 指定された住所コードに紐づく住所マスタのレコード
	 */
	private CAANMsg zM0081CurrentSearch(CAANMsg inMsg, String adcd)
	{
		// カレント検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(ZM0081ETMsg.class.getName());
		String opeDate = JKKModelCommon.getOpeDate(inMsg);
		inETMsg.set(ZM0081ETMsg.AD_CD, adcd);
		inETMsg.set(ZM0081ETMsg.RSV_APLY_YMD, opeDate);

		// 作成したメッセージを使用して検索を行う
		CAANMsg otETMsg = new JKKejbZM0081DBABase().findByCurrent(inETMsg);
		
		// 取得できない時はnullを返却する
		if (otETMsg == null)
		{
			return null;
		}
		
		// 住所適用開始年月日と住所適用終了年月日のレコードを取得
		String adTstaYmd = otETMsg.getString(ZM0081ETMsg.AD_TSTAYMD);
		String adTendYmd = otETMsg.getString(ZM0081ETMsg.AD_TENDYMD);
		
		// 住所適用開始年月日≦運用日付≦住所適用終了年月日のレコードが取得できた場合
		if (JKKModelCommon.isPastDate(adTstaYmd, opeDate, "1") 
				&& JKKModelCommon.isFutureDate(adTendYmd, opeDate, "1"))
		{
			return otETMsg;
		}
		return null;
	}

	/**
	 * <p>
	 * 検索したサービス契約のカレントレコードとパラメータのsysIdが一致しているかチェックします。
	 * </p>
	 * 
	 * @param sysId    パラメータのsysId
	 * @param inETMsg  検索結果のレコード
	 * @return 比較結果が正常ならtrue,それ以外ならfalse
	 */
	private boolean isSysidAgreeCheck(String sysId, CAANMsg inETMsg)
	{
		if (!isParamCheck(sysId))
		{
			return false;
		}

		if (!sysId.equals(inETMsg.getString(KK0081ETMsg.SYSID)))
		{
			return false;
		}

		// 異動区分の比較を行う
		if (!JKKModelConst.IDO_DIV_KSI_DSL_FIX.equals(inETMsg.getString(KK0081ETMsg.IDO_DIV)))
		{
			return false;

		}

		return true;
	}

	/**
	 * <p>
	 * サービス契約回線内訳のチェックを行います
	 * </p>
	 * 
	 * @param inMsgs   検索結果のレコード
	 * @param pcd      郵便番号
	 * @param stateNm  都道府県名
	 * @param cityNm   市区町村名
	 * @param oaztsuNm 大字通称名
	 * @param azchoNm  字丁目
	 * @param bnchigo  番地号
	 * @param adrttm   住所補記・建物名
	 * @param adrrm    住所補記・部屋番号
	 * @return 比較結果がすべて一致しtrueが返却された場合はtrue、それ以外はfalse
	 * 
	 */
	private boolean isAdreesDisCodeCheck(CAANMsg[] inMsgs, String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm,
			String bnchigo, String adrttm, String adrrm)
	{
		ArrayList<String> arraySvcKeiKaienUcwkNo = new ArrayList<String>();

		for (int i = 0; i < inMsgs.length; i++)
		{

			if (!arraySvcKeiKaienUcwkNo.contains(inMsgs[i].getString(KK0241ETMsg.SVC_KEI_KAISEN_UCWK_NO)))
			{
				arraySvcKeiKaienUcwkNo.add(inMsgs[i].getString(KK0241ETMsg.SVC_KEI_KAISEN_UCWK_NO));
			}
		}

		for (int i = 0; i < arraySvcKeiKaienUcwkNo.size(); i++)
		{
			// サービス契約回線内訳のカレント検索を行います。
			CAANMsg otETMsg = kK0251CurrentSearch(arraySvcKeiKaienUcwkNo.get(i));

			if(otETMsg == null)
			{
				continue;
			}

			// パラメータと検索結果の比較を行う
			if (isKaiAdressAgreeCheck(otETMsg, pcd, stateNm, cityNm, oaztsuNm, azchoNm, bnchigo, adrttm, adrrm))
			{
				return true;
			}
		}

		return false;
	}

	/**
	 * <p>
	 * 回線対象サービス契約の検索を行います。
	 * </p>
	 * 
	 * @param svckeiNo サービス契約番号
	 * @return 検索にて取得したレコード
	 */
	private CAANMsg[] kK0241Search(String svckeiNo)
	{
		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0241ETMsg.class.getName());
		inETMsg.set(KK0241ETMsg.SVC_KEI_NO, svckeiNo);
		inETMsg.set(KK0241ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0241LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * サービス契約の検索を行います。
	 * </p>
	 * 
	 * @param sysId SYSID
	 * @return 取得したレコード
	 */
	private CAANMsg[] kK0081Search(String sysId)
	{
		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0081ETMsg.class.getName());
		inETMsg.set(KK0081ETMsg.SYSID, sysId);
		inETMsg.set(KK0081ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		// サービス契約の一覧検索を行う
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0081LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;

	}

	/**
	 * <p>
	 * サービス契約のカレント検索を行います。
	 * </p>
	 * 
	 * @param inMsg    処理対象のメッセージキャリア
	 * @param svckeiNo サービス契約番号
	 * @return 取得したレコード
	 */
	private CAANMsg kK0081CurrentSearch(CAANMsg inMsg, String svckeiNo)
	{
		// カレント検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0081ETMsg.class.getName());
		inETMsg.set(KK0081ETMsg.SVC_KEI_NO, svckeiNo);
		inETMsg.set(KK0081ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(inMsg));

		CAANMsg otETMsg = new JKKejbKK0081DBABase().findByCurrent(inETMsg);

		return otETMsg;
	}

	/**
	 * <p>
	 * サービス契約回線内訳の一覧検索を行います。
	 * </p>
	 * 
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param pcd        郵便番号
	 * @param stateNm    都道府県名
	 * @param cityNm     市区町村名
	 * @param oaztsuNm   大字通称名
	 * @param azchoNm    字丁目
	 * @param bnchigo    番地号
	 * @param adrttm     住所補記・建物名
	 * @param adrrm      住所補記・部屋番号
	 * @return レコードが取得できた場合true、それ以外false
	 */
	private CAANMsg[] kK0251Search(String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm, String bnchigo, String adrttm,
			String adrrm)
	{

		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0251ETMsg.class.getName());
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_PCD, pcd);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_STATE_NM, stateNm);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_CITY_NM, cityNm);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM, azchoNm);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM, oaztsuNm);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_BNCHIGO, bnchigo);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_ADRTTM, adrttm);
		inETMsg.set(KK0251ETMsg.KAISEN_PLACE_ADRRM, adrrm);
		inETMsg.set(KK0251ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		// サービス契約回線内訳の一覧検索を行う
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0251LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * サービス契約回線内訳のカレント検索を行います
	 * </p>
	 * 
	 * @param svcKeiKaienUcwkNo  サービス契約内訳番号
	 * @return 検索結果のカレントレコード
	 */
	private CAANMsg kK0251CurrentSearch(String svcKeiKaienUcwkNo)
	{
		// カレント検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0251ETMsg.class.getName());
		inETMsg.set(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO, svcKeiKaienUcwkNo);

		CAANMsg otETMsg = new JKKejbKK0251DBABase().findByCurrent(inETMsg);

		return otETMsg;
	}

	/**
	 * <p>
	 * 督促の検索を行います。
	 * </p>
	 * 
	 * @param seikyKeiNo  請求契約番号
	 * @return 検索結果のレコード
	 */
	private CAANMsg[] cH0231Search(String seikyKeiNo)
	{
		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(CH0231ETMsg.class.getName());
		inETMsg.set(CH0231ETMsg.SEIKY_KEI_NO, seikyKeiNo);
		inETMsg.set(CH0231ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		// 督促の一覧検索を行う
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new CH0231LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * 請求契約の検索を行います。
	 * </p>
	 * 
	 * @param inMsg        処理対象のメッセージキャリア
	 * @param seikyukeiNo  請求契約番号
	 * @return 請求契約のカレントレコード
	 */
	private CAANMsg kk0491CurrentSearch(CAANMsg inMsg, String seikyukeiNo)
	{
		// カレント検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0491ETMsg.class.getName());
		inETMsg.set(KK0491ETMsg.SEIKY_KEI_NO, seikyukeiNo);
		inETMsg.set(KK0491ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(inMsg));

		CAANMsg otEtMsg = new JKKejbKK0491DBABase().findByCurrent(inETMsg);

		return otEtMsg;
	}

	/**
	 * <p>
	 * 料金スケジュール定義の検索を行います。
	 * </p>
	 * 
	 * @param inMsg   処理対象のメッセージキャリア
	 * @param eventCd イベントコード
	 * @return 検索結果のレコード
	 */
	private CAANMsg[] cH0501Search(CAANMsg inMsg, String eventCd)
	{
		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(CH0501ETMsg.class.getName());
		inETMsg.set(CH0501ETMsg.EVENT_CD, eventCd);
		inETMsg.set(CH0501ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);
		inETMsg.set(CH0501ETMsg.SEIKY_YM, JKKModelCommon.getOpeDate(inMsg).substring(0, 6));

		// 料金スケジュール定義の一覧検索を行う
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new CH0501LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * サービス契約回線内訳のカレント検索の結果とパラメータとの比較を行います。
	 * </p>
	 * 
	 * @param inMsg             サービス契約回線内訳のカレントレコード
	 * @param svcKeiKaienUcwkNo サービス回線契約内訳番号
	 * @param pcd               郵便番号
	 * @param stateNm           都道府県名
	 * @param cityNm            市区町村名
	 * @param oaztsuNm          大字通称名
	 * @param azchoNm           字丁目名
	 * @param bnchigo           番地号
	 * @param adrttm            住所補記・建物名
	 * @param adrrm             住所補記・部屋番号
	 * @return 比較した結果一致すれば、true、それ以外false
	 */
	private boolean isKK0251Cehck(CAANMsg inMsg, String svcKeiKaienUcwkNo, String pcd, String stateNm, String cityNm, String oaztsuNm,
			String azchoNm, String bnchigo, String adrttm, String adrrm)
	{

		if (!isParamCheck(svcKeiKaienUcwkNo))
		{
			return false;
		}

		if (svcKeiKaienUcwkNo.equals(inMsg.getString(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO)))
		{
			return true;
		}

		if (isKaiAdressAgreeCheck(inMsg, pcd, stateNm, cityNm, oaztsuNm, azchoNm, bnchigo, adrttm, adrrm))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * 申込明細の一覧検索を行います。
	 * </p>
	 * 
	 * @param mskmshoNo 申込書番号
	 * @return 指定された申込書番号に紐づく申込明細のカレント一覧
	 */
	private CAANMsg[] kK0021Search(String mskmshoNo)
	{
		// 全件検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK0021ETMsg.class.getName());
		inETMsg.set(KK0021ETMsg.MSKMSHO_NO, mskmshoNo);
		inETMsg.set(KK0021ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		// 申込明細の一覧検索を行う
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0021LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		ArrayList<CAANMsg> retArray = new ArrayList<CAANMsg>();
		HashMap<String, String> hash = new HashMap<String, String>();

		// 申込明細番号ごとにカレントを取得
		for (CAANMsg msgCnd : otETMsg)
		{
			// 申込明細番号を取得
			String mskmDtlNo = msgCnd.getString(KK0021ETMsg.MSKM_DTL_NO);

			// カレント検索済の場合は次のレコードへ
			if (hash.containsKey(mskmDtlNo))
			{
				continue;
			}

			hash.put(mskmDtlNo, mskmDtlNo);

			// カレント検索を行う
			CAANMsg inETMsgCur = new CAANMsg(KK0021ETMsg.class.getName());
			inETMsgCur.set(KK0021ETMsg.MSKM_DTL_NO, mskmDtlNo);

			CAANMsg retCurKK0021 = new JKKejbKK0021DBABase().findByCurrent(inETMsgCur);

			// カレントレコードの申込書番号が、パラメータと一致しているかチェック
			// （上記一覧で取得したのがカレントではない可能性があるため）
			if (!mskmshoNo.equals(retCurKK0021.getString(KK0021ETMsg.MSKMSHO_NO)))
			{
				// カレントレコードの申込書番号がパラメータと一致していない場合、次のレコードへ
				continue;
			}

			retArray.add(retCurKK0021);
		}

		return (CAANMsg[])retArray.toArray(new CAANMsg[0]);
	}

	/**
	 * <p>
	 * 日付の比較を行います。
	 * </p>
	 * 
	 * @param ymd  基準となる日付
	 * @param ymd2 差分対照となる日付
	 * @return 比較結果にて0以上であればtrue、それ以外はfalse
	 */
	private boolean isDateCheck(String ymd, String ymd2)
	{

		int diff = JPCDateUtil.subtractDay(ymd, ymd2);

		if (diff < 0)
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * 督促のステータスチェックを行います。
	 * </p>
	 * @param inMsg    処理対象のメッセージキャリア
	 * @param inMsgs   検索結果のレコード
	 * @return 強制解約予告済以上("15")、または
	 *          督促ステータスが利用停止予告済("10")かつ
	 *          口座振替日 + 1日 <= 運用日付 <= 請求処理日であればtrue、それ以外はfalse
	 */
	private boolean isStateCheck(CAANMsg inMsg, CAANMsg[] inMsgs)
	{
		
		// 初回フラグ(請求処理日,口座振替日取得用)
		boolean isFirst = true;

		// 請求処理日
		String seikyuDay = null;
		String kozaDay = null;

		for (int i = 0; i < inMsgs.length; i++)
		{
			// 督促ステータスが強制解約予告済("15")以上のコード値であればエラー
			if (JKKModelConst.TKSKST_KSI_DSL_YKK_ZM.compareTo(inMsgs[i].getString(CH0231ETMsg.TOKUSOKU_STAT)) <= 0)
			{
				return true;
			}
			// 督促ステータスが利用停止予告済("10")かつ、
			// 口座振替日 + 1日 <= 運用日付 <= 請求処理日であればエラー
			else if (JKKModelConst.TKSKST_USE_STP_ZM.equals(inMsgs[i].getString(CH0231ETMsg.TOKUSOKU_STAT)))
			{
				// 初回のみ口座振替日と請求処理日の取得処理を行う
				if (isFirst)
				{
					isFirst = false;

					// 請求処理日を取得する
					CAANMsg[] oETCH0501Msgs = cH0501Search(inMsg, EVENT_CD_SEIKYU_DAY);
					if (oETCH0501Msgs.length == 0)
					{
						return false;
					}
	
					// 口座振替日を取得する
					CAANMsg[] oETCH0501KozaMsgs = cH0501Search(inMsg, EVENT_CD_KOZAHURIKAE_DAY);
	
					if (oETCH0501KozaMsgs.length == 0)
					{
						return false;
					}
					
					// Null対応
					if (oETCH0501Msgs[0].isNull(CH0501ETMsg.EVENT_YMD))
					{
						return false;
					}

					// Null対応
					if (oETCH0501KozaMsgs[0].isNull(CH0501ETMsg.EVENT_YMD))
					{
						return false;
					}

					seikyuDay = oETCH0501Msgs[0].getString(CH0501ETMsg.EVENT_YMD);
					kozaDay = oETCH0501KozaMsgs[0].getString(CH0501ETMsg.EVENT_YMD);
					
				}

				// 口座振替日 + 1日 <= 運用日付 <= 請求処理日であればエラー
				if (JPCDateUtil.addDay(kozaDay, 1).compareTo(JKKModelCommon.getOpeDate(inMsg)) <= 0)
				{
					if (seikyuDay.compareTo(JKKModelCommon.getOpeDate(inMsg)) >= 0)
					{
						return true;
					}
				}
			}
		}

		return false;
	}

	/**
	 * <p>
	 * コードのALL0判定を行います。
	 * </p>
	 * @param code コード
	 * @return ALL0でなければtrue、それ以外はfalse
	 */
	private boolean isCodeCheck(String code)
	{
		for (int i = 0; i < code.length(); i++)
		{
			char caadcd = code.charAt(i);

			if (!(caadcd == ZERO))
			{
				return true;
			}
		}

		return false;
	}

	/**
	 * <p>
	 * パラメータと検索結果のチェックをを行います。
	 * </p>
	 * @param inMsg    検索結果のレコードの値
	 * @param pcd      郵便番号
	 * @param stateNm  都道府県名
	 * @param cityNm   市区町村名
	 * @param oaztsuNm 大字通称名
	 * @param azchoNm  字丁目名
	 * @param adcd		住所コード
	 * @return チェック結果(OK:"00",NG(郵便番号存在判定):"02",NG(都道府県存在判定):"030",NG(市区町村存在判定):"031",NG(大字通称、字丁目名一致判定):"03")
	 */
	private Object getAdressAgreeCheckRslt(CAANMsg inMsg, String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm, String adcd)
	{

		// 検索結果とパラメータと比較を行う
		// 郵便番号
		if (!isCheck(pcd, inMsg.getString(ZM0081ETMsg.PCD)))
		{
			return NG_PCD;
		}

		//都道府県名
		if (!isCheck(stateNm, inMsg.getString(ZM0081ETMsg.STATE_NM)))
		{
			return NG_STATE;
		}

		// 市区町村名
		if (!isCheck(cityNm, inMsg.getString(ZM0081ETMsg.CITY_NM)))
		{
			return NG_CITY;
		}

		// 大字通称名
		if (!isCheck(oaztsuNm, inMsg.getString(ZM0081ETMsg.OAZTSU_NM)))
		{
			return NG_MEISHO;
		}

		// 字丁目名
		if (!isCheck(azchoNm, inMsg.getString(ZM0081ETMsg.AZCHO_NM)))
		{
			return NG_MEISHO;
		}

		return RETURN_OK;
	}


	/**
	 * <p>
	 * パラメータと検索結果のチェックをを行います。
	 * </p>
	 * @param inMsg      検索結果のレコードの値
	 * @param pcd        郵便番号
	 * @param stateNm    都道府県名
	 * @param cityNm     市区町村名
	 * @param oaztsuNm   大字通称名
	 * @param azchoNm    字丁目名
	 * @param bnchigo    番地号
	 * @param adrttm     住所補記・建物名
	 * @param adrrm      住所補記・部屋番号
	 * @return 比較が一致した場合、true、一致しない場合false
	 */
	private boolean isKaiAdressAgreeCheck(CAANMsg inMsg, String pcd, String stateNm, String cityNm, String oaztsuNm, String azchoNm, String bnchigo,
			String adrttm, String adrrm)
	{

		// 検索結果とパラメータと比較を行う
		// 郵便番号
		if (!isCheck(pcd, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_PCD)))
		{
			return false;
		}

		//都道府県名
		if (!isCheck(stateNm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_STATE_NM)))
		{
			return false;
		}

		// 市区町村名
		if (!isCheck(cityNm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_CITY_NM)))
		{
			return false;
		}

		// 大字通称名
		if (!isCheck(oaztsuNm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM)))
		{
			return false;
		}

		// 字丁目名
		if (!isCheck(azchoNm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM)))
		{
			return false;
		}

		// 番地号
		if (!isCheck(bnchigo, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_BNCHIGO)))
		{
			return false;
		}

		// 住所補記・建物名
		if (!isCheck(adrttm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_ADRTTM)))
		{
			return false;
		}

		// 住所補記・部屋番号
		if (!isCheck(adrrm, inMsg.getString(KK0251ETMsg.KAISEN_PLACE_ADRRM)))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * パラメータのチェックをを行います。
	 * </p>
	 * @param param  パラメータ
	 * @return パラメータに値が設定されていればtrue、それ以外ならfalse
	 */
	private boolean isParamCheck(String param)
	{
		if (param == null || "".equals(param))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * 二つのパラメータが等しいかチェックを行います。
	 * </p>
	 * @param arg0 比較パラメータ１
	 * @param arg1 比較パラメータ２
	 * @return 比較結果
	 */
	private boolean isCheck(String arg0, String arg1)
	{
		if (arg0 == null)
		{
			if (arg1 != null)
			{
				return false;
			}
		}

		else if (arg0 != null)
		{
			if (arg1 == null)
			{
				return false;
			}
			else if (!arg0.equals(arg1))
			{
				return false;
			}
		}

		return true;
	}

	/**
	 * <p>
	 * 適用範囲の判断を実施する
	 * </p>
	 * @param staYmd 開始年月日
	 * @param endYmd 終了年月日
	 * @param opeDate 運用日付
	 * @return true:適用範囲内、false:適用範囲外
	 */
	protected boolean isChtYmdRange(String staYmd, String endYmd, String opeDate)
	{
		if(!isChkTStaYmd(staYmd, opeDate))
		{
			return false;
		}

		if(!isChkTEndYmd(endYmd, opeDate))
		{
			return false;
		}
		return true;
	}


	/**
	 * <p>
	 * 適用開始日の判断を実施する
	 * </p>
	 * @param baseYmd 基準となる日付
	 * @param trgYmd 判定対象の日付
	 * @return true:適用範囲内、false:適用範囲外
	 */
	private boolean isChkTStaYmd(String baseYmd, String trgYmd)
	{
		// 適用開始年月日が設定されていない場合、適用開始されていないと判断
		if (baseYmd == null || "".equals(baseYmd))
		{
			return false;
		}
		// 適用開始日を迎えていない場合、falseとする
		if (JPCUtilCommon.isPastDate(trgYmd, baseYmd, "0"))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * 適用終了日の判断を実施する
	 * </p>
	 * @param baseYmd 基準となる日付
	 * @param trgYmd 判定対象の日付
	 * @return true:適用範囲内、false:適用範囲外
	 */
	private boolean isChkTEndYmd(String baseYmd, String trgYmd)
	{
		// 適用終了日が設定されていない場合、適用終了されていないと判断
		if (baseYmd == null || "".equals(baseYmd))
		{
			return true;
		}
		// 適用終了日を迎えている場合、falseとする
		if (JPCUtilCommon.isFutureDate(trgYmd, baseYmd, "0"))
		{
			return false;
		}

		return true;
	}

	/**
	 * <p>
	 * 指定した条件で審査詳細実施条件を検索し、エラー結果コードの項目値を行います。
	 * </p>
	 * @param inMsg	 処理対象のメッセージキャリア
	 * @param jdgStaCd	審査起動元識別コード
	 * @param jdgDtlSbtCd 審査詳細種別コード
	 * @return エラー結果コードの項目設定値（レコードが取得できなかった場合はnull）
	 */
	public String getErrRsltKK1831(CAANMsg inMsg, String jdgStaCd, String jdgDtlSbtCd)
	{
		// 審査詳細実施条件の一意検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK1831ETMsg.class.getName());
		inETMsg.set(KK1831ETMsg.JDG_DTL_SBT_CD, jdgDtlSbtCd);
		inETMsg.set(KK1831ETMsg.JDG_JSSI_KINO_SKBT_CD, jdgStaCd);

		// 一意検索の実施
		CAANMsg otETMsg = new KK1831LE().findByPrimaryKey(inETMsg);

		// レコードが取得できなかった場合はnullを返却する
		if (otETMsg == null)
		{
			return null;
		}

		// 実施要否が「要」でない場合はnullを返却する
		if (!JUDGE_JSSI_YH_YO.equals(otETMsg.getString(KK1831ETMsg.JUDGE_JSSI_YH)))
		{
			return null;
		}

		// エラー結果コードの値を返却する
		return otETMsg.getString(KK1831ETMsg.ERR_RSLT_CD);
	}

	/**
	 * <p>
	 * 審査チェックエラー時の審査詳細へのレコードの登録を行います。
	 * </p>
	 * @param inMsg	 処理対象のメッセージキャリア
	 * @param addMsg 登録用メッセージ
	 * @return 登録処理が正常終了した場合はtrue。PKが重複した場合はfalse。
	 */
	public boolean createJudgeDtl(CAANMsg inMsg, CAANMsg addMsg)
	{
		// 審査詳細の一意検索用のメッセージを作成
		CAANMsg inETMsg = new CAANMsg(KK1981ETMsg.class.getName());
		inETMsg.set(KK1981ETMsg.JUDGE_NO, addMsg.getString(KK1981ETMsg.JUDGE_NO));
		inETMsg.set(KK1981ETMsg.JDG_DTL_SBT_CD, addMsg.getString(KK1981ETMsg.JDG_DTL_SBT_CD));

		// 一意検索の実施
		CAANMsg otETMsg = new KK1981LE().findByPrimaryKey(inETMsg);; 

		// レコードが存在する場合はfalseを返却する。
		if (otETMsg != null)
		{
			return false;
		}

		createKK1981(inMsg, addMsg);
		return true;

	}

	/**
	 * <p>
	 * 審査チェックエラー時の審査詳細へのレコードの登録を行います。
	 * </p>
	 * @param inMsg	 処理対象のメッセージキャリア
	 * @param addMsg 登録用メッセージ
	 */
	private void createKK1981(CAANMsg inMsg, CAANMsg addMsg)
	{
		// 機能コードのチェック（チェックモードの場合は採番しない）
		if (isFuncMode(inMsg))
		{
			return;
		}

		// 審査詳細の登録用のメッセージの共通部を作成
		addMsg.set(KK1981ETMsg.ADD_DTM, inMsg.getString(JCMConstants.OPERATE_DATETIME_KEY));
		addMsg.set(KK1981ETMsg.ADD_OPEACNT, inMsg.getString(KK1981ETMsg.OPERATORID));
		addMsg.set(KK1981ETMsg.UPD_DTM, inMsg.getString(JCMConstants.OPERATE_DATETIME_KEY));
		addMsg.set(KK1981ETMsg.UPD_OPEACNT, inMsg.getString(KK1981ETMsg.OPERATORID));
		addMsg.set(KK1981ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);

		// 登録処理の実施
		JKKejbDBAUtil dbaUtilKK1981 = new JKKejbDBAUtil(inMsg);
		dbaUtilKK1981.create(addMsg);

	}

	/**
	 * <p>
	 * 機能コードがチェックのみの実行モードか判定します。<br>
	 * 制約上、奇数は実行モード、偶数はチェックモードとして扱います。
	 * </p>
	 * @param inMsg 処理対象のCBSMsg
	 * @return チェックモードの場合はtrue
	 */
	protected boolean isFuncMode(CAANMsg inMsg)
	{
		String func = inMsg.getString(JCMConstants.FUNC_CODE_KEY);
		int in = Integer.parseInt(func);
		boolean ret = (in % 2) == 0;
		return ret;
	}

	/**
	 * <p>
	 * 機器在庫チェックを行います。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param kikiList   機器サービス契約明細リスト
	 * @param zaikoList  機器在庫情報リスト
	 * @return チェックエラーとなった機器提供サービスコードの名称のリスト
	 */
	public ArrayList<String> kikiZaikoCheck(CAANMsg inMsg, CAANMsg[] kikiList, CAANMsg[] zaikoList)
	{
		// 返却用リストの作成
		ArrayList<String> retArray = new ArrayList<String>();

		if(kikiList == null || kikiList.length == 0)
		{
			return retArray;
		}

		if(zaikoList == null || zaikoList.length == 0)
		{
			return retArray;
		}
		int cnt = 0;

		for(int i = 0; i < zaikoList.length; i++)
		{
			cnt = 0;
			String taknkikiModelCd_ZL = zaikoList[i].getString(EKK1071C131CBSMsg2List.KK0341_02_TAKNKIKI_MODEL_CD);
			if(!isParamCheck(taknkikiModelCd_ZL))
			{
				continue;
			}
			String kktkSvcCd = null;
			for(int j = 0; j < kikiList.length; j++)
			{
				String taknkikiModelCd_KL = kikiList[j].getString(EKK1071C131CBSMsg1List.KK0341_01_TAKNKIKI_MODEL_CD);
				kktkSvcCd = kikiList[j].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD);
				if(taknkikiModelCd_ZL.equals(taknkikiModelCd_KL))
				{
					cnt++;
				}
			}
			int zaiko = 0;
			if(zaikoList[i].getString(EKK1071C131CBSMsg2List.ZAIKO_CNT) != null)
			{
				zaiko = Integer.parseInt(zaikoList[i].getString(EKK1071C131CBSMsg2List.ZAIKO_CNT));
			}
			if(zaiko < cnt)
			{
				retArray.add(getKktkSvcCdNm(kktkSvcCd));
			}
		}

		return retArray;
	}

	/**
	 * <p>
	 * 接続機器数チェックを行います。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param kikiList   機器サービス契約明細リスト
	 * @param pcrsCd  	  料金コースコード
	 * @return チェックエラーとなった機器提供サービスコードの名称のリスト
	 */
	public ArrayList<String> setsuzokuKikiCheck(CAANMsg inMsg, CAANMsg[] kikiList, String pcrsCd)
	{
		// 返却用リストの作成
		ArrayList<String> retArray = new ArrayList<String>();
        
		// 機器サービス契約明細リストが存在しない場合、チェック対象外
		if(kikiList == null || kikiList.length == 0)
		{
			return retArray;
		// 機器サービス契約リストの明細内の機器提供サービスコードがNullの場合も審査不可のためチェック対象外とする
		}else if(kikiList[0].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD) == null){
			return retArray;
		}

		// 機器サービス契約コードの重複を排除
		ArrayList<String> kktkSvcCdList = getKktkSvcCdList(kikiList);
		// 機器サービス契約コードごとの件数取得
		for(int j = 0; j < kktkSvcCdList.size(); j++)
		{
			int cnt = 0;
			String cd = kktkSvcCdList.get(j);
			for(int k = 0; k < kikiList.length; k++)
			{
				if(cd.equals(kikiList[k].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD)))
				{
					cnt++;
				}
			}
			// 料金コース_機器提供サービスの検索を行う
			CAANMsg[] retKK0801ETMsg = searchKK0801(inMsg.getString(EKK1071C131CBSMsg.PCRS_CD), cd);
			if(retKK0801ETMsg.length == 0)
			{
				return retArray;
			}
			for(int i = 0; i < retKK0801ETMsg.length; i++)
			{
				// 適用範囲の判定
				String staYmd = retKK0801ETMsg[i].getString(KK0801ETMsg.PCRS_KKTK_SVC_TSTAYMD);
				String endYmd = retKK0801ETMsg[i].getString(KK0801ETMsg.PCRS_KKTK_SVC_TENDYMD);
				if(isChtYmdRange(staYmd, endYmd, JKKModelCommon.getOpeDate(inMsg)))
				{
					int maxKktkSvc = Integer.parseInt(retKK0801ETMsg[i].getString(KK0801ETMsg.MAX_KKTK_SVC_CNT));
					if(maxKktkSvc < cnt)
					{
						retArray.add(getKktkSvcCdNm(cd));
					}
				}
			}
		}	
		return retArray;
	}

	/**
	 * <p>
	 * 機器管理チェックを行います。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param kikiList   機器サービス契約明細リスト
	 * @param macAdList  機器MACアドレスリスト
	 * @param pcrsCd  	  料金コースコード
	 * @return チェックエラーとなった機器提供サービスコードの名称のリスト
	 */
	public ArrayList<String> kikiKanriCheck(CAANMsg inMsg, CAANMsg[] kikiList, CAANMsg[] macAdList, String pcrsCd)
	{
		// 返却用リストの作成
		ArrayList<String> retArray = new ArrayList<String>();

		if(kikiList == null || kikiList.length == 0)
		{
			return retArray;
		}

		if(macAdList == null || macAdList.length == 0)
		{
			return retArray;
		}

		for(int i = 0; i < kikiList.length; i++)
		{
			String seizoNo_KL = kikiList[i].getString(EKK1071C131CBSMsg1List.KK0341_01_KIKI_SEIZO_NO);
			if(!isParamCheck(seizoNo_KL))
			{
				continue;
			}
			for(int j = 0; j < macAdList.length; j++)
			{
				String seizoNo_ML = macAdList[j].getString(EKK1071C131CBSMsg3List.KK0341_02_KIKI_SEIZO_NO);
				if(seizoNo_KL.equals(seizoNo_ML))
				{
					if(!isParamCheck(macAdList[j].getString(EKK1071C131CBSMsg3List.MACAD)))
					{
						retArray.add(getKktkSvcCdNm(kikiList[i].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD)));
					}
				}
			}
		}
		return retArray;
	}

	/**
	 * <p>
	 * 料金コース_機器提供サービスの検索を行う。
	 * </p>
	 * @param pcrsCd  	  料金コースコード
	 * @param kktkSvcCd  機器提供サービスコード
	 * @return 検索結果のETMsg
	 */
	private CAANMsg[] searchKK0801(String pcrsCd, String kktkSvcCd)
	{
		CAANMsg inETMsg = new CAANMsg(KK0801ETMsg.class.getName());
		inETMsg.set(KK0801ETMsg.PCRS_CD, pcrsCd);
		inETMsg.set(KK0801ETMsg.KKTK_SVC_CD, kktkSvcCd);
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0801LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * 料金コース_機器提供サービスの検索を行う。(料金コースコード) 
	 * </p>
	 * @param pcrsCd  	  料金コースコード
	 * @param kktkSvcCd  機器提供サービスコード
	 * @return 検索結果のETMsg
	 */
	private CAANMsg[] searchKK0801ForPcrsCd(String pcrsCd)
	{
		CAANMsg inETMsg = new CAANMsg(KK0801ETMsg.class.getName());
		inETMsg.set(KK0801ETMsg.PCRS_CD, pcrsCd);
		inETMsg.set(KK0801ETMsg.MK_FLG, JKKModelConst.MK_FLG_YK);
		CAANMsg[] otETMsg = null;
		try
		{
			otETMsg = new KK0801LE().findByCondition(inETMsg);
		}
		catch (CAANException e1)
		{
			throw new CAANRuntimeException(e1);
		}

		return otETMsg;
	}

	/**
	 * <p>
	 * 料金コース_機器提供サービスのカレント検索を行う。
	 * </p>
	 * @param inMsg  	  処理対象のメッセージキャリア
	 * @param pcrsCd  	  料金コースコード
	 * @param kktkSvcCd  機器提供サービスコード
	 * @return 検索結果のETMsg
	 */
	private CAANMsg searchCrrKK0801(CAANMsg inMsg, String pcrsCd, String kktkSvcCd)
	{
		CAANMsg inETMsg = new CAANMsg(KK0801ETMsg.class.getName());
		inETMsg.set(KK0801ETMsg.PCRS_CD, pcrsCd);
		inETMsg.set(KK0801ETMsg.KKTK_SVC_CD, kktkSvcCd);
		inETMsg.set(KK0801ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(inMsg));

		return new JKKejbKK0801DBABase().findByCurrent(inETMsg);
	}

	/**
	 * <p>
	 * 機器サービス契約コードの重複を排除する。
	 * </p>
	 * @param kikiList   機器サービス契約明細リスト
	 * @return 検索結果のArrayList
	 */
	private ArrayList<String> getKktkSvcCdList(CAANMsg[] kikiList)
	{
		// 処理済み機器提供サービス契約保持用
		HashMap<String, String> hash = new HashMap<String, String>();
		ArrayList<String> kktkSvcCdList = new ArrayList<String>();
		// 機器サービス契約コードの種類取得
		for(int i = 0; i < kikiList.length; i++)
		{
			String kktkSvcCd = kikiList[i].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD);
			if (hash.containsKey(kikiList[i].getString(EKK1071C131CBSMsg1List.KKTK_SVC_CD)))
			{
				continue;
			}
			// 読み込んだ機器提供サービス契約番号を控える
			hash.put(kktkSvcCd, kktkSvcCd);
			kktkSvcCdList.add(kktkSvcCd);
		}
		return kktkSvcCdList;
	}

	/**
	 * <p>
	 * 機器提供サービスの名称取得を行う。
	 * </p>
	 * @param kktkSvcCd  機器提供サービスコード
	 * @return 検索結果のETMsg
	 */
	protected String getKktkSvcCdNm(String kktkSvcCd)
	{
		CAANMsg inETMsg = new CAANMsg(KK0771ETMsg.class.getName());
		inETMsg.set(KK0771ETMsg.KKTK_SVC_CD, kktkSvcCd);
		CAANMsg otETMsg = new KK0771LE().findByPrimaryKey(inETMsg);

		if (otETMsg == null)
		{
			return "";
		}

		return otETMsg.getString(KK0771ETMsg.KKTK_SVC_NM);
	}

	/**
	 * <p>
	 * 機器同時申込チェックを行う。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param pcrsCd  	  料金コースコード
	 * @param kktkSvcCdList  機器提供サービスコードリスト
	 * @return 機器提供サービス名
	 */
	public String kikiDojiMskmCheck(CAANMsg inMsg, String pcrsCd, CAANMsg[] kktkSvcCdList)
	{
		// 料金コース_機器提供サービスの検索を行う
		CAANMsg[] retKK0801ETMsg = searchKK0801ForPcrsCd(pcrsCd);

		if(retKK0801ETMsg.length == 0)
		{
			return null;
		}
		String kktkSvcCd = null;
		// 処理済み機器提供サービスコード保持用
		HashMap<String, String> hash = new HashMap<String, String>();
		for(int i = 0; i < retKK0801ETMsg.length; i++)
		{
			CAANMsg retMsg = searchCrrKK0801(inMsg, pcrsCd, retKK0801ETMsg[i].getString(KK0801ETMsg.KKTK_SVC_CD));

			if(retMsg == null)
			{
				return null;
			}
			kktkSvcCd = retMsg.getString(KK0801ETMsg.KKTK_SVC_CD);
			if (hash.containsKey(kktkSvcCd))
			{
				continue;
			}
			// 読み込んだ機器提供サービスを控える
			hash.put(kktkSvcCd, kktkSvcCd);
		}
		
		for(int j = 0; j < kktkSvcCdList.length; j++)
		{
			String tgtKktkSvcCd = kktkSvcCdList[j].getString(EKK1071C021CBSMsg1List.KKTK_SVC_CD);
			// リスト内の存在チェックを行う。
			if (!hash.containsKey(tgtKktkSvcCd))
			{
				return getKktkSvcCdNm(kktkSvcCd);
			}
		}
		return null;
	}

	/**
	 * <p>
	 * 割引期間判定を行う。
	 * </p>
	 * @param inMsg      処理対象のメッセージキャリア
	 * @param mskmYmd  	  申込年月日
	 * @param wribSvcCdList  割引サービスコードリスト
	 * @return チェック結果(OK:"00",NG:"01")
	 */
	public Object wribKikanCheck(CAANMsg inMsg, String mskmYmd, CAANMsg[] wribSvcCdList)
	{
		if(wribSvcCdList == null || wribSvcCdList.length == 0)
		{
			return RETURN_OK;
		}
		for(int i = 0; i < wribSvcCdList.length; i++)
		{
			// 割引サービスの検索を行う
			CAANMsg kK0841Msg = kK0841CurrentSearch(inMsg, wribSvcCdList[i].getString(EKK1071C021CBSMsg2List.WRIB_SVC_CD));

			if (kK0841Msg == null)
			{
				return RETURN_OK;
			}

			if (mskmYmd == null)
			{
				return RETURN_OK;
			}

			if (kK0841Msg.getString(KK0841ETMsg.UK_STA_YMDHM) == null)
			{
				return RETURN_OK;
			}

			if (kK0841Msg.getString(KK0841ETMsg.UK_END_YMDHM) == null)
			{
				return RETURN_OK;
			}

			// 割引期間判定を行う（受付開始年月日時分と申込年月日）
			if (!isDateCheck(mskmYmd, kK0841Msg.getString(KK0841ETMsg.UK_STA_YMDHM).substring(0, 8)))
			{
				return RETURN_NG;
			}
			// 割引期間判定を行う（申込年月日と受付終了年月日時分）
			if (!isDateCheck(kK0841Msg.getString(KK0841ETMsg.UK_END_YMDHM).substring(0, 8), mskmYmd))
			{
				return RETURN_NG;
			}
		}
		return RETURN_OK;
	}

	/**
	 * <p>
	 * 各審査チェックの審査結果コードをもとに、審査.審査結果コードの判定を行う。
	 * </p>
	 * @param errCdList  各審査チェックの審査結果コード(審査詳細の審査結果コード)のリスト
	 * @return チェック結果(00:OK/01:NG/02:警告)
	 */
	protected Object getJudgeJudgeRsltCd(String[] errCdList)
	{
		// 審査.審査結果コード
		Object retCdKK1071 = RETURN_OK;

		if(errCdList != null)
		{
			for (int i = 0; i < errCdList.length; i++)
			{
				if(null == errCdList[i])
				{
					continue;
				}

				// エラーコード設定
				if(!retCdKK1071.equals(errCdList[i]))
				{
					// 戻り値がOKの場合、上書き
					if(RETURN_OK.equals(retCdKK1071))
					{
						retCdKK1071 = errCdList[i];
					}
					// 戻り値が警告、入力のエラーCDがエラーの場合、上書き
					else if(RETURN_WN.equals(retCdKK1071) && RETURN_NG.equals(errCdList[i]))
					{
						retCdKK1071 = errCdList[i];
					}
				}	
			}
		}
		
		return retCdKK1071;
	}

	/**
	 * <p>
	 * 親権者情報不備チェックを行う
	 * </p>
	 * @param inMsg           処理対象のメッセージキャリア
	 * @param custBirthYmd    お客様生年月日
	 * @param keiyakuTypeCd   契約者タイプコード
	 * @param shinkNm         親権者名
	 * @param shinkKanaNm     親権者カナ名
	 * @param shinkBirthYmd   親権者生年月日
	 * @param shinkZokugaraCd 親権者続柄コード
	 * @param shinkTelNo      親権者電話番号
	 * @return チェック結果(OK:"00", NG:"01")
	 */
	protected Object shinkensyaHbiCheck(CAANMsg inMsg, String custBirthYmd, String keiyakuTypeCd, String shinkNm, String shinkKanaNm,
			String shinkBirthYmd, String shinkZokugaraCd, String shinkTelNo)
	{

		// 契約者タイプコードがnull(未入力)または契約者タイプコードが"1"(個人)以外の場合、チェックを実施しない
		if (keiyakuTypeCd == null || keiyakuTypeCd.compareTo(JKKModelConst.KEISHA_TYPE_CD_KOJIN) != 0)
		{
			return RETURN_OK;
		}

		// 運用日付を取得
		String opeDate = JKKModelCommon.getOpeDate(inMsg);

		// お客様生年月日がnull(未入力)または契約者の年齢が20歳以上の場合、チェックを実施しない。
		if (custBirthYmd == null || !this.ageCheck(inMsg, custBirthYmd, opeDate))
		{
			return RETURN_OK;
		}

		// 親権者名,親権者カナ名,親権者生年月日,親権者続柄コード,親権者電話番号の何れかが未入力(null)の場合エラーを返却
		if (shinkNm == null || shinkKanaNm == null || shinkBirthYmd == null || shinkZokugaraCd == null || shinkTelNo == null)
		{
			return NG_MISEINEN;
		}

		// 親権者生年月日が運用年月日より未来日の場合エラーとする
		if(!JKKModelCommon.isPastDate(shinkBirthYmd, opeDate, "1")){
			return NG_MIRAI;
		}

		return RETURN_OK;
	}
	
	/**
	 * <p>
	 * 法人格入力不備チェックを行う
	 * </p>
	 * @param inMsg           処理対象のメッセージキャリア
	 * @param keiyakuTypeCd   契約者タイプコード
	 * @param houjinSbtCd     法人格種別コード
	 * @param houjinStiCd     法人格前後指定コード
	 * @return チェック結果(OK:"00", NG:"01")
	 */
	protected Object houjinkakuHbiCheck(CAANMsg inMsg, String keiyakuTypeCd, String houjinSbtCd, String houjinStiCd)
	{

		// 契約者タイプコードがnull(未入力)または契約者タイプコードが"2"(法人)以外の場合、チェックを実施しない
		if (keiyakuTypeCd == null || keiyakuTypeCd.compareTo(JKKModelConst.KEISHA_TYPE_CD_HOJIN) != 0)
		{
			return RETURN_OK;
		}

		// 法人格前後指定コードが未入力(null)の場合エラーを返却
		if (houjinStiCd == null)
		{
			return NG_HOUJINZENGO;
		}

		// 法人格前後指定コードが'2'（なし）以外かつ法人格種別コードがnullの場合エラーとする
		if (houjinStiCd.compareTo(JKKModelConst.HOJIN_ZENGO_SHITEI_CD_NON) != 0 && houjinSbtCd == null)
		{
			return NG_HOUJINSBT;
		}

		return RETURN_OK;
	}
	
	
	/**
	 * <p>
	 * お客様生年月日を元に運用日付から遡って満年齢を算出する。
	 * </p>
	 * @param inMsg           処理対象のメッセージキャリア
	 * @param custBirthYmd    お客様生年月日
	 * @param opeDate         運用日付
	 * @return true：17歳以下 false：18歳以上
	 */	
	private boolean ageCheck(CAANMsg inMsg, String custBirthYmd, String opeDate)
	{

		//運用日付を年（西暦）、月、日に分割
		int opeDateYear = Integer.parseInt(opeDate.substring(0, 4));
		int opeDateMonth = Integer.parseInt(opeDate.substring(4, 6));
		int opeDateDay = Integer.parseInt(opeDate.substring(6, 8));

		//年齢
		int nenrei = 0;

		//生年月日を年（西暦）、月、日に分割
		int birthdayYear = Integer.parseInt(custBirthYmd.substring(0, 4));
		int birthdayMonth = Integer.parseInt(custBirthYmd.substring(4, 6));
		int birthdayDay = Integer.parseInt(custBirthYmd.substring(6, 8));

		//年齢の取得
		nenrei = opeDateYear - birthdayYear;
		if ((birthdayMonth > opeDateMonth) || ((birthdayMonth == opeDateMonth) && (birthdayDay > opeDateDay)))
		{
			nenrei--;
		}

		// ANK-4296-00-00 MOD START
		// 17歳以下ならtrueを返却する
		//if (nenrei <= 19)
		if (nenrei <= 17)
		// ANK-4296-00-00 MOD END
		{
			return true;
		}
		return false;
	}

	/**
	 * <p>
	 * 番号区画一致チェック
	 * </p>
	 * @param inMsg	 処理対象のメッセージキャリア
	 * @param telno 電話番号
	 * @param adCd 住所コード
	 * @param bmpUm 番ポ有無
	 * @return 住所対象番号区画に一致する場合true
	 */
	public boolean noKukakuCdCheck(CAANMsg inMsg, String telno, String adCd, String bmpUm)
	{

		// 運用日付の取得
		String opeDate = JKKModelCommon.getOpeDate(inMsg);

		CAANMsg zm0121OutMsg = null;
		if (!JKKModelConst.UM_U.equals(bmpUm)) {
			CAANMsg zm0121InMsg = new CAANMsg(ZM0121ETMsg.class.getName());
			zm0121InMsg.set(ZM0121ETMsg.TELNO, telno);
			
			// 一意照会を行う
			zm0121OutMsg = new ZM0121LE().findByPrimaryKey(zm0121InMsg);
		

			if(null == zm0121OutMsg)
			{
				return false;
			}
			
			// 無効なレコードだった場合
			if (!JKKModelConst.MK_FLG_YK.equals(zm0121OutMsg.getString(ZM0121ETMsg.MK_FLG)))
			{
				return false;
			}
	
			// 該当レコードが適用範囲外の場合
			if(!isChtYmdRange(zm0121OutMsg.getString(ZM0121ETMsg.TELNO_TSTAYMD), zm0121OutMsg.getString(ZM0121ETMsg.TELNO_TENDYMD), opeDate))
			{
				return false;
			}
		}
		String kyokuNo = null;
		if (JKKModelConst.UM_U.equals(bmpUm)) {
			// 番ポ時で、照査前登録画面からの場合は「電話番号」が作成前の為
			kyokuNo = telno.substring(0, 6);
		} else {
			kyokuNo = zm0121OutMsg.getString(ZM0121ETMsg.KYOKU_NO);
		}
		
		CAANMsg zm0301InMsg = new CAANMsg(ZM0301ETMsg.class.getName());
		zm0301InMsg.set(ZM0301ETMsg.KYOKU_NO, kyokuNo);
		
		// 一意照会を行う
		CAANMsg zm0301OutMsg = new ZM0301LE().findByPrimaryKey(zm0301InMsg);
		
		if(null == zm0301OutMsg)
		{
			return false;
		}
		
		// 無効なレコードだった場合
		if (!JKKModelConst.MK_FLG_YK.equals(zm0301OutMsg.getString(ZM0301ETMsg.MK_FLG)))
		{
			return false;
		}

		// 該当レコードが適用範囲外の場合
		if(!isChtYmdRange(zm0301OutMsg.getString(ZM0301ETMsg.KYOKU_NO_TSTAYMD), zm0301OutMsg.getString(ZM0301ETMsg.KYOKU_NO_TENDYMD), opeDate))
		{
			return false;
		}
		
		String noKukakuCd = zm0301OutMsg.getString(ZM0301ETMsg.NO_KUKAKU_CD);
		
		// 住所対象番号区画のカレント検索用のメッセージを作成
		CAANMsg zm0091InMsg = new CAANMsg(ZM0091ETMsg.class.getName());
		zm0091InMsg.set(ZM0091ETMsg.AD_CD, adCd);
		zm0091InMsg.set(ZM0091ETMsg.NO_KUKAKU_CD, noKukakuCd);
		zm0091InMsg.set(ZM0091ETMsg.RSV_APLY_YMD, opeDate);

		CAANMsg zm0091OutMsg = new JKKejbZM0091DBABase().findByCurrent(zm0091InMsg);
		
		if(null == zm0091OutMsg)
		{
			return false;
		}
		
		// 無効なレコードだった場合
		if (!JKKModelConst.MK_FLG_YK.equals(zm0091OutMsg.getString(ZM0091ETMsg.MK_FLG)))
		{
			return false;
		}

		// 該当レコードが適用範囲外の場合
		if(!isChtYmdRange(zm0091OutMsg.getString(ZM0091ETMsg.AD_TG_NO_KUKAKU_TSTAYMD), zm0091OutMsg.getString(ZM0091ETMsg.AD_TG_NO_KUKAKU_TENDYMD), opeDate))
		{
			return false;
		}
		
		return true;

	}
}
