/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：KKA182SFLogic
*   ソースファイル名：KKA182SFLogic.java
*   作成者          ：富士通
*   日付            ：2018年03月07日
*＜機能概要＞
*   申込情報登録連携（新規・追加）（卸先事業者）(API)のビューロジックです。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v37.00.00   2018/03/07   FJ          新規作成 【ANK-3366-00-00】 eo光設備卸対応
*   v39.00.00	2018/09/21   FJ)北村     【ST-2018-0000033】支払申込書未到着フラグ対応
*   v39.00.00   2018/09/06   FJ          【ANK-3488-00-00】４KSTB（ACASチップ）導入対応
*   v59.00.00	2022/06/06	 FJ) 西窪	 【ANK-4296-00-00】成人年齢引き下げに伴うバックヤード改修対応
*   v72.00.00	2024/03/25   FJ) 松永	 【ANK-4556-00-00】オプションチャンネル変更対応（残対応）
*
**********************************************************************/
package eo.web.webview.KKA182SF;

import static com.fujitsu.futurity.web.x31.X31SWebLog.DEBUG_LOG;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONObject;

import com.fujitsu.futurity.model.base.jcc.util.JCCStringConverter;
import com.fujitsu.futurity.model.common.check.EmsizeCharCheck;
import com.fujitsu.futurity.web.x00.JCCWebServiceException;
import com.fujitsu.futurity.web.x31.X31CWebConst;
import com.fujitsu.futurity.web.x31.X31SDataBeanAccess;

import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.web.webview.JCCWebBusinessLogic;
import eo.web.webview.common.JKKApiCommon;
import eo.web.webview.commonOneStop.JCCWebCommon;
import eo.web.webview.commonOneStop.JKKWebCommon;
import eo.web.webview.mapping.KKSV0895_KKSV0895OPDBMapper;

/**
 * KKA182のビューロジックです。<p>
 * <BR>
 * @author 富士通
 */
public class KKA182SFLogic extends JCCWebBusinessLogic
{
	
	/**
	 * 業務処理名
	 */
	private static final String BUSINESS_LOGIC_NM = "申込情報登録連携（新規・追加）（卸先事業者）";
	
