/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKNetflixOpAddDslCC
*   ソースファイル名：JKKNetflixOpAddDslCC.java
*   作成者          ：FJ
*   日付            ：2021年01月26日
*＜機能概要＞
*   Netflixオプション登録解約CC
*＜修正履歴＞
*   バージョン  修正日      修正者      修正内容
*	v52.00.00	2021/01/26	FJ) 三原	【ANK-3987-00-00】Netflix導入対応(STEP2)
*	v52.00.01	2021/02/17	FJ) 三原	【ANK-3987-00-00】Netflix導入対応(STEP2)
*	v52.00.02	2021/02/22	FJ) 三原	【IT1-2021-0000019】予約取消時にNetflixプレミアムが解約されない
*	v52.00.03	2021/03/10	FJ) 三原	【ST-2021-0000003】Netflix画面からNetfilxプレミアムが付かない
*	v52.00.04	2021/04/06	FJ) 三原	【OM-2021-0000542】Ｎｅｔｆｌｉｘプレミアムプランオプションが課金開始される
*	v54.00.00	2021/08/23	FJ) 舘山	【ANK-4055-00-00】【eo】Netflix対応 STEP4
*	v54.00.01	2021/08/31	FJ) 舘山	【ANK-4055-01-00】全ての契約メールアドレスに送信する
*	v71.00.00	2024/03/20	GDC) J.Tagongtong 【ANK-4468-00-00】 eo光ネット「シンプルプラン」追加対応
**	v71.00.01	2024/08/29	FJ) 張      【ANK-4468-00-01】 eo光ネット「シンプルプラン」追加対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
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.SCCallException;
import com.fujitsu.futurity.bp.x21.sc.exception.SCException;
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 eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
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.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0201B002CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201B002CBSMsg1List;
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.EKK0321B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0351A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0361B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0361B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0351C220CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351C240CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351C250CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0361C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0361C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0361C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0361D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3081D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B050CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B050CBSMsg1List;

/**
 * Netflixオプション登録解約CC
 * 
 * @author 富士通
 */
public class JKKNetflixOpAddDslCC  extends AbstractCommonComponent
{
	// IT1-2021-0000019 DEL START
//	/** 請求契約一覧照会（サービス契約番号） */
//	private static final Object TEMPLATE_ID_EKK0491B507 = "EKK0491B507";
	// IT1-2021-0000019 DEL END
	
	// IT1-2021-0000019 ADD START
	/** 課金先一覧照会 */
	private static final Object TEMPLATE_ID_EKK0321B002 = "EKK0321B002";
	// IT1-2021-0000019 ADD END
	
	/** サービス契約一意照会 */
	private static final Object TEMPLATE_ID_EKK0081A010 = "EKK0081A010";
	
	/** オプションサービス契約＜ISP＞登録 */
	private static final String TEMPLATE_ID_EKK0361D010 = "EKK0361D010";
	
	/** オプションサービス契約<ISP>照査 */
	private static final String TEMPLATE_ID_EKK0361C010 = "EKK0361C010";
	
	/** オプションサービス契約＜ISP＞照査締結 */
	private static final String TEMPLATE_ID_EKK0361C030 = "EKK0361C030";
	
	/** オプションサービス契約＜ISP＞開始 */
	private static final String TEMPLATE_ID_EKK0361C040 = "EKK0361C040";
	
	// v52.00.01 ANK-3987-00-00 DEL START
//	/** 課金先登録 */
//	private static final String TEMPLATE_ID_EKK0321D010 = "EKK0321D010";
	// v52.00.01 ANK-3987-00-00 DEL END
	
	/** 進捗登録 */
	private static final String TEMPLATE_ID_EKK1091D010 = "EKK1091D010";
	
	/** オプションサービス契約一意照会 */
	private static final Object TEMPLATE_ID_EKK0351A010 = "EKK0351A010";
	
	/** オプションサービス契約キャンセル	 **/
	private static final String TEMPLATE_ID_EKK0351C220 = "EKK0351C220";
	
	/** オプションサービス契約解約	 **/
	private static final String TEMPLATE_ID_EKK0351C240 = "EKK0351C240";
	
	/** オプションサービス契約解約確定	 **/
	private static final String TEMPLATE_ID_EKK0351C250 = "EKK0351C250";
	
	/** 他事業者契約異動通知登録	 **/
	private static final String TEMPLATE_ID_EKK3081D010 = "EKK3081D010";
	
	// OM-2021-0000542 ADD START
	/** 申込内容承認登録	 **/
	private static final String TEMPLATE_ID_EKK0011D020 = "EKK0011D020";
	
	/** 申込明細照査・後続業務依頼 */
	private static final String TEMPLATE_ID_EKK0021C060 = "EKK0021C060";
	// OM-2021-0000542 ADD END
	
	// ANK-4468-00-00 ADD START
	/** お客様一意照会 */
	// ANK-4468-00-01 MOD START
	//private static final String TEMPLATE_ID_ECK0201B002 = "ECK0201B002";
	private static final String TEMPLATE_ID_ECK0011B050 = "ECK0011B050";
	//// ANK-4468-00-01 MOD END
	// ANK-4468-00-00 ADD END
	
// ▽▽▽ ANK-4055-00-00 ADD START
	/** お客様一意照会 */
	private static final String TEMPLATE_ID_ECK0011A010 = "ECK0011A010";

	/** オプションサービス契約<ISP>一覧照会 */
	private static final String TEMPLATE_ID_EKK0361B001 = "EKK0361B001";
	
	/** メールコード（Netflixプレミアムプラン登録受付） */
	private static final String MAIL_ID_KKM1000029 = "KKM1000029";
	
	/** メールコード（Netflixプレミアムプラン解約受付） */
	private static final String MAIL_ID_KKM1000030 = "KKM1000030";
	
// △△△ ANK-4055-00-00 ADD END
	/** リターンメッセージの書式指定文字列 */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	
	/** エラー項目接尾辞 */
	private static final String ERRITEM_SUFFIX = "_err";
	
	/** リターンメッセージ取得キー */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	
	/** コース変更予約取消	 **/
	private static final String IDO_DIV_00054 = "00054";
	
	/** プランタイプ_プレミアム	 **/
	private static final String PLAN_TYPE_PREMIUM = "Premium";
	
	/** プランタイプ_スタンダード	 **/
	private static final String PLAN_TYPE_STANDARD = "Standard";
	
	/** 進捗特記事項1_文言_登録	 **/
	private static final String PRG_TKJK_1_ADD = "登録";
	
	/** 進捗特記事項1_文言_解約	 **/
	private static final String PRG_TKJK_1_DSL = "解約";
	
	/** 進捗特記事項1_文言_Ｎｅｔｆｌｉｘプレミアムプラン	 **/
	private static final String PRG_TKJK_1_NETFLIX_PREMIUM_PLAN = "Ｎｅｔｆｌｉｘプレミアムプラン";
	
	// OM-2021-000054 ADD START
	/** 申込種別コード(オプション申込) */
	private static final String MSKM_SBT_CD_OP_MSKM = "00026";
	
	/** コンシューマ営業用申込状態識別コード(承認済) */
	private static final String CONSMBSN_MSKM_STAT_SKBT_CD_SHONIN_ZM = "04";
	// OM-2021-000054 ADD END


