/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKCmpAplyKhShokaiAddCC
*	ソースファイル名：JKKCmpAplyKhShokaiAddCC.java
*	作成者			：FJ)渋谷
*	日付			：2024年3月27日
*＜機能概要＞
*	キャンペーン適用可否照会・登録サービスの共通コンポーネントクラスです。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*   v71.00.00	2024/03/27	FJ)渋谷  【ANK-4468-00-00】eo光ネット「シンプルプラン」追加対応
*   v71.00.00	2024/05/31	FJ)渋谷  【IT1-2024-0000012】料金プランチェック
*   v71.00.01	2025/07/09	FJ)渋谷  【ANK-4468-00-01】割引対象サービス契約登録処理修正
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.model.common.check.HalfCharCheck;
import com.fujitsu.futurity.model.common.check.LengthCheck;

import eo.common.constant.JACStrConst;
import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JCHStringUtil;
import eo.common.util.JKKStringUtil;
import eo.ejb.cbs.cbsmsg.ECC0021D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECC0021D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECC0021D010CBSMsg2List;
import eo.ejb.cbs.cbsmsg.ECC0121A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0011B050CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B050CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021C060CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0481B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0481B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0841B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0841B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0851B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321B010CBSMsg1List;


/**
 * キャンペーン適用可否照会・登録サービスの共通コンポーネントクラスです。
 * <br>
 * @author FJ
 */
public class JKKCmpAplyKhShokaiAddCC extends AbstractCommonComponent
{
	/*
	 * ============
	 * CCパラメータ
	 * ============
	 */
	/** CC共通パラメータ：ボディ情報 */
	public static final String BODY_INFO = "BODY_INFO";
	/** CC共通パラメータ：業務用エラーリスト情報 */
	public static final String GYOM_ERR_LIST = "gyomuErrorList";
	/** CC共通パラメータ：キャンペーン適用可否一覧情報 */
	public static final String CAMPAIGN_APLY_KH_LIST = "campaignAplyKhList";
	
	
	/** CC入力パラメータ：SYSID */
	public static final String IN_SYSID = "sysid";
	/** CC入力パラメータ：変換後SYSID */
	public static final String IN_CNG_SYSID = "_sysid";
	/** CC入力パラメータ：サービス契約番号 */
	public static final String IN_SVC_KEI_NO = "svcKeiNo";
	/** CC入力パラメータ：照会登録区分 */
	public static final String IN_MODE = "mode";
	/** CC入力パラメータ：キャンペーンコード */
	public static final String IN_CAMPAIGN_CD = "campaignCode";
	
	
	/** CC出力パラメータ：SYSID */
	public static final String OUT_SYSID = "sysid";
	/** CC出力パラメータ：サービス契約番号 */
	public static final String OUT_SVC_KEI_NO = "svcKeiNo";
	/** CC出力パラメータ：登録結果コード */
	public static final String OUT_ADD_RSLT_CD = "addRsltCode";
	/** CC出力パラメータ：キャンペーンコード */
	public static final String OUT_CAMPAIGN_CD = "campaignCode";
	/** CC出力パラメータ：キャンペンーン名称 */
	public static final String OUT_CAMPAIGN_NM = "campaignName";
	/** CC出力パラメータ：適用可否コード */
	public static final String OUT_APLY_KH_CD = "aplyKhCode";
	
	/** CC出力パラメータ：エラー情報 */
	public static final String ERROR_INFO = "ERROR_INFO";
	/** CC出力パラメータ：エラーコード */
	public static final String ERROR_CODE = "errorCode";
	/** CC出力パラメータ：エラーメッセージ */
	public static final String ERROR_MESSAGE = "errorMessage";
	
	
	/*
	 * ==============
	 * テンプレートID
	 * ==============
	 */
	/** テンプレートID：サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0081A010 = "EKK0081A010";
	/** テンプレートID：割引サービス一覧照会（表示用キャンペーンコード） */
	private static final String TEMPLATE_ID_EKK0841B002 = "EKK0841B002";
	/** テンプレートID：業務パラメータ管理一覧照会 */
	private static final String TEMPLATE_ID_EZM0321B010 = "EZM0321B010";
	/** テンプレートID：割引サービス対象契約一覧照会 */
	private static final String TEMPLATE_ID_EKK0481B001 = "EKK0481B001";
	/** テンプレートID：割引サービス契約一覧照会（サービス契約番号） */
	private static final String TEMPLATE_ID_EKK0451B002 = "EKK0451B002";
	/** テンプレートID：サービス契約<eo光ネット>一意照会 */
	private static final String TEMPLATE_ID_EKK0091A010 = "EKK0091A010";
	/** テンプレートID：申込内容承認登録 */
	private static final String TEMPLATE_ID_EKK0011D020 = "EKK0011D020";
	
	/** テンプレートID：割引サービス契約登録 */
	private static final String TEMPLATE_ID_EKK0451D010 = "EKK0451D010";
	/** テンプレートID：進捗登録 */
	private static final String TEMPLATE_ID_EKK1091D010 = "EKK1091D010";
	/** テンプレートID：お客様情報照会(PMP連携用)*/
	private static final String TEMPLATE_ID_ECK0011B050 = "ECK0011B050";
	/** テンプレートID：メール送信情報登録*/
	private static final String TEMPLATE_ID_ECC0021D010 = "ECC0021D010";
	/** テンプレートID：お客様一意照会 */
	private static final String TEMPLATE_ID_ECK0011A010 = "ECK0011A010";
	/** テンプレートID：申込明細照査・後続業務依頼 */
	private static final String TEMPLATE_ID_EKK0021C060 = "EKK0021C060";
	// IT1-2024-0000012 ADD START
	/** テンプレートID：割引サービス対象サービス一覧照会 */
	private static final String TEMPLATE_ID_EKK0851B001 = "EKK0851B001";
	// IT1-2024-0000012 ADD END
	
	/*
	 * ========
	 * 共通定数
	 * ========
	 */
	/** リターンメッセージ取得キー */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージの書式指定文字列 */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** エラー項目接尾辞 */
	private static final String ERRITEM_SUFFIX = "_err";
	
	/* 
	 * ============
	 * 資産固有定数
	 * ============
	 */
	
	/** 定数：照会登録区分 "1"(照会)*/
	private static final String CONST_MODE_SHOKAI = "1";
	/** 定数：照会登録区分 "2"(登録)*/
	private static final String CONST_MODE_ADD = "2";
	/** 定数：パラメータチェックメッセージ(1004)*/
	private static final String PARAM_CHK_ERROR_MSG_1004 = "";
	/** 定数：パラメータチェックメッセージ(2001)*/
	private static final String PARAM_CHK_ERROR_MSG_2001 = "契約が見つかりません";
	/** 定数：パラメータチェックメッセージ(2002)*/
	private static final String PARAM_CHK_ERROR_MSG_2002 = "キャンペーンが見つかりません";
	/** 定数：パラメータチェックメッセージ(2003)*/
	private static final String PARAM_CHK_ERROR_MSG_2003 = "対象外のキャンペーンです";
	/** 定数：パラメータチェックメッセージ(3001)*/
	private static final String PARAM_CHK_ERROR_MSG_3001 = "";
	/** 定数：キャンペーン適用可否判定 適用可否コード(1)*/
	private static final String PARAM_APLY_KH_CD_1 = "1";
	/** 定数：キャンペーン適用可否判定 適用可否コード(2)*/
	private static final String PARAM_APLY_KH_CD_2 = "2";
	/** 定数：キャンペーン適用可否判定 適用可否コード(3)*/
	private static final String PARAM_APLY_KH_CD_3 = "3";
	/** 定数：キャンペーン適用可否判定 適用可否コード(0)*/
	private static final String PARAM_APLY_KH_CD_0 = "0";
	/** 定数：業務パラメータID()*/
	private static final String WORK_PARAM_ID = "CH_SAD_SMPLN_CMP_*";
	/** 定数：進捗特記事項1)*/
	private static final String PRG_TKJK_1 = "キャンペーンコード：23002000";
	/** 定数：進捗特記事項2*/
	private static final String PRG_TKJK_2 = "";
	/** 定数：登録結果コード（正常）*/
	private static final String ADD_RSLT_CD_SEIJOU = "0";
	/** 定数：登録結果コード（異常）*/
	private static final String ADD_RSLT_CD_IJOU = "1";
	/** 定数：メールコード	*/
	private static final String MAIL_CD = "KKM1000049";
	/** 定数：キャンペーンコード（シンプルプラン）	*/
	private static final String CMP_CD_23002000 = "23002000";
	
	/** 定数：必須チェック */
	
	private static final String[] PARAM_CHK_UM = new String[]{
		  IN_SVC_KEI_NO,				// サービス契約番号
		  IN_MODE						// 照会登録区分
		  };
	/** 定数：属性チェック(半角英数字1) */
	private static final String[] PARAM_CHK_ZOKUSEI_ENNUMBER1 = new String[]{
		IN_SYSID,						// SYSID
		IN_CNG_SYSID,					// 変換後SYSID
		IN_SVC_KEI_NO					// サービス契約番号
	};
	