	/**
	 * 申込情報登録連携（新規・追加）（卸先事業者）処理です。
	 * <br>
	 * @return 処理の成否
	 * @throws Exception エラーが発生した場合
	 */
	public boolean init() throws Exception
	{
		// サービス結果格納用サービスフォームBean
		X31SDataBeanAccess bean = null;

		//JSON形式のレスポンスデータを作成する。
		JSONObject jsonRspMap = null;
		
		// リクエストデータ
		Map<String, Object> reqMap = null;

		try
		{
			// サービス結果格納用サービスフォームBean取得
			bean = getServiceFormBean();
			
			reqMap = JKKApiCommon.getJsonDataFromOrs(getSessionId());
			
			X31SDataBeanAccess commonBean = super.getCommonInfoBean();

			// 業務規制チェック
			if (!JKKApiCommon.checkRequestRestriction(commonBean))
			{
				// 規制中の場合
				DEBUG_LOG.debug("■業務規制エラー");

				// 処理応答電文(エラー)を取得
				String msg = JKKApiCommon.createJsonResponse(reqMap, 
						JKKStrConst.RETURN_CD_8000, JKKStrConst.RETURN_MESSAGE_SYSTEM_TIME_OUT).toString();
				// 応答電文に設定
				bean.sendMessageString(KKA182SFConst.RSP_MSG, 
						X31CWebConst.DATABEAN_SET_VALUE, JKKApiCommon.getResponseMsg(msg));
				
				return true;
			}
			
			// チェック結果
			JSONObject checkResult = null;
			
			// ■ 単項目チェック
			checkResult = checkTM(reqMap);
			
			// 単項目チェックエラーが存在する場合
			if (checkResult != null)
			{
				// 返却値の設定
				bean.sendMessageString(KKA182SFConst.RSP_MSG, X31CWebConst.DATABEAN_SET_VALUE, JKKApiCommon.getResponseMsg(checkResult.toString()));
				return true;
			}
			
			// ■ 単項目関連チェック
			checkResult = checkTK(reqMap);
			
			// 単項目関連チェックエラーが存在する場合
			if (checkResult != null)
			{
				// 返却値の設定
				bean.sendMessageString(KKA182SFConst.RSP_MSG, X31CWebConst.DATABEAN_SET_VALUE, JKKApiCommon.getResponseMsg(checkResult.toString()));
				return true;
			}
			
			// ■ サービス呼び出し準備
			HashMap<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put(X31CWebConst.TELEGRAM_INFO_USECASE_ID, "KKSV0895");
			
			Map<String, Object> inputMap = new HashMap<String, Object>();
			Map<String, Map<String, Object>> outputMap = new HashMap<String, Map<String, Object>>();
			
			KKSV0895_KKSV0895OPDBMapper mapper = new KKSV0895_KKSV0895OPDBMapper(reqMap);
			
			// 上りマッピングの実施
			
			// 申込情報登録(卸先事業者)事前処理
			mapper.setPreInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 契約者情報
			mapper.setKeishaInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 申込情報
			mapper.setMskmInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 支払方法情報
// ST-2018-0000033 MOD START
			//mapper.setPaywayInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			mapper.setPaywayInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1, JCCWebCommon.getOpeDate(this, null));
// ST-2018-0000033 MOD END
			// eo光ネット情報
			mapper.setSvcKeiNetInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// eo光電話(1番号用)情報
			mapper.setSvcKeiTel1Info(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// eo光電話(2番号用)情報
			mapper.setSvcKeiTel2Info(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// eo光テレビ情報
			mapper.setSvcKeiTvInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 利用場所住所追加情報
			mapper.setAddUsePlaceInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 利用場所住所更新情報
			mapper.setUpdUsePlaceInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 一時金設定情報
			mapper.setIcjknSetteInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 割引サービス自動適用入力情報
			mapper.setWrisvcAutoAplyInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1, JCCWebCommon.getOpeDate(this, null));
			// 進捗登録情報
			mapper.setPrgInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 断面適用情報
			mapper.setAplyDmenInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 断面XML
			mapper.setDmenXml(reqMap, inputMap, JCCWebCommon.getOpeDate(this, null));
			// 申込画面入力支援ワーク情報
			mapper.setEKK2201D01Info(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			// 申込情報登録(卸先事業者)事前処理
			mapper.setPostInfo(reqMap, inputMap, JPCModelConstant.FUNC_CD_1);
			
			// ■ サービス呼出
			try
			{
				invokeService(paramMap, inputMap, outputMap);
			}
			catch(JCCWebServiceException jwse)
			{
				throw jwse;
			}
			
			// ■ サービス結果の転記
			HashMap<String, Object> checkResultMap = new HashMap<String, Object>();
			
			// チェック結果の取得
			mapper.getKKSV089501CC(checkResultMap, outputMap);
			
			// チェック結果でエラーが発生している場合
			if (!checkResultMap.isEmpty())
			{
				String errorCode = (String)checkResultMap.get("errorCode");
				
				// 
				if ("1100".equals(errorCode))
				{
					String retMessage = "「既存契約共通キー（ネット）」のサービス契約が存在しない";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, errorCode, retMessage);
				}
				else if ("1101".equals(errorCode))
				{
					String retMessage = "電話サービスが登録済み";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, errorCode, retMessage);
				}
				else if ("1102".equals(errorCode))
				{
					String retMessage = "テレビサービスが登録済み";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, errorCode, retMessage);
				}
				else if ("1104".equals(errorCode))
				{
					String retMessage = "「依頼元区分」設備卸事業者マスタ存在チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, errorCode, retMessage);
				}
				else if ("1105-1".equals(errorCode))
				{
					String retMessage = "「利用中の電話サービス提供事業者１」通信事業者マスタ存在チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, "1105", retMessage);
				}
				else if ("1105-2".equals(errorCode))
				{
					String retMessage = "「利用中の電話サービス提供事業者２」通信事業者マスタ存在チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, "1105", retMessage);
				}
				else if ("1106".equals(errorCode))
				{
					String retMessage = "受付番号２重登録チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, errorCode, retMessage);
				}
				else if ("1107-1".equals(errorCode))
				{
					String retMessage = "「番ポ電話番号１」番ポ電話番号２重登録チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, "1107", retMessage);
				}
				else if ("1107-2".equals(errorCode))
				{
					String retMessage = "「番ポ電話番号２」番ポ電話番号２重登録チェックエラー";
					checkResult = JKKApiCommon.createJsonResponse(reqMap, "1107", retMessage);
				}
				
				bean.sendMessageString(KKA182SFConst.RSP_MSG, X31CWebConst.DATABEAN_SET_VALUE, JKKApiCommon.getResponseMsg(checkResult.toString()));
				return true;
			}
			
			Map<String, Object> resultMap = new HashMap<String, Object>();

			// 申込情報登録(卸先事業者)事後処理の処理結果取得
			mapper.getKKSV089515CC(resultMap, outputMap);

			// 返却値の設定
			jsonRspMap = JKKApiCommon.createJsonResponse(reqMap, "0000", null);

			jsonRspMap.put("receivingNum", JKKApiCommon.getJsonValue(resultMap.get("receivingNum")));
			jsonRspMap.put("commonKeyNet", JKKApiCommon.getJsonValue(resultMap.get("commonKeyNet")));
			jsonRspMap.put("commonKeyTel", JKKApiCommon.getJsonValue(resultMap.get("commonKeyTel")));
			jsonRspMap.put("commonKeyTv", JKKApiCommon.getJsonValue(resultMap.get("commonKeyTv")));
			
		}
		catch (Exception e)
		{
			DEBUG_LOG.debug("■致命的なエラー発生");
			
			// ■例外トレースのログ出力
			JKKApiCommon.printDebugLog(e);
			
			jsonRspMap = JKKApiCommon.createJsonResponse(reqMap,
					JKKStrConst.RETURN_CD_9000, JKKStrConst.RETURN_MESSAGE_SYSTEM_ERROR);
		}
		