	/**
	 * <p>
	 *  Netflixオプション登録解約CCを実行する。
	 * </p>
	 * @param inCBSMsg CBSメッセージ
	 * @param inContext ディスパッチコンテキスト
	 * @throws Throwable 
	 */
	@SuppressWarnings({ "unchecked" })
	public IRequestParameterReadWrite execute(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable 
	{
		// ユーザデータ情報
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(fixedText);
		IRequestParameterReadWrite retParam = param;
		
		//データマップがNULLの場合、処理終了する。
		if (dataMap == null)
		{
			return retParam;
		}
		
		// 結果フラグを設定 初期値は０を設定
		dataMap.put("result_flg", "0");
		
		// プランタイプ
		String planType = JKKStringUtil.nullToBlank((String)dataMap.get("plan_type"));
		// サービス契約番号
		String svcKeiNo = JKKStringUtil.nullToBlank((String)dataMap.get("svc_kei_no"));
		// サービス契約ステータス
		String svcKeiStat = JKKStringUtil.nullToBlank((String)dataMap.get("svc_kei_stat"));
		// SYSID
		String sysid = JKKStringUtil.nullToBlank((String)dataMap.get("sysid"));
		// Netflix料金コースフラグ
		String netflixPcrsFlg = JKKStringUtil.nullToBlank((String)dataMap.get("netflix_pcrs_flg"));
		// Netflixオプションサービス契約番号
		String netflixOpSvcKeiNo = JKKStringUtil.nullToBlank((String)dataMap.get("netflix_op_svc_kei_no"));
		// Netflixオプションサービス契約ステータス
		String netflixOpSvcKeiStat = JKKStringUtil.nullToBlank((String)dataMap.get("netflix_op_svc_kei_stat"));
		// パートナーアカウントID
		String ptnracntId = JKKStringUtil.nullToBlank((String)dataMap.get("ptnracnt_id"));
		// 他事業者契約開始・終了年月日
		// ST-2021-0000003 MOD START
		//String tajgsKeiStaEndYmd = JKKStringUtil.nullToBlank((String)dataMap.get("tajgs_kei_sta_end_ymd"));
		String tajgsKeiStaEndYmd = JCCBPCommon.getSysDateTimeStamp().substring(0,8);
		// ST-2021-0000003 MOD 
		
		if (PLAN_TYPE_PREMIUM.equals(planType))
		{
			// IT1-2021-0000019 DEL START
//			// 請求契約番号
//			String seikyKeiNo = "";
//			// v52.00.01 ANK-3987-00-00 DEL START
////			// 更新年月日時分秒(請求契約)
////			String updDtmKK0491 = "";
//			// v52.00.01 ANK-3987-00-00 DEL END
//			
//			// EKK0491B507_請求契約一覧照会（サービス契約番号）の結果リスト
//			CAANMsg[] eKK0491B507Msg1List = callEKK0491B507(handle, retParam, fixedText, svcKeiNo);
//			
//			if (eKK0491B507Msg1List != null && eKK0491B507Msg1List.length > 0)
//			{
//				CAANMsg eKK0491B507Msg = eKK0491B507Msg1List[0];
//				
//				if (eKK0491B507Msg != null)
//				{
//					// 請求契約番号を設定
//					seikyKeiNo = eKK0491B507Msg.getString(EKK0491B507CBSMsg1List.SEIKY_KEI_NO);
//					// v52.00.01 ANK-3987-00-00 DEL START
////					// 更新年月日時分秒を設定
////					updDtmKK0491 = eKK0491B507Msg.getString(EKK0491B507CBSMsg1List.UPD_DTM);
//					// v52.00.01 ANK-3987-00-00 DEL END
//				}
//			}
			// IT1-2021-0000019 DEL END
			
			// IT1-2021-0000019 ADD START
			// 課金先一覧照会（請求契約番号／サービス契約番号）
			String seikyKeiNo = callEKK0321B002(handle, param, fixedText, svcKeiNo);
			// IT1-2021-0000019 ADD END
			
			// 申込明細番号
			String mskmDtlNo = "";
			// 最終更新年月日時分秒(サービス契約)
			String lastUpdDtmKK0081 = "";
			
			// EKK0081A010_サービス契約一意照会の結果リスト
			CAANMsg[] eKK0081A010Msg1List = callEKK0081A010(handle, retParam, fixedText, svcKeiNo);
			
			if (eKK0081A010Msg1List != null && eKK0081A010Msg1List.length > 0)
			{
				CAANMsg eKK0081A010Msg = eKK0081A010Msg1List[0];
				
				if (eKK0081A010Msg != null)
				{
					// OM-2021-0000542 DEL START
					//// 申込明細番号を設定
					//mskmDtlNo = eKK0081A010Msg.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO);
					// OM-2021-0000542 DEL END
					// 最終更新年月日時分秒(サービス契約)を設定
					lastUpdDtmKK0081 = eKK0081A010Msg.getString(EKK0081A010CBSMsg1List.LAST_UPD_DTM);
				}
			}
			
			// OM-2021-0000542 ADD START
			// 申込明細番号
			mskmDtlNo = addMskmNaiyo(handle, param, fixedText, sysid);
			// OM-2021-0000542 ADD END
			
			HashMap<String, Object> paramMapEKK0361D010 = new HashMap<String, Object>();
			// EKK0361D010_オプションサービス契約＜ISP＞登録を実行する
			CAANMsg retEKK0361D010Msg = (CAANMsg)callEKK0361D010(handle, retParam, paramMapEKK0361D010, JKKStrConst.PCRS_CD_BE7, JKKStrConst.PPLAN_CD_PBE701, sysid, seikyKeiNo, lastUpdDtmKK0081, svcKeiNo, mskmDtlNo);
			
			// オプションサービス契約番号
			String opSvcKeiNo = "";
			// 最終更新年月日時分秒(オプションサービス契約)
			String lastUpdDtmKK0361 = "";
			
			if (retEKK0361D010Msg != null)
			{
				opSvcKeiNo = retEKK0361D010Msg.getString(EKK0361D010CBSMsg.OP_SVC_KEI_NO);
				lastUpdDtmKK0361 = retEKK0361D010Msg.getString(EKK0361D010CBSMsg.UPD_DTM);
			}
			
			// サービス契約ステータスが"020"(照査済)の場合
			if (JKKStrConst.CD00037_SHOSA_ZUMI.equals(svcKeiStat))
			{
				HashMap<String, Object> paramMapEKK0361C010 = new HashMap<String, Object>();
				// EKK0361C010_オプションサービス契約＜ISP＞照査を実行する
				CAANMsg retEKK0361C010Msg = (CAANMsg)callEKK0361C010(handle, retParam, paramMapEKK0361C010, opSvcKeiNo, lastUpdDtmKK0361);
				
				lastUpdDtmKK0361 = "";
				
				if (retEKK0361C010Msg != null)
				{
					lastUpdDtmKK0361 = retEKK0361C010Msg.getString(EKK0361C010CBSMsg.UPD_DTM);
				}
			}
			// サービス契約ステータスが"030"(締結済)の場合
			else if (JKKStrConst.CD00037_CNC_ZM.equals(svcKeiStat))
			{
				
				HashMap<String, Object> paramMapEKK0361C030 = new HashMap<String, Object>();
				// EKK0361C030_オプションサービス契約＜ISP＞照査締結を実行する
				CAANMsg retEKK0361C030Msg = (CAANMsg)callEKK0361C030(handle, retParam, paramMapEKK0361C030, opSvcKeiNo, lastUpdDtmKK0361);
				
				lastUpdDtmKK0361 = "";
				
				if (retEKK0361C030Msg != null)
				{
					lastUpdDtmKK0361 = retEKK0361C030Msg.getString(EKK0361C030CBSMsg.UPD_DTM);
				}
			}
			// サービス契約ステータスが"100"(サービス提供中)の場合
			else if (JKKStrConst.CD00037_SVCTK_CHU.equals(svcKeiStat))
			{
				HashMap<String, Object> paramMapEKK0361C030 = new HashMap<String, Object>();
				// EKK0361C030_オプションサービス契約＜ISP＞照査締結を実行する
				CAANMsg retEKK0361C030Msg = (CAANMsg)callEKK0361C030(handle, retParam, paramMapEKK0361C030, opSvcKeiNo, lastUpdDtmKK0361);
				
				lastUpdDtmKK0361 = "";
				
				if (retEKK0361C030Msg != null)
				{
					lastUpdDtmKK0361 = retEKK0361C030Msg.getString(EKK0361C030CBSMsg.UPD_DTM);
				}
				
				// Netflix料金コースフラグが"1"(Netflix料金コース)の場合(料金コースがNetflixの料金コースである場合)
				if ("1".equals(netflixPcrsFlg))
				{
					HashMap<String, Object> paramMapEKK0361C040 = new HashMap<String, Object>();
					// EKK0361C040_オプションサービス契約＜ISP＞開始を実行する
					CAANMsg retEKK0361C040Msg = (CAANMsg)callEKK0361C040(handle, retParam, paramMapEKK0361C040, opSvcKeiNo, lastUpdDtmKK0361);
				}
			}
			
			// v52.00.01 ANK-3987-00-00 DEL START
//			HashMap<String, Object> paramMapEKK0321D010 = new HashMap<String, Object>();
//			
//			// EKK0321D010_課金先登録を実行する
//			CAANMsg retEKK0321D010Msg = (CAANMsg)callEKK0321D010(handle, retParam, paramMapEKK0321D010, seikyKeiNo, opSvcKeiNo, updDtmKK0491);
			// v52.00.01 ANK-3987-00-00 DEL END
			
			HashMap<String, Object> paramMapEKK1091D010 = new HashMap<String, Object>();
			// EKK1091D010_進捗登録を実行する
			// OM-2021-0000542 MOD START
			//CAANMsg retEKK1091D010Msg = (CAANMsg)callEKK1091D010(handle, retParam, paramMapEKK1091D010, svcKeiNo, PRG_TKJK_1_ADD, mskmDtlNo);
			CAANMsg retEKK1091D010Msg = (CAANMsg)callEKK1091D010(handle, retParam, paramMapEKK1091D010, svcKeiNo, PRG_TKJK_1_ADD, mskmDtlNo, opSvcKeiNo);
			// OM-2021-0000542 MOD END
// ▽▽▽ ANK-4055-00-00 ADD START
			// 受付メール（登録）を送信する
			sendUkMail(handle, retParam, (String)dataMap.get("sysid"), (String)dataMap.get("send_mail_map_key"), MAIL_ID_KKM1000029, (String)dataMap.get("svc_kei_no"));
// △△△ ANK-4055-00-00 ADD END
		}
		else if (PLAN_TYPE_STANDARD.equals(planType))
		{
			// 申込明細番号
			String mskmDtlNo = "";
			// 更新年月日時分秒(オプションサービス契約)
			String lastUpdDtmKK0351 = "";
			
			// EKK0351A010_オプションサービス契約一意照会の結果リスト
			CAANMsg[] eKK0351A010Msg1List = callEKK0351A010(handle, retParam, fixedText, netflixOpSvcKeiNo);
			
			if (eKK0351A010Msg1List != null && eKK0351A010Msg1List.length > 0)
			{
				CAANMsg eKK0351A010Msg = eKK0351A010Msg1List[0];
				
				if (eKK0351A010Msg != null)
				{
					// OM-2021-0000542 DEL START
					//// 申込明細番号
					//mskmDtlNo = eKK0351A010Msg.getString(EKK0351A010CBSMsg1List.MSKM_DTL_NO);
					// OM-2021-0000542 DEL END
					// 最終更新年月日時分秒を設定
					lastUpdDtmKK0351 = eKK0351A010Msg.getString(EKK0351A010CBSMsg1List.LAST_UPD_DTM);
				}
			}
			
			// OM-2021-0000542 ADD START
			// 申込明細番号
			mskmDtlNo = addMskmNaiyo(handle, param, fixedText, sysid);
			// OM-2021-0000542 ADD END
			
			// Netflixオプションサービス契約ステータスが"010"(受付済)または"020"(照査済)の場合
			if (JKKStrConst.OP_SVC_STAT_UKETSUKEZUMI.equals(netflixOpSvcKeiStat) || JKKStrConst.CD01616_STAT_SHOSAZUMI.equals(netflixOpSvcKeiStat))
			{
				HashMap<String, Object> paramMap = new HashMap<String, Object>();
				// EKK0351C220_オプションサービス契約キャンセルを実行する
				callEKK0351C220(handle, retParam, paramMap, netflixOpSvcKeiNo, mskmDtlNo, lastUpdDtmKK0351);
			}
			// Netflixオプションサービス契約ステータスが"030"(締結済)または"100"(サービス提供中)または"210"(停止中)または"220"(休止・中断中)の場合
			else if (!JKKStrConst.OP_SVC_STAT_UKETSUKEZUMI.equals(netflixOpSvcKeiStat) && !JKKStrConst.CD01616_STAT_SHOSAZUMI.equals(netflixOpSvcKeiStat))
			{
				HashMap<String, Object> paramMap = new HashMap<String, Object>();
				// EKK0351C240_オプションサービス契約解約を実行する
				String updDtmEKK0351C240 = callEKK0351C240(handle, retParam, paramMap, netflixOpSvcKeiNo, mskmDtlNo, lastUpdDtmKK0351);
				
				// EKK0351C250_オプションサービス契約解約確定を実行する
				callEKK0351C250(handle, retParam, paramMap, netflixOpSvcKeiNo, updDtmEKK0351C240);
			}
			
			HashMap<String, Object> paramMapEKK1091D010 = new HashMap<String, Object>();
			// EKK1091D010_進捗登録を実行する
			// OM-2021-0000542 MOD START
			//CAANMsg retEKK1091D010Msg = (CAANMsg)callEKK1091D010(handle, retParam, paramMapEKK1091D010, svcKeiNo, PRG_TKJK_1_DSL, mskmDtlNo);
			CAANMsg retEKK1091D010Msg = (CAANMsg)callEKK1091D010(handle, retParam, paramMapEKK1091D010, svcKeiNo, PRG_TKJK_1_DSL, mskmDtlNo, netflixOpSvcKeiNo);
			// OM-2021-0000542 MOD END
// ▽▽▽ ANK-4055-00-00 ADD START
			// 受付メール（登録）を送信する
			sendUkMail(handle, retParam, (String)dataMap.get("sysid"), (String)dataMap.get("send_mail_map_key"), MAIL_ID_KKM1000030, (String)dataMap.get("svc_kei_no"));
// △△△ ANK-4055-00-00 ADD END
		}
		else
		{
			// 処理終了
			return retParam;
		}
		
		HashMap<String, Object> paramMapEKK3081D010 = new HashMap<String, Object>();
		// EKK3081D010_他事業者契約異動通知登録を実行する
		CAANMsg retEKK3081D010Msg = (CAANMsg)callEKK3081D010(handle, retParam, paramMapEKK3081D010, svcKeiNo, ptnracntId, tajgsKeiStaEndYmd, planType);
		
		return retParam;
	}

	// IT1-2021-0000019 DEL START
//	/**
//	 * EKK0491B507_請求契約一覧照会（サービス契約番号）を実行する。
//	 * <br>
//	 * @param handle セッションハンドル
//	 * @param param リクエストパラメータ
//	 * @param fixedText ユーザ定義文字列
//	 * @param svcKeiNo サービス契約番号
//	 * @return 結果
//	 * @throws Throwable 例外が発生した場合
//	 */
//	private CAANMsg[] callEKK0491B507(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)throws Throwable
//	{
//		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
//		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//		
//		// 請求契約一覧照会（サービス契約番号）の上りマッピング
//		Object[][] eKK0491B507In =
//		{
//			{EKK0491B507CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491B507}
//			// 機能コード："1"
//			, {EKK0491B507CBSMsg.FUNC_CODE, "1"}
//			// ＫＥＹ＿サービス契約番号
//			, {EKK0491B507CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
//		};
//		
//		// サービスIF実行
//		CAANMsg[] eKK0491B507Msg1List = callSC(handle, scCall, param, fixedText, eKK0491B507In,
//				new EKK0491B507CBSMsg().getContents()).getCAANMsgList(EKK0491B507CBSMsg.EKK0491B507CBSMSG1LIST);
//		
//		return eKK0491B507Msg1List;
//	}
	// IT1-2021-0000019 DEL END

	// IT1-2021-0000019 ADD START
	/**
	 * EKK0321B002_課金先一覧照会を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private String callEKK0321B002(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会の上りマッピング
		Object[][] eKK0321B002In =
		{
			{EKK0321B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321B002}
			// 機能コード："2"
			, {EKK0321B002CBSMsg.FUNC_CODE, "2"}
			// ＫＥＹ＿サービス契約番号
			, {EKK0321B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};
		
		// サービスIF実行
		CAANMsg[] eKK0321B002Msg1List = callSC(handle, scCall, param, fixedText, eKK0321B002In,
				new EKK0321B002CBSMsg().getContents()).getCAANMsgList(EKK0321B002CBSMsg.EKK0321B002CBSMSG1LIST);
		
		String seikyKeiNo = eKK0321B002Msg1List[0].getString(EKK0321B002CBSMsg1List.SEIKY_KEI_NO);
		
		return seikyKeiNo;
	}
	// IT1-2021-0000019 ADD END

	/**
	 * EKK0081A010_サービス契約一意照会を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callEKK0081A010(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo)throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会の上りマッピング
		Object[][] eKK0081A010In =
		{
			{EKK0081A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081A010}
			// 機能コード："2"
			, {EKK0081A010CBSMsg.FUNC_CODE, "2"}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
			// ＫＥＹ＿予約適用年月日
			, {EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, (String)JCCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] eKK0081A010Msg1List = callSC(handle, scCall, param, fixedText, eKK0081A010In,
				new EKK0081A010CBSMsg().getContents()).getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		return eKK0081A010Msg1List;
	}

	/**
	 * オプションサービス契約＜ISP＞登録の処理です。
	 * @param handle
	 * @param param
	 * @param pcrsCd
	 * @param pplanCd
	 * @param sysid
	 * @param seikyKeiNo
	 * @param lastUpdDtmKK0081
	 * @param svcKeiNo
	 * @param mskmDtlNo
	 * @return @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK0361D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String pcrsCd, String pplanCd, String sysid, String seikyKeiNo, String lastUpdDtmKK0081, String svcKeiNo, String mskmDtlNo)
			throws RequestParameterException, SCException, Throwable
	{
		// オプションサービス契約＜ISP＞登録
		paramMap = editInMsgEKK0361D010(param, pcrsCd, pplanCd, sysid, seikyKeiNo, lastUpdDtmKK0081, svcKeiNo, mskmDtlNo);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0361D010);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * オプションサービス契約＜ISP＞登録のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param pcrsCd
	 * @param pplanCd
	 * @param sysid
	 * @param seikyKeiNo
	 * @param lastUpdDtmKK0081
	 * @param svcKeiNo
	 * @param mskmDtlNo
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0361D010(IRequestParameterReadWrite param,
			String pcrsCd, String pplanCd, String sysid, String seikyKeiNo, String lastUpdDtmKK0081, String svcKeiNo, String mskmDtlNo) 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));
		
		CAANMsg template = new CAANMsg(EKK0361D010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0361D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0361D010);
		
		// 機能コード
		template.set(EKK0361D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービスコード(B136:Ｎｅｔｆｌｉｘプレミアムプラン)
		template.set(EKK0361D010CBSMsg.OP_SVC_CD, JKKStrConst.OP_SVC_CD_B136);
		
		// 料金コースコード
		if (pcrsCd == null || "".equals(pcrsCd)) 
		{
			template.setNull(EKK0361D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.PCRS_CD, pcrsCd);
		}
		
		// 料金プランコード
		if (pplanCd == null || "".equals(pplanCd)) 
		{
			template.setNull(EKK0361D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.PPLAN_CD, pplanCd);
		}
		
		// 親契約識別コード(01:サービス契約)
		template.set(EKK0361D010CBSMsg.OYA_KEI_SKBT_CD, JKKStrConst.CD00804_SVC_KEI);
		
		// サービス契約番号
		if (svcKeiNo == null || "".equals(svcKeiNo))
		{
			template.setNull(EKK0361D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.SVC_KEI_NO, svcKeiNo);
		}
		
		// SYSID
		if (sysid == null || "".equals(sysid)) 
		{
			template.setNull(EKK0361D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.SYSID, sysid);
		}
		
		// 申込明細番号
		if (mskmDtlNo == null || "".equals(mskmDtlNo)) 
		{
			template.setNull(EKK0361D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		}
		
		// 異動区分(00031:オプション設定)
		template.set(EKK0361D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		
		// 請求契約番号
		if (seikyKeiNo == null || "".equals(seikyKeiNo)) 
		{
			template.setNull(EKK0361D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.SEIKY_KEI_NO, seikyKeiNo);
		}
		
		// OM-2021-0000542 ADD START
		// サービス利用開始希望年月日
		template.set(EKK0361D010CBSMsg.SVC_USE_STA_KIBO_YMD, (String)JCCBPCommon.getOpeDate(null));
		// OM-2021-0000542 ADD END
		
		// 更新年月日時分秒(更新前)
		if (lastUpdDtmKK0081 == null || "".equals(lastUpdDtmKK0081)) 
		{
			template.setNull(EKK0361D010CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0361D010CBSMsg.UPD_DTM_BF, lastUpdDtmKK0081);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * オプションサービス契約<ISP>照査の処理です。
	 * @param handle
	 * @param param
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK0361C010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String lastUpdDtmKK0361)
			throws RequestParameterException, SCException, Throwable
	{
		// オプションサービス契約<ISP>照査
		paramMap = editInMsgEKK0361C010(param, opSvcKeiNo, lastUpdDtmKK0361);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0361C010);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * オプションサービス契約<ISP>照査のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0361C010(IRequestParameterReadWrite param,
			String opSvcKeiNo, String lastUpdDtmKK0361) 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));
		
		CAANMsg template = new CAANMsg(EKK0361C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0361C010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0361C010);
		
		// 機能コード
		template.set(EKK0361C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0361C010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0361C010CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// 異動区分(00031:オプション設定)
		template.set(EKK0361C010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		
		// 更新年月日時分秒(更新前)
		if (lastUpdDtmKK0361 == null || "".equals(lastUpdDtmKK0361)) 
		{
			template.setNull(EKK0361C010CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0361C010CBSMsg.UPD_DTM_BF, lastUpdDtmKK0361);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * オプションサービス契約＜ISP＞照査締結の処理です。
	 * @param handle
	 * @param param
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK0361C030(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String lastUpdDtmKK0361)
			throws RequestParameterException, SCException, Throwable
	{
		// オプションサービス契約＜ISP＞照査締結
		paramMap = editInMsgEKK0361C030(param, opSvcKeiNo, lastUpdDtmKK0361);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0361C030);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * オプションサービス契約＜ISP＞照査締結のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0361C030(IRequestParameterReadWrite param,
			String opSvcKeiNo, String lastUpdDtmKK0361) 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));
		
		CAANMsg template = new CAANMsg(EKK0361C030CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0361C030CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0361C030);
		
		// 機能コード
		template.set(EKK0361C030CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0361C030CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0361C030CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// 異動区分(00031:オプション設定)
		template.set(EKK0361C030CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		
		// 更新年月日時分秒(更新前)
		if (lastUpdDtmKK0361 == null || "".equals(lastUpdDtmKK0361)) 
		{
			template.setNull(EKK0361C030CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0361C030CBSMsg.UPD_DTM_BF, lastUpdDtmKK0361);
		}
		
		// 事務手数料自動適用要否(0:否)
		template.set(EKK0361C030CBSMsg.RULE0059_AUTO_APLY, JKKStrConst.RULE0059_AUTO_APLY_0);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * オプションサービス契約＜ISP＞開始の処理です。
	 * @param handle
	 * @param param
	 * @param paramMap
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK0361C040(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String lastUpdDtmKK0361)
			throws RequestParameterException, SCException, Throwable
	{
		// オプションサービス契約＜ISP＞開始
		paramMap = editInMsgEKK0361C040(param, opSvcKeiNo, lastUpdDtmKK0361);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0361C040);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * オプションサービス契約＜ISP＞開始のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param lastUpdDtmKK0361
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0361C040(IRequestParameterReadWrite param,
			String opSvcKeiNo, String lastUpdDtmKK0361) 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));
		
		CAANMsg template = new CAANMsg(EKK0361C040CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0361C040CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0361C040);
		
		// 機能コード
		template.set(EKK0361C040CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0361C040CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0361C040CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// 異動区分(00031:オプション設定)
		template.set(EKK0361C040CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		
		// 更新年月日時分秒(更新前)
		if (lastUpdDtmKK0361 == null || "".equals(lastUpdDtmKK0361)) 
		{
			template.setNull(EKK0361C040CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0361C040CBSMsg.UPD_DTM_BF, lastUpdDtmKK0361);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	// v52.00.01 ANK-3987-00-00 DEL START
//	/**
//	 * 課金先登録の処理です。
//	 * @param handle
//	 * @param param
//	 * @param paramMap
//	 * @param seikyKeiNo
//	 * @param opSvcKeiNo
//	 * @param updDtmKK0491
//	 * @return resultTemplates[0]
//	 * @throws RequestParameterException
//	 */
//	private Object callEKK0321D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
//			String seikyKeiNo, String opSvcKeiNo, String updDtmKK0491)
//			throws RequestParameterException, SCException, Throwable
//	{
//		// 課金先登録
//		paramMap = editInMsgEKK0321D010(param, seikyKeiNo, opSvcKeiNo, updDtmKK0491);
//		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//		Map<?, ?> result = scCall.run(paramMap, handle);
//		
//		// エラー情報の設定
//		param = editResultRP(result, param, TEMPLATE_ID_EKK0321D010);
//		
//		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
//		
//		return resultTemplates[0];
//	}
//
//	/**
//	 * 課金先登録のサービスI/Fのメッセージを作成します。
//	 * 
//	 * @param param
//	 * @param seikyKeiNo
//	 * @param opSvcKeiNo
//	 * @param updDtmKK0491
//	 * @return HashMap<String, Object>
//	 * @throws RequestParameterException
//	 */
//	private HashMap<String, Object> editInMsgEKK0321D010(IRequestParameterReadWrite param,
//			String seikyKeiNo, String opSvcKeiNo, String updDtmKK0491) 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));
//		
//		CAANMsg template = new CAANMsg(EKK0321D010CBSMsg.class.getName());
//		
//		// テンプレートID
//		template.set(EKK0321D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321D010);
//		
//		// 機能コード
//		template.set(EKK0321D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
//		
//		// オペレータID
//		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
//		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
//		
//		// 運用日付
//		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
//		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
//		
//		// 運用日時
//		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
//		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
//		
//		// 請求契約番号
//		if (seikyKeiNo == null || "".equals(seikyKeiNo)) 
//		{
//			template.setNull(EKK0321D010CBSMsg.SEIKY_KEI_NO);
//		}
//		else
//		{
//			template.set(EKK0321D010CBSMsg.SEIKY_KEI_NO, seikyKeiNo);
//		}
//		
//		// オプションサービス契約番号
//		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
//		{
//			template.setNull(EKK0321D010CBSMsg.OP_SVC_KEI_NO);
//		}
//		else
//		{
//			template.set(EKK0321D010CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
//		}
//		
//		// 課金先適用開始年月日
//		template.set(EKK0321D010CBSMsg.KAKINS_TSTAYMD, JCCBPCommon.getOpeDate(null));
//		
//		// 更新年月日時分秒(更新前)
//		if (updDtmKK0491 == null || "".equals(updDtmKK0491)) 
//		{
//			template.setNull(EKK0321D010CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0321D010CBSMsg.UPD_DTM_BF, updDtmKK0491);
//		}
//		
//		CAANMsg[] templates = new CAANMsg[1];
//		templates[0] = template;
//		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
//		
//		return paramMap;
//	}
	// v52.00.01 ANK-3987-00-00 DEL END

	/**
	 * 進捗登録の処理です。
	 * @param handle
	 * @param param
	 * @param paramMap
	 * @param svcKeiNo
	 * @param prgTkjk1
	 * @param mskmDtlNo
	 * @param opSvcKeiNo
	 * @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK1091D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			// OM-2021-0000542 MOD START
			//String  svcKeiNo, String  prgTkjk1, String mskmDtlNo)
			String  svcKeiNo, String  prgTkjk1, String mskmDtlNo, String opSvcKeiNo)
			// OM-2021-0000542 MOD END
			throws RequestParameterException, SCException, Throwable
	{
		// 進捗登録
		// OM-2021-0000542 MOD START
		//paramMap = editInMsgEKK1091D010(param, svcKeiNo, prgTkjk1, mskmDtlNo);
		paramMap = editInMsgEKK1091D010(param, svcKeiNo, prgTkjk1, mskmDtlNo, opSvcKeiNo);
		// OM-2021-0000542 MOD END
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK1091D010);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * 進捗登録のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param svcKeiNo
	 * @param prgTkjk1
	 * @param mskmDtlNo
	 * @param opSvcKeiNo
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK1091D010(IRequestParameterReadWrite param,
			// OM-2021-0000542 MOD START
			//String svcKeiNo, String prgTkjk1, String mskmDtlNo) throws RequestParameterException
			String svcKeiNo, String prgTkjk1, String mskmDtlNo, String opSvcKeiNo) throws RequestParameterException
			// OM-2021-0000542 MOD END
	{
		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));
		
		CAANMsg template = new CAANMsg(EKK1091D010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK1091D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1091D010);
		
		// 機能コード
		template.set(EKK1091D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 申込明細番号
		if (mskmDtlNo == null || "".equals(mskmDtlNo)) 
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		}
		
		// サービス契約番号
		if (svcKeiNo == null || "".equals(svcKeiNo)) 
		{
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK1091D010CBSMsg.SVC_KEI_NO, svcKeiNo);
		}
		
		// 異動区分(00031:オプション設定)
		template.set(EKK1091D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		
		// 異動年月日時分秒(システム日時)
		template.set(EKK1091D010CBSMsg.IDO_DTM, JCCBPCommon.getSysDateTimeStamp());
		
		// 進捗ステータス(5102:オプション設定完了)
		template.set(EKK1091D010CBSMsg.PRG_STAT, JKKStrConst.CD00647_OP_SETTE_FIN);
		
		// 進捗特記事項1
		template.set(EKK1091D010CBSMsg.PRG_TKJK_1, PRG_TKJK_1_NETFLIX_PREMIUM_PLAN + prgTkjk1);
		
		// OM-2021-0000542 ADD START
		// オプションサービス契約番号
		template.set(EKK1091D010CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		
		//異動理由明細
		CAANMsg[] list = new CAANMsg[1];
		CAANMsg idoRsnTemp = new CAANMsg(EKK1091D010CBSMsg1List.class.getName());
		// 異動理由コード(56:その他)
		idoRsnTemp.set(EKK1091D010CBSMsg1List.IDO_RSN_CD, "56");
		// 異動理由メモ
		idoRsnTemp.setNull(EKK1091D010CBSMsg1List.IDO_RSN_MEMO);
		list[0] = idoRsnTemp;
		
		// 異動理由明細
		template.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, list);
		// OM-2021-0000542 ADD END
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * EKK0351A010_オプションサービス契約一意照会を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param netflixOpSvcKeiNo Netflixオプションサービス契約番号
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callEKK0351A010(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String netflixOpSvcKeiNo)throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会の上りマッピング
		Object[][] eKK0351A010In =
		{
			{EKK0351A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0351A010}
			// 機能コード："2"
			, {EKK0351A010CBSMsg.FUNC_CODE, "2"}
			// ＫＥＹ＿サービス契約番号
			, {EKK0351A010CBSMsg.KEY_OP_SVC_KEI_NO, netflixOpSvcKeiNo}
			// ＫＥＹ＿予約適用年月日
			, {EKK0351A010CBSMsg.KEY_RSV_APLY_YMD, (String)JCCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] eKK0351A010Msg1List = callSC(handle, scCall, param, fixedText, eKK0351A010In,
				new EKK0351A010CBSMsg().getContents()).getCAANMsgList(EKK0351A010CBSMsg.EKK0351A010CBSMSG1LIST);
		
		return eKK0351A010Msg1List;
	}
	
	/**
	 * オプションサービス契約キャンセルの処理です。
	 * @param handle
	 * @param param
	 * @param opSvcKeiNo
	 * @param mskmDtlNo
	 * @param updDtmBf
	 * @throws RequestParameterException
	 */
	private void callEKK0351C220(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String mskmDtlNo, String updDtmBf)
			throws RequestParameterException, SCException, Throwable
	{
		//オプションサービス契約キャンセル
		paramMap = editInMsgEKK0351C220(param, opSvcKeiNo, mskmDtlNo, updDtmBf);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0351C220);
	}
	