	/** 定数：属性チェック(半角英数字1) */
	private static final String[] PARAM_CHK_ZOKUSEI_NUMBER1 = new String[]{
		IN_MODE,						// 照会登録区分
		IN_CAMPAIGN_CD					// キャンペーンコード
	};
	/** 定数：桁数チェック1 */
	private static final String[][] PARAM_CHK_KETASUU = new String[][]{
		  {IN_SYSID,			"10"}	// SYSID
		 ,{IN_CNG_SYSID,		"10"}	// 変換後SYSID
		 ,{IN_SVC_KEI_NO,		"10"}	// サービス契約番号
		 ,{IN_MODE,				"1"}	// 照会登録区分
		 ,{IN_CAMPAIGN_CD,		"8"}	// キャンペーンコード
	};
	/*
	 * ==============
	 * グローバル変数
	 * ==============
	 */
	/** 業務処理用work */
	HashMap<Object, Object> workMap = new HashMap<Object, Object>();
	/** 業務処理用sysid */
	String sysid = null;
	


	/**
	 * キャンペーン適用可否照会・登録を行う。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return リクエストパラメータ
	 * @throws Throwable 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite execute(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws Throwable
	{
		
		// CCパラメータ
		HashMap ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		// レスポンス
		HashMap<String, Object> responseMap = new HashMap<String, Object>();
		

		try
		{
			
			// SYSID
			sysid = (String)ccMsg.get(IN_CNG_SYSID);
			
			if(JKKStringUtil.isNullBlank(sysid))
			{
				sysid = (String)ccMsg.get(IN_SYSID);
			}
			
			// 単項目チェック
			if (!checkUnitParam(handle, param, fixedText))
			{
				param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_5000);
				return param;
			}
			
			// パラメータチェック
			if (!checkParameter(handle, param, fixedText))
			{
				param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_5000);
				return param;
			}
			
			// 登録結果コード 初期化
			String addRsltCode = null;
			// 照会登録区分
			String mode = (String)ccMsg.get(IN_MODE);
			
			// キャンペーン適用可否判定
			if (!checkCmpAplyKh(handle, param, fixedText))
			{
				// 「照会登録区分」が"2"(登録)の場合、キャンペーン登録処理を行う
				if (CONST_MODE_ADD.equals(mode))
				{
					addRsltCode = ADD_RSLT_CD_SEIJOU;
					// キャンペーン登録処理
					if(CmpAdd(handle, param, fixedText))
					{
						// メール送信
						sendMail(handle, param, fixedText);
					}
					else
					{
						addRsltCode = ADD_RSLT_CD_IJOU;
					}
				}
			}
			// キャンペーン適用可否判定NGの場合
			else
			{
				addRsltCode = ADD_RSLT_CD_IJOU;
			}

			// レスポンスの作成
			responseMap = getResponseMap(handle, param, fixedText, addRsltCode);
			
			// ボディ情報にレスポンス内容を設定する
			ccMsg.put(BODY_INFO, responseMap);

			// 正常終了
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_0000);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, null);
			
			// 登録が失敗した場合
			if(ADD_RSLT_CD_IJOU.equals(addRsltCode))
			{
				// CCExceptionを発行してロールバックさせる。
				throw new CCException("", new Exception());
			}
		}
		
		catch (CCException cce)
		{
			throw cce;
		}
		catch (Throwable throwable)
		{
			// 出力用設定値:エラーリスト
			ArrayList<HashMap<String, String>> errList = new ArrayList<HashMap<String, String>>();
			// エラー情報を格納する
			errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_9000, JACStrConst.KARA_MOJI));
			ccMsg.put(ERROR_INFO, errList);
			throw throwable;
		}
		
		return param;
	}


	/**
	 * 単項目チェックを行います。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return true:異常なし false:異常あり
	 * @throws Exception 例外が発生した場合
	 */
	private boolean checkUnitParam(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws Throwable
	{
		
		// CCパラメータ
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		// 出力用設定値:エラーリスト
		ArrayList<HashMap<String, String>> errList = new ArrayList<HashMap<String, String>>();
		
		String itemValue = null;
		String errorMessage = null;
		int length = 0;
		
		// 必須チェック
		for(int i = 0; i < PARAM_CHK_UM.length ; i++)
		{
			itemValue = (String)ccMsg.get(PARAM_CHK_UM[i]);
			errorMessage = PARAM_CHK_UM[i] + JACStrConst.COLON + itemValue;
			// 必須チェック
			if (JCHStringUtil.isNullBlank(itemValue))
			{
				// 必須チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_1001, errorMessage));
			}
		}
		
		// 属性チェック(半角英字1)
		for(int i = 0; i < PARAM_CHK_ZOKUSEI_ENNUMBER1.length ; i++)
		{
			itemValue = (String)ccMsg.get(PARAM_CHK_ZOKUSEI_ENNUMBER1[i]);
			errorMessage = PARAM_CHK_ZOKUSEI_ENNUMBER1[i] + JACStrConst.COLON + itemValue;
			// 属性チェック
			if (!HalfCharCheck.isEnNumber1Check(itemValue))
			{
				// 属性チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_1002, errorMessage));
			}
		}
		
		// 属性チェック(数字1)
		for(int i = 0; i < PARAM_CHK_ZOKUSEI_NUMBER1.length ; i++)
		{
			itemValue = (String)ccMsg.get(PARAM_CHK_ZOKUSEI_NUMBER1[i]);
			errorMessage = PARAM_CHK_ZOKUSEI_NUMBER1[i] + JACStrConst.COLON + itemValue;
			// 属性チェック
			if (!HalfCharCheck.isNumber1Check(itemValue))
			{
				// 属性チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_1002, errorMessage));
			}
		}
		
		// 桁数チェック
		for(int i = 0; i < PARAM_CHK_KETASUU.length ; i++)
		{
			itemValue = (String)ccMsg.get(PARAM_CHK_KETASUU[i][0]);
			length = Integer.parseInt(PARAM_CHK_KETASUU[i][1]);
			errorMessage = PARAM_CHK_KETASUU[i][0] + JACStrConst.COLON + itemValue;
			// 桁数チェック
			if (!LengthCheck.isLength1Check(itemValue, length))
			{
				// 桁数チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_1003, errorMessage));
			}
		}
		
		// エラーが存在する場合
		if (errList.size() > 0)
		{
			ccMsg.put(ERROR_INFO, errList);
			return false;
		}
		
		return true;
		
	}

	/**
	 * パラメータチェックを行います。<br>
	 * ※後続処理に必要な情報の取得も行う。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return true:異常なし false:異常あり
	 * @throws RequestParameterException 
	 * @throws Throwable 例外が発生した場合
	 */
	private boolean checkParameter(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		// 返却用設定値:エラーリスト
		ArrayList<HashMap<String, String>> errList = new ArrayList<HashMap<String, String>>();
		// CCパラメータ
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		try
		{
			// リクエスト.照会登録区分
			String mode = (String)ccMsg.get(IN_MODE);
			
			/*
			 *  ＝＝＝照会登録区分コード値チェック＝＝＝
			 */
			// 照会登録区分が"1"(照会)、"2"(登録)以外の場合エラー
			
			if (!(CONST_MODE_SHOKAI.equals(mode) || CONST_MODE_ADD.equals(mode)))
			{
				// 照会登録区分コード値チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_1004, PARAM_CHK_ERROR_MSG_1004));
				ccMsg.put(ERROR_INFO, errList);
				return false;
			}
			
			/*
			 *  ＝＝＝サービス契約番号チェック＝＝＝
			 */
			// サービス契約番号が下記有効なサービス契約でない場合エラー
			// サービス契約に存在しないサービス契約番号
			// サービス契約の契約状態が「解約済」
			// サービス契約の契約状態が「キャンセル済」
			 
			// リクエスト.サービス契約番号
			String svcKeiNo = (String)ccMsg.get(IN_SVC_KEI_NO);
			
			// サービス契約一意照会結果格納リスト
			CAANMsg[] ekk0081a010MsgList = null;
			
			// サービス契約一意照会(機能コード2)
			ekk0081a010MsgList = callEKK0081A010_FUNC2(handle, param, fixedText, svcKeiNo);
			
			// サービスIFの結果がNULLまたは空の場合
			if (rsltSifList(ekk0081a010MsgList))
			{
				// サービス契約番号チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_2001, PARAM_CHK_ERROR_MSG_2001));
				ccMsg.put(ERROR_INFO, errList);
				return false;
			}
			
			// サービス契約の契約状態が「解約済」または、「キャンセル済」
			if (JKKStrConst.CD00037_DSL_ZM.equals(ekk0081a010MsgList[0].getString(EKK0081A010CBSMsg1List.SVC_KEI_STAT)) 
					|| JKKStrConst.CD00037_CANCEL_ZM.equals(ekk0081a010MsgList[0].getString(EKK0081A010CBSMsg1List.SVC_KEI_STAT)))
			{
				// サービス契約番号チェックエラー
				errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_2001, PARAM_CHK_ERROR_MSG_2001));
				ccMsg.put(ERROR_INFO, errList);
				return false;
			}
			
			// 料金プランコード
			String pplanCd = ekk0081a010MsgList[0].getString(EKK0081A010CBSMsg1List.PPLAN_CD);
			// 後続で使用するため業務パラメータ管理一覧照会を退避
			workMap.put(TEMPLATE_ID_EKK0081A010, ekk0081a010MsgList);
			
			/*
			 *  ＝＝＝料金プランチェック＝＝＝
			 */
			// サービス契約の料金プランがキャンペーン適用対象外である場合エラー
			 
			
			// 業務パラメータ管理一覧照会結果格納リスト
			CAANMsg[] ezm0321b010MsgList = null;
			
			// 業務パラメータ管理一覧照会(機能コード1)
			ezm0321b010MsgList = callEZM0321B010_FUNC1(handle, param, fixedText);
			// 後続で使用するため業務パラメータ管理一覧照会を退避
			workMap.put(TEMPLATE_ID_EZM0321B010, ezm0321b010MsgList);
			
			// キャンペーンコード初期化
			String campCD = null;
			
			// 照会登録区分」が"2"(登録)
			if (CONST_MODE_ADD.equals(mode))
			{
				/*
				 *  ＝＝＝料金プランチェック＝＝＝
				 */
				// サービス契約の料金プランがキャンペーン適用対象外である場合エラー
				
				// リクエスト.キャンペーンコード
				campCD = (String)ccMsg.get(IN_CAMPAIGN_CD);
				
				if(!pplanCdChk(handle, param, fixedText, campCD,pplanCd))
				{
					// 料金プランチェックエラー
					errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_2002, PARAM_CHK_ERROR_MSG_2002));
					ccMsg.put(ERROR_INFO, errList);
					return false;
				}
				/*
				 *  ＝＝＝キャンペーンコードチェック＝＝＝
				 */
				// キャンペーンコードが、照会モードで返却されたキャンペーンコードでない場合、エラー
				