		// 返却値の設定
		bean.sendMessageString(KKA182SFConst.RSP_MSG, X31CWebConst.DATABEAN_SET_VALUE, JKKApiCommon.getResponseMsg(jsonRspMap.toString()));
		return true;
		
	}
	
	/**
	 * 
	 * 返却用オブジェクトに値を設定（nullであった場合は空文字を設定）
	 * 
	 * @param jo	返却用オブジェクト
	 * @param key  項目キー
	 * @param val  値
	 * @throws Exception
	 */
	private void setRespData(JSONObject jo, String key, Object val) throws Exception
	{
		if (val != null)
		{
			jo.put(key, val);
		}
		else
		{
			jo.put(key, "");
		}
	}
	
	/**
	 * 単項目チェック
	 * 
	 * @param reqMap	リクエスト
	 * @return	result	チェック結果
	 * @throws Exception
	 */
	private JSONObject checkTM(Map<String, Object> reqMap) throws Exception
	{
		
		JSONObject checkResult = null;
		
		// コード値不整合チェック
		checkResult = cdValueFuseiChk(reqMap);
		
		// エラーがあればチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// カナ項目内部属性チェック
		checkResult = kanaKmkChk(reqMap);
		
		// チェック結果を返却
		return checkResult;
	}
	
	/**
	* コード値不整合チェック
	*
	* @param reqMap	リクエスト
	* @return	チェック結果
	* @throws Exception
	*/
	private JSONObject cdValueFuseiChk(Map<String, Object> reqMap) throws Exception
	{
		List<String[][]> chkList = new ArrayList<String[][]>();
		
		// チェック対象項目
		// 1 : 項目名(英字)
		// 2 : 設定値
		// 3 : 項目名
		String[][] cdchk1 = {{"serviceID"}, {"wsale010"}, {"サービスID"}};
		String[][] cdchk2 = {{"gender"}, {"1", "2", "3"}, {"性別"}};
		String[][] cdchk3 = {{"lineAddressType"}, {"1", "2", "3"}, {"利用場所形態"}};
		String[][] cdchk4 = {{"lineAddressFixed"}, {"1", "2"}, {"利用場所_番地決定状況"}};
		String[][] cdchk5 = {{"fax"}, {"1", "0"}, {"FAX希望"}};
		String[][] cdchk6 = {{"parentalRelationship1"}, {"1", "2", "3", "4", "5"}, {"親権者続柄"}};
		String[][] cdchk7 = {{"router"}, {"0", "1", "2"}, {"多機能ルーター種別"}};
		String[][] cdchk8 = {{"phoneEntry"}, {"0", "1", "2"}, {"電話申込"}};
		String[][] cdchk9 = {{"numberPortability1"}, {"0", "1"}, {"番ポ有無1"}};
		String[][] cdchk10 = {{"packOption1"}, {"0", "1", "2"}, {"パックオプション1"}};
		String[][] cdchk11 = {{"option1_1"}, {"0", "1"}, {"発信者番号通知1"}};
		String[][] cdchk12 = {{"option2_1"}, {"0", "1"}, {"発信者番号表示1"}};
		String[][] cdchk13 = {{"option3_1"}, {"0", "1"}, {"非通知着信拒否1"}};
		String[][] cdchk14 = {{"numberPortability2"}, {"0", "1"}, {"番ポ有無2"}};
		String[][] cdchk15 = {{"packOption2"}, {"0", "1", "2"}, {"パックオプション2"}};
		String[][] cdchk16 = {{"option1_2"}, {"0", "1"}, {"発信者番号通知2"}};
		String[][] cdchk17 = {{"option2_2"}, {"0", "1"}, {"発信者番号表示2"}};
		String[][] cdchk18 = {{"option3_2"}, {"0", "1"}, {"非通知着信拒否2"}};
		// ANK-4556-00-00 MOD START
		// String[][] cdchk19 = {{"tvEntry"}, {"0", "1", "2", "3"}, {"テレビ申込"}};
		String[][] cdchk19 = {{"tvEntry"}, {"0", "1", "2"}, {"テレビ申込"}};
		// ANK-4556-00-00 MOD END
		// ANK-3488-00-00 MOD START
		//String[][] cdchk20 = {{"stbType1"}, {"01", "02", "03", "04"}, {"STB種別１"}};
		String[][] cdchk20 = {{"stbType1"}, {"01", "02", "03", "04", "10", "11"}, {"STB種別１"}};
		// ANK-3488-00-00 MOD END
		String[][] cdchk21 = {{"tvCourse1"}, {"01", "02", "03"}, {"テレビコース１"}};
		// ANK-3488-00-00 MOD START
		//String[][] cdchk22 = {{"stbType2"}, {"01", "02", "03", "04"}, {"STB種別２"}};
		String[][] cdchk22 = {{"stbType2"}, {"01", "02", "03", "04", "10", "11"}, {"STB種別２"}};
		// ANK-3488-00-00 MOD END
		String[][] cdchk23 = {{"tvCourse2"}, {"01", "02", "03"}, {"テレビコース２"}};
		// ANK-3488-00-00 MOD START
		//String[][] cdchk24 = {{"stbType3"}, {"01", "02", "03", "04"}, {"STB種別３"}};
		String[][] cdchk24 = {{"stbType3"}, {"01", "02", "03", "04", "10", "11"}, {"STB種別３"}};
		// ANK-3488-00-00 MOD END
		String[][] cdchk25 = {{"tvCourse3"}, {"01", "02", "03"}, {"テレビコース３"}};
		// ANK-3488-00-00 MOD START
		//String[][] cdchk26 = {{"stbType4"}, {"01", "02", "03", "04"}, {"STB種別４"}};
		String[][] cdchk26 = {{"stbType4"}, {"01", "02", "03", "04", "10", "11"}, {"STB種別４"}};
		// ANK-3488-00-00 MOD END
		String[][] cdchk27 = {{"tvCourse4"}, {"01", "02", "03"}, {"テレビコース４"}};
		// ANK-3488-00-00 MOD START
		//String[][] cdchk28 = {{"stbType5"}, {"01", "02", "03", "04"}, {"STB種別５"}};
		String[][] cdchk28 = {{"stbType5"}, {"01", "02", "03", "04", "10", "11"}, {"STB種別５"}};
		// ANK-3488-00-00 MOD END
		String[][] cdchk29 = {{"tvCourse5"}, {"01", "02", "03"}, {"テレビコース５"}};
		String[][] cdchk30 = {{"tvGuideNum"}, {"0", "1", "2", "3", "4", "5"}, {"テレビガイド誌冊数"}};
		
		chkList.add(cdchk1);
		chkList.add(cdchk2);
		chkList.add(cdchk3);
		chkList.add(cdchk4);
		chkList.add(cdchk5);
		chkList.add(cdchk6);
		chkList.add(cdchk7);
		chkList.add(cdchk8);
		chkList.add(cdchk9);
		chkList.add(cdchk10);
		chkList.add(cdchk11);
		chkList.add(cdchk12);
		chkList.add(cdchk13);
		chkList.add(cdchk14);
		chkList.add(cdchk15);
		chkList.add(cdchk16);
		chkList.add(cdchk17);
		chkList.add(cdchk18);
		chkList.add(cdchk19);
		chkList.add(cdchk20);
		chkList.add(cdchk21);
		chkList.add(cdchk22);
		chkList.add(cdchk23);
		chkList.add(cdchk24);
		chkList.add(cdchk25);
		chkList.add(cdchk26);
		chkList.add(cdchk27);
		chkList.add(cdchk28);
		chkList.add(cdchk29);
		chkList.add(cdchk30);
		
		List<String> chkItem = null;
		
		for(String[][] chk : chkList)
		{
			String chkTarget = (String)reqMap.get(chk[0][0]);
			
			// 設定がない場合はチェックしない
			if (chkTarget != null)
			{
				chkItem = Arrays.asList(chk[1]);
				
				// 項目が設定値に一致しない場合
				if (!chkItem.contains(chkTarget))
				{
					// エラーコード、エラーメッセージを設定して
					String retMessage = "「" + chk[2][0] + "」コード値不整合チェックエラー";
					return JKKApiCommon.createJsonResponse(reqMap, "1000", retMessage);
				}
			}
		}
		
		// エラーなし
		return null;
		
	}
	
	/**
	 * カナ項目内部属性チェック
	 * @param reqMap
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject kanaKmkChk(Map<String, Object> reqMap) throws Exception
	{
		JSONObject chkRs = null; 
		
		String[][] condition = {{"nameKana", "氏名（カナ）"},
				{"parentalNameKana", "親権者氏名（カナ）"},
				{"numberPortabilityNameKana1", "番ポ契約者名（カナ）１"},
				{"numberPortabilityNameKana2", "番ポ契約者名（カナ）２"}};

		for(String[] cond : condition)
		{
			chkRs = checkKana(reqMap, cond[0], cond[1]);
			if (chkRs != null)
			{
				return chkRs;
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * 全角カナ文字のチェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkKana(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (!EmsizeCharCheck.isEmsizeEnNumKanaCheck((String)reqMap.get(key)))
		{
			String retMessage = "「" + itemName + "」内部属性チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1001", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 単関連チェックを行う
	 * @param reqMap
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkTK(Map<String, Object> reqMap) throws Exception
	{
		
		JSONObject checkResult = null;
		
		// 条件付き必須チェックを行う
		checkResult = checkJknHissu(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// 申込年月日未来日チェックを行う
		checkResult = checkEntryDayFt(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// 追加申込時追加サービス必須チェックを行う
		checkResult = checkMkmAddHissu(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// 番ポ電話番号重複入力チェックを行う
		checkResult = checkBmpTelNoDble(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// 非通知着信拒否親オプション有無チェックを行う
		checkResult = checkHitchiOyaOp(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// STB種別・テレビコース必須設定チェックを行う
		checkResult = checkStbTvCourse(reqMap);
		
		// エラーがあった場合はチェック終了
		if (checkResult != null)
		{
			return checkResult;
		}
		
		// テレビガイド誌申込可否チェックを行う
		checkResult = checkTvGuide(reqMap);
		
		return checkResult;
	}
	
	/**
	 * 条件付必須チェックを行う
	 * @param reqMap
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkJknHissu(Map<String, Object> reqMap) throws Exception
	{
		
		// 運用日付
		String opeDate = JCCWebCommon.getOpeDate(this, null);
		
		JSONObject chkRs = null; 
		
		
		// 新規受付の場合の必須チェック
		if (reqMap.get("commonKeyNet") == null)
		{
			String[][] condition = {{"name","氏名"},
					{"nameKana", "氏名（カナ）"},
					{"birthday", "生年月日"},
					{"gender", "性別"},
					{"lineAddressZipcode", "利用場所住所＿郵便番号"},
					{"lineAddress5", "利用場所住所＿番地号"},
					{"lineAddressX", "利用場所住所＿Ｘ座標"},
					{"lineAddressY", "利用場所住所＿Ｙ座標"},
					{"lineAddressType", "利用場所形態"},
					{"lineAddressFixed", "利用場所＿番地決定状況"},
					{"contractorAddressZipcode", "契約者住所＿郵便番号"},
					{"contractorAddress5", "契約者住所＿番地号"},
					{"addressReplacement", "開通時住所更新"},
					{"contractorPhoneNum", "契約者電話番号"},
					{"priorityPhoneNum", "優先連絡先電話番号"},
					{"fax", "ＦＡＸ希望"},
					{"router", "多機能ルーター種別"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkNewMkmHissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// 新規受付で契約者が未成年の場合の必須チェック
		if (reqMap.get("commonKeyNet") == null &&
				// ANK-4296-00-00 MOD START
				//Integer.parseInt(JKKWebCommon.getAge((String)reqMap.get("birthday"), opeDate)) < 20)
				Integer.parseInt(JKKWebCommon.getAge((String)reqMap.get("birthday"), opeDate)) < 18)
				// ANK-4296-00-00 MOD END
		{
			String[][] condition = {{"parentalName","親権者氏名"},
					{"parentalNameKana","親権者氏名（カナ）"},
					{"parentalRelationship1","親権者続柄"},
					{"parentalBirthday","親権者生年月日"},
					{"parentalPhoneNum","親権者電話番号"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkMiseinenHissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// 電話1申込時条件付き必須チェック
		if ("1".equals(reqMap.get("phoneEntry")) ||
				"2".equals(reqMap.get("phoneEntry")))
		{
			String[][] condition = {{"numberPortability1", "番ポ有無１"},
					{"packOption1", "バックオプション１"},
					{"option1_1", "発信者番号通知１"},
					{"option2_1", "発信者番号表示１"},
					{"option3_1", "非通知着信拒否１"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkPhone1Hissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// 番ポ1申込時条件付き必須チェック
		if ("1".equals(reqMap.get("numberPortability1")))
		{
			String[][] condition = {{"numberPortabilityPhone1", "番ポ電話番号１"},
					{"numberPortabilityCompany1", "利用中の電話サービス提供事業者１"},
					{"numberPortabilityName1", "番ポ契約者名１"},
					{"numberPortabilityNameKana1", "番ポ契約者名（カナ）１"},
					{"numberPortabilityAddressZipcode1", "番ポ住所_郵便番号１"},
					{"numberPortabilityAddress5_1", "番ポ住所_番地号１"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkBmp1Hissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// 親権者続柄(その他)条件付き必須チェック
		if ("5".equals(reqMap.get("parentalRelationship1")))
		{
			if (reqMap.get("parentalRelationship2") == null)
			{
				String retMessage = "「親権者続柄（その他の場合）」親権者続柄（その他）条件付き必須チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1054", retMessage);
			}
		}
		
		// 電話2申込時条件付き必須チェック
		if ("2".equals(reqMap.get("phoneEntry")))
		{
			String[][] condition = {{"numberPortability2", "番ポ有無２"},
					{"packOption2", "パックオプション２"},
					{"option1_2", "発信者番号通知２"},
					{"option2_2", "発信者番号表示２"},
					{"option3_2", "非通知着信拒否２"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkPhone2Hissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// 番ポ2申込時条件付き必須チェック
		if ("1".equals(reqMap.get("numberPortability2")))
		{
			String[][] condition = {{"numberPortabilityPhone2", "番ポ電話番号２"},
					{"numberPortabilityCompany2", "利用中の電話サービス提供事業者２"},
					{"numberPortabilityName2", "番ポ契約者名２"},
					{"numberPortabilityNameKana2", "番ポ契約者名（カナ）２"},
					{"numberPortabilityAddressZipcode2", "番ポ住所_郵便番号２"},
					{"numberPortabilityAddress5_2", "番ポ住所_番地号２"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkBmp2Hissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// テレビ申込時条件付き必須チェック
		if ("1".equals(reqMap.get("tvEntry")))
		{
			String[][] condition = {{"stbType1", "STB種別1"},
					{"tvCourse1", "テレビコース1"},
					{"tvGuideNum", "テレビガイド誌冊数"}};
			
			for (String[] cond : condition)
			{
				chkRs = checkTvHissu(reqMap, cond[0], cond[1]);
				if (chkRs != null)
				{
					return chkRs;
				}
			}
		}
		
		// FAX希望時条件付き必須チェック
		if ("1".equals(reqMap.get("fax")))
		{
			if (reqMap.get("faxNum") == null)
			{
				String retMessage = "「ＦＡＸ電話番号」ＦＡＸ希望時条件付き必須チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1058", retMessage);
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * 新規申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkNewMkmHissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」新規申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1050", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 未成年条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkMiseinenHissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」未成年条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1051", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 電話1申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkPhone1Hissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」電話１申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1052", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 番ポ1申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkBmp1Hissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」番ポ有無１申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1053", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 電話2申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkPhone2Hissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」電話２申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1055", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 番ポ2申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkBmp2Hissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」番ポ有無２申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1056", retMessage);
		}
		
		return null;
	}
	
	/**
	 * テレビ申込時条件付き必須チェックを行う
	 * @param reqMap
	 * @param key
	 * @param itemName
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkTvHissu(Map<String, Object> reqMap, String key, String itemName) throws Exception
	{
		if (reqMap.get(key) == null)
		{
			String retMessage = "「" + itemName + "」テレビ申込時条件付き必須チェックエラー";
			return JKKApiCommon.createJsonResponse(reqMap, "1057", retMessage);
		}
		
		return null;
	}
	
	/**
	 * 申込年月日未来日チェックを行う
	 * @param	reqMap	リクエスト
	 * @return	チェック結果
	 */
	private JSONObject checkEntryDayFt(Map<String, Object> reqMap) throws Exception
	{
		// 運用日付
		String opeDate = JCCWebCommon.getOpeDate(this, null);
		
		if (((String)reqMap.get("entryDay")).compareTo(opeDate) > 0)
		{
			String retMessage = "「申込年月日」が未来日";
			return JKKApiCommon.createJsonResponse(reqMap, "1059", retMessage);
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * 追加申込時追加サービス必須チェックを行う
	 * @param	reqMap	リクエスト
	 * @return	チェック結果
	 */
	private JSONObject checkMkmAddHissu(Map<String, Object> reqMap) throws Exception
	{
		// 「既存契約共通キー(ネット)」が空でない場合
		if (reqMap.get("commonKeyNet") != null)
		{
			// 電話申込、テレビ申込の両方が申込なしである場合エラー
			if ("0".equals(reqMap.get("phoneEntry")) &&
					"0".equals(reqMap.get("tvEntry")))
			{
				String retMessage = "追加申込サービスなし";
				return JKKApiCommon.createJsonResponse(reqMap, "1060", retMessage);
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * 番ポ電話番号重複入力チェックを行う
	 * @param	reqMap	リクエスト
	 * @return	チェック結果
	 */
	private JSONObject checkBmpTelNoDble(Map<String, Object> reqMap) throws Exception
	{
		// 番ポ有無2が"1"(番ポ)である場合
		if ("1".equals(reqMap.get("numberPortability2")))
		{
			// 番ポ電話番号1と番ポ電話番号2が同じ番号であった場合エラー
			if (reqMap.get("numberPortabilityPhone2").equals(reqMap.get("numberPortabilityPhone1")))
			{
				String retMessage = "番ポ電話番号重複入力チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1061", retMessage);
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * 非通知着信拒否親オプション有無チェックを行う
	 * @param	reqMap	リクエスト
	 * @return	チェック結果
	 */
	private JSONObject checkHitchiOyaOp(Map<String, Object> reqMap) throws Exception
	{
		// 非通知着信拒否1が"1"(申し込む)の場合
		if ("1".equals(reqMap.get("option3_1")))
		{
			// パックオプション1が"1"(パック3)または"2"(パック7)、
			// または、発信者番号表示1が"1"(申し込む)でない場合
			if (!"1".equals(reqMap.get("packOption1")) &&
					!"2".equals(reqMap.get("packOption1")) &&
					!"1".equals(reqMap.get("option2_1")))
			{
				String retMessage = "「非通知着信拒否１」親オプション有無チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1062", retMessage);
			}
		}
		
		// 非通知着信拒否2が"1"(申し込む)の場合
		if ("1".equals(reqMap.get("option3_2")))
		{
			// パックオプション2が"1"(パック3)または"2"(パック7)、
			// または、発信者番号表示2が"1"(申し込む)でない場合
			if (!"1".equals(reqMap.get("packOption2")) &&
					!"2".equals(reqMap.get("packOption2")) &&
					!"1".equals(reqMap.get("option2_2")))
			{
				String retMessage = "「非通知着信拒否２」親オプション有無チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1062", retMessage);
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * STB種別・テレビコース必須設定チェックを行う
	 * @param reqMap
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkStbTvCourse(Map<String, Object> reqMap) throws Exception
	{
		for (int i = 1; i <= 5; i++)
		{
			// STB種別
			String stbType = (String)reqMap.get("stbType" + i);
			// テレビコース
			String tvCourse = (String)reqMap.get("tvCourse" + i);
			
			// STB種別が設定されていて、テレビコースの設定がない場合
			if (stbType != null && tvCourse == null)
			{
				String retMessage = "「テレビコース" + JCCStringConverter.toWide(String.valueOf(i)) + "」ＳＴＢ種別・テレビコース必須設定チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1063", retMessage);
			}
			// テレビコースの設定がされていて、STB種別の設定がない場合
			if (tvCourse != null && stbType == null)
			{
				String retMessage = "「ＳＴＢ種別" + JCCStringConverter.toWide(String.valueOf(i)) + "」ＳＴＢ種別・テレビコース必須設定チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1063", retMessage);
			}
		}
		
		// エラーなし
		return null;
	}
	
	/**
	 * テレビガイド誌申込可否チェックを行う
	 * @param reqMap
	 * @return チェック結果
	 * @throws Exception
	 */
	private JSONObject checkTvGuide(Map<String, Object> reqMap) throws Exception
	{
		// テレビ申込が"1":ＨＤコースでない場合
		if (!"1".equals(reqMap.get("tvEntry")))
		{
			// テレビガイド誌冊数が1以上設定されている場合
			if (reqMap.get("tvGuideNum") != null && Integer.parseInt((String)reqMap.get("tvGuideNum")) >= 1)
			{
				String retMessage = "テレビガイド誌申込可否チェックエラー";
				return JKKApiCommon.createJsonResponse(reqMap, "1064", retMessage);
			}
		}
			
		// エラーなし
		return null;
	}
}