	/**
	 * オプションサービス契約キャンセルのサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param mskmDtlNo
	 * @param updDtmBf
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0351C220(IRequestParameterReadWrite param,
			String opSvcKeiNo, String mskmDtlNo, String updDtmBf) 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));
		
		CAANMsg template = new CAANMsg(EKK0351C220CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0351C220CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0351C220);
		
		// 機能コード
		template.set(EKK0351C220CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0351C220CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0351C220CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// 申込明細番号
		if (mskmDtlNo == null || "".equals(mskmDtlNo)) 
		{
			template.setNull(EKK0351C220CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0351C220CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		}
		
		// サービスキャンセル理由コード(05:その他理由によるキャンセル)
		template.set(EKK0351C220CBSMsg.SVC_CANCEL_RSN_CD, JKKStrConst.CD01390_CL_OTHER);
		
		// OM-2021-0000542 MOD START
		// 異動区分(00031:オプション設定)
		//template.set(EKK0351C220CBSMsg.IDO_DIV, IDO_DIV_00054);
		template.set(EKK1091D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		// OM-2021-0000542 MOD END
		
		//更新年月日時分秒(更新前)
		if (updDtmBf == null || "".equals(updDtmBf)) 
		{
			template.setNull(EKK0351C220CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0351C220CBSMsg.UPD_DTM_BF, updDtmBf);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * オプションサービス契約解約の処理です。
	 * @param handle
	 * @param param
	 * @param opSvcKeiNo
	 * @param mskmDtlNo
	 * @param updDtmBf
	 * @throws RequestParameterException
	 */
	private String callEKK0351C240(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String mskmDtlNo, String updDtmBf)
			throws RequestParameterException, SCException, Throwable
	{
		//オプションサービス契約キャンセル
		paramMap = editInMsgEKK0351C240(param, opSvcKeiNo, mskmDtlNo, updDtmBf);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0351C240);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		CAANMsg msg = templates[0];
		