				// キャンペーンコード有無判断用フラグ
				boolean cmpUmJudgeFlg = false;
				
				// 業パラから取得したキャンペーンコード
				String resultCmpCd = null;
				
				// サービス契約の料金プランコードと一致する割引情報を取得する
				for(int i = 0; i < ezm0321b010MsgList.length; i++)
				{
					if(!JKKStringUtil.isNullBlank(ezm0321b010MsgList[i].getString(EZM0321B010CBSMsg1List.WORK_PARAM_SETTE_VALUE)))
					{
						String[] result = ezm0321b010MsgList[i].getString(EZM0321B010CBSMsg1List.WORK_PARAM_SETTE_VALUE).split(",");
						resultCmpCd = result[0];
						if(campCD.equals(resultCmpCd))
						{
							// キャンペーン名 退避
							workMap.put(OUT_CAMPAIGN_NM, result[1]);
							cmpUmJudgeFlg = true;
						}
					}
				}
				
				// リクエストパラメータのキャンペーンコードが業務パラメータ管理一覧照会結果に存在しない値の場合
				if(!cmpUmJudgeFlg)
				{
					// キャンペーンコードチェックエラー
					errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_2003, PARAM_CHK_ERROR_MSG_2003));
					ccMsg.put(ERROR_INFO, errList);
					return false;
				}
			}
			else
			{
				/*
				 *  ＝＝＝料金プランチェック＝＝＝
				 */
				// サービス契約の料金プランがキャンペーン適用対象外である場合エラー
				
				// 料金プランチェック用フラグ
				boolean pplanChkFlg = false;
				
				// 業務パラメータ管理から取得できた分チェックを行う
				for(CAANMsg rslt : ezm0321b010MsgList)
				{
					String[] str = rslt.getString(EZM0321B010CBSMsg1List.WORK_PARAM_SETTE_VALUE).split(",");
					campCD = str[0];
					if(pplanCdChk(handle, param, fixedText, campCD,pplanCd))
					{
						pplanChkFlg = true;
					}
				}
				// 一致する割引情報がない場合
				if(!pplanChkFlg)
				{
					// 料金プランチェックエラー
					errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_2002, PARAM_CHK_ERROR_MSG_2002));
					ccMsg.put(ERROR_INFO, errList);
					return false;
				}
			}
			return true;
		}
		catch(Throwable e)
		{
			// その他エラー
			errList.add(getErrorInfoMap(JKKStrConst.RETURN_CD_3001, PARAM_CHK_ERROR_MSG_3001));
			ccMsg.put(ERROR_INFO, errList);
			return false;
		}
	}
	
	/**
	 * キャンペーン適用可否チェックを行います。<br>
	 * ※後続処理に必要な情報の取得も行う。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return true:チェック結果NG false:チェック結果すべてOK
	 * @throws Throwable 例外が発生した場合
	 */
	private boolean checkCmpAplyKh(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws Throwable
	{
		
		// CCパラメータ
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		// チェック結果判定用
		boolean chkRsltJudgeFlg = false;
		
		// リクエスト.サービス契約番号
		String svcKeiNo = (String)ccMsg.get(IN_SVC_KEI_NO);
		
		// 割引サービス契約一覧照会（サービス契約番号）結果格納リスト
		CAANMsg[] ekk0451b002MsgList = null;
		
		// 割引サービス契約一覧照会（サービス契約番号）(機能コード1)
		ekk0451b002MsgList = callEKK0451B002_FUNC1(handle, param, fixedText, svcKeiNo);
		
		// リクエスト.照会登録区分
		String mode = (String)ccMsg.get(IN_MODE);
		
		// 業務パラメータ管理一覧照会結果格納リスト
		CAANMsg[] ezm0321b010MsgList = null;
		
		// 業務パラメータ管理一覧照会結果
		ezm0321b010MsgList = (CAANMsg[]) workMap.get(TEMPLATE_ID_EZM0321B010);
		
		// キャンペーンコード
		String cmpCd = null;
		// キャンペーン名称
		String cmpNm = null;
		
		// 可否判定結果とキャンペーンコードを退避させる用
		List<HashMap<String, Object>> khRsltLst = new ArrayList<HashMap<String, Object>>();
		
		/*
		 *  ＝＝＝キャンペーン適用可否チェック＝＝＝
		 */
		// 照会登録区分が"1"(照会)場合
		if (CONST_MODE_SHOKAI.equals(mode) )
		{
			for(CAANMsg rslt : ezm0321b010MsgList)
			{
				String[] str = rslt.getString(EZM0321B010CBSMsg1List.WORK_PARAM_SETTE_VALUE).split(",");
				cmpCd = str[0];
				cmpNm = str[1];
				
				// キャンペーン可否判定処理
				khRsltLst.add(chkCmpCd(handle, param, fixedText, ekk0451b002MsgList,cmpCd,cmpNm));
			}
		}	
		else
		{
			// キャンペーンコード
			cmpCd = (String)ccMsg.get(IN_CAMPAIGN_CD);
			cmpNm = (String) workMap.get(OUT_CAMPAIGN_NM);
			// キャンペーン可否判定処理
			khRsltLst.add(chkCmpCd(handle, param, fixedText, ekk0451b002MsgList,cmpCd,cmpNm));
		}
		
		// 適用可否判定NG存在確認
		for(HashMap<String, Object> dataMap : khRsltLst)
		{
			if(!PARAM_APLY_KH_CD_0.equals(dataMap.get(OUT_APLY_KH_CD)))
			{
				chkRsltJudgeFlg = true;
			}
		}
		
		workMap.put(CAMPAIGN_APLY_KH_LIST, khRsltLst);

		return chkRsltJudgeFlg;
	}
	
	


	/**
	 * 出力：エラーコードとエラーメッセージをセットした業務エラーマップを返却する。<br>
	 * <br>
	 * @return returnMap
	 */
	public static HashMap<String, String> getErrorInfoMap(String errorCode, String errorMessage)
	{
		HashMap<String, String> returnMap = new HashMap<String, String>();
		
		returnMap.put(ERROR_CODE, errorCode);
		returnMap.put(ERROR_MESSAGE, errorMessage);
		
		return returnMap;
	}

	/**
	 * サービスインターフェース：サービス契約一意照会
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param svcKeiNo
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callEKK0081A010_FUNC2(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk0081a010In =
		{
			{EKK0081A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081A010}
			// 機能コード
			, {EKK0081A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
			// ＫＥＹ＿予約適用年月日
			, {EKK0081A010CBSMsg.KEY_RSV_APLY_YMD,  JPCBPCommon.getOpeDate(null)}
		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0081a010In)
				.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
	}
	
	/**
	 * サービスインターフェース：割引サービス一覧照会（表示用キャンペーンコード）
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param cmpCd
	 * @param pplanCd
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callEKK0841B002_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String cmpCd)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk0841b002In =
		{
			{EKK0841B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0841B002}
			// 機能コード
			// IT1-2024-0000012 MOD START
//			, {EKK0841B002CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2}
			, {EKK0841B002CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// IT1-2024-0000012 MOD END
			// ＫＥＹ＿表示用キャンペーンコード
			, {EKK0841B002CBSMsg.KEY_DSP_CAMPAIGN_CD, cmpCd}
			// ＫＥＹ＿割引タイプコード
			, {EKK0841B002CBSMsg.KEY_WRIB_TYPE_CD, JKKStrConst.WARIB_TYPE_CMP}
			// IT1-2024-0000012 ADD START
			// 最大件数 ダミーで99件を設定
			, {EKK0841B002CBSMsg.MAX_SEARCH_NUM, "99"}
			// IT1-2024-0000012 ADD END
		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0841b002In)
				.getCAANMsgList(EKK0841B002CBSMsg.EKK0841B002CBSMSG1LIST);
	}
	
	/**
	 * 業務パラメータ管理一覧照会
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callEZM0321B010_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ezm0321b010In =
		{
			{EZM0321B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321B010}
			// 機能コード
			, {EZM0321B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// ＫＥＹ＿業務パラメータID
			, {EZM0321B010CBSMsg.KEY_WORK_PARAM_ID, WORK_PARAM_ID}

		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ezm0321b010In)
				.getCAANMsgList(EZM0321B010CBSMsg.EZM0321B010CBSMSG1LIST);
	}
	
	/**
	 * 引数で受けっとたキャンペーンコードに対して適用可否判定を行う
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param WriSvcKeiList
	 * @param cmpCd
	 * @param cmpNm
	 * @return
	 * @throws Throwable
	 */
	private HashMap<String, Object> chkCmpCd(SessionHandle handle, IRequestParameterReadWrite param, String fixedText,CAANMsg[] WriSvcKeiList, String cmpCd , String cmpNm) throws Throwable
	{

		
		// CCパラメータ
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		// 作業用マップ
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		
		// サービス契約一意照会結果格納リスト
		ArrayList<CAANMsg> ekk0841b020MsgList = new ArrayList<CAANMsg>();
		
		// 割引サービス一覧照会（表示用キャンペーンコード）結果取得
		ekk0841b020MsgList = (ArrayList<CAANMsg>) workMap.get(TEMPLATE_ID_EKK0841B002);
		
		dataMap.put(OUT_CAMPAIGN_CD, cmpCd);
		dataMap.put(OUT_CAMPAIGN_NM, cmpNm);
		
		// キャンペーンコードが「シンプルプランアプリキャンペーン」の場合下記チェックを行う
		if(CMP_CD_23002000.equals(cmpCd))
		{
			/*
			 *  ＝＝＝同一キャンペーンチェック＝＝＝
			 */
			// すでに同一キャンペーンが「受付済」、または、「サービス提供中」の場合、エラー
			
			
			if(!rsltSifList(WriSvcKeiList))
			{
				for (CAANMsg ekk0451b002Msg : WriSvcKeiList)
				{
					boolean cmpAplyFlg = false;
					
					// 同一キャンペーン確認
					for(CAANMsg ekk0841b020Msg : ekk0841b020MsgList)
					{
						if(ekk0841b020Msg.getString(EKK0841B002CBSMsg1List.DSP_CAMPAIGN_CD).equals(cmpCd))
						{
							if(ekk0841b020Msg.getString(EKK0841B002CBSMsg1List.WRIB_SVC_CD).equals(ekk0451b002Msg.getString(EKK0451B002CBSMsg1List.WRIB_SVC_CD)))
							{
								cmpAplyFlg = true;
							}
						}
					}
					// 割引サービス契約ステータスが"受付済"または、"サービス提供中"の場合、エラー
					if(cmpAplyFlg
							&& (JKKStrConst.CD00055_UKZM.equals(ekk0451b002Msg.getString(EKK0481B001CBSMsg1List.WRIB_SVC_KEI_STAT))
									|| JKKStrConst.CD00055_SVCTK_CHU.equals(ekk0451b002Msg.getString(EKK0481B001CBSMsg1List.WRIB_SVC_KEI_STAT))))
					{
						// 同一キャンペーンチェックエラー
						dataMap.put(OUT_APLY_KH_CD, PARAM_APLY_KH_CD_1);
						return dataMap;
					}
				}
			}
			
			/*
			 *  ＝＝＝乗り換え契約者チェック＝＝＝
			 */
			// eo光ネットからの乗り換え契約者の場合、エラー
			
			// サービス契約＜eo光ネット＞一意照会結果格納リスト
			CAANMsg[] ekk0091a010MsgList = null;
			
			// サービス契約＜eo光ネット＞一意照会(機能コード1)
			ekk0091a010MsgList = call_EKK0091A010_FUNC1(handle, param, fixedText, (String)ccMsg.get(IN_SVC_KEI_NO));
			
			if (!rsltSifList(ekk0091a010MsgList))
			{
				// 乗換元サービス契約番号が設定されている場合、エラー
				if (!JKKStringUtil.isNullBlank(ekk0091a010MsgList[0].getString(EKK0091A010CBSMsg1List.NRKEMT_SVKEI_NO)))
				{
					// 乗り換え契約者チェックエラー
					dataMap.put(OUT_APLY_KH_CD, PARAM_APLY_KH_CD_2);
					return dataMap;
				}
			}
			
			/*
			 *  ＝＝＝開通後サービス契約チェック＝＝＝
			 */
			// サービス契約の契約状態が「サービス提供中」以降の場合、エラー
			
			// サービス契約一意照会結果格納リスト
			CAANMsg[] ekk0081a010ResultList = (CAANMsg[]) workMap.get(TEMPLATE_ID_EKK0081A010);
			
			// 「サービス契約の契約状態が「サービス提供中」以降の場合エラー
			if (JKKStrConst.CD00037_SVCTK_CHU.compareTo(ekk0081a010ResultList[0].getString(EKK0081A010CBSMsg1List.SVC_KEI_STAT)) <= 0)
			{
				// 開通後サービス契約チェックエラー
				dataMap.put(OUT_APLY_KH_CD, PARAM_APLY_KH_CD_3);
				return dataMap;
			}
		}
		// 適用可能 
		dataMap.put(OUT_APLY_KH_CD, PARAM_APLY_KH_CD_0);
		return dataMap;
	}
	
	
	/**
	 * 割引サービス対象契約一覧照会
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param svcKeiNo
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callEKK0481B001_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk0481b001In =
		{
			{EKK0481B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0481B001}
			// 機能コード
			, {EKK0481B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// ＫＥＹ＿サービス契約番号
			, {EKK0481B001CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}

		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0481b001In)
				.getCAANMsgList(EKK0481B001CBSMsg.EKK0481B001CBSMSG1LIST);
	}
	
	/**
	 * サービス契約内訳<eo光ネット>一意照会
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param svcKeiNo
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] call_EKK0091A010_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk0091a010In =
		{
			{EKK0091A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0091A010}
			// 機能コード
			, {EKK0091A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2}
			// ＫＥＹ＿サービス契約番号
			, {EKK0091A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}

		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0091a010In)
				.getCAANMsgList(EKK0091A010CBSMsg.EKK0091A010CBSMSG1LIST);
	}
	
	/**
	 * 割引サービス契約一覧照会（サービス契約番号）
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param svcKeiNo
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callEKK0451B002_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk0451b002In =
		{
			{EKK0451B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0451B002}
			// 機能コード
			, {EKK0451B002CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// ＫＥＹ＿サービス契約番号
			, {EKK0451B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0451b002In)
				.getCAANMsgList(EKK0451B002CBSMsg.EKK0451B002CBSMSG1LIST);
	}
	

	/**
	 * SC(サービスインターフェイス）を呼び出します。
	 * @param handle セッションハンドル
	 * @param scCall SC呼び出し部品
	 * @param param リクエストパラメータ
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @return サービスインターフェイス実行結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg callSC(SessionHandle handle, 
							ServiceComponentRequestInvoker scCall, 
							IRequestParameterReadWrite param, 
							String dataMapKey,
							Object[][] mappingData)
	throws Throwable
	{
		HashMap<String, Object> paramMap = editInMsg(param, mappingData);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		Object RETURN_CODE = result.get(JCMConstants.RET_CD_INT_KEY);
		
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		editErrorInfoCom(param, templates, (Integer)RETURN_CODE, dataMapKey);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if (null == errList)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if (!("0".equals(RETURN_CODE.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", RETURN_CODE.toString(), status);
		}
		
		return msg;
	}
	
	/**
	 * 共通項目のメッセージを作成します。
	 * @param param リクエストパラメータ
	 * @param mappingData マッピングデータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException リクエストパラメータの操作でエラーが発生した場合
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param, Object[][] mappingData)
	throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());
		
		// 【取得元：ユーザエリア(コントロールマップ)】
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		String svcIf = (String)mappingData[0][1];
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));
		
		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if (mappingData[i][1] instanceof CAANMsg[])
			{
				template.set((String)mappingData[i][0], (CAANMsg[])mappingData[i][1]);
			}
			else
			{
				if ("".equals(mappingData[i][1]))
				{
					template.setNull((String)mappingData[i][0]);
				}
				else
				{
					template.set((String)mappingData[i][0], mappingData[i][1]);
				}
			}
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		
		templates[0] = template;
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * エラー情報を取得します。
	 * @param param リクエストパラメータ
	 * @param templates CAANMsgクラス
	 * @param errorCode リターンコード
	 * @param dataMapKey パラメータキー
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException リクエストパラメータの操作でエラーが発生した場合
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCom(IRequestParameterReadWrite param, CAANMsg[] templates, int errorCode, String dataMapKey)
	throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (0 != errorCode)
		{
			templateStatus = 9000;
		}
		
		if (null == JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus)))
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if (null == obj)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// ユーザデータ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(dataMapKey);
		
		HashMap map = template.getHashMap();
		Iterator it = map.keySet().iterator();
		while (it.hasNext())
		{
			String key = (String)it.next();
			Object value = map.get(key);
			if (value instanceof HashMap[])
			{
				HashMap[] childMapList = (HashMap[])value;
				for (HashMap childMap : childMapList)
				{
					Iterator childIt = childMap.keySet().iterator();
					while (childIt.hasNext())
					{
						String childKey = (String)childIt.next();
						if (childKey.endsWith(ERRITEM_SUFFIX))
						{
							int keyIdx = childKey.lastIndexOf(ERRITEM_SUFFIX);
							if (inMap.containsKey(childKey.substring(0, keyIdx)))
							{
								inMap.put(childKey, childMap.get(childKey));
							}
						}
					}
				}
			}
			else
			{
				if (key.endsWith(ERRITEM_SUFFIX))
				{
					int keyIdx = key.lastIndexOf(ERRITEM_SUFFIX);
					if (inMap.containsKey(key.substring(0, keyIdx)))
					{
						inMap.put(key, map.get(key));
					}
				}
			}
		}
		
		return param;
	}
	
	/**
	 * キャンペーン登録処理
	 * 
	 * @param resultList お得額集計区分
	 * @return true   NULLまたは、空
	 *          false 上記以外
	 */
	private boolean CmpAdd(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		try
		{
			// CCパラメータ
			HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
			// 返却用設定値:エラーリスト
			ArrayList<HashMap<String, String>> errList = new ArrayList<HashMap<String, String>>();
			
			/*
			 *  ＝＝＝申込登録＝＝＝
			 */
			
			// 申込登録結果格納リスト
			CAANMsg ekk0011d020Msg = null;
			
			// 申込登録(機能コード1)
			ekk0011d020Msg = callEKK0011D020_FUNC1(handle, param, fixedText);
			
			// サービスIFの結果がNULLの場合
			if (ekk0011d020Msg == null)
			{
				return false;
			}
			
			// 申込明細番号,更新年月日時分秒を取得
			CAANMsg ekk0011D020CBSMsg1List = ekk0011d020Msg.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST)[0];
			String mskmDtlNo = ekk0011D020CBSMsg1List.getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO);
			String updDtm = ekk0011d020Msg.getString(EKK0011D020CBSMsg.UPD_DTM);
			
			/*
			 *  ＝＝＝申込明細照査・後続業務依頼＝＝＝
			 */
			
			// 申込明細照査・後続業務依頼(機能コード1)
			callEKK0021C060_FUNC1(handle, param, fixedText,mskmDtlNo, updDtm);
			
			/*
			 *  ＝＝＝割引サービス契約登録(割引サービス契約内訳、割引サービス対象サービス契約)＝＝＝
			 */
			
			String svcKeiNo = (String)ccMsg.get(IN_SVC_KEI_NO);
			
			// 割引サービス対象契約一覧照会結果格納リスト
			CAANMsg[] ekk0481b001MsgList = null;
			
			// 割引サービス対象契約一覧照会(機能コード1)
			ekk0481b001MsgList = callEKK0481B001_FUNC1(handle, param, fixedText,svcKeiNo);
			
			// 割引サービス契約登録(機能コード1)
			callEKK0451D010_FUNC1(handle, param, fixedText, mskmDtlNo,ekk0481b001MsgList,svcKeiNo);
			
			/*
			 *  ＝＝＝進捗,異動理由＝＝＝
			 */
			
			// 進捗登録(機能コード1)
			callEKK1091D010_FUNC1(handle, param, fixedText, mskmDtlNo, svcKeiNo);
			
			return true;
		}
		catch(Throwable e)
		{
			return false;
		}
	}
	
	/**
	 * サービスIFの結果が件数判定
	 * 
	 * @param resultList サービスインターフェイス結果List
	 * @return true   NULLまたは、空
	 *          false 上記以外
	 */
	private boolean rsltSifList(CAANMsg[] resultList) throws Throwable
	{
		if(resultList == null || resultList.length == 0)
		{
			return true;
		}
		return false;
	}
	
	/**
	 * 申込登録
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg callEKK0011D020_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会結果
		CAANMsg[] ekk0081a010ResltList= (CAANMsg[]) workMap.get(TEMPLATE_ID_EKK0081A010);
		
		Object[][] ekk0011d020In =
		{
			{EKK0011D020CBSMsg.TEMPLATEID,                 TEMPLATE_ID_EKK0011D020},
			// 機能コード
			{EKK0011D020CBSMsg.FUNC_CODE,                  JPCModelConstant.FUNC_CD_1},
			// SYSID
			{EKK0011D020CBSMsg.SYSID,                      ekk0081a010ResltList[0].getString(EKK0081A010CBSMsg1List.SYSID)},
			// 申込年月日
			{EKK0011D020CBSMsg.MSKM_YMD,                   JCCBPCommon.getOpeDate(null)},
			// 申込受付年月日時分秒
			{EKK0011D020CBSMsg.MSKM_UK_DTM,                JCCBPCommon.getOpeDateTimeStamp(null)},
			// 申込種別コード
			{EKK0011D020CBSMsg.MSKM_SBT_CD,                JKKStrConst.MSKM_SBT_CD_WARIB_MSKM},
			// コンシューマ営業用申込状態識別コード
			{EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD, JKKStrConst.CD00760_04},
			// 申込書到着年月日
			{EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD,           JKKStrConst.KARA},
			// 申込受付担当ユーザーID
			{EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID,        JKKStrConst.KARA},
			// 申込受付担当ユーザーID
			{EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO,  JKKStrConst.KARA},
			// 総合営業申込契機コード
			{EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD,   JKKStrConst.KARA},
			// 総合営業申込契機コード
			{EKK0011D020CBSMsg.MSKM_RRKS_TELNO,            JKKStrConst.KARA},
			// 申込実施者種別コード
			{EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD,          JKKStrConst.KARA},
			// お客様ご要望事項
			{EKK0011D020CBSMsg.CUST_YOBO_JIKO,             JKKStrConst.KARA},
			// 電話連絡希望日種別コード
			{EKK0011D020CBSMsg.TEL_RRK_KIBOD_SBT_CD,       JKKStrConst.KARA},
			// 電話連絡希望時間帯コード
			{EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD,       JKKStrConst.KARA},
			// 宅内調査希望日種別コード
			{EKK0011D020CBSMsg.TAKCHO_KIBOD_SBT_CD,        JKKStrConst.KARA},
			// 宅内調査希望時間帯コード
			{EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD,        JKKStrConst.KARA},
			// 仮申込フラグ
			{EKK0011D020CBSMsg.KARI_MSKM_FLG,              JKKStrConst.KARA},
			// リファラー
			{EKK0011D020CBSMsg.REFERER,                    JKKStrConst.KARA},
			// 関西電力お客様情報授受同意有無
			{EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, JKKStrConst.KARA},
			// 照査前連絡事項要否
			{EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO_YH,       JKKStrConst.KARA},
			// 照査前連絡事項要否
			{EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO,          JKKStrConst.KARA},
			// 利用サービス継続種別コード
			{EKK0011D020CBSMsg.USE_SVC_KEIZK_SBT_CD,       JKKStrConst.KARA},
			// 受付担当者識別コード
			{EKK0011D020CBSMsg.UK_TNTSHA_SKBT_CD,          JKKStrConst.KARA},
			// 受付担当者識別コード
			{EKK0011D020CBSMsg.KOJI_REQ_INFO_RRK_JIKO,     JKKStrConst.KARA},
			// 受付担当者識別コード
			{EKK0011D020CBSMsg.MSKM_ROUTE_SKBT_CD,         JKKStrConst.KARA},
		};		

		ArrayList<HashMap<String, Object>> inList = getArrayListEKK0011D020CBSMsg();
		
		// サービスIF実行
		return callSCArray(handle, scCall, param, fixedText, ekk0011d020In, "EKK0011D020CBSMsg1List", inList);
	}
	
	/**
	 * 割引サービス契約登録
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param mskmDtlNo
	 * @param wribsvcTgKeiList
	 * @param svcKeiNo
	 * @return
	 * @throws Throwable
	 */
	private void callEKK0451D010_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			String mskmDtlNo, CAANMsg[] wribsvcTgKeiList, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会結果
		CAANMsg[] ekk0081a010ResltList= (CAANMsg[]) workMap.get(TEMPLATE_ID_EKK0081A010);

		// 割引サービス一覧照会（表示用キャンペーンコード）結果
		// 退避用
		ArrayList<CAANMsg> ekk0841b002ResltList= (ArrayList<CAANMsg>) workMap.get(TEMPLATE_ID_EKK0841B002);
		CAANMsg ekk0841b002Msg = ekk0841b002ResltList.get(0);
		
		Object[][] ekk0451d010In =
		{
			{EKK0451D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0451D010}
			// 機能コード
			, {EKK0451D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// SYSID
			, {EKK0451D010CBSMsg.SYSID,  ekk0081a010ResltList[0].getString(EKK0081A010CBSMsg1List.SYSID)}
			// 割引サービスコード
			, {EKK0451D010CBSMsg.WRIB_SVC_CD, ekk0841b002Msg.getString(EKK0841B002CBSMsg1List.WRIB_SVC_CD)}
			// サービス利用開始希望年月日
			, {EKK0451D010CBSMsg.SVC_USE_STA_KIBO_YMD, JKKStrConst.KARA}
			// 予約適用開始希望年月日
			, {EKK0451D010CBSMsg.RSV_TSTA_KIBO_YMD, JKKStrConst.KARA}
			// 申込明細番号
			, {EKK0451D010CBSMsg.MSKM_DTL_NO, mskmDtlNo}
			// 即時適用フラグ
			, {EKK0451D010CBSMsg.APLY_JUN, JKKStrConst.CD00403_NO}
			// 違約金発生コード
			, {EKK0451D010CBSMsg.PNLTY_HASSEI_CD, JKKStrConst.KARA}
			// 異動区分
			, {EKK0451D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_WRIB_INF_ADD}
			// 申込起算年月日
			, {EKK0451D010CBSMsg.MSKM_KISAN_YMD, JCCBPCommon.getOpeDate(null)}
			// 割引登録契機コード
			, {EKK0451D010CBSMsg.WRIB_ADD_OPTY_CD, JKKStrConst.CD00874_MAN_SET}
			// 割引サービス契約ステータス
			, {EKK0451D010CBSMsg.WRIB_SVC_KEI_STAT, JKKStrConst.CD00055_UKZM}
			// 予約適用コード
			, {EKK0451D010CBSMsg.RSV_APLY_CD, JKKStrConst.CD00343_2}
			// 更新年月日時分秒(更新前)
			, {EKK0451D010CBSMsg.UPD_DTM_BF, ekk0081a010ResltList[0].getString(EKK0081A010CBSMsg1List.LAST_UPD_DTM)}
			// 割引課金開始月指定コード
			, {EKK0451D010CBSMsg.WRIB_CHRG_STA_MON_STI_CD, JKKStrConst.KARA}
		};
		
		// 引継ぎ先割引サービス対象契約
		ArrayList<HashMap<String, Object>> sakiWribsvcTgKeiList = new ArrayList<HashMap<String, Object>>();
		// ANK-4468-00-00 MOD START
//		// 引継ぎ先
//		HashMap<String, Object> sakiWribsvcTgKei = new HashMap<String, Object>();
//		// 引継ぎ先割引サービス対象契約
//		String tgKeiSkbtCd = "";
//		if(!rsltSifList(wribsvcTgKeiList))
//		{
//			for (int i = 0; i < wribsvcTgKeiList.length; i++)
//			{
//				tgKeiSkbtCd = "";
//				// 引継ぎ元
//				CAANMsg row = wribsvcTgKeiList[i];
//				
//				
//				sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.SVC_KEI_NO, row.getString(EKK0481B001CBSMsg1List.SVC_KEI_NO));										// サービス契約番号
//				sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.TG_KEI_SKBT_CD, "01");																				// 対象契約識別コード
//				sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRIB_SVC_TRGT_SVC_CD, ekk0841b002Msg.getString(EKK0841B002CBSMsg1List.WRIB_SVC_TRGT_SVC_CD));		// 割引サービス対象サービスコード
//				sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TSTAYMD, JCCBPCommon.getOpeDate(null));												// 割引サービス対象契約適用開始年月日
//				sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TENDYMD, JKKStrConst.END_YMD_DEFAULT);												// 割引サービス対象契約適用終了年月日
//				
//				sakiWribsvcTgKeiList.add(sakiWribsvcTgKei);
//			}
//		}
//		else
//		{
//			sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.SVC_KEI_NO, svcKeiNo);																					// サービス契約番号
//			sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.TG_KEI_SKBT_CD, "01");																					// 対象契約識別コード
//			sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRIB_SVC_TRGT_SVC_CD, ekk0841b002Msg.getString(EKK0841B002CBSMsg1List.WRIB_SVC_TRGT_SVC_CD));			// 割引サービス対象サービスコード
//			sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TSTAYMD, JCCBPCommon.getOpeDate(null));													// 割引サービス対象契約適用開始年月日
//			sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TENDYMD, JKKStrConst.END_YMD_DEFAULT);													// 割引サービス対象契約適用終了年月日
//			
//			sakiWribsvcTgKeiList.add(sakiWribsvcTgKei);
//		}
		HashMap<String, Object> sakiWribsvcTgKei = new HashMap<String, Object>();
		sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.SVC_KEI_NO, svcKeiNo);										// サービス契約番号
		sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.TG_KEI_SKBT_CD, "01");																				// 対象契約識別コード
		sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRIB_SVC_TRGT_SVC_CD, ekk0841b002Msg.getString(EKK0841B002CBSMsg1List.WRIB_SVC_TRGT_SVC_CD));		// 割引サービス対象サービスコード
		sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TSTAYMD, JCCBPCommon.getOpeDate(null));												// 割引サービス対象契約適用開始年月日
		sakiWribsvcTgKei.put(EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TENDYMD, JKKStrConst.END_YMD_DEFAULT);
		sakiWribsvcTgKeiList.add(sakiWribsvcTgKei);
		// ANK-4468-00-00 MOD END
		// サービスIF実行
		callSCArray(handle, scCall, param, fixedText, ekk0451d010In, "EKK0451D010CBSMsg1List", sakiWribsvcTgKeiList);
	}
	
	
	/**
	 * 	進捗登録<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return 照会結果
	 * @throws Throwable 例外が発生した場合
	 */
	private void callEKK1091D010_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			 String mskmDtlNo, String svcKeiNo)
	throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		Object[][] ekk1091d010In =
		{
			{EKK1091D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1091D010}
			// 機能コード
			,{EKK1091D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}
			// 申込明細番号
			,{EKK1091D010CBSMsg.MSKM_DTL_NO, mskmDtlNo}
			// 請求契約番号
			,{EKK1091D010CBSMsg.SEIKY_KEI_NO, JKKStrConst.KARA}
			// 請求方法番号(口座)
			,{EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA, JKKStrConst.KARA}
			// 請求方法番号(クレジットカード)
			,{EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD, JKKStrConst.KARA}
			// サービス契約番号
			,{EKK1091D010CBSMsg.SVC_KEI_NO, svcKeiNo}
			// サービス契約内訳番号
			,{EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, JKKStrConst.KARA}
			// サービス契約回線内訳番号
			,{EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, JKKStrConst.KARA}
			// 機器提供サービス契約番号
			,{EKK1091D010CBSMsg.KKTK_SVC_KEI_NO, JKKStrConst.KARA}
			// オプションサービス契約番号
			,{EKK1091D010CBSMsg.OP_SVC_KEI_NO, JKKStrConst.KARA}
			// 請求オプションサービス契約番号
			,{EKK1091D010CBSMsg.SEIOPSVC_KEI_NO, JKKStrConst.KARA}
			// サブオプションサービス契約番号
			,{EKK1091D010CBSMsg.SBOP_SVC_KEI_NO, JKKStrConst.KARA}
			// 割引サービス契約番号
			,{EKK1091D010CBSMsg.WRIB_SVC_KEI_NO, JKKStrConst.KARA}
			// 異動区分
			,{EKK1091D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_WRIB_INF_ADD}
			// 異動年月日時分秒
			,{EKK1091D010CBSMsg.IDO_DTM, JCCBPCommon.getOpeDateTimeStamp(null)}
			// 進捗ステータス
			,{EKK1091D010CBSMsg.PRG_STAT, JKKStrConst.CD00647_CAMPAIGN_FIN}
			// 進捗メモ
			,{EKK1091D010CBSMsg.PRG_MEMO, JKKStrConst.KARA}
			// 進捗特記事項1
			,{EKK1091D010CBSMsg.PRG_TKJK_1, PRG_TKJK_1}
			// 進捗特記事項2
			,{EKK1091D010CBSMsg.PRG_TKJK_2, PRG_TKJK_2}
		};
		
		ArrayList<HashMap<String, Object>> inList = getArrayListEKK1091D010CBSMsg();
		
		// サービスIF実行
		callSCArray(handle, scCall, param, fixedText, ekk1091d010In, "EKK1091D010CBSMsg1List", inList);
	}
	
	/**
	 * キャンペーン登録処理
	 * 
	 * @param resultList お得額集計区分
	 * @return true   NULLまたは、空
	 *          false 上記以外
	 */
	private boolean sendMail(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		/*
		 *  ＝＝＝お客様情報照会(PMP連携用)＝＝＝
		 */
		
		// お客様情報照会(PMP連携用)結果格納リスト
		CAANMsg[] eck0011b050MsgList = null;
		
		// お客様情報照会(PMP連携用)を実行し、コンテンツ連絡先メールアドレスを取得する。
		eck0011b050MsgList = callECK0011B050_FUNC1(handle, param, fixedText);
		
		// メールアドレス変数初期化
		Set<String> mladSet = new HashSet<String>();
		
		// コンテンツ連絡先メールアドレスの存在チェック
		if (!rsltSifList(eck0011b050MsgList))
		{
			// メールアドレスを取得し、設定する。
			mladSet = getRrksMailAddress(eck0011b050MsgList);
		}
		
		/*
		 *  ＝＝＝お客様一意照会＝＝＝
		 */
		
		// お客様一意照会結果格納リスト
		CAANMsg[] eck0011a010MsgList = null;
		
		eck0011a010MsgList = callECK0011A010_FUNC2(handle, param, fixedText);
		
		// お客様一意照会の存在チェック
		if (rsltSifList(eck0011a010MsgList))
		{
			return false;
		}
		
		//契約者名取得 メール内の文章で使用
		String keiNm = eck0011a010MsgList[0].getString(ECK0011A010CBSMsg1List.CUST_NM);
		// キャンペーン名 メール内の文章で使用
		String CmpNm = (String) workMap.get(OUT_CAMPAIGN_NM);
		/*
		 *  ＝＝＝メール送信情報登録実行＝＝＝
		 */
		
		// メール送信情報登録実行
		for (String mlad : mladSet)
		{
			callECC0021D010_FUNC1(handle, param, fixedText, mlad, keiNm, CmpNm);
		}
		
		return true;
	}
	/**
	 * ECK0011B050_お客様情報照会(PMP連携用)を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param sysid SYSID
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callECK0011B050_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// サービス契約一覧照会(SYSID)の上りマッピング
		Object[][] eck0011b050In =
		{
				{ECK0011B050CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011B050},
				{ECK0011B050CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1}, 	// 機能コード："1"
				{ECK0011B050CBSMsg.KEY_SYSID, sysid}						// ＫＥＹ＿SYSYID
		};

		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, eck0011b050In)
				.getCAANMsgList(ECK0011B050CBSMsg.ECK0011B050CBSMSG1LIST);

	}
	
	/**
	 * メール送信情報登録サービスIFを行う。
	 * 
	 * @param handle セッションハンドル
	 * @param scCall SC呼び出し部品
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param mlad メールアドレス
	 * @return 
	 * @throws Throwable 
	 */
	private CAANMsg[] callECC0021D010_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText,
			String mlad, String custNm, String cmpNm) throws Throwable {
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		CAANMsg childTemplateECC0021D010List1 = new CAANMsg(ECC0021D010CBSMsg1List.class.getName());
		CAANMsg childTemplateECC0021D010List2_1 = new CAANMsg(ECC0021D010CBSMsg2List.class.getName());
		CAANMsg childTemplateECC0021D010List2_2 = new CAANMsg(ECC0021D010CBSMsg2List.class.getName());
		
		childTemplateECC0021D010List1.set(ECC0021D010CBSMsg1List.MLAD, mlad);
		childTemplateECC0021D010List1.set(ECC0021D010CBSMsg1List.MLAD_SET_FIELD_CD, "01");
		childTemplateECC0021D010List2_1.set(ECC0021D010CBSMsg2List.TEXT_HTK_CKAM_MOJI, custNm);
		childTemplateECC0021D010List2_2.set(ECC0021D010CBSMsg2List.TEXT_HTK_CKAM_MOJI, cmpNm);
		
		
		// メール本文登録の上りマッピング
		Object[][] ecc0021d010In =
		{
			{ECC0021D010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECC0021D010},
			{ECC0021D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
			{ECC0021D010CBSMsg.MAIL_CD, MAIL_CD},
			{ECC0021D010CBSMsg.MAIL_SEND_PATTERN_CD, "01"},
			{ECC0021D010CBSMsg.SENDM_MLAD, ""},
			{ECC0021D010CBSMsg.ECC0021D010CBSMSG1LIST, new CAANMsg[] { childTemplateECC0021D010List1 }},
			{ECC0021D010CBSMsg.ECC0021D010CBSMSG2LIST, new CAANMsg[] { childTemplateECC0021D010List2_1,childTemplateECC0021D010List2_2}},
			{ECC0021D010CBSMsg.ECC0021D010CBSMSG3LIST, new CAANMsg[] {}},
			{ECC0021D010CBSMsg.ECC0021D010CBSMSG4LIST, new CAANMsg[] {}},
			{ECC0021D010CBSMsg.ECC0021D010CBSMSG5LIST, new CAANMsg[] {}}
		};
		
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ecc0021d010In)
				.getCAANMsgList(ECC0021D010CBSMsg.ECC0021D010CBSMSG1LIST);
	}
	
	/**
	 * 重複しない連絡先メールアドレスを全て取得する。
	 * 
	 * @param eck0201b050List お客様情報照会(PMP連携用)リスト
	 * @return 連絡先メールアドレスセット
	 * @throws Exception
	 */
	private Set<String> getRrksMailAddress(CAANMsg[] eck0011b050List) throws Exception
	{
		Set<String> mladSet = new HashSet<String>();
		
		if (eck0011b050List == null || eck0011b050List.length == 0)
		{
			return mladSet;
		}
		
		for (CAANMsg eck0011b050 : eck0011b050List)
		{
			if (eck0011b050.getString(ECK0011B050CBSMsg1List.MLAD) != null 
					&& eck0011b050.getString(ECK0011B050CBSMsg1List.MLAD).equals(eck0011b050.getString(ECK0011B050CBSMsg1List.CHGECHU_MLAD)))
			{
				continue;
			}
			// 取得したメールアドレスがNULLか空でなければセットに格納
			if (!JKKStringUtil.isNullBlank(eck0011b050.getString(ECK0011B050CBSMsg1List.MLAD)))
			{
				mladSet.add(eck0011b050.getString(ECK0011B050CBSMsg1List.MLAD));
			}
		}
		return mladSet;
	}
	
	/**
	 * お客様一意照会を実行する。
	 * 
	 * @param handle セッションハンドル
	 * @param scCall SC呼出部品
	 * @param param パラメーター
	 * @param fixedText ユーザ定義文字列
	 * @param sysid SYSID
	 * @return 取得結果
	 * @throws Throwable 
	 */
	private CAANMsg[] callECK0011A010_FUNC2(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 戻り値
		
		// 上りマッピング
		Object[][] eck0011a010In = {
				{ECK0011A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011A010},
				{ECK0011A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2},
				{ECK0011A010CBSMsg.KEY_SYSID, sysid},
				{ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, JCCBPCommon.getOpeDate(null)}
		};
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, eck0011a010In)
				.getCAANMsgList(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
	}

	/**
	 * レスポンス情報を設定
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param addResult
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")

	private HashMap<String, Object> getResponseMap(SessionHandle handle,
		IRequestParameterReadWrite param, String fixedText,
		String addResult)
		throws Throwable
	{
		// CCパラメータ
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		// レスポンス格納マップ
		HashMap<String, Object> responseMap = new HashMap<String, Object>();
		
		responseMap.put(OUT_SVC_KEI_NO, ccMsg.get(IN_SVC_KEI_NO));								// サービス契約番号
		
		// 「照会登録区分」が"2"(登録)の場合
		if(CONST_MODE_ADD.equals((String)ccMsg.get(IN_MODE)))
		{
			responseMap.put(OUT_ADD_RSLT_CD, addResult);										// 登録結果コード
			// 登録が正常終了した以外の場合、キャンペーン適用可否一覧に値を設定する。
			if(!ADD_RSLT_CD_SEIJOU.equals(addResult))
			{
				responseMap.put(CAMPAIGN_APLY_KH_LIST, workMap.get(CAMPAIGN_APLY_KH_LIST));			// キャンペーン適用可否一覧
			}
		}
		// 「照会登録区分」が"1"(照会)の場合、登録結果コードを設定する
		else
		{
			responseMap.put(CAMPAIGN_APLY_KH_LIST, workMap.get(CAMPAIGN_APLY_KH_LIST));			// キャンペーン適用可否一覧
		}

		
		return responseMap;
		
	}
	/**
	 * サービスIF(EKK0011D020)に格納する申込明細の組み立て(登録用)<br>
	 * <br>
	 * @return ArrayList
	 */
	private ArrayList<HashMap<String, Object>> getArrayListEKK0011D020CBSMsg()
	{
		
		ArrayList<HashMap<String, Object>> inList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> inMap = new HashMap<String, Object>();
		
		inMap.put(EKK0011D020CBSMsg1List.MSKMSHO_NO, "");
		inMap.put(EKK0011D020CBSMsg1List.WEB_UK_NO, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKM_FORM_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO, "");
		inMap.put(EKK0011D020CBSMsg1List.RRKS_OFFC_NM, "");
		inMap.put(EKK0011D020CBSMsg1List.DT_RRKS_TELNO, "");
		inMap.put(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD, "");
		inMap.put(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO, "");
		inMap.put(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD, "");
		inMap.put(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD, "");
		inMap.put(EKK0011D020CBSMsg1List.RRK_JIKO, "");
		inMap.put(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD, "");
		inMap.put(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG, "");
		inMap.put(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO, "");
		inMap.put(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN, "");
		inMap.put(EKK0011D020CBSMsg1List.OP_SVC_HKTGI_UM, "");
		inMap.put(EKK0011D020CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM, "");
		inMap.put(EKK0011D020CBSMsg1List.RRK_WAY_HOKI, "");
		inMap.put(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG, "");
		inMap.put(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKMSHO_SBT_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.KEI_HUKA_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MAP_TEMP_UM, "");
		inMap.put(EKK0011D020CBSMsg1List.KCN_STB_MSKM_CNT, "");
		inMap.put(EKK0011D020CBSMsg1List.KCN_STB_KIND_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN, "");
		inMap.put(EKK0011D020CBSMsg1List.MANSION_ID, "");
		inMap.put(EKK0011D020CBSMsg1List.CATID, "");
		inMap.put(EKK0011D020CBSMsg1List.MKM_UK_SBT_CD, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TELNO, "");
		
		inList.add(inMap);
		
		return inList;
		
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return メッセージキャリア
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSCArray(SessionHandle handle, 
							ServiceComponentRequestInvoker scCall, 
							IRequestParameterReadWrite param, 
							String dataMapKey,
							Object[][] mappingData,
							String inListMsgName, 
							ArrayList<HashMap<String, Object>> inList) throws Exception
	{
		HashMap<String, Object> paramMap = editInArrayMsg(param, mappingData, inListMsgName, inList);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		editErrorInfoComArray(param, templates, (Integer)return_code, dataMapKey, mappingData, inListMsgName, inList);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		return msg;
	}
	
	/**
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param dataMapKey
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoComArray(IRequestParameterReadWrite param,
														CAANMsg[] templates, 
														int returnCode,
														String dataMapKey,
														Object[][] mappingData,
														String inListMsgName, 
														ArrayList<HashMap<String, Object>> inList) throws RequestParameterException
	{
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, String> inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		CAANMsg[] templateArray = template.getCAANMsgList(inListMsgName);
		
		for (int i = 0; i < inList.size(); i++)
		{
			HashMap childMap = (HashMap)inList.get(i);
			CAANMsg childTemplate = templateArray[i];
			
			Iterator it = childMap.keySet().iterator();
			while (it.hasNext())
			{
				String key = (String)it.next();
				
				if (!childTemplate.isNull(key + "_err"))
				{
					if (!inMap.containsKey(key + "_err"))
					{
						inMap.put(key + "_err", childTemplate.getString(key + "_err"));
					}
				}
			}
		}
		
		if(!template.isNull(inListMsgName + "_err"))
		{
			if(!inMap.containsKey(inListMsgName + "_err"))
			{
				inMap.put(inListMsgName + "_err", template.getString(inListMsgName + "_err"));
			}
		}

		return param;
	}
	/**
	 * @param param
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return HashMap
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInArrayMsg(IRequestParameterReadWrite param,
													Object[][] mappingData, 
													String inListMsgName, 
													ArrayList<HashMap<String, Object>> inList) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// 【取得元：ユーザエリア(コントロールマップ)】
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		String svcIf = (String)mappingData[0][1];
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));


		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if ("".equals(mappingData[i][1]))
			{
				template.setNull((String)mappingData[i][0]);
			}
			else
			{
				template.set((String)mappingData[i][0], mappingData[i][1]);
			}
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(inListMsgName);
		
		if(templateArray == null)
		{
			templateArray = new CAANMsg[inList.size()];
		}
		
		for (int i = 0; i < inList.size(); i++)
		{
			HashMap childMap = (HashMap)inList.get(i);
			CAANMsg childTemplate = templateArray[i];
			if(childTemplate == null)
			{
				childTemplate = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg1List", svcIf));
			}
			
			Iterator it = childMap.keySet().iterator();
			while (it.hasNext())
			{
				String key = (String)it.next();
				
				if ("".equals(childMap.get(key)))
				{
					childTemplate.setNull(key);
				}
				else
				{
					childTemplate.set(key, (String)childMap.get(key));
				}
			}

			templateArray[i] = childTemplate;
		}
		
		template.set(inListMsgName, templateArray);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *  申込明細照査・後続業務依頼
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param mskmDtlNo
	 * @param updDtm
	 * @return
	 * @throws Throwable 
	 */
	private void callEKK0021C060_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText,
			String mskmDtlNo, String updDtm) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		String operateDate = JCCBPCommon.getOpeDate(null);
		
		Object[][] ekk0021c060In = {
				{EKK0021C060CBSMsg.TEMPLATEID,    TEMPLATE_ID_EKK0021C060},
				{EKK0021C060CBSMsg.FUNC_CODE,     JPCModelConstant.FUNC_CD_1},
				{EKK0021C060CBSMsg.MSKM_DTL_NO,   mskmDtlNo},
				{EKK0021C060CBSMsg.KZKWRK_REQYMD, operateDate},
				{EKK0021C060CBSMsg.UPD_DTM_BF,    updDtm},
			};
		
		// サービスIF実行
		callSC(handle, scCall, param, fixedText, ekk0021c060In);
	}
	
	/**
	 *  料金プランチェック処理
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param mskmDtlNo
	 * @param updDtm
	 * @return
	 * @throws Throwable 
	 */
	private boolean pplanCdChk(SessionHandle handle, IRequestParameterReadWrite param, String fixedText,
			String campCD, String pplanCd) throws Throwable
	{
		
		// 退避用
		ArrayList<CAANMsg> rsltWorkParamlst = new ArrayList<CAANMsg>();
		if(workMap.get(TEMPLATE_ID_EKK0841B002) != null)
		{
			rsltWorkParamlst = (ArrayList<CAANMsg>) workMap.get(TEMPLATE_ID_EKK0841B002);
		}
		
		//割引サービス一覧照会（表示用キャンペーンコード）結果格納リスト
		CAANMsg[] ekk0841b020MsgList = null;
		
		// 割引サービス一覧照会（表示用キャンペーンコード）(機能コード2)
		ekk0841b020MsgList = callEKK0841B002_FUNC1(handle, param, fixedText, campCD);
		
		// サービスIFの結果がNULLまたは空の場合
		if (rsltSifList(ekk0841b020MsgList))
		{
			return false;
		}
		boolean judgeFlg = false;
		
		// IT1-2024-0000012 ADD START
		// 割引サービス対象サービス一覧照会結果格納リスト
		CAANMsg[] ekk0851b001MsgList = null;
		// IT1-2024-0000012 ADD END
		
		// サービス契約の料金プランコードと一致する割引情報を取得する
		for(int i = 0; i < ekk0841b020MsgList.length; i++)
		{
			// 取得結果を退避
			rsltWorkParamlst.add(ekk0841b020MsgList[i]);
			// IT1-2024-0000012 ADD START
			// 割引サービス対象サービス一覧照会(機能コード4)
			ekk0851b001MsgList = callEKK0851B001_FUNC1(handle, param, fixedText, pplanCd, ekk0841b020MsgList[i].getString(EKK0841B002CBSMsg1List.WRIB_SVC_CD));
			// IT1-2024-0000012 ADD END
			
			// IT1-2024-0000012 MOD START
//			if(pplanCd.equals(ekk0841b020MsgList[i].getString(EKK0841B002CBSMsg1List.PPLAN_CD)))
			// サービスIFの結果がNULLまたは空以外の場合
			if(!rsltSifList(ekk0851b001MsgList))
			// IT1-2024-0000012 MOD END
			{
				judgeFlg = true;
			}
		}
		
		// 後続で使用するため割引サービス一覧照会（表示用キャンペーンコード）を退避
		workMap.put(TEMPLATE_ID_EKK0841B002, rsltWorkParamlst);
		
		return judgeFlg;
	}
	/**
	 * サービスIF(EKK1091D010)に格納する申込明細の組み立て(登録用)<br>
	 * <br>
	 * @return ArrayList
	 */
	private ArrayList<HashMap<String, Object>> getArrayListEKK1091D010CBSMsg()
	{
		
		ArrayList<HashMap<String, Object>> inList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> inMap = new HashMap<String, Object>();
		
		inMap.put(EKK1091D010CBSMsg1List.IDO_RSN_CD, JKKStrConst.CD00846_OTHER);
		inMap.put(EKK1091D010CBSMsg1List.IDO_RSN_MEMO, JKKStrConst.KARA);
		
		inList.add(inMap);
		
		return inList;
		
	}
	
	// IT1-2024-0000012 ADD START
	/**
	 * <dl>
	 * <dt>処理概要:
	 * <dd>割引サービス対象サービス一覧照会
	 * </dl>
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param pplanCd
	 * @param wribSvcCd
	 * @return
	 * @throws Throwable 
	 */
	private CAANMsg[] callEKK0851B001_FUNC1(SessionHandle handle, IRequestParameterReadWrite param, String fixedText,
			String pplanCd, String wribSvcCd)throws Throwable {
		
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		String operateDate = JCCBPCommon.getOpeDate(null);
		
		Object[][] ekk0851b001In = {
				{EKK0851B001CBSMsg.TEMPLATEID,         TEMPLATE_ID_EKK0851B001},
				{EKK0851B001CBSMsg.FUNC_CODE,          JPCModelConstant.FUNC_CD_1},
				{EKK0851B001CBSMsg.KEY_WRIB_SVC_CD,    wribSvcCd},
				{EKK0851B001CBSMsg.KEY_PRC_GRP_CD,     null},
				{EKK0851B001CBSMsg.KEY_PCRS_CD,        null},
				{EKK0851B001CBSMsg.KEY_PPLAN_CD,       pplanCd},
				{EKK0851B001CBSMsg.KEY_KJNYMD,         operateDate},
				// IT1-2024-0000012 ADD START
				// 最大件数 ダミーで99件を設定
				 {EKK0851B001CBSMsg.MAX_SEARCH_NUM, "99"},
				// IT1-2024-0000012 ADD END
			};
		
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, ekk0851b001In)
				.getCAANMsgList(EKK0851B001CBSMsg.EKK0851B001CBSMSG1LIST);
	}
	// IT1-2024-0000012 ADD END
}