		String updDtm = msg.getString(EKK0351C240CBSMsg.UPD_DTM);
		
		return updDtm;
	}
	
	/**
	 * オプションサービス契約解約のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param mskmDtlNo
	 * @param updDtmBf
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0351C240(IRequestParameterReadWrite param,
			String opSvcKeiNo, String mskmDtlNo, String updDtmBf) 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));
		
		CAANMsg template = new CAANMsg(EKK0351C240CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0351C240CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0351C240);
		
		// 機能コード
		template.set(EKK0351C240CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0351C240CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0351C240CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// 申込明細番号
		if (mskmDtlNo == null || "".equals(mskmDtlNo)) 
		{
			template.setNull(EKK0351C240CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0351C240CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		}
		
		// サービス解約理由コード(01:通常解約)
		template.set(EKK0351C240CBSMsg.SVC_DLRE_CD, JKKStrConst.CD00879_TUJYO_DSL);
		
		// OM-2021-0000542 MOD START
		// 異動区分(00031:オプション設定)
		//template.set(EKK0351C220CBSMsg.IDO_DIV, IDO_DIV_00054);
		template.set(EKK1091D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		// OM-2021-0000542 MOD END
		
		//更新年月日時分秒(更新前)
		if (updDtmBf == null || "".equals(updDtmBf)) 
		{
			template.setNull(EKK0351C240CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0351C240CBSMsg.UPD_DTM_BF, updDtmBf);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * オプションサービス契約解約確定の処理です。
	 * @param handle
	 * @param param
	 * @param opSvcKeiNo
	 * @param updDtmBf
	 * @throws RequestParameterException
	 */
	private void callEKK0351C250(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String opSvcKeiNo, String updDtmBf)
			throws RequestParameterException, SCException, Throwable
	{
		//オプションサービス契約キャンセル
		paramMap = editInMsgEKK0351C250(param, opSvcKeiNo, updDtmBf);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK0351C250);
	}
	
	/**
	 * オプションサービス契約解約確定のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param opSvcKeiNo
	 * @param updDtmBf
	 * @return HashMap<String, Object>
	 * @throws Throwable 
	 */
	private HashMap<String, Object> editInMsgEKK0351C250(IRequestParameterReadWrite param,
			String opSvcKeiNo, String updDtmBf) throws Throwable
	{
		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));
		
		CAANMsg template = new CAANMsg(EKK0351C250CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0351C250CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0351C240);
		
		// 機能コード
		template.set(EKK0351C250CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// サービス終了年月日
		String svcEndYmd = null;
		{
			svcEndYmd = (String)JCCBPCommon.getOpeDate(null);		// 運用日
		}
		// サービス課金終了年月日（適用日−１日）
		String svcChrgEndYmd = addYYYYMMDD((String)JCCBPCommon.getOpeDate(null), -1);
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0351C250CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0351C250CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// オプションサービス契約番号
		if (opSvcKeiNo == null || "".equals(opSvcKeiNo)) 
		{
			template.setNull(EKK0351C250CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0351C250CBSMsg.OP_SVC_KEI_NO, opSvcKeiNo);
		}
		
		// OM-2021-0000542 DEL START
		//// サービス終了年月日
		//template.set(EKK0351C250CBSMsg.SVC_ENDYMD, (String)JCCBPCommon.getOpeDate(null));
		// OM-2021-0000542 DEL END
		
		// サービス解約理由コード(01:通常解約)
		template.set(EKK0351C250CBSMsg.SVC_DLRE_CD, JKKStrConst.CD00879_TUJYO_DSL);
		
		// OM-2021-0000542 MOD START
		// 異動区分(00031:オプション設定)
		//template.set(EKK0351C220CBSMsg.IDO_DIV, IDO_DIV_00054);
		template.set(EKK1091D010CBSMsg.IDO_DIV, JKKStrConst.CD00576_00031);
		// OM-2021-0000542 MOD END
		
		//更新年月日時分秒(更新前)
		if (updDtmBf == null || "".equals(updDtmBf)) 
		{
			template.setNull(EKK0351C250CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0351C250CBSMsg.UPD_DTM_BF, updDtmBf);
		}
		
		// サービス終了年月日
		template.set(EKK0351C250CBSMsg.SVC_ENDYMD, svcEndYmd);
		
		// サービス課金終了年月日
		template.set(EKK0351C250CBSMsg.SVC_CHRG_ENDYMD, svcChrgEndYmd);
		
		// 解約時課金フラグ(1:課金)
		template.set(EKK0351C250CBSMsg.DSLJI_CHRG_FLG, "1");
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * @param handle セッションハンドル
	 * @param scCall SC呼び出し部品
	 * @param param リクエストパラメータ
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @param contents CAANMsgのコンテンツ
	 * @return CAANMsg
	 * @throws Throwable 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle
								, ServiceComponentRequestInvoker scCall
								, IRequestParameterReadWrite param
								, String dataMapKey
								, Object[][] mappingData
								, Object[][] contents) 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, mappingData, contents);
		
		//エラー情報のマップを取得
		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 templates CAANMsgクラス
	 * @param returnCode リターンコード
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @param contents CAANMsgのコンテンツ
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException リクエストパラメータの操作でエラーが発生した場合
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCom(IRequestParameterReadWrite param
															, CAANMsg[] templates
															, int returnCode
															, String dataMapKey
															, Object[][] mappingData
															, Object[][] contents) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (0 != returnCode)
		{
			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, String> inMap = null;
		
		// ユーザデータ情報
		inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		for (int i = 0; null != contents && i < contents.length ; i++)
		{
			String itemNm = (String)contents[i][0];
			if (itemNm.endsWith(ERRITEM_SUFFIX))
			{
				String errCd = (String)template.getString(itemNm);
				if (!JKKStringUtil.isNullBlank(errCd))
				{
					inMap.put(itemNm, errCd);
				}
			}
		}
		
		return param;
	}
	
	/**
	 * <dl>
	 * <dt>処理概要：
	 * <dd>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする<br>
	 * <dt>処理補足：
	 * <dd>
	 * </dl>
	 * 
	 * @param msgList
	 * @param param
	 * @param mapName
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings({ "unchecked", "cast", "boxing" })
	public IRequestParameterReadWrite editResultRP(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String mapName) throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		
		// 業務データ設定
		dataMap = (HashMap)param.getData(mapName);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(mapName, dataMap);
		}
		
		CAANMsg msg = templates[0];
		
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// エラー情報の設定
		param = editErrorInfo(param, templates, (Integer)return_code, mapName);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		
		return param;
	}
	
	/**
	 * <dl>
	 * <dt>処理概要：
	 * <dd>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする<br>
	 * <dt>処理補足：
	 * <dd>
	 * </dl>
	 * 
	 * @param param      業務データ取得・書込用I/F
	 * @param templates  CAANMsgクラス配列
	 * @param returnCode リターンコード
	 * @param mapName    SCマップ名
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings({ "unchecked", "cast", "boxing" })
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param,
			CAANMsg[] templates,
			int returnCode,
			String mapName) throws Throwable
	{
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		
		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 = null;
		
		// ユーザデータ情報
		inMap = (HashMap<String, String>)param.getData(mapName);
		
		Iterator<String> it = template.getHashMap().keySet().iterator();
		while (it.hasNext())
		{
			String key = it.next();
			if (key.endsWith("_err"))
			{
				if (!template.isNull(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	
	/**
	 * 共通項目のメッセージを作成します。
	 * @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));
		
		// サービスインターフェイス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[] templates = new CAANMsg[1];
		
		templates[0] = template;
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * 他事業者契約異動通知登録の処理です。
	 * @param handle
	 * @param param
	 * @param paramMap
	 * @param svcKeiNo
	 * @param ptnracntId
	 * @param tajgsKeiStaEndYmd
	 * @param planType
	 * @return resultTemplates[0]
	 * @throws RequestParameterException
	 */
	private Object callEKK3081D010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			String svcKeiNo, String ptnracntId, String tajgsKeiStaEndYmd, String planType)
			throws RequestParameterException, SCException, Throwable
	{
		// 他事業者契約異動通知登録
		paramMap = editInMsgEKK3081D010(param, svcKeiNo, ptnracntId, tajgsKeiStaEndYmd, planType);
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// エラー情報の設定
		param = editResultRP(result, param, TEMPLATE_ID_EKK1091D010);
		
		CAANMsg[] resultTemplates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		return resultTemplates[0];
	}

	/**
	 * 他事業者契約異動通知登録のサービスI/Fのメッセージを作成します。
	 * 
	 * @param param
	 * @param svcKeiNo
	 * @param ptnracntId
	 * @param tajgsKeiStaEndYmd
	 * @param planType
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK3081D010(IRequestParameterReadWrite param,
			String svcKeiNo, String ptnracntId, String tajgsKeiStaEndYmd, String planType) 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));
		
		CAANMsg template = new CAANMsg(EKK3081D010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK3081D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3081D010);
		
		// 機能コード
		template.set(EKK3081D010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 他事業者契約異動通知先識別コード(04:Netflix社)
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDT_SK_SKCD, JKKStrConst.TAJGS_KEI_IDT_SK_SKCD_04);
		
		// 他事業者契約異動種別コード
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDO_SBT_CD, JKKStrConst.TAJGS_KEI_IDO_SBT_CD_0403);
		
		// サービス契約番号
		if (svcKeiNo == null || "".equals(svcKeiNo)) 
		{
			template.setNull(EKK3081D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK3081D010CBSMsg.SVC_KEI_NO, svcKeiNo);
		}
		
		// 他事業者契約異動通知状態コード(1:通知済)
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDT_STAT_CD, JKKStrConst.TAJGS_KEI_IDT_STAT_CD_TCHI_ZUMI);
		
		// 他事業者契約異動発生年月日
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDO_HSI_YMD, (String)JCCBPCommon.getOpeDate(null));
		
		// 他事業者契約異動通知予定年月日
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDT_RSV_YMD, (String)JCCBPCommon.getOpeDate(null));
		
		// 他事業者契約異動通知年月日時分秒
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDT_DTM, JCCBPCommon.getSysDateTimeStamp());
		
		// 他事業者契約異動通知結果コード(0:正常終了)
		template.set(EKK3081D010CBSMsg.TAJGS_KEI_IDT_RSLT_CD, JKKStrConst.TAJGS_KEI_IDT_RSLT_CD_0);
		
		// パートナーアカウントID
		if (ptnracntId == null || "".equals(ptnracntId)) 
		{
			template.setNull(EKK3081D010CBSMsg.PTNRACNT_ID);
		}
		else
		{
			template.set(EKK3081D010CBSMsg.PTNRACNT_ID, ptnracntId);
		}
		
		// 他事業者契約開始・終了年月日
		if (tajgsKeiStaEndYmd == null || "".equals(tajgsKeiStaEndYmd)) 
		{
			template.setNull(EKK3081D010CBSMsg.TAJGS_KEI_STA_END_YMD);
		}
		else
		{
			template.set(EKK3081D010CBSMsg.TAJGS_KEI_STA_END_YMD, tajgsKeiStaEndYmd);
		}
		
		// 他事業者契約プランコード
		if (PLAN_TYPE_PREMIUM.equals(planType))
		{
			template.set(EKK3081D010CBSMsg.TAJGS_KEI_PLAN_CD, JKKStrConst.TAJGS_KEI_IDO_SBT_CD_0402);
		}
		else if (PLAN_TYPE_STANDARD.equals(planType))
		{
			template.set(EKK3081D010CBSMsg.TAJGS_KEI_PLAN_CD, JKKStrConst.TAJGS_KEI_IDO_SBT_CD_0401);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * 年月日の加算をします。
	 * 
	 * @param trgtYmd
	 * @param addDay
	 * @return String
	 * @throws Throwable
	 */
	private static String addYYYYMMDD(String trgtYmd, int addDay) throws Throwable
	{
		// 年月日の抽出
		int year  = Integer.parseInt(trgtYmd.substring(0, 4));
		int month = Integer.parseInt(trgtYmd.substring(4, 6));
		int day   = Integer.parseInt(trgtYmd.substring(6, 8));

		Calendar cal = Calendar.getInstance();
		cal.set(year, month - 1, day);
		// 日付を算出
		cal.add(Calendar.DATE, addDay);

		return String.format("%tY%tm%td", cal, cal, cal);
	}

	// OM-2021-0000542 ADD START
	/**
	 * 申込内容を登録します
	 * 
	 * @param trgtYmd
	 * @param addDay
	 * @throws Throwable
	 */
	private String addMskmNaiyo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String sysid) throws Throwable
	{
		// オンライン運用日
		String opeDate = (String)JCCBPCommon.getOpeDate(null);
		
		// オンライン運用日+システム日付の時分秒
		String opeDateTimeStamp = opeDate + JCCBPCommon.getSysDateTimeStamp().substring(8, 17);
		
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 申込内容承認登録
		Object[][] ekk0011d020InMsg = editInMsgEKK0011D020(sysid, MSKM_SBT_CD_OP_MSKM, opeDate, CONSMBSN_MSKM_STAT_SKBT_CD_SHONIN_ZM, opeDateTimeStamp);
		
		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, "");
		inMap.put(EKK0011D020CBSMsg1List.MSKMSHO_DTL_NO, "");
		inMap.put(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_NM, "");
		inList.add(inMap);
		
		CAANMsg ekk0011d020outMsg = callSCArray(handle, scCall, param, fixedText, ekk0011d020InMsg, "EKK0011D020CBSMsg1List", inList);
		
		CAANMsg ekk0011D020CBSMsg1List = ekk0011d020outMsg.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST)[0];
		
		// 申込明細番号 申込内容承認登録実行時
		String mskmDtlNoD020 = ekk0011D020CBSMsg1List.getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO);
		
		// 更新年月日時分秒 申込内容承認登録実行時
		String updDtmD020 = ekk0011d020outMsg.getString(EKK0011D020CBSMsg.UPD_DTM);
		
		// 申込明細照査・後続業務依頼
		Object[][] ekk0021c060InMsg = editInMsgEKK0021C060(mskmDtlNoD020, opeDate, updDtmD020);
		
		// サービスIF実行
		CAANMsg ekk0021c060outMsg = callSC(handle, scCall, param, fixedText, ekk0021c060InMsg);
		
		return mskmDtlNoD020;
	}
	
	/**
	 * 
	 * EKK0011D020_申込内容承認登録上り電文作成処理
	 * <br>
	 * @param sysid SYSID
	 * @param mskmSbtCd 申込種別コード
	 * @param opeDate オンライン運用日
	 * @param consmbsnMskmStatSkbtCd コンシューマ営業用申込状態識別コード
	 * @param opeDateTimeStamp 運用日+システム日付の時分秒ミリ秒
	 * @return Object[][] 上り電文
	 */
	private Object[][] editInMsgEKK0011D020(String sysid, String mskmSbtCd, String opeDate, String consmbsnMskmStatSkbtCd, String opeDateTimeStamp)
	{
		// 申込内容承認登録
		Object[][] inMsg = {{EKK0011D020CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0011D020},
							{EKK0011D020CBSMsg.FUNC_CODE,  "1"},
							{EKK0011D020CBSMsg.SYSID,  sysid},
							{EKK0011D020CBSMsg.MSKM_SBT_CD,  mskmSbtCd},
							{EKK0011D020CBSMsg.MSKM_UK_DTM,  opeDateTimeStamp},
							{EKK0011D020CBSMsg.MSKM_YMD,  opeDate},
							{EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD,  consmbsnMskmStatSkbtCd}
		};
		
		return inMsg;
	}
	
	/**
	 * EKK0021C060_申込明細照査・後続業務依頼上り電文作成処理
	 * <br>
	 * @param mskmDtlNo 申込明細番号
	 * @param opeDate オンライン運用日
	 * @param updDtm 更新年月日時分秒
	 * @return Object[][] 上り電文
	 */
	private Object[][] editInMsgEKK0021C060(String mskmDtlNo, String opeDate, String updDtm)
	{
		// 申込明細照査・後続業務依頼
		Object[][] inMsg = {{EKK0021C060CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0021C060},
							{EKK0021C060CBSMsg.FUNC_CODE,  "1"},
							{EKK0021C060CBSMsg.MSKM_DTL_NO,  mskmDtlNo},
							{EKK0021C060CBSMsg.KZKWRK_REQYMD,  opeDate},
							{EKK0021C060CBSMsg.UPD_DTM_BF,  updDtm}
		};
		
		return inMsg;
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return CAANMsg
	 * @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))
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(return_code.toString()) && 4 == status))
			{
				throw new SCCallException("戻り値不正", return_code.toString(), status);
			}
		}
		return msg;
	}
	
	/**
	 * @param param
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return HashMap<String, Object>
	 * @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 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;
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle,
							ServiceComponentRequestInvoker scCall,
							IRequestParameterReadWrite param,
							String dataMapKey,
							Object[][] mappingData) throws Exception
	{
		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];
		
		// リターンコード取得
		int returnCode = (Integer)result.get(JCMConstants.RET_CD_INT_KEY);
		
		int templateStatus = msg.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);
		}
		
		setErrorInf(msg, (HashMap<String, Object>)param.getData(dataMapKey));
		
		//エラー情報のマップを取得
		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));
		
		/* ◇処理結果の判定*/
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		Integer status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status.intValue()))
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status.intValue()))
			{
				SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
				throw scCallEx;
			}
		}
		return msg;
	}

	/**
	 * エラー情報を設定します。
	 * 
	 * @param msg
	 * @param map
	 * 
	 */
	@SuppressWarnings("unchecked")
	private void setErrorInf(CAANMsg msg, HashMap<String, Object> map)
	{
		Iterator<String> msgKey = msg.getSchema().getSchemaKeySet().iterator();
		
		while (msgKey.hasNext())
		{
			String key = msgKey.next();
			
			if (key.endsWith("_err"))
			{
				if (!msg.isNull(key))
				{
					if (!map.containsKey(key))
					{
						map.put(key, msg.getString(key));
					}
				}
			}
		}
	}
	// OM-2021-0000542 ADD END
// ▽▽▽ ANK-4055-00-00 ADD START
	/**
	 * メールを送信する。
	 * <br>
	 * @param handle
	 * @param param
	 * @param mapkey マップキー
	 * @param sysid
	 * @param mailCd 送信するメールコード
	 * @param svcKeiNo サービス契約番号
	 */
	@SuppressWarnings("unchecked")
	private void sendUkMail(SessionHandle handle, 
			IRequestParameterReadWrite param, String sysid, String mapkey, String mailCd, String svcKeiNo) throws Throwable
	{
		HashMap<String, Object> kksv095402cc = new HashMap<String, Object>();
		param.setData(mapkey, kksv095402cc);

		// パラメータチェック（サービス契約番号）
		if (JKKStringUtil.isNullBlank(svcKeiNo))
		{
			// メールが取得できない為、メールは送らない
			kksv095402cc.put("mail_send_warn_cd", "WARN004");
			return ;
		}
		// パラメータチェック（SYSID）
		if (JKKStringUtil.isNullBlank(sysid))
		{
			// お客様が取得できない場合、メールは送らない
			kksv095402cc.put("mail_send_warn_cd", "WARN002");
			return ;
		}
		// お客様情報を取得する
		CAANMsg[] eck0011a010List = callECK0011A010(handle, param, mapkey, sysid);
		if (eck0011a010List == null || eck0011a010List.length == 0)
		{
			// お客様が取得できない場合、メールは送らない
			kksv095402cc.put("mail_send_warn_cd", "WARN003");
			return ;
		}
		// オプションサービス契約一覧を取得する。
		CAANMsg[] ekk0361b001List = callEKK0361B001(handle, param, mapkey, svcKeiNo);
		if (ekk0361b001List == null)
		{
			// nullの場合、空の配列を作成する
			ekk0361b001List = new CAANMsg[0];
		}
		
		// ANK-4468-00-01 ADD START
		CAANMsg[] eck0011b050MsgList = null;
		// ANK-4468-00-01 ADD END
		

		// ANK-4468-00-00 ADD START
		// 連絡先テーブルから電子メールアドレスを取得する
// ANK-4468-00-01 MOD START
		//String contactMlad = callECK0201B002(handle, param, mapkey, sysid);		
		eck0011b050MsgList = callECK0011B050(handle, param, mapkey, sysid);
// ANK-4468-00-01 MOD END		
// ANK-4468-00-01 ADD START
		// メールアドレス変数初期化
		Set<String> mladSet = new HashSet<String>();
		
		// コンテンツ連絡先メールアドレスの存在チェック
		if (!rsltSifList(eck0011b050MsgList))
		{
			// メールアドレスを取得し、設定する。
			mladSet = getRrksMailAddress(eck0011b050MsgList);
		}
// ANK-4468-00-01 ADD END

		// 連絡先テーブルの電子メールアドレスを使用してメールが送信されたかどうかを確認する
		boolean isContactMladSent = false;
		// ANK-4468-00-00 ADD END
		
		// 有効なメールのみ連携する
		List<String> stateList = Arrays.asList(JKKStrConst.CD00037_CNC_ZM, JKKStrConst.CD00037_SVCTK_CHU, JKKStrConst.CD00037_STAT_PAUSE, JKKStrConst.CD00037_STAT_STP);
		int sendMailCnt = 0;
		
		for (CAANMsg ekk0361b001 : ekk0361b001List)
		{
			if (JKKStrConst.OP_SVC_CD_EMAIL.equals(ekk0361b001.getString(EKK0361B001CBSMsg1List.OP_SVC_CD)) 
					&& stateList.contains(ekk0361b001.getString(EKK0361B001CBSMsg1List.OP_SVC_KEI_STAT))
					&& !ekk0361b001.isNull(EKK0361B001CBSMsg1List.MLAD))
			{			
				// 処理コード
				kksv095402cc.put("func_code", "1");
				
				// メールコードを設定する
				kksv095402cc.put(ECC0021D010CBSMsg.MAIL_CD, mailCd);
				
				// メール送信パターンコード　01:リアルタイム
				kksv095402cc.put(ECC0021D010CBSMsg.MAIL_SEND_PATTERN_CD, "01");
		
				// ＣＣへ渡す変数の定義
				ArrayList<HashMap> ecc0021D010List1 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List2 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List3 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List4 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List5 = new ArrayList<HashMap>();
				
				// 01.メールアドレスを設定する
				HashMap list1Map = new HashMap();
				list1Map.put(ECC0021D010CBSMsg1List.MLAD, ekk0361b001.getString(EKK0361B001CBSMsg1List.MLAD));
		
				// メール設定フィールドコード　01:to
				list1Map.put(ECC0021D010CBSMsg1List.MLAD_SET_FIELD_CD, "01");
				ecc0021D010List1.add(list1Map);
				
//ANK-4468-00-01 DEL START				
//				// ANK-4468-00-00 ADD START
//				if(contactMlad != null && !contactMlad.isEmpty())
//				{
//					if(!contactMlad.equals(ekk0361b001.getString(EKK0361B001CBSMsg1List.MLAD)) && !isContactMladSent)
//					{
//						HashMap contactListMap = new HashMap();
//						contactListMap.put(ECC0021D010CBSMsg1List.MLAD, contactMlad);
//						// メール設定フィールドコード　01
//						contactListMap.put(ECC0021D010CBSMsg1List.MLAD_SET_FIELD_CD, "01");
//						ecc0021D010List1.add(contactListMap);
//						
//						isContactMladSent = true;
//					}
//				}
//				// ANK-4468-00-00 ADD END
//ANK-4468-00-01 DEL END
				
//ANK-4468-00-01 ADD START
				// コンテンツ連絡先メールアドレスがオプションサービスのメールアドレスと一致しない場合送信対象とする
				if(mladSet != null || mladSet.size() !=0){
					for (String mlad : mladSet){
						if(!mlad.equals(ekk0361b001.getString(EKK0361B001CBSMsg1List.MLAD)) && !isContactMladSent){
							
							HashMap contactListMap = new HashMap();
							contactListMap.put(ECC0021D010CBSMsg1List.MLAD, mlad);
							// メール設定フィールドコード　01
							contactListMap.put(ECC0021D010CBSMsg1List.MLAD_SET_FIELD_CD, "01");
							ecc0021D010List1.add(contactListMap);
						}
					}
					isContactMladSent = true;
				}
//ANK-4468-00-01 ADD END				
				
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG1LIST, ecc0021D010List1);
		
				// 02.置換文字を設定する。
				HashMap list2Map = new HashMap();
				
				// メール本文の置換文字列にお客様名を設定
				list2Map.put(ECC0021D010CBSMsg2List.TEXT_HTK_CKAM_MOJI, eck0011a010List[0].getString(ECK0011A010CBSMsg1List.CUST_NM));
				ecc0021D010List2.add(list2Map);
		
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG2LIST, ecc0021D010List2);
		
				// その他の設定
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG3LIST, ecc0021D010List3);
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG4LIST, ecc0021D010List4);
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG5LIST, ecc0021D010List5);
		
				// CCを呼び出す（このＣＣはエラーを返さない為、エラーの場合は）
				JKKSendMailCC mailCC = new JKKSendMailCC();
				mailCC.sendMailCC(handle, param, mapkey);
				sendMailCnt ++; // 送信件数をカウントアップする
			}
		}
		
//ANK-4468-00-01 ADD START
		//オプションサービスメールが存在しない場合、連絡先メールのみ送信対象とする。
		if(!isContactMladSent && (mladSet != null || mladSet.size() !=0)){
			for (String mlad : mladSet){
				// 処理コード
				kksv095402cc.put("func_code", "1");
				
				// メールコードを設定する
				kksv095402cc.put(ECC0021D010CBSMsg.MAIL_CD, mailCd);
				
				// メール送信パターンコード　01:リアルタイム
				kksv095402cc.put(ECC0021D010CBSMsg.MAIL_SEND_PATTERN_CD, "01");
		
				// ＣＣへ渡す変数の定義
				ArrayList<HashMap> ecc0021D010List1 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List2 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List3 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List4 = new ArrayList<HashMap>();
				ArrayList<HashMap> ecc0021D010List5 = new ArrayList<HashMap>();
				
				HashMap contactListMap = new HashMap();
				contactListMap.put(ECC0021D010CBSMsg1List.MLAD, mlad);
				// メール設定フィールドコード　01
				contactListMap.put(ECC0021D010CBSMsg1List.MLAD_SET_FIELD_CD, "01");
				ecc0021D010List1.add(contactListMap);
				isContactMladSent = true;
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG1LIST, ecc0021D010List1);
				
				// 02.置換文字を設定する。
				HashMap list2Map = new HashMap();
				
				// メール本文の置換文字列にお客様名を設定
				list2Map.put(ECC0021D010CBSMsg2List.TEXT_HTK_CKAM_MOJI, eck0011a010List[0].getString(ECK0011A010CBSMsg1List.CUST_NM));
				ecc0021D010List2.add(list2Map);
		
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG2LIST, ecc0021D010List2);
		
				// その他の設定
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG3LIST, ecc0021D010List3);
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG4LIST, ecc0021D010List4);
				kksv095402cc.put(ECC0021D010CBSMsg.ECC0021D010CBSMSG5LIST, ecc0021D010List5);
		
				// CCを呼び出す（このＣＣはエラーを返さない為、エラーの場合は）
				JKKSendMailCC mailCC = new JKKSendMailCC();
				mailCC.sendMailCC(handle, param, mapkey);
				sendMailCnt ++; // 送信件数をカウントアップする
			}
		}
//ANK-4468-00-01 ADD END
		
		// 送信件数をチェックする
		if (sendMailCnt == 0)
		{
			// メールが取得できない場合、メールは送らない
			kksv095402cc.put("mail_send_warn_cd", "WARN001");
			return ;
		}
	}

	/**
	 * ECK0011A010_お客様一意照会を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param sysid SYSID
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callECK0011A010(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String sysid) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// お客様一意照会の上りマッピング
		Object[][] eCK0011A010In =
		{
			{ECK0011A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011A010}
			// 機能コード："2"
			, {ECK0011A010CBSMsg.FUNC_CODE, "2"}
			// ＫＥＹ＿SYSID
			, {ECK0011A010CBSMsg.KEY_SYSID, sysid}
			// ＫＥＹ＿予約適用年月日
			, {ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, (String)JCCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] eCK0011A010Msg1List = callSC(handle, scCall, param, fixedText, eCK0011A010In,
				new ECK0011A010CBSMsg().getContents()).getCAANMsgList(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
		
		return eCK0011A010Msg1List;
	}
	
	/**
	 * EKK0361B001_オプションサービス契約＜ＩＳＰ＞一覧照会を実行する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callEKK0361B001(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// お客様一意照会の上りマッピング
		Object[][] eKK0361B001In =
		{
			{EKK0361B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0361B001}
			// 機能コード："1"
			, {EKK0361B001CBSMsg.FUNC_CODE, "1"}
			// ＫＥＹ＿サービス契約番号
			, {EKK0361B001CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};
		
		// サービスIF実行
		CAANMsg[] eKK0361B001Msg1List = callSC(handle, scCall, param, fixedText, eKK0361B001In,
				new EKK0361B001CBSMsg().getContents()).getCAANMsgList(EKK0361B001CBSMsg.EKK0361B001CBSMSG1LIST);
		
		return eKK0361B001Msg1List;
	}
// △△△ ANK-4055-00-00 ADD END
	
	// ANK-4468-00-01 DEL START
//	// ANK-4468-00-00 ADD START
//	/**
//	 * ECK0201B002_連絡先(コンテンツ用メールアドレス)一覧照会明細。
//	 * <br>
//	 * @param handle セッションハンドル
//	 * @param param リクエストパラメータ
//	 * @param fixedText ユーザ定義文字列
//	 * @param sysid SYSID
//	 * @return contactMlad 送信先メールアドレス
//	 * @throws Throwable 例外が発生した場合
//	 */
//	private String callECK0201B002(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String sysid) throws Throwable
//	{
//		String contactMlad = "";
//		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
//		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//		
//		// お客様一意照会の上りマッピング
//		Object[][] eCK0201B002In =
//		{
//			{ECK0201B002CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0201B002}
//			// 機能コード："1"
//			, {ECK0201B002CBSMsg.FUNC_CODE, "1"}
//			// ＫＥＹ＿SYSID
//			, {ECK0201B002CBSMsg.KEY_SYSID, sysid}
//			// 運用日付
//			, {ECK0201B002CBSMsg.OPERATEDATE, (String)JCCBPCommon.getOpeDate(null)}
//		};
//		
//		// サービスIF実行
//		CAANMsg[] eCK0201B002Msg1List = callSC(handle, scCall, param, fixedText, eCK0201B002In,
//				new ECK0201B002CBSMsg().getContents()).getCAANMsgList(ECK0201B002CBSMsg.ECK0201B002CBSMSG1LIST);
//		
//		if(eCK0201B002Msg1List.length > 0){
//			contactMlad = eCK0201B002Msg1List[0].getString(ECK0201B002CBSMsg1List.MLAD);
//		}
//		
//		return contactMlad;
//	}
//	// ANK-4468-00-00 ADD END
	// ANK-4468-00-01 DEL END
	
	// ANK-4468-00-01 ADD START
	/**
	 * ECK0011B050_連絡先(コンテンツ用メールアドレス)一覧照会明細。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param sysid SYSID
	 * @return contactMlad 送信先メールアドレス
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg[] callECK0011B050(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String sysid) throws Throwable
	{
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// お客様一意照会の上りマッピング
		Object[][] eCK0011B050In =
		{
			{ECK0011B050CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011B050}
			// 機能コード："1"
			, {ECK0011B050CBSMsg.FUNC_CODE, "1"}
			// ＫＥＹ＿SYSID
			, {ECK0011B050CBSMsg.KEY_SYSID, sysid}
			
		};
		
		// サービスIF実行
		return callSC(handle, scCall, param, fixedText, eCK0011B050In)
		.getCAANMsgList(ECK0011B050CBSMsg.ECK0011B050CBSMSG1LIST);	
		
	}
	
	/**
	 * 重複しない連絡先メールアドレスを全て取得する。
	 * 
	 * @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;
	}
	
	/**
	 * サービス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;
	}
	// ANK-4468-00-01 ADD END
}