/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JKKJdgRsltUpdCC
*	ソースファイル名	：JKKJdgRsltUpdCC.java
*	作成者				：富士通　
*	作成日				：2011年08月23日
*＜機能概要＞
*　審査部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00		2011/08/23	富士通		新規作成
*	v3.00		2012/05/30	FJ)伊藤		エリアチェックSIF変更に伴う修正
*	v4.00		2012/08/17	FJ)伊藤		審査結果コード更新値判断処理追加
*	v4.01		2013/01/09	FJ)藤原		【IT1-2012-0002379】地図顧客位置ワークに登録(更新)する処理を追加
*	v4.02		2013/01/14	FJ)藤原		【ST2-2013-0000103】fixedTextがnullまたは空文字だった場合に代理文字列を設定
*	v5.00		2013/02/18	FJ)清崎		【ANK-1402-00-00】地図顧客位置ワーク.代表者名の設定内容変更対応
*	v4.03		2013/04/09	FJ)砂川		【IT1-2013-0000551】サービス契約番号がNULLの場合は処理を終了する対応
*	v73.0.0		2024/11/01	FJ)張		【ANK-4427-00-00】NTT卸対応：STEP1
*********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

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

import eo.common.constant.JPCModelConstant;
import eo.common.util.JPCEditString;
import eo.ejb.cbm.entity.KK0081ETMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0031A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0031A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0201B001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0091C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0101A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0101A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0101C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0111A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0111A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0111C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0121A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0121A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0121C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0141A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0141A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0141C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071B011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071B011CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2691A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2691A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2691C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2691D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;

/**
 * 審査結果更新クラス
 * @author 富士通
 */
public class JKKJdgRsltUpdCC extends AbstractCommonComponent
{
// 2013/01/09 IT1-2012-0002379 add start
	/** サービス契約番号キー値 */
	private static final String SVC_KEI_NO = "svc_kei_no";
	/** 運用年月日キー値 */
	private static final String UNYO_YMD = "unyo_ymd";
	/** SYSIDキー値 */
	private static final String SYSID = "sysid";
	/** 現在工程コードキー値 */
	private static final String NOW_STEP_CD = "now_step_cd";
	/** 現在工程名キー値 */
	private static final String NOW_STEP_CD_NM = "now_step_cd_nm";
	/** 料金グループコードキー値 */
	private static final String PRC_GRP_CD = "prc_grp_cd";
	/** 料金グループコード名称キー値 */
	private static final String PRC_GRP_CD_NM = "prc_grp_cd_nm";
	/** X座標キー値 */
	private static final String XZAHYO = "xzahyo";
	/** Y座標キー値 */
	private static final String YZAHYO = "yzahyo";
	/** 経度キー値 */
	private static final String LGTD = "lgtd";
	/** 緯度キー値 */
	private static final String LTTD = "lttd";
	/** お客様名キー値 */
	private static final String CUST_NM = "cust_nm";
	/** お客様カナ名キー値 */
	private static final String CUST_KANA = "cust_kana";
	/** 契約者タイプコード名称キー値 */
	private static final String KEISHA_TYPE_CD_NM = "keisha_type_cd_nm";
	/** 自宅電話番号キー値 */
	private static final String HOME_TELNO = "home_telno";
	/** 携帯電話番号キー値 */
	private static final String KTAI_TELNO = "ktai_telno";
	/** 会社電話番号キー値 */
	private static final String COMP_TELNO = "comp_telno";
	/** メールアドレスキー値 */
	private static final String MLAD = "mlad";
	/** お客様生年月日キー値 */
	private static final String CUST_BIRTHD = "cust_birthd";
	/** お客様性別コード名称キー値 */
	private static final String CUST_SEX_CD_NM = "cust_sex_cd_nm";
	/** 業種コード名称キー値 */
	private static final String GSHU_CD_NM = "gshu_cd_nm";
	/** 会社名キー値 */
	private static final String COMP_NM = "comp_nm";
	/** 代表者役職名キー値 */
	private static final String DIHYSHA_POST_NM = "dihysha_post_nm";
	/** 代表者名キー値 */
	private static final String DIHYSHA_NM = "dihysha_nm";
	/** 契約者住所コードキー値 */
	private static final String KEISHA_AD_CD = "keisha_ad_cd";
	/** 契約者郵便番号キー値 */
	private static final String KEISHA_PCD = "keisha_pcd";
	/** 契約者都道府県名キー値 */
	private static final String KEISHA_STATE_NM = "keisha_state_nm";
	/** 契約者市区町村名キー値 */
	private static final String KEISHA_CITY_NM = "keisha_city_nm";
	/** 契約者大字通称名キー値 */
	private static final String KEISHA_OAZTSU_NM = "keisha_oaztsu_nm";
	/** 契約者字丁目名キー値 */
	private static final String KEISHA_AZCHO_NM = "keisha_azcho_nm";
	/** 契約者番地号キー値 */
	private static final String KEISHA_BNCHIGO = "keisha_bnchigo";
	/** 契約者住所補記・建物名キー値 */
	private static final String KEISHA_ADRTTM = "keisha_adrttm";
	/** 契約者住所補記・部屋番号キー値 */
	private static final String KEISHA_ADRRM = "keisha_adrrm";
	/** 申込年月日キー値 */
	private static final String MSKM_YMD = "mskm_ymd";
	/** 申込書番号キー値 */
	private static final String MSKMSHO_NO = "mskmsho_no";
	/** 申込受付年月日キー値 */
	private static final String MSKM_UK_YMD = "mskm_uk_ymd";
	/** サービス開始年月日キー値 */
	private static final String SVC_STA_YMD = "svc_sta_ymd";
	/** サービス終了年月日キー値 */
	private static final String SVC_END_YMD = "svc_end_ymd";
	/** 申込明細番号キー値 */
	private static final String MSKM_DTL_NO = "mskm_dtl_no";
	/** 申込番号キー値 */
	private static final String MSKM_NO = "mskm_no";
	/** 連絡先種別コードキー値 */
	private static final String RRKS_SBT_CD = "rrks_sbt_cd";
	/** 地図顧客位置ワーク更新前更新年月日時分秒キー値 */
	private static final String UPD_DTM_BF = "upd_dtm_bf";
// 2013/01/09 IT1-2012-0002379 add end
	
	/**
	 * 審査結果更新処理を実施する
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Throwable 
	 */
	public IRequestParameterReadWrite execute(
			SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
// 2013/01/14 ST2-2013-0000103 add start
		if(null == fixedText || "".equals(fixedText))
		{
			fixedText = "JKKjdgRsltUpdCC_err_map";
		}
// 2013/01/14 ST2-2013-0000103 add end
		
		// 審査実施フラグを取得
		String judgeJssiFlg = (String)param.getData(JKKJudgeConstCC.JUDGE_JSSI_FLG);
		
		// 審査実施フラグが無の場合
		if(JKKJudgeConstCC.UM_CD_0.equals(judgeJssiFlg))
		{
			// 更新処理を実施しない
			return param;
		}
		
		// サービス契約情報を取得
		ArrayList<HashMap<String, String>> svcKeiList = 
			(ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 20130404 IT1-2013-0000551 Add Start
		if(null == svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO) || "".equals(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO)))
		{
			// 更新処理を実施しない
			return param;
		}
		// 20130404 IT1-2013-0000551 Add End
		
		// 審査一覧照会で取得した結果コードを設定するMap
		HashMap<String, String> judgeMap = getJudgShokaiMap(svcKeiMap, param, handle);
		
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		
		// 順序情報を情報を取得する
		ArrayList<String> junList = getWorkParam(JKKJudgeConstCC.KK_JDG_JUN, param, handle);
		
		// 更新処理を実施する
		executeSvcKeiUpdate(svcKeiMap, 
							getFirstNg(judgeMap, junList), 
							JPCEditString.Rtrim(svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD)), 
							caanUpdateList,
							param,
							handle);
		
// 2013/01/09 IT1-2012-0002379 add start
		// 対象のサービス契約番号を取得
		String svcKeiNo = svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO);
		// 運用年月日を取得
		String unyoYmd = JCCBPCommon.getOpeDate(null);
		// 地図顧客位置ワーク情報マップ
		HashMap<String, Object> mapCustPstWkMap = new HashMap<String, Object>();
		// サービス契約番号を設定
		mapCustPstWkMap.put(SVC_KEI_NO, svcKeiNo);
		// 運用年月日を設定
		mapCustPstWkMap.put(UNYO_YMD, unyoYmd);
		// サービス契約一意照会実行
		HashMap<String, Object> EKK0081A010Hash = executeEKK0081A010(mapCustPstWkMap, param, handle, fixedText);
		
		// 料金グループコード取得
		String prcGrpCd = "";
		if(null != EKK0081A010Hash && null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.PRC_GRP_CD))
		{
			prcGrpCd = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.PRC_GRP_CD);
		}
		// 審査結果コード取得
		String skekkaCd = "";
		if(null != EKK0081A010Hash && null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SKEKKA_CD))
		{
			skekkaCd = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SKEKKA_CD);
		}
		// 「条件２」対象サービスの場合 ＆ 「条件３」審査ＯＫの場合 地図顧客位置ワークを登録（更新）する
		if((JKKJudgeConstCC.EOH_NET_HOME.equals(prcGrpCd) ||		// eo光ネットホーム
			JKKJudgeConstCC.EOH_NET_MAISON.equals(prcGrpCd) ||		// eo光ネットメゾン
			JKKJudgeConstCC.EOH_NET_MANS.equals(prcGrpCd) ||		// eo光ネットマンション
			JKKJudgeConstCC.EOH_TEL.equals(prcGrpCd) ||				// eo光電話
			JKKJudgeConstCC.EOH_TV_KCAT.equals(prcGrpCd) ||			// eo光テレビ
			JKKJudgeConstCC.EOH_TV_KCN.equals(prcGrpCd) ||			// eo光テレビ(KCN)
			JKKJudgeConstCC.EOH_TV_RESENND.equals(prcGrpCd)) &&		// eo光テレビ(再送信) のいずれか かつ
			JKKJudgeConstCC.JUDGE_RSLT_KANUORESO.equals(skekkaCd))	// 審査結果コードが加入御礼書(サービス開始日前)
		{
			// SYSIDを取得
			if(null == EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SYSID))
			{
				return param;
			}
			String sysid = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SYSID);
			// SYSIDを設定
			mapCustPstWkMap.put(SYSID, sysid);
			// 料金グループコードを設定
			mapCustPstWkMap.put(PRC_GRP_CD, prcGrpCd);
			// 料金グループコード名称を設定
			String prcGrpCdNm = "";
			if(null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.PRC_GRP_CD_NM))
			{
				prcGrpCdNm = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.PRC_GRP_CD_NM);
			}
			mapCustPstWkMap.put(PRC_GRP_CD_NM, prcGrpCdNm);
			// サービス開始年月日を設定
			String svcStaYmd = "";
			if(null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SVC_STA_YMD))
			{
				svcStaYmd = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SVC_STA_YMD);
			}
			mapCustPstWkMap.put(SVC_STA_YMD, svcStaYmd);
			// サービス終了年月日を設定
			String svcEndYmd = "";
			if(null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SVC_ENDYMD))
			{
				svcEndYmd = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.SVC_ENDYMD);
			}
			mapCustPstWkMap.put(SVC_END_YMD, svcEndYmd);
			// 申込明細番号を設定
			String mskmDtlNo = "";
			if(null != EKK0081A010Hash.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO))
			{
				mskmDtlNo = (String)EKK0081A010Hash.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO);
			}
			mapCustPstWkMap.put(MSKM_DTL_NO, mskmDtlNo);
			
			// サービス契約回線内訳一覧照会(現在利用中)実行
			HashMap<String, Object> EKK0251B003Hash = executeEKK0251B003(mapCustPstWkMap, param, handle, fixedText);
			String xzahyo = "0";
			String yzahyo = "0";
			String lgtd = "0";
			String lttd = "0";
			if(null != EKK0251B003Hash)
			{
				// X座標を取得
				if(null != EKK0251B003Hash.get(EKK0251B003CBSMsg1List.XZAHYO) &&
						!"".equals(EKK0251B003Hash.get(EKK0251B003CBSMsg1List.XZAHYO)))
				{
					xzahyo = (String)EKK0251B003Hash.get(EKK0251B003CBSMsg1List.XZAHYO);
				}
				// Y座標を取得
				if(null != EKK0251B003Hash.get(EKK0251B003CBSMsg1List.YZAHYO) &&
						!"".equals(EKK0251B003Hash.get(EKK0251B003CBSMsg1List.YZAHYO)))
				{
					yzahyo = (String)EKK0251B003Hash.get(EKK0251B003CBSMsg1List.YZAHYO);
				}
				// 経度を取得
				if(null != EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LGTD) &&
						!"".equals(EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LGTD)))
				{
					lgtd = (String)EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LGTD);
				}
				// 緯度を取得
				if(null != EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LTTD) &&
						!"".equals(EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LTTD)))
				{
					lttd = (String)EKK0251B003Hash.get(EKK0251B003CBSMsg1List.LTTD);
				}
			}
			// X座標を設定
			mapCustPstWkMap.put(XZAHYO, xzahyo);
			// Y座標を設定
			mapCustPstWkMap.put(YZAHYO, yzahyo);
			// 経度を設定
			mapCustPstWkMap.put(LGTD, lgtd);
			// 緯度を設定
			mapCustPstWkMap.put(LTTD, lttd);
			
			// お客様一意照会実行
			HashMap<String, Object> ECK0011A010Hash = executeECK0011A010(mapCustPstWkMap, param, handle, fixedText);
			String custNm = "";
			String custKana = "";
			String keishaTypeCdNm = "";
			String custBirthd = "";
			String custSexCdNm = "";
			String keishaAdCd = "";
			String keishaPcd = "";
			String keishaStateNm = "";
			String keishaCityNm = "";
			String keishaOaztsuNm = "";
			String keishaAzchoNm = "";
			String keishaBnchigo = "";
			String keishaAdrttm = "";
			String keishaAdrrm = "";
			if(null != ECK0011A010Hash)
			{
				// お客様名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_NM))
				{
					custNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_NM);
				}
				// お客様カナ名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_KANA))
				{
					custKana = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_KANA);
				}
				// 契約者タイプコード名称を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM))
				{
					keishaTypeCdNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM);
				}
				// お客様生年月日を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_BIRTHD))
				{
					custBirthd = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_BIRTHD);
				}
				// お客様性別コード名称を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_SEX_CD_NM))
				{
					custSexCdNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.CUST_SEX_CD_NM);
				}
				// 契約者住所コードを取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_AD_CD))
				{
					keishaAdCd = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_AD_CD);
				}
				// 契約者郵便番号を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_PCD))
				{
					keishaPcd = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_PCD);
				}
				// 契約者都道府県名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_STATE_NM))
				{
					keishaStateNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_STATE_NM);
				}
				// 契約者市区町村名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_CITY_NM))
				{
					keishaCityNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_CITY_NM);
				}
				// 契約者大字通称名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_OAZTSU_NM))
				{
					keishaOaztsuNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_OAZTSU_NM);
				}
				// 契約者字丁目名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_AZCHO_NM))
				{
					keishaAzchoNm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_AZCHO_NM);
				}
				// 契約者番地号を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_BNCHIGO))
				{
					keishaBnchigo = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_BNCHIGO);
				}
				// 契約者住所補記・建物名を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_ADRTTM))
				{
					keishaAdrttm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_ADRTTM);
				}
				// 契約者住所補記・部屋番号を取得
				if(null != ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_ADRRM))
				{
					keishaAdrrm = (String)ECK0011A010Hash.get(ECK0011A010CBSMsg1List.KEISHA_ADRRM);
				}
			}
			// お客様名を設定
			mapCustPstWkMap.put(CUST_NM, custNm);
			// お客様カナ名を設定
			mapCustPstWkMap.put(CUST_KANA, custKana);
			// 契約者タイプコード名称を設定
			mapCustPstWkMap.put(KEISHA_TYPE_CD_NM, keishaTypeCdNm);
			// お客様生年月日を設定
			mapCustPstWkMap.put(CUST_BIRTHD, custBirthd);
			// お客様性別コード名称を設定
			mapCustPstWkMap.put(CUST_SEX_CD_NM, custSexCdNm);
			// 契約者住所コードを設定
			mapCustPstWkMap.put(KEISHA_AD_CD, keishaAdCd);
			// 契約者郵便番号を設定
			mapCustPstWkMap.put(KEISHA_PCD, keishaPcd);
			// 契約者都道府県名を設定
			mapCustPstWkMap.put(KEISHA_STATE_NM, keishaStateNm);
			// 契約者市区町村名を設定
			mapCustPstWkMap.put(KEISHA_CITY_NM, keishaCityNm);
			// 契約者大字通称名を設定
			mapCustPstWkMap.put(KEISHA_OAZTSU_NM, keishaOaztsuNm);
			// 契約者字丁目名を設定
			mapCustPstWkMap.put(KEISHA_AZCHO_NM, keishaAzchoNm);
			// 契約者番地号を設定
			mapCustPstWkMap.put(KEISHA_BNCHIGO, keishaBnchigo);
			// 契約者住所補記・建物名を設定
			mapCustPstWkMap.put(KEISHA_ADRTTM, keishaAdrttm);
			// 契約者住所補記・部屋番号を設定
			mapCustPstWkMap.put(KEISHA_ADRRM, keishaAdrrm);
			
			// 連絡先一覧照会(連絡先種別コード＝"1":自宅で)実行
			String rrksSbtCd = "1";
			mapCustPstWkMap.put(RRKS_SBT_CD, rrksSbtCd);
			HashMap<String, Object> ECK0201B001Hash1 = executeECK0201B001(mapCustPstWkMap, param, handle, fixedText);
			String homeTelno = "";
			String mlad = "";
			if(null != ECK0201B001Hash1)
			{
				// 自宅電話番号を取得
				if(null != ECK0201B001Hash1.get(ECK0201B001CBSMsg1List.TELNO))
				{
					homeTelno = (String)ECK0201B001Hash1.get(ECK0201B001CBSMsg1List.TELNO);
				}
				// メールアドレスを取得
				if(null != ECK0201B001Hash1.get(ECK0201B001CBSMsg1List.MLAD) &&
						!"".equals(ECK0201B001Hash1.get(ECK0201B001CBSMsg1List.MLAD)))
				{
					mlad = (String)ECK0201B001Hash1.get(ECK0201B001CBSMsg1List.MLAD);
				}
			}
			// 自宅電話番号を設定
			mapCustPstWkMap.put(HOME_TELNO, homeTelno);
			// 連絡先一覧照会(連絡先種別コード＝"2":携帯で)実行
			rrksSbtCd = "2";
			mapCustPstWkMap.put(RRKS_SBT_CD, rrksSbtCd);
			HashMap<String, Object> ECK0201B001Hash2 = executeECK0201B001(mapCustPstWkMap, param, handle, fixedText);
			String ktaiTelno = "";
			if(null != ECK0201B001Hash2)
			{
				// 携帯電話番号を取得
				if(null != ECK0201B001Hash2.get(ECK0201B001CBSMsg1List.TELNO))
				{
					ktaiTelno = (String)ECK0201B001Hash2.get(ECK0201B001CBSMsg1List.TELNO);
				}
				// メールアドレスを取得
				if(null != ECK0201B001Hash2.get(ECK0201B001CBSMsg1List.MLAD) &&
						!"".equals(ECK0201B001Hash2.get(ECK0201B001CBSMsg1List.MLAD)))
				{
					mlad = (String)ECK0201B001Hash2.get(ECK0201B001CBSMsg1List.MLAD);
				}
			}
			// 携帯電話番号を設定
			mapCustPstWkMap.put(KTAI_TELNO, ktaiTelno);
			// 連絡先一覧照会(連絡先種別コード＝"3":勤務先で)実行
			rrksSbtCd = "3";
			mapCustPstWkMap.put(RRKS_SBT_CD, rrksSbtCd);
			HashMap<String, Object> ECK0201B001Hash3 = executeECK0201B001(mapCustPstWkMap, param, handle, fixedText);
			String compTelno = "";
			if(null != ECK0201B001Hash3)
			{
				// 会社電話番号を取得
				if(null != ECK0201B001Hash3.get(ECK0201B001CBSMsg1List.TELNO))
				{
					compTelno = (String)ECK0201B001Hash3.get(ECK0201B001CBSMsg1List.TELNO);
				}
				// メールアドレスを取得
				if(null != ECK0201B001Hash3.get(ECK0201B001CBSMsg1List.MLAD) &&
						!"".equals(ECK0201B001Hash3.get(ECK0201B001CBSMsg1List.MLAD)))
				{
					mlad = (String)ECK0201B001Hash3.get(ECK0201B001CBSMsg1List.MLAD);
				}
			}
			// 会社電話番号を設定
			mapCustPstWkMap.put(COMP_TELNO, compTelno);
			// メールアドレスを設定
			mapCustPstWkMap.put(MLAD, mlad);
			
			// お客様<法人>一意照会実行
			HashMap<String, Object> ECK0031A010Hash = executeECK0031A010(mapCustPstWkMap, param, handle, fixedText);
			String gshuCdNm = "";
			String compNm = "";
			String dihyshaPostNm = "";
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD START
			String dihyshaNm = "";
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD END
			if(null != ECK0031A010Hash)
			{
				// 業種コード名称を取得
				if(null != ECK0031A010Hash.get(ECK0031A010CBSMsg1List.GSHU_CD_NM))
				{
					gshuCdNm = (String)ECK0031A010Hash.get(ECK0031A010CBSMsg1List.GSHU_CD_NM);
				}
				// 会社名を設定を取得
				if(null != ECK0031A010Hash.get(ECK0031A010CBSMsg1List.COMP_NM))
				{
					compNm = (String)ECK0031A010Hash.get(ECK0031A010CBSMsg1List.COMP_NM);
				}
				// 代表者役職名を取得
				if(null != ECK0031A010Hash.get(ECK0031A010CBSMsg1List.DIHYSHA_POST_NM))
				{
					dihyshaPostNm = (String)ECK0031A010Hash.get(ECK0031A010CBSMsg1List.DIHYSHA_POST_NM);
				}
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD START
				// 代表者名を取得
				if(null != ECK0031A010Hash.get(ECK0031A010CBSMsg1List.DIHYSHA_NM))
				{
					dihyshaNm = (String)ECK0031A010Hash.get(ECK0031A010CBSMsg1List.DIHYSHA_NM);
				}
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD END
			}
			// 業種コード名称を設定
			mapCustPstWkMap.put(GSHU_CD_NM, gshuCdNm);
			// 会社名を設定を設定
			mapCustPstWkMap.put(COMP_NM, compNm);
			// 代表者役職名を設定
			mapCustPstWkMap.put(DIHYSHA_POST_NM, dihyshaPostNm);
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD START
			// 代表者名を設定
			mapCustPstWkMap.put(DIHYSHA_NM, dihyshaNm);
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD END
			
			String mskmNo = "";
			if(null != mskmDtlNo && !"".equals(mskmDtlNo))
			{
				// 申込明細一意照会実行
				HashMap<String, Object> EKK0021A010Hash = executeEKK0021A010(mapCustPstWkMap, param, handle, fixedText);
				String mskmYmd = "";
				String mskmshoNo = "";
				if(null != EKK0021A010Hash)
				{
					// 申込年月日を取得
					if(null != EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKM_YMD))
					{
						mskmYmd = (String)EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKM_YMD);
					}
					// 申込書番号を取得
					if(null != EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKMSHO_NO))
					{
						mskmshoNo = (String)EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKMSHO_NO);
					}
					// 申込番号を取得
					if(null != EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKM_NO))
					{
						mskmNo = (String)EKK0021A010Hash.get(EKK0021A010CBSMsg1List.MSKM_NO);
					}
				}
				// 申込年月日を設定
				mapCustPstWkMap.put(MSKM_YMD, mskmYmd);
				// 申込書番号を設定
				mapCustPstWkMap.put(MSKMSHO_NO, mskmshoNo);
				// 申込番号を設定
				mapCustPstWkMap.put(MSKM_NO, mskmNo);
			}
			
			if(null != mskmNo && !"".equals(mskmNo))
			{
				// 申込一意照会実行
				HashMap<String, Object> EKK0011A010Hash = executeEKK0011A010(mapCustPstWkMap, param, handle, fixedText);
				String mskmUkYmd = "";
				if(null != EKK0011A010Hash)
				{
					// 申込受付年月日を取得
					if(null != EKK0011A010Hash.get(EKK0011A010CBSMsg1List.MSKM_UK_DTM))
					{
						mskmUkYmd = (String)EKK0011A010Hash.get(EKK0011A010CBSMsg1List.MSKM_UK_DTM);
						if(8 < mskmUkYmd.length())
						{
							mskmUkYmd = mskmUkYmd.substring(0, 8);
						}
					}
				}
				// 申込受付年月日を設定
				mapCustPstWkMap.put(MSKM_UK_YMD, mskmUkYmd);
			}
			
			// 現在工程コードを設定
			String now_step_cd = "122";
			mapCustPstWkMap.put(NOW_STEP_CD, now_step_cd);
			// 現在工程名を設定
			String now_step_cd_nm = "審査終了（ＯＫ）";
			mapCustPstWkMap.put(NOW_STEP_CD_NM, now_step_cd_nm);
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 DEL START
			// 代表者名を設定
//			mapCustPstWkMap.put(DIHYSHA_NM, "");
// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 DEL END
			
			// 地図顧客位置ワーク一意照会実行
			HashMap<String, Object> EKK2691A010Hash = executeEKK2691A010(mapCustPstWkMap, param, handle, fixedText);
			// 「条件１」地図顧客位置ワークに登録されている場合 ⇒ 更新
			if(null != EKK2691A010Hash &&
					null != EKK2691A010Hash.get(EKK2691A010CBSMsg1List.UPD_DTM) &&
					!"".equals(EKK2691A010Hash.get(EKK2691A010CBSMsg1List.UPD_DTM)))
			{
				// 更新年月日時分秒を設定
				String updDtm = (String)EKK2691A010Hash.get(EKK2691A010CBSMsg1List.UPD_DTM);
				mapCustPstWkMap.put(UPD_DTM_BF, updDtm);
				// 地図顧客位置ワーク変更実行
				executeEKK2691C010(mapCustPstWkMap, param, handle, fixedText);
			}
			// 「条件１」地図顧客位置ワークに登録されていない場合 ⇒ 登録
			else
			{
				// 地図顧客位置ワーク登録実行
				executeEKK2691D010(mapCustPstWkMap, param, handle, fixedText);
			}
		}
// 2013/01/09 IT1-2012-0002379 add end
		
		// 結果を返却する
		return param;
	}
	
	
	/**
	 * 審査一覧照会を実施し、結果を取得する
	 * @param svcKeiMap サービス契約情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル 
	 * @return 審査情報マップ
	 * @throws Throwable 
	 */
	private HashMap<String, String> getJudgShokaiMap(
			HashMap<String, String> svcKeiMap, IRequestParameterReadWrite param, 
			SessionHandle handle)  throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 審査一覧照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK1071B011CBSMsg.class.getName(), "EKK1071B011", "1", param);
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071B011CBSMsg.KEY_SVC_KEI_NO, judgeTemp);
		//  審査番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_NO, judgeTemp);
		//  審査種別コード
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_SBT_CD, judgeTemp);
		//  審査対象種別コード
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_TG_SBT_CD, judgeTemp);
		//  機器提供サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_KKTK_SVC_KEI_NO, judgeTemp);
		//  申込番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_MSKM_DTL_NO, judgeTemp);
		//  オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_OP_SVC_KEI_NO, judgeTemp);
		//  サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SBOP_SVC_KEI_NO, judgeTemp);
		//  請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SEIOPSVC_KEI_NO, judgeTemp);
		//  サービス契約内訳番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SVC_KEI_UCWK_NO, judgeTemp);
		//  SYSID
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SYSID, judgeTemp);
		//  割引サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_WRIB_SVC_KEI_NO, judgeTemp);
		
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071B011(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		
		// 審査一覧照会で取得した結果コードを設定するMap
		HashMap<String, String> judgeMap = new HashMap<String, String>();
		
		CAANMsg judgeRsltTemp = rsltCaanList.get(0);
		CAANMsg[] judgeRsltList = judgeRsltTemp.getCAANMsgList(EKK1071B011CBSMsg.EKK1071B011CBSMSG1LIST);
		if(judgeRsltList != null)
		{
			for(CAANMsg judgeInTemp : judgeRsltList)
			{
				// 審査種別コードを取得
				String judgeSbtCd = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_SBT_CD);
				// 結果コードを取得
				String rsltCd = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_JUDGE_RSLT_CD);
				judgeMap.put(judgeSbtCd, rsltCd);
			}
		}
		
		return judgeMap;
	}
	
	/**
	 * 業務パラメータより業務設定値を取得し、制御リストを取得する処理
	 * @param workParamId 業務パラメータID
	 * @param param リクエストパラメータ 
	 * @param handle セッションハンドル
	 * @return 制御リスト
	 * @throws Throwable 
	 */
	private ArrayList<String> getWorkParam(
			String workParamId, IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 業務パラメータ一覧照会サービスIF */
		CAANMsg workParamTemp = editInMsg(EZM0321A010CBSMsg.class.getName(), "EZM0321A010", "1", param);
		// 業務パラメータID → 業務パラメータID
		setSvcIFMapping(workParamId, EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, workParamTemp);
		caanList.add(workParamTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEZM0321A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 取得した業務パラメータより取得した制御リストを設定する変数
		ArrayList<String> ctrlList = new ArrayList<String>();
		
		CAANMsg workParamRsltTemp = rsltCaanList.get(0);
		CAANMsg[] workParamRsltList = workParamRsltTemp.getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
		if(workParamRsltList != null)
		{
			// 業務パラメータ設定値を取得
			String paramValue = workParamRsltList[0].getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
			// 業務パラメータ設定値より制御リストを取得
			ctrlList = getCtrlList(paramValue);
		}
		
		return ctrlList;
	}
	
	/**
	 * 識別文字列から実施するチェックの審査種別コードを格納したリストを返却する
	 * @param paramValue 業務パラメータ設定値
	 * @return 実施チェックが格納されたリスト
	 */
	private static ArrayList<String> getCtrlList(String paramValue)
	{
		String[] values = paramValue.split(",");
		ArrayList<String> ctrlList = new ArrayList<String>();
		for(int cnt = 0; cnt < values.length; cnt++)
		{
			ctrlList.add(values[cnt]);
		}
		
		return ctrlList;
	}
	
	/**
	 * 初めにNGとなった審査種別を取得する
	 * 
	 * @param judgeMap 審査情報マップ 
	 * @param chkJunList 順序情報リスト
	 * @return サービスコード
	 * @throws Throwable 
	 */
	private String getFirstNg(HashMap<String, String> judgeMap, ArrayList<String> chkJunList)  throws Throwable
	{
		String firstNg = "";
		
		// チェック順に更新処理を実施する
		for(String chkRsltKey : chkJunList)
		{
			String judgeRslt = judgeMap.get(chkRsltKey);
			// 審査結果がチェックNGの場合
			if(JKKJudgeConstCC.RSLT_NG.equals(judgeRslt))
			{
				firstNg = chkRsltKey;
				break;
			}
		}
		
		return firstNg;
	}
	
	/**
	 * サービス契約の更新を実施する
	 * @param svcKeiMap サービス契約マップ
	 * @param firstNgRsltKey 初めにNGとなったチェックの審査結果取得キー
	 * @param prcGrpCd 料金グループコード
	 * @param caanUpdateList CAANMsgクラスリスト
	 * @param param リクエストパラメータ 
	 * @param handle セッションハンドル
	 * @throws Throwable
	 */
	private void executeSvcKeiUpdate(
			HashMap<String, String> svcKeiMap, String firstNgRslt, 
			String prcGrpCd, ArrayList<CAANMsg> caanUpdateList,
			IRequestParameterReadWrite param, SessionHandle handle)  throws Throwable
	{
		// サービス契約番号を取得
		String svcKeiNo = svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO);
		// サービスコードを取得
		String svcCd = svcKeiMap.get(KK0081ETMsg.SVC_CD);
		// 料金グループコードを取得
		String prgGrpCd = svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD);
		
		/* サービス契約一意照会 */
		CAANMsg svcKeiInfo = editInMsg(EKK0081A010CBSMsg.class.getName(), "EKK0081A010", "2", param);
		
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiNo, EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiInfo);
		// サービス契約マップ.世代登録年月日 → 世代登録年月日
		setSvcIFMapping(null, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiInfo);
		// サービス契約マップ.予約適用年月日 → 予約適用年月日
		setSvcIFMapping("20991231", EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, svcKeiInfo);
		
		caanUpdateList.add(svcKeiInfo);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanUpdateList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0081A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg svcKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] svcKeiRsltList = svcKeiRsltTemp.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		CAANMsg svcKeiInTemp = null;
		
		// サービス契約情報が取得できた場合
		if(svcKeiRsltList.length > 0) 
		{
			svcKeiInTemp = svcKeiRsltList[0];
		// 取得できない場合は更新を行わない
		}
		else
		{
			return;
		}
		
		
		// 更新を行う審査結果コードを設定する変数
		String skekkaCd = "";
		// 更新を行う異動NG状態コードを設定する変数
		String idoNgStatCd = "";
		
		// 全てのチェックでチェックOKの場合
		if("".equals(firstNgRslt))
		{
			// 審査結果コードに加入御礼書(サービス開始日前)を設定
			skekkaCd = JKKJudgeConstCC.JUDGE_RSLT_KANUORESO;
			// 異動NG状態コードに半角空白を設定
			idoNgStatCd = null;
		}
		// チェックNGとなるチェックが存在した場合
		else
		{
			// 審査種別コードを取得する
			skekkaCd = getJdgRslt(firstNgRslt, prcGrpCd);
			// 異動NG状態コードを取得する
			idoNgStatCd = getIdoNgStatCd(firstNgRslt);
		}
		
		// 審査結果引継フラグを取得
		// 設定値が「1」であれば、審査結果コードは更新しないため、
		// サービス契約.審査結果コードを取得する
		String isTransJdgRsltFlg = (String)param.getData(JKKJudgeConstCC.IS_TRANSFER_JUDGE_RESULT);
		if (null != isTransJdgRsltFlg && JKKJudgeConstCC.TRANSFER_JUDGE_RESULT_KBN.equals(isTransJdgRsltFlg))
		{
			skekkaCd = svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_CD);
		}
		
		// サービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		/* サービス契約更新サービスIF */
		// サービスコードが光電話の場合
		if(JKKJudgeConstCC.TEL_SVC.equals(svcCd))
		{
			// サービス契約<eo光電話>一意照会を実施し、情報を取得
			CAANMsg eoTelInfo = getEoTelInfo(param, handle, svcKeiNo);
			// サービス契約<eo光電話>情報変更SIFの設定項目を設定
			setEoTel(svcKeiMap, caanList, param, svcKeiNo, skekkaCd, idoNgStatCd, svcKeiInTemp, eoTelInfo, handle);
		}
		// サービスコードが光テレビの場合
		else if(JKKJudgeConstCC.TV_SVC.equals(svcCd))
		{
			// サービス契約<eo光テレビ>一意照会を実施し、情報を取得
			CAANMsg eoTVInfo = getEoTVInfo(param, handle, svcKeiNo);
			// サービス契約<eo光テレビ>情報変更SIFの設定項目を設定
			setEoTV(svcKeiMap, caanList, param, svcKeiNo, skekkaCd, idoNgStatCd, svcKeiInTemp, eoTVInfo, handle);
		}
		// サービスコードが光ネットの場合
		else if(JKKJudgeConstCC.IN_SVC.equals(svcCd))
		{
			// 料金グループコードがeoADSL(eAccess)または、eoADSL(フレッツ)の場合
			if(JKKJudgeConstCC.EOH_ADSL_EACCESS.equals(prgGrpCd) ||
				JKKJudgeConstCC.EOH_ADSL_FU.equals(prgGrpCd))
			{
				// サービス契約<eoADSL>一意照会を実施し、情報を取得
				CAANMsg eoAdslInfo = getEoAdslInfo(param, handle, svcKeiNo);
				// サービス契約<eoADSL>情報変更SIFの設定項目を設定
				setEoAdsl(svcKeiMap, caanList, param, svcKeiNo, skekkaCd, idoNgStatCd, svcKeiInTemp, eoAdslInfo, handle);
			}
			// 料金グループコードがeoモバイル(WiFi)または、eoモバイル(EM)または、eoモバイル(UQ-WiMAX)の場合
			else if(JKKJudgeConstCC.EOH_MBL_WIFI.equals(prgGrpCd) ||
					JKKJudgeConstCC.EOH_MBL_EM.equals(prgGrpCd) ||
					JKKJudgeConstCC.EOH_MBL_UQWIMAX.equals(prgGrpCd)||
					JKKJudgeConstCC.EOH_MBL_MAILADDRESS.equals(prgGrpCd))
			{
				// サービス契約<eoモバイル>一意照会を実施し、情報を取得
				CAANMsg eoMobaInfo = getEoMobaInfo(param, handle, svcKeiNo);
				// サービス契約<eoモバイル>情報変更SIFの設定項目を設定
				setEoMoba(svcKeiMap, caanList, param, svcKeiNo, skekkaCd, idoNgStatCd, svcKeiInTemp, eoMobaInfo, handle);
			}
			else
			{
				// サービス契約<eo光ネット>一意照会を実施し、情報を取得
				CAANMsg eoNetInfo = getEoNetInfo(param, handle, svcKeiNo);
				// サービス契約<eo光ネット>情報変更SIFの設定項目を設定
				setEoNet(svcKeiMap, caanList, param, svcKeiNo, skekkaCd, idoNgStatCd, svcKeiInTemp, eoNetInfo, handle);
			}
		}
	}
	
	/**
	 * マッピングする際に行う共通の判定を行い、項目を設定する。
	 * @param jdgSbtCd 審査種別コード
	 * @param prcGrpCd 料金グループコード
	 * @throws Throwable
	 * @return jdgRslt 審査結果コード
	 */
	private String getJdgRslt(String jdgSbtCd, String prcGrpCd) throws Throwable
	{
		String jdgRslt = "";
		
		// 更新を実施するチェック内容がエリアチェックまたは不良顧客チェックの場合
		if(JKKJudgeConstCC.JUDGE_SBT_AREA.equals(jdgSbtCd))
		{
			// 料金グループコードがeo光ネットホームタイプまたはeo光ネットメゾンタイプの場合
			if(isNetHomeOrMaison(prcGrpCd))
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_SVC_AREA_OUT_31;
			}
			// 料金グループコードがeo光テレビ(K-CAT)またはeo光テレビ(KCN)またはeo光テレビ(再送信)の場合
			else if(isTv(prcGrpCd))
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_SVC_AREA_OUT_91;
			}
			// 料金グループコードが上記以外の場合
			else
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_SVC_AREA_OUT_31;
			}
		}
		// 更新を実施するチェック内容がエリアチェックまたは不良顧客チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST.equals(jdgSbtCd))
		{
			// 料金グループコードがeo光ネットホームタイプまたはeo光ネットメゾンタイプの場合
			if(isNetHomeOrMaison(prcGrpCd))
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_KEI_KTWR_33;
			}
			// 料金グループコードがeo光テレビ(K-CAT)またはeo光テレビ(KCN)またはeo光テレビ(再送信)の場合
			else if(isTv(prcGrpCd))
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_KEI_KTWR_93;
			}
			// 料金グループコードが上記以外の場合
			else
			{
				jdgRslt = JKKJudgeConstCC.JUDGE_RSLT_KEI_KTWR_33;
			}
		}
		// 更新を実施するチェック内容が上記以外の場合
		else
		{
			jdgRslt = null;
		}
		
		
		return jdgRslt;
	}
	
	/**
	 * マッピングする際に行う共通の判定を行い、項目を設定する。
	 * @param prcGrpCd 料金グループコード
	 * @return 判定結果
	 * @throws Throwable
	 */
	private boolean isNetHomeOrMaison(String prcGrpCd) throws Throwable
	{
		boolean rslt = false;
		
		// 料金グループコードがeo光ネットホームタイプまたはeo光ネットメゾンタイプの場合
		if(JKKJudgeConstCC.EOH_NET_HOME.equals(prcGrpCd) || JKKJudgeConstCC.EOH_NET_MAISON.equals(prcGrpCd))
		{
			rslt = true;
		}
		
		return rslt;
	}
	
	/**
	 * 料金グループがテレビの場合trueを返却する。
	 * @param prcGrpCd 料金グループコード
	 * @return 判定結果
	 * @throws Throwable
	 */
	private boolean isTv(String prcGrpCd) throws Throwable
	{
		boolean rslt = false;
		
		// 料金グループがeo光テレビ(K-CAT)、eo光テレビ(KCN)、eo光テレビ(再送信)の場合
		if(JKKJudgeConstCC.EOH_TV_KCAT.equals(prcGrpCd) || 
			JKKJudgeConstCC.EOH_TV_KCN.equals(prcGrpCd) || 
			JKKJudgeConstCC.EOH_TV_RESENND.equals(prcGrpCd))
		{
			rslt = true;
		}
		
		return rslt;
	}
	
	/**
	 * 審査種別により異動NG状態コードを取得する
	 * @param jdgSbtCd 審査種別コード
	 * @return 異動NG状態コード
	 * @throws Throwable
	 */
	private String getIdoNgStatCd(String jdgSbtCd) throws Throwable
	{
		String idoNgStatCd = "";
		
		// 審査種別が住所不備の場合
		if(isAdHbi(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_AD_ERR;
		}
		// 審査種別が記載不備の場合
		else if(isKsHbi(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_KS_HBI;
		}
		// 審査種別がエリアチェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AREA.equals(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_AREA;
		}
		// 審査種別が不良顧客チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST.equals(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_HURYO;
		}
		// 審査種別が番ポエリアチェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_BMP_AREA.equals(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_BMP_AREA;
		}
		// 審査種別が支払方法チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_PAY_WAY.equals(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_PAY_WAY;
		}
		// 審査種別が多重登録チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_TAJU_ADD.equals(jdgSbtCd))
		{
			idoNgStatCd = JKKJudgeConstCC.IDO_NG_TAJU_ADD;
		}
		
		
		return idoNgStatCd;
	}
	
	/**
	 * 住所不備チェックの場合trueを返却する
	 * @param jdgSbtCd 審査種別コード
	 * @return 判定結果
	 * @throws Throwable
	 */
	private boolean isAdHbi(String jdgSbtCd) throws Throwable
	{
		boolean rlst = false;
		
		// 審査種別が住所不備チェック（サービス契約情報）の場合
		if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		// 審査種別が住所不備チェック（お客様情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST.equals(jdgSbtCd))
		{
			rlst = true;
		}
		// 審査種別が住所不備チェック（請求契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		// 審査種別が住所不備チェック（機器サービス契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		// 審査種別が住所不備チェック（電話番号情報）の場合
		else if (JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO.equals(jdgSbtCd))
		{
			rlst = true;
		}
		
		return rlst;
	}
	
	/**
	 * 記載不備チェックの場合trueを返却する
	 * @param jdgSbtCd 審査種別コード
	 * @return 判定結果
	 * @throws Throwable
	 */
	private boolean isKsHbi(String jdgSbtCd) throws Throwable
	{
		boolean rlst = false;
		
		if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST.equals(jdgSbtCd))
		{
			rlst = true;
		}
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI.equals(jdgSbtCd))
		{
			rlst = true;
		}
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO.equals(jdgSbtCd))
		{
			rlst = true;
		}
		
		return rlst;
	}
	
	/**
	 * マッピングする際に行う共通の判定を行い、項目を設定する。
	 * @param setValue 設定項目値
	 * @param key マッピングキー
	 * @param template CAANMsgクラス
	 * @throws Throwable
	 */
	private void setSvcIFMapping(String setValue, String key, CAANMsg template) throws Throwable
	{
		// 設定項目値が空文字またはnullの場合
		if ("".equals(setValue) || setValue == null)
		{
			template.setNull(key);
		// 設定値がある場合
		}
		else
		{
			template.set(key, setValue);
		}
	}
	
	/**
	 * 共通の設定項目を設定する
	 * @param schemaClassNm スキーマクラス名
	 * @param templateID テンプレートID
	 * @param funcCd 機能ID
	 * @param param リクエストパラメータ 
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg editInMsg(String schemaClassNm, String templateID, String funcCd,
								IRequestParameterReadWrite param) throws Throwable
	{
		CAANMsg template = new CAANMsg(schemaClassNm);
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, templateID);
		
		// 機能コード
		template.set(JCMConstants.FUNC_CODE_KEY, funcCd);
		
		// オペレータ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);
		
		return template;
	}
	
	/**
	 * サービスIFを呼び出し、その結果を取得する。
	 * @param caanList サービスIFリスト
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return templateList 結果が格納されたリスト
	 * @throws Throwable 
	 */
	private Map<?, ?> executeSvcIF(ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		CAANMsg[] caan = new CAANMsg[caanList.size()];
		int count = 0;
		for(CAANMsg template : caanList)
		{
			caan[count++] = template;
		}
		
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文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));
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, caan);
		
		// SC呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		return scCall.run(paramMap, handle);
	}
	
	/**
	 * サービスIFの結果を取得する。
	 * @param rsltMap サービスIFリスト
	 * @return templateList 結果が格納されたリスト
	 * @throws Throwable 
	 */
	private ArrayList<CAANMsg> getRsltList(Map<?, ?> rsltMap) throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		ArrayList<CAANMsg> rsltCaanList = new ArrayList<CAANMsg>();
		for(int i = 0; i < templates.length; i++)
		{
			rsltCaanList.add(templates[i]);
		}
		
		return rsltCaanList;
	}
	
	/**
	 * 単項目のエラーマッピング.
	 * <br>
	 * @param  template  テンプレート情報
	 * @param  dataMap   マップ情報
	 * @param  targetNm  マッピング対象項目
	 */
	@SuppressWarnings("unchecked")
	private void errMapping(CAANMsg template, HashMap dataMap, String targetNm)
	{
		if ((!template.isNull(targetNm)) && (!dataMap.containsKey(targetNm)))
		{
			dataMap.put(targetNm, template.getString(targetNm));
		}
	}
	
	/**
	 * サービスコンポーネント実行結果確認.
	 * <br>
	 * @param param
	 * @param resultMap
	 * @throws  Throwable  例外が発生した場合
	 */
	private void scResultCheck(IRequestParameterReadWrite param, Map<?, ?> resultMap) throws Throwable
	{
		int rtnCode = Integer.parseInt(param.getControlMapData(SCControlMapKeys.RETURN_CODE).toString());
//		CAANMsg[] templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// サービスコンポーネントの実行結果に単項目以上のエラーがある場合、例外とする
		if (rtnCode >= JPCModelConstant.SINGLEDATA_ERR)
		{
			throw new CCException("", new Exception());
		}
	}
	
	/**
	 * サービス契約＜eo光電話＞情報変更の設定する
	 * @param param スキーマクラス名
	 * @param handle セッションハンドル
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg getEoTelInfo(IRequestParameterReadWrite param, SessionHandle handle, String svcKeiNo) throws Throwable
	{
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		//サービスコードが光ネットの場合：EKK0111A010_サービス契約＜eo光ネット＞一意照会
		CAANMsg svcKeiTemp = editInMsg(EKK0111A010CBSMsg.class.getName(), "EKK0111A010", "2", param);
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0111A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日を設定
		setSvcIFMapping(null, EKK0111A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		
		caanList.add(svcKeiTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0111A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg eoNetRsltTemp = rsltCaanList.get(0);
		CAANMsg[] eoTelList = eoNetRsltTemp.getCAANMsgList(EKK0111A010CBSMsg.EKK0111A010CBSMSG1LIST);
		if(eoTelList == null)
		{
			return null;
		}
		else
		{
			return eoTelList[0];
		}
	}
	
	/**
	 * サービス契約＜eo光電話＞情報変更の設定する
	 * @param svcKeiMap サービス契約情報(入力)
	 * @param caanList CAANMsgクラスリスト
	 * @param param スキーマクラス名
	 * @param svcKeiNo サービス契約番号
	 * @param skekkaCd 審査結果コード
	 * @param idoNgStatCd 異動NG状態コード
	 * @param svcKeiInTemp サービス契約情報(DB)
	 * @param eoTelInfo サービス契約＜eo光電話＞情報(DB)
	 * @param handle ハンドル情報
	 * @throws Throwable 
	 */
	private void setEoTel(
			HashMap<String, String> svcKeiMap, ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, String svcKeiNo,
			String skekkaCd, String idoNgStatCd, CAANMsg svcKeiInTemp, 
			CAANMsg eoTelInfo, SessionHandle handle) throws Throwable
	{
		
		//サービスコードが光電話の場合：EKK0111C040_サービス契約＜eo光電話＞情報変更
		CAANMsg svcKeiUpdTemp = editInMsg(EKK0111C040CBSMsg.class.getName(), "EKK0111C040", "1", param);
		
		
		//サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0111C040CBSMsg.SVC_KEI_NO, svcKeiUpdTemp);
		// 申込明細番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO), EKK0111C040CBSMsg.MSKM_DTL_NO, svcKeiUpdTemp);
		// 整理番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SEIRI_NO), EKK0111C040CBSMsg.SEIRI_NO, svcKeiUpdTemp);
		// 面開発案件番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MENKAIHAT_ANKEN_NO), EKK0111C040CBSMsg.MENKAIHAT_ANKEN_NO, svcKeiUpdTemp);
		// 提供方式契約番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.TK_HOSHIKI_KEI_NO), EKK0111C040CBSMsg.TK_HOSHIKI_KEI_NO, svcKeiUpdTemp);
		// ID速報書出力要否を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.ID_SOKHOSHO_OUTPUT_YH), EKK0111C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH, svcKeiUpdTemp);
		// 審査結果詳細コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_DTL_CD), EKK0111C040CBSMsg.SKEKKA_DTL_CD, svcKeiUpdTemp);
		// 審査結果補記コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_HOKI_CD), EKK0111C040CBSMsg.SKEKKA_HOKI_CD, svcKeiUpdTemp);
		// 審査結果送信コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_SEND_CD), EKK0111C040CBSMsg.SKEKKA_SEND_CD, svcKeiUpdTemp);
		// 支払い方法継続フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PAYWAY_KEIZOKU_FLG), EKK0111C040CBSMsg.PAYWAY_KEIZOKU_FLG, svcKeiUpdTemp);
		// 試用加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_KANYU_YMD), EKK0111C040CBSMsg.FTRIAL_KANYU_YMD, svcKeiUpdTemp);
		// 試用期間終了年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_PRD_ENDYMD), EKK0111C040CBSMsg.FTRIAL_PRD_ENDYMD, svcKeiUpdTemp);
		// 本加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_YMD), EKK0111C040CBSMsg.HONKANYU_YMD, svcKeiUpdTemp);
		// 本加入移行期限年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD), EKK0111C040CBSMsg.HONKANYU_IKO_KIGEN_YMD, svcKeiUpdTemp);
		// レター発送仕分区分を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.LETTER_HASSO_SHIWAKE_DIV), EKK0111C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV, svcKeiUpdTemp);
		// サンキューレター送付先コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.THNX_LETTER_SHS_CD), EKK0111C040CBSMsg.THNX_LETTER_SHS_CD, svcKeiUpdTemp);
		// WEBオプション追加不可フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WEB_OP_ADD_FAIL_FLG), EKK0111C040CBSMsg.WEB_OP_ADD_FAIL_FLG, svcKeiUpdTemp);
		// 違約金発生コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PNLTY_HASSEI_CD), EKK0111C040CBSMsg.PNLTY_HASSEI_CD, svcKeiUpdTemp);
		// 異動区分を設定
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK0111C040CBSMsg.IDO_DIV, svcKeiUpdTemp);
		// 紹介コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.INTR_CD), EKK0111C040CBSMsg.INTR_CD, svcKeiUpdTemp);
		// 業務連絡備考を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WORK_RRK_BIKO), EKK0111C040CBSMsg.WORK_RRK_BIKO, svcKeiUpdTemp);
		// 自動照査処理状態コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.AUTO_SHOSA_TRAN_STAT_CD), EKK0111C040CBSMsg.AUTO_SHOSA_TRAN_STAT_CD, svcKeiUpdTemp);
		// サービス利用開始希望年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SVC_USE_STA_KIBO_YMD), EKK0111C040CBSMsg.SVC_USE_STA_KIBO_YMD, svcKeiUpdTemp);
		
		// サービス契約<eo光電話>が取得できた場合
		if(eoTelInfo != null)
		{
//			// VLAN-ID確定フラグを設定
//			setSvcIFMapping(eoTelInfo.getString(EKK0111A010CBSMsg1List.VLAN_ID_FIX_FLG), EKK0111C040CBSMsg.VLAN_ID_FIX_FLG, svcKeiUpdTemp);
			// PPP認証ID消去完了年月日を設定
			setSvcIFMapping(eoTelInfo.getString(EKK0111A010CBSMsg1List.PPP_NINSHO_ID_DEL_FIN_YMD), EKK0111C040CBSMsg.PPP_NINSHO_ID_DEL_FIN_YMD, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(eoTelInfo.getString(EKK0111A010CBSMsg1List.LAST_UPD_DTM), EKK0111C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
		}
		else
		{
//			// VLAN-ID確定フラグを設定
//			setSvcIFMapping(null, EKK0111C040CBSMsg.VLAN_ID_FIX_FLG, svcKeiUpdTemp);
			// PPP認証ID消去完了年月日を設定
			setSvcIFMapping(null, EKK0111C040CBSMsg.PPP_NINSHO_ID_DEL_FIN_YMD, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(null, EKK0111C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
		}
		
		
		// 審査結果コードを設定
		setSvcIFMapping(skekkaCd, EKK0111C040CBSMsg.SKEKKA_CD, svcKeiUpdTemp);
		// 異動NG状態コードを設定
		setSvcIFMapping(idoNgStatCd, EKK0111C040CBSMsg.IDO_NG_STAT_CD, svcKeiUpdTemp);
		
		caanList.add(svcKeiUpdTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0111C040(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}
	
	/**
	 * サービス契約＜eo光TV＞情報変更の設定する
	 * @param param スキーマクラス名
	 * @param handle セッションハンドル
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg getEoTVInfo(IRequestParameterReadWrite param, SessionHandle handle, String svcKeiNo) throws Throwable
	{
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		//サービスコードが光ネットの場合：EKK0101A010_サービス契約＜eo光TV＞一意照会
		CAANMsg svcKeiTemp = editInMsg(EKK0101A010CBSMsg.class.getName(), "EKK0101A010", "2", param);
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0101A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日を設定
		setSvcIFMapping(null, EKK0101A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		
		
		caanList.add(svcKeiTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0101A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg eoNetRsltTemp = rsltCaanList.get(0);
		
		CAANMsg[] eoTVList = eoNetRsltTemp.getCAANMsgList(EKK0101A010CBSMsg.EKK0101A010CBSMSG1LIST);
		if(eoTVList == null)
		{
			return null;
		}
		else
		{
			return eoTVList[0];
		}
	}

	
	/**
	 * サービス契約＜eo光TV＞情報変更の設定する
	 * @param svcKeiMap サービス契約情報
	 * @param caanList CAANMsgクラスリスト
	 * @param param スキーマクラス名
	 * @param svcKeiNo サービス契約番号
	 * @param skekkaCd 審査結果コード
	 * @param idoNgStatCd 異動NG状態コード
	 * @param svcKeiInTemp サービス契約情報(DB)
	 * @param eoTVInfo サービス契約＜eo光TV＞情報(DB)
	 * @param handle ハンドル情報
	 * @throws Throwable 
	 */
	private void setEoTV(
			HashMap<String, String> svcKeiMap, ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, String svcKeiNo,
			String skekkaCd, String idoNgStatCd, CAANMsg svcKeiInTemp, 
			CAANMsg eoTVInfo, SessionHandle handle) throws Throwable
	{
		//サービスコードが光TVの場合：EKK0101C040_サービス契約＜eo光TV＞情報変更
		CAANMsg svcKeiUpdTemp = editInMsg(EKK0101C040CBSMsg.class.getName(), "EKK0101C040", "1", param);
		
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiNo, EKK0101C040CBSMsg.SVC_KEI_NO, svcKeiUpdTemp);
		
		// 申込明細番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO), EKK0101C040CBSMsg.MSKM_DTL_NO, svcKeiUpdTemp);
		// 整理番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SEIRI_NO), EKK0101C040CBSMsg.SEIRI_NO, svcKeiUpdTemp);
		// 面開発案件番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MENKAIHAT_ANKEN_NO), EKK0101C040CBSMsg.MENKAIHAT_ANKEN_NO, svcKeiUpdTemp);
		// 提供方式契約番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.TK_HOSHIKI_KEI_NO), EKK0111C040CBSMsg.TK_HOSHIKI_KEI_NO, svcKeiUpdTemp);
		// ID速報書出力要否を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.ID_SOKHOSHO_OUTPUT_YH), EKK0101C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH, svcKeiUpdTemp);
		// 審査結果詳細コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_DTL_CD), EKK0101C040CBSMsg.SKEKKA_DTL_CD, svcKeiUpdTemp);
		// 審査結果補記コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_HOKI_CD), EKK0101C040CBSMsg.SKEKKA_HOKI_CD, svcKeiUpdTemp);
		// 審査結果送信コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_SEND_CD), EKK0101C040CBSMsg.SKEKKA_SEND_CD, svcKeiUpdTemp);
		// 支払い方法継続フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PAYWAY_KEIZOKU_FLG), EKK0101C040CBSMsg.PAYWAY_KEIZOKU_FLG, svcKeiUpdTemp);
		// 試用加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_KANYU_YMD), EKK0101C040CBSMsg.FTRIAL_KANYU_YMD, svcKeiUpdTemp);
		// 試用期間終了年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_PRD_ENDYMD), EKK0101C040CBSMsg.FTRIAL_PRD_ENDYMD, svcKeiUpdTemp);
		// 本加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_YMD), EKK0101C040CBSMsg.HONKANYU_YMD, svcKeiUpdTemp);
		// 本加入移行期限年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD), EKK0101C040CBSMsg.HONKANYU_IKO_KIGEN_YMD, svcKeiUpdTemp);
		// レター発送仕分区分を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.LETTER_HASSO_SHIWAKE_DIV), EKK0101C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV, svcKeiUpdTemp);
		// サンキューレター送付先コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.THNX_LETTER_SHS_CD), EKK0101C040CBSMsg.THNX_LETTER_SHS_CD, svcKeiUpdTemp);
		// WEBオプション追加不可フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WEB_OP_ADD_FAIL_FLG), EKK0101C040CBSMsg.WEB_OP_ADD_FAIL_FLG, svcKeiUpdTemp);
		// 違約金発生コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PNLTY_HASSEI_CD), EKK0101C040CBSMsg.PNLTY_HASSEI_CD, svcKeiUpdTemp);
		// 異動区分を設定
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK0101C040CBSMsg.IDO_DIV, svcKeiUpdTemp);
		// 紹介コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.INTR_CD), EKK0101C040CBSMsg.INTR_CD, svcKeiUpdTemp);
		// 業務連絡備考を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WORK_RRK_BIKO), EKK0101C040CBSMsg.WORK_RRK_BIKO, svcKeiUpdTemp);
		// 自動照査処理状態コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.AUTO_SHOSA_TRAN_STAT_CD), EKK0101C040CBSMsg.AUTO_SHOSA_TRAN_STAT_CD, svcKeiUpdTemp);
		// サービス利用開始希望年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SVC_USE_STA_KIBO_YMD), EKK0101C040CBSMsg.SVC_USE_STA_KIBO_YMD, svcKeiUpdTemp);
		
		// サービス契約<eo光電話>が取得できた場合
		if(eoTVInfo != null)
		{
			// 電波障害案件番号を設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.DMPS_ANKEN_NO), EKK0101C040CBSMsg.DMPS_ANKEN_NO, svcKeiUpdTemp);
			// 再送信提供サービス種別コードを設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.RE_SEND_TK_SVC_SBT_CD), EKK0101C040CBSMsg.RE_SEND_TK_SVC_SBT_CD, svcKeiUpdTemp);
			// TV営業地区コードを設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.TV_BUSINESS_CHIK_CD), EKK0101C040CBSMsg.TV_BUSINESS_CHIK_CD, svcKeiUpdTemp);
			// TV営業担当ユーザーIDを設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.TV_BUSINESS_TNT_USER_ID), EKK0101C040CBSMsg.TV_BUSINESS_TNT_USER_ID, svcKeiUpdTemp);
			//バンドル情報コードを設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.BUNDLE_IF_CD), EKK0101C040CBSMsg.BUNDLE_IF_CD, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(eoTVInfo.getString(EKK0101A010CBSMsg1List.LAST_UPD_DTM), EKK0101C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
		} 
		else 
		{
			// 電波障害案件番号を設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.DMPS_ANKEN_NO, svcKeiUpdTemp);
			// 再送信提供サービス種別コードを設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.RE_SEND_TK_SVC_SBT_CD, svcKeiUpdTemp);
			// TV営業地区コードを設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.TV_BUSINESS_CHIK_CD, svcKeiUpdTemp);
			// TV営業担当ユーザーIDを設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.TV_BUSINESS_TNT_USER_ID, svcKeiUpdTemp);
			//バンドル情報コードを設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.BUNDLE_IF_CD, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(null, EKK0101C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
		}
		
		// 審査結果コードを設定
		setSvcIFMapping(skekkaCd, EKK0111C040CBSMsg.SKEKKA_CD, svcKeiUpdTemp);
		// 異動NG状態コードを設定
		setSvcIFMapping(idoNgStatCd, EKK0111C040CBSMsg.IDO_NG_STAT_CD, svcKeiUpdTemp);
		
		caanList.add(svcKeiUpdTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0101C040(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}
	
	/**
	 * サービス契約＜eo光ネット＞情報変更の設定する
	 * @param param スキーマクラス名
	 * @param handle セッションハンドル
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg getEoNetInfo(IRequestParameterReadWrite param, SessionHandle handle, String svcKeiNo) throws Throwable
	{
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		//サービスコードが光ネットの場合：EKK0091A010_サービス契約＜eo光ネット＞一意照会
		CAANMsg svcKeiTemp = editInMsg(EKK0091A010CBSMsg.class.getName(), "EKK0091A010", "2", param);
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0091A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日を設定
		setSvcIFMapping(null, EKK0091A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		
		caanList.add(svcKeiTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0091A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg eoNetRsltTemp = rsltCaanList.get(0);
		
		CAANMsg[] eoNetList = eoNetRsltTemp.getCAANMsgList(EKK0091A010CBSMsg.EKK0091A010CBSMSG1LIST);
		if(eoNetList == null)
		{
			return null;
		}
		else
		{
			return eoNetList[0];
		}
	}
	
	/**
	 * サービス契約＜eo光ネット＞情報変更の設定する
	 * @param svcKeiMap サービス契約マップ
	 * @param caanList CAANMsgクラスリスト
	 * @param param スキーマクラス名
	 * @param svcKeiNo サービス契約番号
	 * @param skekkaCd 審査結果コード
	 * @param idoNgStatCd 異動NG状態コード
	 * @param svcKeiInTemp サービス契約情報(DB)
	 * @param eoNetInfo サービス契約＜eo光ネット＞情報(DB)
	 * @param handle ハンドル情報
	 * @throws Throwable 
	 */
	private void setEoNet(
			HashMap<String, String> svcKeiMap, ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, 
			String svcKeiNo, String skekkaCd, String idoNgStatCd, 
			CAANMsg svcKeiInTemp, CAANMsg eoNetInfo, SessionHandle handle) throws Throwable
	{
		//サービスコードが光ネットの場合：EKK0091C040_サービス契約＜eo光ネット＞情報変更
		CAANMsg svcKeiUpdTemp = editInMsg(EKK0091C040CBSMsg.class.getName(), "EKK0091C040", "1", param);
		
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0091C040CBSMsg.SVC_KEI_NO, svcKeiUpdTemp);
		// 申込明細番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO), EKK0091C040CBSMsg.MSKM_DTL_NO, svcKeiUpdTemp);
		// 整理番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SEIRI_NO), EKK0091C040CBSMsg.SEIRI_NO, svcKeiUpdTemp);
		// 面開発案件番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MENKAIHAT_ANKEN_NO), EKK0091C040CBSMsg.MENKAIHAT_ANKEN_NO, svcKeiUpdTemp);
		// ID速報書出力要否を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.ID_SOKHOSHO_OUTPUT_YH), EKK0091C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH, svcKeiUpdTemp);
		// 審査結果詳細コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_DTL_CD), EKK0091C040CBSMsg.SKEKKA_DTL_CD, svcKeiUpdTemp);
		// 審査結果補記コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_HOKI_CD), EKK0091C040CBSMsg.SKEKKA_HOKI_CD, svcKeiUpdTemp);
		// 審査結果送信コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_SEND_CD), EKK0091C040CBSMsg.SKEKKA_SEND_CD, svcKeiUpdTemp);
		// 支払い方法継続フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PAYWAY_KEIZOKU_FLG), EKK0091C040CBSMsg.PAYWAY_KEIZOKU_FLG, svcKeiUpdTemp);
		// 試用加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_KANYU_YMD), EKK0091C040CBSMsg.FTRIAL_KANYU_YMD, svcKeiUpdTemp);
		// 試用期間終了年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_PRD_ENDYMD), EKK0091C040CBSMsg.FTRIAL_PRD_ENDYMD, svcKeiUpdTemp);
		// 本加入年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_YMD), EKK0091C040CBSMsg.HONKANYU_YMD, svcKeiUpdTemp);
		// 本加入移行期限年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD), EKK0091C040CBSMsg.HONKANYU_IKO_KIGEN_YMD, svcKeiUpdTemp);
		// レター発送仕分区分を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.LETTER_HASSO_SHIWAKE_DIV), EKK0091C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV, svcKeiUpdTemp);
		// サンキューレター送付先コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.THNX_LETTER_SHS_CD), EKK0091C040CBSMsg.THNX_LETTER_SHS_CD, svcKeiUpdTemp);
		// WEBオプション追加不可フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WEB_OP_ADD_FAIL_FLG), EKK0091C040CBSMsg.WEB_OP_ADD_FAIL_FLG, svcKeiUpdTemp);
		// 変更元法人eo読替サービス契約番号を設定
		setSvcIFMapping(
				svcKeiInTemp.getString(EKK0081A010CBSMsg1List.CHMT_HJIN_EO_YKAE_SVKEI_NO), 
				EKK0091C040CBSMsg.CHMT_HJIN_EO_YKAE_SVKEI_NO, svcKeiUpdTemp);
		// 違約金発生コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PNLTY_HASSEI_CD), EKK0091C040CBSMsg.PNLTY_HASSEI_CD, svcKeiUpdTemp);
		// 異動区分を設定
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK0091C040CBSMsg.IDO_DIV, svcKeiUpdTemp);
		// 紹介コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.INTR_CD), EKK0091C040CBSMsg.INTR_CD, svcKeiUpdTemp);
		// 業務連絡備考を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WORK_RRK_BIKO), EKK0091C040CBSMsg.WORK_RRK_BIKO, svcKeiUpdTemp);
		// 自動照査処理状態コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.AUTO_SHOSA_TRAN_STAT_CD), EKK0091C040CBSMsg.AUTO_SHOSA_TRAN_STAT_CD, svcKeiUpdTemp);
		// サービス利用開始希望年月日を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SVC_USE_STA_KIBO_YMD), EKK0091C040CBSMsg.SVC_USE_STA_KIBO_YMD, svcKeiUpdTemp);
		
		if(eoNetInfo != null)
		{
			// 固定IPアドレス引継ぎ有無を設定
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.KOTEI_IP_AD_HKTGI_UM), EKK0091C040CBSMsg.KOTEI_IP_AD_HKTGI_UM, svcKeiUpdTemp);
			// PCパック有無を設定
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.PC_PACK_UM), EKK0091C040CBSMsg.PC_PACK_UM, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.LAST_UPD_DTM), EKK0091C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
// ANK-4427-00-00 ADD START
			// WAO派遣要否希望
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_HAKEN_YH_KIBO), EKK0091C040CBSMsg.WAO_HAKEN_YH_KIBO, svcKeiUpdTemp);
			// WAO工事希望年月日１
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_YMD_1), EKK0091C040CBSMsg.WAO_KOJI_KIBO_YMD_1, svcKeiUpdTemp);
			// WAO工事希望時間帯１
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_TIMEZ_1), EKK0091C040CBSMsg.WAO_KOJI_KIBO_TIMEZ_1, svcKeiUpdTemp);
			// WAO工事希望年月日２
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_YMD_2), EKK0091C040CBSMsg.WAO_KOJI_KIBO_YMD_2, svcKeiUpdTemp);
			// WAO工事希望時間帯２
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_TIMEZ_2), EKK0091C040CBSMsg.WAO_KOJI_KIBO_TIMEZ_2, svcKeiUpdTemp);
			// WAO工事希望年月日３
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_YMD_3), EKK0091C040CBSMsg.WAO_KOJI_KIBO_YMD_3, svcKeiUpdTemp);
			// WAO工事希望時間帯３
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOJI_KIBO_TIMEZ_3), EKK0091C040CBSMsg.WAO_KOJI_KIBO_TIMEZ_3, svcKeiUpdTemp);
			// WAO工事会社連絡事項
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_KOCOMP_RRK_JIKO), EKK0091C040CBSMsg.WAO_KOCOMP_RRK_JIKO, svcKeiUpdTemp);
			// WAO転用区分
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_TENYO_DIV), EKK0091C040CBSMsg.WAO_TENYO_DIV, svcKeiUpdTemp);
			// WAO転用承諾番号
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_TENYO_SHODAKU_NO), EKK0091C040CBSMsg.WAO_TENYO_SHODAKU_NO, svcKeiUpdTemp);
			// WAO有効期限
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_YK_KIGEN), EKK0091C040CBSMsg.WAO_YK_KIGEN, svcKeiUpdTemp);
			// WAO住所番地メモ
			setSvcIFMapping(eoNetInfo.getString(EKK0091A010CBSMsg1List.WAO_AD_BNCHI_MEMO), EKK0091C040CBSMsg.WAO_AD_BNCHI_MEMO, svcKeiUpdTemp);
// ANK-4427-00-00 ADD END	
		}
		else
		{
			// 固定IPアドレス引継ぎ有無を設定
			setSvcIFMapping(null, EKK0091C040CBSMsg.KOTEI_IP_AD_HKTGI_UM, svcKeiUpdTemp);
			// PCパック有無を設定
			setSvcIFMapping(null, EKK0091C040CBSMsg.PC_PACK_UM, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(null, EKK0091C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
		}
		
		
		// 審査結果コードを設定
		svcKeiUpdTemp.set(EKK0091C040CBSMsg.SKEKKA_CD, skekkaCd);
		// 異動NG状態コードを設定
		svcKeiUpdTemp.set(EKK0091C040CBSMsg.IDO_NG_STAT_CD, idoNgStatCd);

		caanList.add(svcKeiUpdTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0091C040(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}

	/**
	 * サービス契約<eoADSL>情報変更の設定する
	 * @param param スキーマクラス名
	 * @param handle セッションハンドル
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg getEoAdslInfo(IRequestParameterReadWrite param, SessionHandle handle, String svcKeiNo) throws Throwable
	{
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		// EKK0141A010_サービス契約<eoADSL>一意照会
		CAANMsg svcKeiTemp = editInMsg(EKK0141A010CBSMsg.class.getName(), "EKK0141A010", "2", param);
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0141A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日を設定
		setSvcIFMapping(null, EKK0141A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		
		caanList.add(svcKeiTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0141A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg eoAdslRsltTemp = rsltCaanList.get(0);
		
		CAANMsg[] eoAdslList = eoAdslRsltTemp.getCAANMsgList(EKK0141A010CBSMsg.EKK0141A010CBSMSG1LIST);
		if(eoAdslList == null)
		{
			return null;
		}
		else
		{
			return eoAdslList[0];
		}
	}

	/**
	 * サービス契約＜eoADSL＞情報変更の設定する
	 * @param svcKeiMap サービス契約マップ
	 * @param caanList CAANMsgクラスリスト
	 * @param param スキーマクラス名
	 * @param svcKeiNo サービス契約番号
	 * @param skekkaCd 審査結果コード
	 * @param idoNgStatCd 異動NG状態コード
	 * @param svcKeiInTemp サービス契約情報(DB)
	 * @param eoAdslInfo サービス契約＜eoADSL＞情報(DB)
	 * @param handle ハンドル情報
	 * @throws Throwable 
	 */
	private void setEoAdsl(
			HashMap<String, String> svcKeiMap, ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, 
			String svcKeiNo, String skekkaCd, String idoNgStatCd, CAANMsg svcKeiInTemp, 
			CAANMsg eoAdslInfo, SessionHandle handle) throws Throwable
	{
		//EKK0141C040_サービス契約＜eoADSL＞情報変更
		CAANMsg svcKeiUpdTemp = editInMsg(EKK0141C040CBSMsg.class.getName(), "EKK0141C040", "1", param);
		
		
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0141C040CBSMsg.SVC_KEI_NO, svcKeiUpdTemp);
		// 申込明細番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO), EKK0141C040CBSMsg.MSKM_DTL_NO, svcKeiUpdTemp);
		// 整理番号を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SEIRI_NO), EKK0141C040CBSMsg.SEIRI_NO, svcKeiUpdTemp);
		// 支払い方法継続フラグを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PAYWAY_KEIZOKU_FLG), EKK0141C040CBSMsg.PAYWAY_KEIZOKU_FLG, svcKeiUpdTemp);
		// ID速報書出力要否を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.ID_SOKHOSHO_OUTPUT_YH), EKK0141C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH, svcKeiUpdTemp);
		// レター発送仕分区分を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.LETTER_HASSO_SHIWAKE_DIV), EKK0141C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV, svcKeiUpdTemp);
		// 違約金発生コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PNLTY_HASSEI_CD), EKK0141C040CBSMsg.PNLTY_HASSEI_CD, svcKeiUpdTemp);
		// 異動区分を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.IDO_DIV), EKK0141C040CBSMsg.IDO_DIV, svcKeiUpdTemp);
		// 紹介コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.INTR_CD), EKK0141C040CBSMsg.INTR_CD, svcKeiUpdTemp);
		// 業務連絡備考を設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WORK_RRK_BIKO), EKK0141C040CBSMsg.WORK_RRK_BIKO, svcKeiUpdTemp);
		// 審査結果詳細コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_DTL_CD), EKK0141C040CBSMsg.SKEKKA_DTL_CD, svcKeiUpdTemp);
		// 審査結果補記コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_HOKI_CD), EKK0141C040CBSMsg.SKEKKA_HOKI_CD, svcKeiUpdTemp);
		// 審査結果送信コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_SEND_CD), EKK0141C040CBSMsg.SKEKKA_SEND_CD, svcKeiUpdTemp);
		// 自動照査処理状態コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.AUTO_SHOSA_TRAN_STAT_CD), EKK0141C040CBSMsg.AUTO_SHOSA_TRAN_STAT_CD, svcKeiUpdTemp);
		
		if(eoAdslInfo != null)
		{
			// ADSL使用電話番号を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ADSL_USE_TELNO), EKK0141C040CBSMsg.ADSL_USE_TELNO, svcKeiUpdTemp);
			// エリア判定局番を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.AREA_JUDGE_KYOKU_NO), EKK0141C040CBSMsg.AREA_JUDGE_KYOKU_NO, svcKeiUpdTemp);
			// 設置先既設電話番号を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.STC_SAKI_KST_TELNO), EKK0141C040CBSMsg.STC_SAKI_KST_TELNO, svcKeiUpdTemp);
			// NTT集約局名を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.NTT_SHYAKK_NM), EKK0141C040CBSMsg.NTT_SHYAKK_NM, svcKeiUpdTemp);
			// ADSL回線種別コードを設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ADSL_KAISEN_SBT_CD), EKK0141C040CBSMsg.ADSL_KAISEN_SBT_CD, svcKeiUpdTemp);
			// ADSL回線名義人名を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ADSL_KAISEN_MEIGIN_NM), EKK0141C040CBSMsg.ADSL_KAISEN_MEIGIN_NM, svcKeiUpdTemp);
			// ADSL宅内工事コードを設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ADSL_TAKNIKJ_CD), EKK0141C040CBSMsg.ADSL_TAKNIKJ_CD, svcKeiUpdTemp);
			// アナログ切替承認区分を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ANALOG_SWITCH_SHONIN_DIV), EKK0141C040CBSMsg.ANALOG_SWITCH_SHONIN_DIV, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.LAST_UPD_DTM), EKK0141C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
			// ＡＤＳＬタイプコードを設定
			setSvcIFMapping(eoAdslInfo.getString(EKK0141A010CBSMsg1List.ADSL_TYPE_CD), EKK0141C040CBSMsg.ADSL_TYPE_CD, svcKeiUpdTemp);
		}
		else
		{
			// ADSL使用電話番号を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ADSL_USE_TELNO, svcKeiUpdTemp);
			// エリア判定局番を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.AREA_JUDGE_KYOKU_NO, svcKeiUpdTemp);
			// 設置先既設電話番号を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.STC_SAKI_KST_TELNO, svcKeiUpdTemp);
			// NTT集約局名を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.NTT_SHYAKK_NM, svcKeiUpdTemp);
			// ADSL回線種別コードを設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ADSL_KAISEN_SBT_CD, svcKeiUpdTemp);
			// ADSL回線名義人名を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ADSL_KAISEN_MEIGIN_NM, svcKeiUpdTemp);
			// ADSL宅内工事コードを設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ADSL_TAKNIKJ_CD, svcKeiUpdTemp);
			// アナログ切替承認区分を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ANALOG_SWITCH_SHONIN_DIV, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)を設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
			// ＡＤＳＬタイプコードを設定
			setSvcIFMapping(null, EKK0141C040CBSMsg.ADSL_TYPE_CD, svcKeiUpdTemp);
		}
		
		
		// 審査結果コードを設定
		svcKeiUpdTemp.set(EKK0141C040CBSMsg.SKEKKA_CD, skekkaCd);
		// 異動NG状態コードを設定
		svcKeiUpdTemp.set(EKK0141C040CBSMsg.IDO_NG_STAT_CD, idoNgStatCd);

		caanList.add(svcKeiUpdTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0141C040(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}

	/**
	 * サービス契約<eoモバイル>情報変更の設定する
	 * @param param スキーマクラス名
	 * @param handle セッションハンドル
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg getEoMobaInfo(IRequestParameterReadWrite param, SessionHandle handle, String svcKeiNo) throws Throwable
	{
		// 審査とサービス契約を更新する情報を設定するリスト
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		// EKK0121A010_サービス契約<eoモバイル>一意照会
		CAANMsg svcKeiTemp = editInMsg(EKK0121A010CBSMsg.class.getName(), "EKK0121A010", "2", param);
		// サービス契約番号を設定
		setSvcIFMapping(svcKeiNo, EKK0121A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日を設定
		setSvcIFMapping(null, EKK0121A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		
		caanList.add(svcKeiTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0121A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg eoMobaRsltTemp = rsltCaanList.get(0);
		
		CAANMsg[] eoMobaList = eoMobaRsltTemp.getCAANMsgList(EKK0121A010CBSMsg.EKK0121A010CBSMSG1LIST);
		if(eoMobaList == null)
		{
			return null;
		}
		else
		{
			return eoMobaList[0];
		}
	}

	/**
	 * サービス契約＜eoモバイル＞情報変更の設定する
	 * @param svcKeiMap サービス契約マップ
	 * @param caanList CAANMsgクラスリスト
	 * @param param スキーマクラス名
	 * @param svcKeiNo サービス契約番号
	 * @param skekkaCd 審査結果コード
	 * @param idoNgStatCd 異動NG状態コード
	 * @param svcKeiInTemp サービス契約情報(DB)
	 * @param eoMobaInfo サービス契約＜eoモバイル＞情報(DB)
	 * @param handle ハンドル情報
	 * @throws Throwable 
	 */
	private void setEoMoba(
			HashMap<String, String> svcKeiMap, ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, 
			String svcKeiNo, String skekkaCd, String idoNgStatCd, 
			CAANMsg svcKeiInTemp, CAANMsg eoMobaInfo, SessionHandle handle) throws Throwable
	{
		// EKK0121C040_サービス契約＜eo光ネット＞情報変更
		CAANMsg svcKeiUpdTemp = editInMsg(EKK0121C040CBSMsg.class.getName(), "EKK0121C040", "1", param);
		
		
		// サービス契約番号
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SVC_KEI_NO), EKK0121C040CBSMsg.SVC_KEI_NO, svcKeiUpdTemp);
		// 申込明細番号
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO), EKK0121C040CBSMsg.MSKM_DTL_NO, svcKeiUpdTemp);
		// 整理番号
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SEIRI_NO), EKK0121C040CBSMsg.SEIRI_NO, svcKeiUpdTemp);
		// 面開発案件番号
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.MENKAIHAT_ANKEN_NO), EKK0121C040CBSMsg.MENKAIHAT_ANKEN_NO, svcKeiUpdTemp);
		// ID速報書出力要否
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.ID_SOKHOSHO_OUTPUT_YH), EKK0121C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH, svcKeiUpdTemp);
		// 審査結果詳細コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_DTL_CD), EKK0121C040CBSMsg.SKEKKA_DTL_CD, svcKeiUpdTemp);
		// 審査結果補記コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_HOKI_CD), EKK0121C040CBSMsg.SKEKKA_HOKI_CD, svcKeiUpdTemp);
		// 審査結果送信コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.SKEKKA_SEND_CD), EKK0121C040CBSMsg.SKEKKA_SEND_CD, svcKeiUpdTemp);
		// 支払い方法継続フラグ
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PAYWAY_KEIZOKU_FLG), EKK0121C040CBSMsg.PAYWAY_KEIZOKU_FLG, svcKeiUpdTemp);
		// 試用加入年月日
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_KANYU_YMD), EKK0121C040CBSMsg.FTRIAL_KANYU_YMD, svcKeiUpdTemp);
		// 試用期間終了年月日
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.FTRIAL_PRD_ENDYMD), EKK0121C040CBSMsg.FTRIAL_PRD_ENDYMD, svcKeiUpdTemp);
		// 本加入年月日
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_YMD), EKK0121C040CBSMsg.HONKANYU_YMD, svcKeiUpdTemp);
		// 本加入移行期限年月日
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD), EKK0121C040CBSMsg.HONKANYU_IKO_KIGEN_YMD, svcKeiUpdTemp);
		// レター発送仕分区分
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.LETTER_HASSO_SHIWAKE_DIV), EKK0121C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV, svcKeiUpdTemp);
		// サンキューレター送付先コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.THNX_LETTER_SHS_CD), EKK0121C040CBSMsg.THNX_LETTER_SHS_CD, svcKeiUpdTemp);
		// WEBオプション追加不可フラグ
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WEB_OP_ADD_FAIL_FLG), EKK0121C040CBSMsg.WEB_OP_ADD_FAIL_FLG, svcKeiUpdTemp);
		// 違約金発生コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.PNLTY_HASSEI_CD), EKK0121C040CBSMsg.PNLTY_HASSEI_CD, svcKeiUpdTemp);
		// 異動区分
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.IDO_DIV), EKK0121C040CBSMsg.IDO_DIV, svcKeiUpdTemp);
		// 紹介コード
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.INTR_CD), EKK0121C040CBSMsg.INTR_CD, svcKeiUpdTemp);
		// 業務連絡備考
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.WORK_RRK_BIKO), EKK0121C040CBSMsg.WORK_RRK_BIKO, svcKeiUpdTemp);
		// 自動照査処理状態コードを設定
		setSvcIFMapping(svcKeiInTemp.getString(EKK0081A010CBSMsg1List.AUTO_SHOSA_TRAN_STAT_CD), EKK0121C040CBSMsg.AUTO_SHOSA_TRAN_STAT_CD, svcKeiUpdTemp);

		if(eoMobaInfo != null)
		{
			// MACアドレス
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.MACAD), EKK0121C040CBSMsg.MACAD, svcKeiUpdTemp);
			// 事業者用契約ID
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JIGYOSHA_KEI_ID), EKK0121C040CBSMsg.JIGYOSHA_KEI_ID, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.LAST_UPD_DTM), EKK0121C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
			// 事業者解約情報連携年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_DSL_INFO_RNKI_YMD), EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_YMD, svcKeiUpdTemp);
			// 事業者解約情報連携受付年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_DSL_INFO_RNKI_UK_YMD), EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_UK_YMD, svcKeiUpdTemp);
			// 事業者利用停止連携年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_USE_STP_RNKI_YMD), EKK0121C040CBSMsg.JGS_USE_STP_RNKI_YMD, svcKeiUpdTemp);
			// 事業者利用停止受付年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_USE_STP_UK_YMD), EKK0121C040CBSMsg.JGS_USE_STP_UK_YMD, svcKeiUpdTemp);
			// 事業者利用停止解除連携年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_USE_STP_RLS_RNKI_YMD), EKK0121C040CBSMsg.JGS_USE_STP_RLS_RNKI_YMD, svcKeiUpdTemp);
			// 事業者利用停止解除受付年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_USE_STP_RLS_UK_YMD), EKK0121C040CBSMsg.JGS_USE_STP_RLS_UK_YMD, svcKeiUpdTemp);
			// 事業者中断電話連絡年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_STP_TEL_RRK_YMD), EKK0121C040CBSMsg.JGS_STP_TEL_RRK_YMD, svcKeiUpdTemp);
			// 事業者中断再開電話連絡年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_STP_SKAI_TEL_RRK_YMD), EKK0121C040CBSMsg.JGS_STP_SKAI_TEL_RRK_YMD, svcKeiUpdTemp);
			// 事業者解約電話連絡年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_DSL_TEL_RRK_YMD), EKK0121C040CBSMsg.JGS_DSL_TEL_RRK_YMD, svcKeiUpdTemp);
			// コース変更NG状態コード
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.COURSECHG_NG_STAT_CD), EKK0121C040CBSMsg.COURSECHG_NG_STAT_CD, svcKeiUpdTemp);
			// 事業者コース変更連携年月日
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.JGS_COURSECHG_RNK_YMD), EKK0121C040CBSMsg.JGS_COURSECHG_RNK_YMD, svcKeiUpdTemp);
			// コース変更通知メール作成年月日
			setSvcIFMapping(
					eoMobaInfo.getString(EKK0121A010CBSMsg1List.COURSECHG_TCH_ML_SKSI_YMD), 
					EKK0121C040CBSMsg.COURSECHG_TCH_ML_SKSI_YMD, svcKeiUpdTemp);
			// USIM返却年月日(KOPT)
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.USIM_RTN_YMD_KOPT), EKK0121C040CBSMsg.USIM_RTN_YMD_KOPT, svcKeiUpdTemp);
			// USIM返却年月日(モバイル事業者)
			setSvcIFMapping(eoMobaInfo.getString(EKK0121A010CBSMsg1List.USIM_RTN_YMD_MBL_JGS), EKK0121C040CBSMsg.USIM_RTN_YMD_MBL_JGS, svcKeiUpdTemp);
		}
		else
		{
			// MACアドレス
			setSvcIFMapping(null, EKK0121C040CBSMsg.MACAD, svcKeiUpdTemp);
			// 事業者用契約ID
			setSvcIFMapping(null, EKK0121C040CBSMsg.JIGYOSHA_KEI_ID, svcKeiUpdTemp);
			// 更新年月日時分秒(更新前)
			setSvcIFMapping(null, EKK0121C040CBSMsg.UPD_DTM_BF, svcKeiUpdTemp);
			// 事業者解約情報連携年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_YMD, svcKeiUpdTemp);
			// 事業者解約情報連携受付年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_UK_YMD, svcKeiUpdTemp);
			// 事業者利用停止連携年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_USE_STP_RNKI_YMD, svcKeiUpdTemp);
			// 事業者利用停止受付年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_USE_STP_UK_YMD, svcKeiUpdTemp);
			// 事業者利用停止解除連携年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_USE_STP_RLS_RNKI_YMD, svcKeiUpdTemp);
			// 事業者利用停止解除受付年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_USE_STP_RLS_UK_YMD, svcKeiUpdTemp);
			// 事業者中断電話連絡年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_STP_TEL_RRK_YMD, svcKeiUpdTemp);
			// 事業者中断再開電話連絡年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_STP_SKAI_TEL_RRK_YMD, svcKeiUpdTemp);
			// 事業者解約電話連絡年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_DSL_TEL_RRK_YMD, svcKeiUpdTemp);
			// コース変更NG状態コード
			setSvcIFMapping(null, EKK0121C040CBSMsg.COURSECHG_NG_STAT_CD, svcKeiUpdTemp);
			// 事業者コース変更連携年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.JGS_COURSECHG_RNK_YMD, svcKeiUpdTemp);
			// コース変更通知メール作成年月日
			setSvcIFMapping(null, EKK0121C040CBSMsg.COURSECHG_TCH_ML_SKSI_YMD, svcKeiUpdTemp);
			// USIM返却年月日(KOPT)
			setSvcIFMapping(null, EKK0121C040CBSMsg.USIM_RTN_YMD_KOPT, svcKeiUpdTemp);
			// USIM返却年月日(モバイル事業者)
			setSvcIFMapping(null, EKK0121C040CBSMsg.USIM_RTN_YMD_MBL_JGS, svcKeiUpdTemp);
		}
		
		// 審査結果コードを設定
		svcKeiUpdTemp.set(EKK0121C040CBSMsg.SKEKKA_CD, skekkaCd);
		// 異動NG状態コードを設定
		svcKeiUpdTemp.set(EKK0121C040CBSMsg.IDO_NG_STAT_CD, idoNgStatCd);

		caanList.add(svcKeiUpdTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0121C040(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071B011(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071B011CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 審査詳細一覧照会マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_NO_ERR);
		// 審査詳細一覧照会マップ.審査種別コード → 審査種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_SBT_CD_ERR);
		// 審査詳細一覧照会マップ.審査対象種別コード → 審査対象種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_TG_SBT_CD_ERR);
		// 審査詳細一覧照会マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_MSKM_DTL_NO_ERR);
		// 審査詳細一覧照会マップ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_OP_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SBOP_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SEIOPSVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SVC_KEI_UCWK_NO_ERR);
		// 審査詳細一覧照会マップ.SYSID → SYSID のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SYSID_ERR);
		// 審査詳細一覧照会マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_WRIB_SVC_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(業務パラメータ一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEZM0321A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EZM0321A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 業務パラメータ一意照会マップ.業務パラメータＩＤ → 業務パラメータＩＤ のエラー情報返却
		errMapping(template, inMap, EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0081A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約一意照会マップ.予約適用年月日 → 予約適用年月日 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		// サービス契約一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光電話＞一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0111A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0111A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光電話＞一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0111A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約＜eo光電話＞一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0111A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光TV＞一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0101A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0101A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光TV＞一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0101A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約＜eo光TV＞一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0101A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光ネット＞一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0091A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0091A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光ネット＞一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0091A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約＜eo光ネット＞一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0091A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eoADSL＞一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0141A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0141A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eoADSL＞一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0141A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約＜eoADSL＞一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0141A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eoモバイル＞一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0121A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0121A010CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eoモバイル＞一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0121A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約＜eoモバイル＞一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0121A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光電話＞情報変更)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0111C040(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0111C040CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光電話＞情報変更マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.整理番号 → 整理番号 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SEIRI_NO_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.面開発案件番号 → 面開発案件番号 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.MENKAIHAT_ANKEN_NO_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.提供方式契約番号 → 提供方式契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.TK_HOSHIKI_KEI_NO_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.ID速報書出力要否 → ID速報書出力要否 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.審査結果詳細コード → 審査結果詳細コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SKEKKA_DTL_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.審査結果補記コード → 審査結果補記コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SKEKKA_HOKI_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.審査結果送信コード → 審査結果送信コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SKEKKA_SEND_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.支払い方法継続フラグ → 支払い方法継続フラグ のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.PAYWAY_KEIZOKU_FLG_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.FTRIAL_KANYU_YMD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.FTRIAL_PRD_ENDYMD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.HONKANYU_YMD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.レター発送仕分区分 → レター発送仕分区分 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.サンキューレター送付先コード → サンキューレター送付先コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.THNX_LETTER_SHS_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.WEBオプション追加不可フラグ → WEBオプション追加不可フラグ のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.PNLTY_HASSEI_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.IDO_DIV_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.異動NG状態コード → 異動NG状態コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.IDO_NG_STAT_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.審査結果コード → 審査結果コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.SKEKKA_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.紹介コード → 紹介コード のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.INTR_CD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.業務連絡備考 → 業務連絡備考 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.WORK_RRK_BIKO_ERR);
//		// サービス契約＜eo光電話＞情報変更マップ.VLAN-ID確定フラグ → VLAN-ID確定フラグ のエラー情報返却
//		errMapping(template, inMap, EKK0111C040CBSMsg.VLAN_ID_FIX_FLG_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.PPP認証ID消去完了年月日 → PPP認証ID消去完了年月日 のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.PPP_NINSHO_ID_DEL_FIN_YMD_ERR);
		// サービス契約＜eo光電話＞情報変更マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK0111C040CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光TV＞情報変更)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0101C040(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0101C040CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光TV＞情報変更マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.整理番号 → 整理番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SEIRI_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.面開発案件番号 → 面開発案件番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.MENKAIHAT_ANKEN_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.提供方式契約番号 → 提供方式契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.TK_HOSHIKI_KEI_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.ID速報書出力要否 → ID速報書出力要否 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.審査結果詳細コード → 審査結果詳細コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SKEKKA_DTL_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.審査結果補記コード → 審査結果補記コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SKEKKA_HOKI_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.審査結果送信コード → 審査結果送信コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SKEKKA_SEND_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.支払い方法継続フラグ → 支払い方法継続フラグ のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.PAYWAY_KEIZOKU_FLG_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.FTRIAL_KANYU_YMD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.FTRIAL_PRD_ENDYMD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.HONKANYU_YMD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.レター発送仕分区分 → レター発送仕分区分 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.サンキューレター送付先コード → サンキューレター送付先コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.THNX_LETTER_SHS_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.WEBオプション追加不可フラグ → WEBオプション追加不可フラグ のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.PNLTY_HASSEI_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.IDO_DIV_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.異動NG状態コード → 異動NG状態コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.IDO_NG_STAT_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.審査結果コード → 審査結果コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.SKEKKA_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.紹介コード → 紹介コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.INTR_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.業務連絡備考 → 業務連絡備考 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.WORK_RRK_BIKO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.電波障害案件番号 → 電波障害案件番号 のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.DMPS_ANKEN_NO_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.再送信提供サービス種別コード → 再送信提供サービス種別コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.RE_SEND_TK_SVC_SBT_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.TV営業地区コード → TV営業地区コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.TV_BUSINESS_CHIK_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.TV営業担当ユーザーID → TV営業担当ユーザーID のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.TV_BUSINESS_TNT_USER_ID_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.バンドル情報コード → バンドル情報コード のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.BUNDLE_IF_CD_ERR);
		// サービス契約＜eo光TV＞情報変更マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK0101C040CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eo光ネット＞情報変更)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0091C040(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0091C040CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光ネット＞情報変更マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.整理番号 → 整理番号 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SEIRI_NO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.面開発案件番号 → 面開発案件番号 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.MENKAIHAT_ANKEN_NO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.ID速報書出力要否 → ID速報書出力要否 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.審査結果詳細コード → 審査結果詳細コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SKEKKA_DTL_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.審査結果補記コード → 審査結果補記コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SKEKKA_HOKI_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.審査結果送信コード → 審査結果送信コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SKEKKA_SEND_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.支払い方法継続フラグ → 支払い方法継続フラグ のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.PAYWAY_KEIZOKU_FLG_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.FTRIAL_KANYU_YMD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.FTRIAL_PRD_ENDYMD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.HONKANYU_YMD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.レター発送仕分区分 → レター発送仕分区分 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.サンキューレター送付先コード → サンキューレター送付先コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.THNX_LETTER_SHS_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.WEBオプション追加不可フラグ → WEBオプション追加不可フラグ のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.PNLTY_HASSEI_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.変更元法人eo読替サービス契約番号 → 変更元法人eo読替サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.CHMT_HJIN_EO_YKAE_SVKEI_NO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.IDO_DIV_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.異動NG状態コード → 異動NG状態コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.IDO_NG_STAT_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.審査結果コード → 審査結果コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.SKEKKA_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.紹介コード → 紹介コード のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.INTR_CD_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.業務連絡備考 → 業務連絡備考 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.WORK_RRK_BIKO_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.固定IPアドレス引継ぎ有無 → 固定IPアドレス引継ぎ有無 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.KOTEI_IP_AD_HKTGI_UM_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.PCパック有無 → PCパック有無 のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.PC_PACK_UM_ERR);
		// サービス契約＜eo光ネット＞情報変更マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK0091C040CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eoADSL＞情報変更)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0141C040(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0141C040CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eo光ADSL＞情報変更マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.整理番号 → 整理番号 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SEIRI_NO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.ID速報書出力要否 → ID速報書出力要否 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.審査結果詳細コード → 審査結果詳細コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SKEKKA_DTL_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.審査結果補記コード → 審査結果補記コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SKEKKA_HOKI_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.審査結果送信コード → 審査結果送信コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SKEKKA_SEND_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.レター発送仕分区分 → レター発送仕分区分 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.PNLTY_HASSEI_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.IDO_DIV_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.異動NG状態コード → 異動NG状態コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.IDO_NG_STAT_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.審査結果コード → 審査結果コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.SKEKKA_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.業務連絡備考 → 業務連絡備考 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.WORK_RRK_BIKO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.ADSL使用電話番号 → ADSL使用電話番号 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ADSL_USE_TELNO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.エリア判定局番 → エリア判定局番 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.AREA_JUDGE_KYOKU_NO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.設置先既設電話番号 → 設置先既設電話番号 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.STC_SAKI_KST_TELNO_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.NTT集約局名 → NTT集約局名 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.NTT_SHYAKK_NM_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.ADSL回線種別コード → ADSL回線種別コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ADSL_KAISEN_SBT_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.ADSL回線名義人名 → ADSL回線名義人名 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ADSL_KAISEN_MEIGIN_NM_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.ADSL宅内工事コード → ADSL宅内工事コード のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ADSL_TAKNIKJ_CD_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.アナログ切替承認区分 → アナログ切替承認区分 のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.ANALOG_SWITCH_SHONIN_DIV_ERR);
		// サービス契約＜eo光ADSL＞情報変更マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK0141C040CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約＜eoモバイル＞情報変更)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0121C040(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0121C040CBSMsg.STATUS);
		if (returnCode.intValue() != 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 inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約＜eoモバイル＞情報変更マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.整理番号 → 整理番号 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SEIRI_NO_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.面開発案件番号 → 面開発案件番号 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.MENKAIHAT_ANKEN_NO_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.ID速報書出力要否 → ID速報書出力要否 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.ID_SOKHOSHO_OUTPUT_YH_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.審査結果詳細コード → 審査結果詳細コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SKEKKA_DTL_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.審査結果補記コード → 審査結果補記コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SKEKKA_HOKI_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.審査結果送信コード → 審査結果送信コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SKEKKA_SEND_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.支払い方法継続フラグ → 支払い方法継続フラグ のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.PAYWAY_KEIZOKU_FLG_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.FTRIAL_KANYU_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.FTRIAL_PRD_ENDYMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.HONKANYU_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.レター発送仕分区分 → レター発送仕分区分 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.LETTER_HASSO_SHIWAKE_DIV_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.サンキューレター送付先コード → サンキューレター送付先コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.THNX_LETTER_SHS_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.WEBオプション追加不可フラグ → WEBオプション追加不可フラグ のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.WEB_OP_ADD_FAIL_FLG_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.PNLTY_HASSEI_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.IDO_DIV_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.異動NG状態コード → 異動NG状態コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.IDO_NG_STAT_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.審査結果コード → 審査結果コード のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.SKEKKA_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.業務連絡備考 → 業務連絡備考 のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.WORK_RRK_BIKO_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者用契約ID → 事業者用契約ID のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.JIGYOSHA_KEI_ID_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.MACアドレス → MACアドレス のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.MACAD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK0121C040CBSMsg.UPD_DTM_BF_ERR);		
		// サービス契約＜eoモバイル＞情報変更マップ.事業者解約情報連携年月日 → 事業者解約情報連携年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者解約情報連携受付年月日 → 事業者解約情報連携受付年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_DSL_INFO_RNKI_UK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者利用停止連携年月日 → 事業者利用停止連携年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_USE_STP_RNKI_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者利用停止受付年月日 → 事業者利用停止受付年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_USE_STP_UK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者利用停止解除連携年月日 → 事業者利用停止解除連携年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_USE_STP_RLS_RNKI_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者利用停止解除受付年月日 → 事業者利用停止解除受付年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_USE_STP_RLS_UK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者中断電話連絡年月日 → 事業者中断電話連絡年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_STP_TEL_RRK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者中断再開電話連絡年月日 → 事業者中断再開電話連絡年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_STP_SKAI_TEL_RRK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者解約電話連絡年月日 → 事業者解約電話連絡年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_DSL_TEL_RRK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.コース変更NG状態コード → コース変更NG状態コード
		errMapping(template, inMap, EKK0121C040CBSMsg.COURSECHG_NG_STAT_CD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.事業者コース変更連携年月日 → 事業者コース変更連携年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.JGS_COURSECHG_RNK_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.コース変更通知メール作成年月日 → コース変更通知メール作成年月日
		errMapping(template, inMap, EKK0121C040CBSMsg.COURSECHG_TCH_ML_SKSI_YMD_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.USIM返却年月日(KOPT) → USIM返却年月日(KOPT)
		errMapping(template, inMap, EKK0121C040CBSMsg.USIM_RTN_YMD_KOPT_ERR);
		// サービス契約＜eoモバイル＞情報変更マップ.USIM返却年月日(モバイル事業者) → USIM返却年月日(モバイル事業者)
		errMapping(template, inMap, EKK0121C040CBSMsg.USIM_RTN_YMD_MBL_JGS_ERR);
		
		return param;
	}
	
// 2013/01/09 IT1-2012-0002379 add start
	
	/**
	 * エラー共通部の設定。<br>
	 * <br>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param status (I) ステータス
	 * @return 業務データ取得・書込用I/F
	 * @exception RequestParameterExceptionがスローされます。
	 * @since 2011.09.07
	 */
	private IRequestParameterReadWrite setControlMap(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, 
			String status) throws RequestParameterException 
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(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);
		}	
		
		return param;
	}
	
	/**
	 * サービス契約一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeEKK0081A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// サービス契約番号
		String svcKeiNo = (String)mapCustPstWkMap.get(SVC_KEI_NO);
		// 運用年月日
		String unyoYmd = (String)mapCustPstWkMap.get(UNYO_YMD);
		
		// サービス契約一意照会
		String templateID = "EKK0081A010";
		String funcCd = "2";
		CAANMsg svcKeiInfo = editInMsg(EKK0081A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// サービス契約番号 ← サービス契約番号
		setSvcIFMapping(svcKeiNo, EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiInfo);
		// 世代登録年月日時分秒 ← null
		setSvcIFMapping(null, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiInfo);
		// 予約適用年月日 ← 運用年月日
		setSvcIFMapping(unyoYmd, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, svcKeiInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(svcKeiInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0) 
		{
			// SYSID
			dataMap.put(EKK0081A010CBSMsg1List.SYSID, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.SYSID));
			// 審査結果コード
			dataMap.put(EKK0081A010CBSMsg1List.SKEKKA_CD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.SKEKKA_CD));
			// 料金グループコード
			dataMap.put(EKK0081A010CBSMsg1List.PRC_GRP_CD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.PRC_GRP_CD));
			// 料金グループコード名称
			dataMap.put(EKK0081A010CBSMsg1List.PRC_GRP_CD_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.PRC_GRP_CD_NM));
			// サービス開始年月日
			dataMap.put(EKK0081A010CBSMsg1List.SVC_STA_YMD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.SVC_STA_YMD));
			// サービス終了年月日
			dataMap.put(EKK0081A010CBSMsg1List.SVC_ENDYMD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.SVC_ENDYMD));
			// 申込明細番号
			dataMap.put(EKK0081A010CBSMsg1List.MSKM_DTL_NO, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST , 0 , EKK0081A010CBSMsg1List.MSKM_DTL_NO));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK0081A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// サービス契約番号エラー
		if (!templates[0].isNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR, templates[0].getString(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// 世代登録年月日時分秒エラー
		if (!templates[0].isNull(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR, templates[0].getString(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 予約適用年月日エラー
		if (!templates[0].isNull(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR, templates[0].getString(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * サービス契約回線内訳一覧照会(現在利用中)を実施する
	 *
	 */
	private HashMap<String, Object> executeEKK0251B003(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// サービス契約番号
		String svcKeiNo = (String)mapCustPstWkMap.get(SVC_KEI_NO);
		
		// サービス契約回線内訳一覧照会(現在利用中)
		String templateID = "EKK0251B003";
		String funcCd = "1";
		CAANMsg svcKeiKaisenUcwkInfo = editInMsg(EKK0251B003CBSMsg.class.getName(), templateID, funcCd, param);
		
		// サービス契約番号 ← サービス契約番号
		setSvcIFMapping(svcKeiNo, EKK0251B003CBSMsg.KEY_SVC_KEI_NO, svcKeiKaisenUcwkInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(svcKeiKaisenUcwkInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// X座標
			dataMap.put(EKK0251B003CBSMsg1List.XZAHYO, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST , 0 , EKK0251B003CBSMsg1List.XZAHYO));
			// Y座標
			dataMap.put(EKK0251B003CBSMsg1List.YZAHYO, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST , 0 , EKK0251B003CBSMsg1List.YZAHYO));
			// 経度
			dataMap.put(EKK0251B003CBSMsg1List.LGTD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST , 0 , EKK0251B003CBSMsg1List.LGTD));
			// 緯度
			dataMap.put(EKK0251B003CBSMsg1List.LTTD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST , 0 , EKK0251B003CBSMsg1List.LTTD));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK0251B003CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// サービス契約番号エラー
		if (!templates[0].isNull(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR))
			{
				inMap.put(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR, templates[0].getString(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * お客様一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeECK0011A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		// 運用年月日
		String unyoYmd = (String)mapCustPstWkMap.get(UNYO_YMD);
		
		// お客様一意照会
		String templateID = "ECK0011A010";
		String funcCd = "2";
		CAANMsg CustInfo = editInMsg(ECK0011A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// SYSID ← SYSID
		setSvcIFMapping(sysid, ECK0011A010CBSMsg.KEY_SYSID, CustInfo);
		// 予約適用年月日
		setSvcIFMapping(unyoYmd, ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, CustInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(CustInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// お客様名
			dataMap.put(ECK0011A010CBSMsg1List.CUST_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.CUST_NM));
			// お客様カナ名
			dataMap.put(ECK0011A010CBSMsg1List.CUST_KANA, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.CUST_KANA));
			// 契約者タイプコード名称
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM));
			// お客様生年月日
			dataMap.put(ECK0011A010CBSMsg1List.CUST_BIRTHD, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.CUST_BIRTHD));
			// お客様性別コード名称
			dataMap.put(ECK0011A010CBSMsg1List.CUST_SEX_CD_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.CUST_SEX_CD_NM));
			// 契約者住所コード
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_AD_CD, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_AD_CD));
			// 契約者郵便番号
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_PCD, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_PCD));
			// 契約者都道府県名
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_STATE_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_STATE_NM));
			// 契約者市区町村名
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_CITY_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_CITY_NM));
			// 契約者大字通称名
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_OAZTSU_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_OAZTSU_NM));
			// 契約者字丁目名
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_AZCHO_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_AZCHO_NM));
			// 契約者番地号
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_BNCHIGO, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_BNCHIGO));
			// 契約者住所補記・建物名
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_ADRTTM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_ADRTTM));
			// 契約者住所補記・部屋番号
			dataMap.put(ECK0011A010CBSMsg1List.KEISHA_ADRRM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST , 0 , ECK0011A010CBSMsg1List.KEISHA_ADRRM));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, ECK0011A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// SYSIDエラー
		if (!templates[0].isNull(ECK0011A010CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey(ECK0011A010CBSMsg.KEY_SYSID_ERR))
			{
				inMap.put(ECK0011A010CBSMsg.KEY_SYSID_ERR, templates[0].getString(ECK0011A010CBSMsg.KEY_SYSID_ERR));
			}
		}
		// 予約適用年月日エラー
		if (!templates[0].isNull(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
			{
				inMap.put(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR, templates[0].getString(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * お客様<法人>一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeECK0031A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		
		// お客様一意照会
		String templateID = "ECK0031A010";
		String funcCd = "2";
		CAANMsg CustHojinInfo = editInMsg(ECK0031A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// SYSID ← SYSID
		setSvcIFMapping(sysid, ECK0031A010CBSMsg.KEY_SYSID, CustHojinInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(CustHojinInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// 業種コード名称
			dataMap.put(ECK0031A010CBSMsg1List.GSHU_CD_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST , 0 , ECK0031A010CBSMsg1List.GSHU_CD_NM));
			// 会社名
			dataMap.put(ECK0031A010CBSMsg1List.COMP_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST , 0 , ECK0031A010CBSMsg1List.COMP_NM));
			// 代表者役職名
			dataMap.put(ECK0031A010CBSMsg1List.DIHYSHA_POST_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST , 0 , ECK0031A010CBSMsg1List.DIHYSHA_POST_NM));
			// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD START
			// 代表者名
			dataMap.put(ECK0031A010CBSMsg1List.DIHYSHA_NM, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST , 0 , ECK0031A010CBSMsg1List.DIHYSHA_NM));
			// 2013/02/18 [ANK-1402-00-00]地図顧客位置ワーク.代表者名の設定内容変更対応 ADD END
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, ECK0031A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// SYSIDエラー
		if (!templates[0].isNull(ECK0031A010CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey(ECK0031A010CBSMsg.KEY_SYSID_ERR))
			{
				inMap.put(ECK0031A010CBSMsg.KEY_SYSID_ERR, templates[0].getString(ECK0031A010CBSMsg.KEY_SYSID_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * 申込明細一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeEKK0021A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// 申込明細番号
		String mskmDtlNo = (String)mapCustPstWkMap.get(MSKM_DTL_NO);
		
		// 申込明細一意照会
		String templateID = "EKK0021A010";
		String funcCd = "2";
		CAANMsg mskmDtlInfo = editInMsg(EKK0021A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// 申込明細番号 ← 申込明細番号
		setSvcIFMapping(mskmDtlNo, EKK0021A010CBSMsg.KEY_MSKM_DTL_NO, mskmDtlInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(mskmDtlInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// 申込年月日
			dataMap.put(EKK0021A010CBSMsg1List.MSKM_YMD, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST , 0 , EKK0021A010CBSMsg1List.MSKM_YMD));
			// 申込書番号
			dataMap.put(EKK0021A010CBSMsg1List.MSKMSHO_NO, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST , 0 , EKK0021A010CBSMsg1List.MSKMSHO_NO));
			// 申込番号
			dataMap.put(EKK0021A010CBSMsg1List.MSKM_NO, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST , 0 , EKK0021A010CBSMsg1List.MSKM_NO));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK0021A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// 申込明細番号エラー
		if (!templates[0].isNull(EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey(EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR))
			{
				inMap.put(EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR, templates[0].getString(EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * 申込一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeEKK0011A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// 申込番号
		String mskmNo = (String)mapCustPstWkMap.get(MSKM_NO);
		
		// 申込明細一意照会
		String templateID = "EKK0011A010";
		String funcCd = "2";
		CAANMsg mskmInfo = editInMsg(EKK0011A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// 申込番号 ← 申込番号
		setSvcIFMapping(mskmNo, EKK0011A010CBSMsg.KEY_MSKM_NO, mskmInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(mskmInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(EKK0011A010CBSMsg.EKK0011A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// 申込受付年月日時分秒
			dataMap.put(EKK0011A010CBSMsg1List.MSKM_UK_DTM, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK0011A010CBSMsg.EKK0011A010CBSMSG1LIST , 0 , EKK0011A010CBSMsg1List.MSKM_UK_DTM));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK0011A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// 申込番号エラー
		if (!templates[0].isNull(EKK0011A010CBSMsg.KEY_MSKM_NO_ERR))
		{
			if (!inMap.containsKey(EKK0011A010CBSMsg.KEY_MSKM_NO_ERR))
			{
				inMap.put(EKK0011A010CBSMsg.KEY_MSKM_NO_ERR, templates[0].getString(EKK0011A010CBSMsg.KEY_MSKM_NO_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * 連絡先一覧照会を実施する
	 *
	 */
	private HashMap<String, Object> executeECK0201B001(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		// 連絡先種別コード
		String rrksSbtCd = (String)mapCustPstWkMap.get(RRKS_SBT_CD);
		
		// 連絡先一覧照会
		String templateID = "ECK0201B001";
		String funcCd = "1";
		CAANMsg rrksInfo = editInMsg(ECK0201B001CBSMsg.class.getName(), templateID, funcCd, param);
		
		// SYSID ← SYSID
		setSvcIFMapping(sysid, ECK0201B001CBSMsg.KEY_SYSID, rrksInfo);
		// 連絡先種別コード
		setSvcIFMapping(rrksSbtCd, ECK0201B001CBSMsg.KEY_RRKS_SBT_CD, rrksInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(rrksInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(ECK0201B001CBSMsg.ECK0201B001CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// 電話番号
			dataMap.put(ECK0201B001CBSMsg1List.TELNO, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0201B001CBSMsg.ECK0201B001CBSMSG1LIST , 0 , ECK0201B001CBSMsg1List.TELNO));
			// メールアドレス
			dataMap.put(ECK0201B001CBSMsg1List.MLAD, JPCBPCommon.getSCListValueString(parentTemplate,
					ECK0201B001CBSMsg.ECK0201B001CBSMSG1LIST , 0 , ECK0201B001CBSMsg1List.MLAD));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, ECK0201B001CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// SYSIDエラー
		if (!templates[0].isNull(ECK0201B001CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_SYSID_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_SYSID_ERR, templates[0].getString(ECK0201B001CBSMsg.KEY_SYSID_ERR));
			}
		}
		// 連絡先種別コードエラー
		if (!templates[0].isNull(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR, templates[0].getString(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * 地図顧客位置ワーク一意照会を実施する
	 *
	 */
	private HashMap<String, Object> executeEKK2691A010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		// サービス契約番号
		String svcKeiNo = (String)mapCustPstWkMap.get(SVC_KEI_NO);
		
		// 地図顧客位置ワーク一意照会
		String templateID = "EKK2691A010";
		String funcCd = "1";
		CAANMsg mapCustPstWkInfo = editInMsg(EKK2691A010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// 地図顧客位置識別値 ← SYSID
		setSvcIFMapping(sysid, EKK2691A010CBSMsg.KEY_MAP_CUST_PST_SKVAL, mapCustPstWkInfo);
		// 地図顧客位置詳細識別値 ← サービス契約番号
		setSvcIFMapping(svcKeiNo, EKK2691A010CBSMsg.KEY_MAP_CUST_PST_DTL_SKVAL, mapCustPstWkInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(mapCustPstWkInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// 結果を詰めるマップを取得
		HashMap<String, Object> dataMap = new HashMap<String, Object>();
		templateArray = parentTemplate.getCAANMsgList(EKK2691A010CBSMsg.EKK2691A010CBSMSG1LIST);
		if (templateArray != null && templateArray.length != 0)
		{
			// 更新年月日時分秒
			dataMap.put(EKK2691A010CBSMsg1List.UPD_DTM, JPCBPCommon.getSCListValueString(parentTemplate,
					EKK2691A010CBSMsg.EKK2691A010CBSMSG1LIST , 0 , EKK2691A010CBSMsg1List.UPD_DTM));
		}
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK2691A010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		// 地図顧客位置識別値エラー
		if (!templates[0].isNull(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_SKVAL_ERR))
			{
				inMap.put(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_SKVAL_ERR, templates[0].getString(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_SKVAL_ERR));
			}
		}
		// 地図顧客位置詳細識別値エラー
		if (!templates[0].isNull(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_DTL_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_DTL_SKVAL_ERR))
			{
				inMap.put(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_DTL_SKVAL_ERR, templates[0].getString(EKK2691A010CBSMsg.KEY_MAP_CUST_PST_DTL_SKVAL_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		
		return dataMap;
	}
	
	/**
	 * 地図顧客位置ワーク登録を実施する
	 *
	 */
	private void executeEKK2691D010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		// サービス契約番号
		String svcKeiNo = (String)mapCustPstWkMap.get(SVC_KEI_NO);
		// 現在工程コード
		String nowStepCd = (String)mapCustPstWkMap.get(NOW_STEP_CD);
		// 現在工程名
		String nowStepCdNm = (String)mapCustPstWkMap.get(NOW_STEP_CD_NM);
		// 料金グループコード
		String prcGrpCd = (String)mapCustPstWkMap.get(PRC_GRP_CD);
		// 料金グループコード名称
		String prcGrpCdNm = (String)mapCustPstWkMap.get(PRC_GRP_CD_NM);
		// X座標
		String xzahyo = (String)mapCustPstWkMap.get(XZAHYO);
		// Y座標
		String yzahyo = (String)mapCustPstWkMap.get(YZAHYO);
		// 経度
		String lgtd = (String)mapCustPstWkMap.get(LGTD);
		// 緯度
		String lttd = (String)mapCustPstWkMap.get(LTTD);
		// お客様名
		String custNm = (String)mapCustPstWkMap.get(CUST_NM);
		// お客様カナ名
		String custKana = (String)mapCustPstWkMap.get(CUST_KANA);
		// 契約者タイプコード名称
		String keishaTypeCdNm = (String)mapCustPstWkMap.get(KEISHA_TYPE_CD_NM);
		// 自宅電話番号
		String homeTelno = (String)mapCustPstWkMap.get(HOME_TELNO);
		// 携帯電話番号
		String ktaiTelno = (String)mapCustPstWkMap.get(KTAI_TELNO);
		// 会社電話番号
		String compTelno = (String)mapCustPstWkMap.get(COMP_TELNO);
		// メールアドレス
		String mlad = (String)mapCustPstWkMap.get(MLAD);
		// お客様生年月日
		String custBirthd = (String)mapCustPstWkMap.get(CUST_BIRTHD);
		// お客様性別コード名称
		String custSexCdNm = (String)mapCustPstWkMap.get(CUST_SEX_CD_NM);
		// 業種コード名称
		String gshuCdNm = (String)mapCustPstWkMap.get(GSHU_CD_NM);
		// 会社名
		String compNm = (String)mapCustPstWkMap.get(COMP_NM);
		// 代表者役職名
		String dihyshaPostNm = (String)mapCustPstWkMap.get(DIHYSHA_POST_NM);
		// 代表者名
		String dihyshaNm = (String)mapCustPstWkMap.get(DIHYSHA_NM);
		// 契約者住所コード
		String keishaAdCd = (String)mapCustPstWkMap.get(KEISHA_AD_CD);
		// 契約者郵便番号
		String keishaPcd = (String)mapCustPstWkMap.get(KEISHA_PCD);
		// 契約者都道府県名
		String keishaStateNm = (String)mapCustPstWkMap.get(KEISHA_STATE_NM);
		// 契約者市区町村名
		String keishaCityNm = (String)mapCustPstWkMap.get(KEISHA_CITY_NM);
		// 契約者大字通称名
		String keishaOaztsuNm = (String)mapCustPstWkMap.get(KEISHA_OAZTSU_NM);
		// 契約者字丁目名
		String keishaAzchoNm = (String)mapCustPstWkMap.get(KEISHA_AZCHO_NM);
		// 契約者番地号
		String keishaBnchigo = (String)mapCustPstWkMap.get(KEISHA_BNCHIGO);
		// 契約者住所補記・建物名
		String keishaAdrttm = (String)mapCustPstWkMap.get(KEISHA_ADRTTM);
		// 契約者住所補記・部屋番号
		String keishaAdrrm = (String)mapCustPstWkMap.get(KEISHA_ADRRM);
		// 申込年月日
		String mskmYmd = (String)mapCustPstWkMap.get(MSKM_YMD);
		// 申込書番号
		String mskmshoNo = (String)mapCustPstWkMap.get(MSKMSHO_NO);
		// 申込受付年月日
		String mskmUkYmd = (String)mapCustPstWkMap.get(MSKM_UK_YMD);
		// サービス開始年月日
		String svcStaYmd = (String)mapCustPstWkMap.get(SVC_STA_YMD);
		// サービス終了年月日
		String svcEndYmd = (String)mapCustPstWkMap.get(SVC_END_YMD);
		
		// 地図顧客位置ワーク登録
		String templateID = "EKK2691D010";
		String funcCd = "1";
		CAANMsg mapCustPstWkInfo = editInMsg(EKK2691D010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// 地図顧客位置識別値 ← SYSID
		setSvcIFMapping(sysid ,EKK2691D010CBSMsg.MAP_CUST_PST_SKVAL, mapCustPstWkInfo);
		// 地図顧客位置詳細識別値 ← サービス契約番号
		setSvcIFMapping(svcKeiNo ,EKK2691D010CBSMsg.MAP_CUST_PST_DTL_SKVAL, mapCustPstWkInfo);
		// 現在工程コード ← 現在工程コード
		setSvcIFMapping(nowStepCd ,EKK2691D010CBSMsg.NOW_STEP_CD, mapCustPstWkInfo);
		// 現在工程名 ← 現在工程名
		setSvcIFMapping(nowStepCdNm ,EKK2691D010CBSMsg.NOW_STEP_NM, mapCustPstWkInfo);
		// 料金グループコード ← 料金グループコード
		setSvcIFMapping(prcGrpCd ,EKK2691D010CBSMsg.PRC_GRP_CD, mapCustPstWkInfo);
		// 料金グループコード名称 ← 料金グループコード名称
		setSvcIFMapping(prcGrpCdNm ,EKK2691D010CBSMsg.PRC_GRP_NM, mapCustPstWkInfo);
		// X座標 ← X座標
		setSvcIFMapping(xzahyo ,EKK2691D010CBSMsg.XZAHYO, mapCustPstWkInfo);
		// Y座標 ← Y座標
		setSvcIFMapping(yzahyo ,EKK2691D010CBSMsg.YZAHYO, mapCustPstWkInfo);
		// 経度 ← 経度
		setSvcIFMapping(lgtd ,EKK2691D010CBSMsg.LGTD, mapCustPstWkInfo);
		// 緯度 ← 緯度
		setSvcIFMapping(lttd ,EKK2691D010CBSMsg.LTTD, mapCustPstWkInfo);
		// お客様名 ← お客様名
		setSvcIFMapping(custNm ,EKK2691D010CBSMsg.CUST_NM, mapCustPstWkInfo);
		// お客様カナ名 ← お客様カナ名
		setSvcIFMapping(custKana ,EKK2691D010CBSMsg.CUST_KANA, mapCustPstWkInfo);
		// 契約者タイプ名 ← 契約者タイプコード名称
		setSvcIFMapping(keishaTypeCdNm ,EKK2691D010CBSMsg.KEISHA_TYPE_NM, mapCustPstWkInfo);
		// 連絡先自宅電話番号 ← 自宅電話番号
		setSvcIFMapping(homeTelno ,EKK2691D010CBSMsg.RRKS_HOME_TELNO, mapCustPstWkInfo);
		// 連絡先携帯電話番号 ← 携帯電話番号
		setSvcIFMapping(ktaiTelno ,EKK2691D010CBSMsg.RRKS_KTAI_TELNO, mapCustPstWkInfo);
		// 連絡先会社電話番号 ← 会社電話番号
		setSvcIFMapping(compTelno ,EKK2691D010CBSMsg.RRKS_COMP_TELNO, mapCustPstWkInfo);
		// 連絡先メールアドレス ← メールアドレス
		setSvcIFMapping(mlad ,EKK2691D010CBSMsg.RRKS_MLAD, mapCustPstWkInfo);
		// お客様生年月日 ← お客様生年月日
		setSvcIFMapping(custBirthd ,EKK2691D010CBSMsg.CUST_BIRTHD, mapCustPstWkInfo);
		// お客様性別 ← お客様性別コード名称
		setSvcIFMapping(custSexCdNm ,EKK2691D010CBSMsg.CUST_SEX, mapCustPstWkInfo);
		// 業種名 ← 業種コード名称
		setSvcIFMapping(gshuCdNm ,EKK2691D010CBSMsg.GSHU_NM, mapCustPstWkInfo);
		// 会社名 ← 会社名
		setSvcIFMapping(compNm ,EKK2691D010CBSMsg.COMP_NM, mapCustPstWkInfo);
		// 代表者役職名 ← 代表者役職名
		setSvcIFMapping(dihyshaPostNm ,EKK2691D010CBSMsg.DIHYSHA_POST_NM, mapCustPstWkInfo);
		// 代表者名 ← 代表者名
		setSvcIFMapping(dihyshaNm ,EKK2691D010CBSMsg.DIHYSHA_NM, mapCustPstWkInfo);
		// 地図顧客位置住所コード ← 契約者住所コード
		setSvcIFMapping(keishaAdCd ,EKK2691D010CBSMsg.MAP_CUST_PST_AD_CD, mapCustPstWkInfo);
		// 地図顧客位置郵便番号 ← 契約者郵便番号
		setSvcIFMapping(keishaPcd ,EKK2691D010CBSMsg.MAP_CUST_PST_PCD, mapCustPstWkInfo);
		// 地図顧客位置都道府県名 ← 契約者都道府県名
		setSvcIFMapping(keishaStateNm ,EKK2691D010CBSMsg.MAP_CUST_PST_STATE_NM, mapCustPstWkInfo);
		// 地図顧客位置市区町村名 ← 契約者市区町村名
		setSvcIFMapping(keishaCityNm ,EKK2691D010CBSMsg.MAP_CUST_PST_CITY_NM, mapCustPstWkInfo);
		// 地図顧客位置大字通称名 ← 契約者大字通称名
		setSvcIFMapping(keishaOaztsuNm ,EKK2691D010CBSMsg.MAP_CUST_PST_OAZTSU_NM, mapCustPstWkInfo);
		// 地図顧客位置字丁目名 ← 契約者字丁目名
		setSvcIFMapping(keishaAzchoNm ,EKK2691D010CBSMsg.MAP_CUST_PST_AZCHO_NM, mapCustPstWkInfo);
		// 地図顧客位置番地号 ← 契約者番地号
		setSvcIFMapping(keishaBnchigo ,EKK2691D010CBSMsg.MAP_CUST_PST_BNCHIGO, mapCustPstWkInfo);
		// 地図顧客位置住所補記・建物名 ← 契約者住所補記・建物名
		setSvcIFMapping(keishaAdrttm ,EKK2691D010CBSMsg.MAP_CUST_PST_ADRTTM, mapCustPstWkInfo);
		// 地図顧客位置住所補記・部屋番号 ← 契約者住所補記・部屋番号
		setSvcIFMapping(keishaAdrrm ,EKK2691D010CBSMsg.MAP_CUST_PST_ADRRM, mapCustPstWkInfo);
		// 申込年月日 ← 申込年月日
		setSvcIFMapping(mskmYmd ,EKK2691D010CBSMsg.MSKM_YMD, mapCustPstWkInfo);
		// 申込書番号 ← 申込書番号
		setSvcIFMapping(mskmshoNo ,EKK2691D010CBSMsg.MSKMSHO_NO, mapCustPstWkInfo);
		// 申込受付年月日 ← 申込受付年月日
		setSvcIFMapping(mskmUkYmd ,EKK2691D010CBSMsg.MSKM_UK_YMD, mapCustPstWkInfo);
		// サービス開始年月日 ← サービス開始年月日
		setSvcIFMapping(svcStaYmd ,EKK2691D010CBSMsg.SVC_STA_YMD, mapCustPstWkInfo);
		// サービス終了年月日 ← サービス終了年月日
		setSvcIFMapping(svcEndYmd ,EKK2691D010CBSMsg.SVC_END_YMD, mapCustPstWkInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(mapCustPstWkInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK2691D010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_SKVAL_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_SKVAL_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_SKVAL_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.NOW_STEP_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.NOW_STEP_CD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.NOW_STEP_CD_ERR, templates[0].getString(EKK2691D010CBSMsg.NOW_STEP_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.NOW_STEP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.NOW_STEP_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.NOW_STEP_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.NOW_STEP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.PRC_GRP_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.PRC_GRP_CD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.PRC_GRP_CD_ERR, templates[0].getString(EKK2691D010CBSMsg.PRC_GRP_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.PRC_GRP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.PRC_GRP_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.PRC_GRP_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.PRC_GRP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.XZAHYO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.XZAHYO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.XZAHYO_ERR, templates[0].getString(EKK2691D010CBSMsg.XZAHYO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.YZAHYO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.YZAHYO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.YZAHYO_ERR, templates[0].getString(EKK2691D010CBSMsg.YZAHYO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.LGTD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.LGTD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.LGTD_ERR, templates[0].getString(EKK2691D010CBSMsg.LGTD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.LTTD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.LTTD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.LTTD_ERR, templates[0].getString(EKK2691D010CBSMsg.LTTD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.CUST_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.CUST_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.CUST_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.CUST_KANA_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.CUST_KANA_ERR, templates[0].getString(EKK2691D010CBSMsg.CUST_KANA_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.KEISHA_TYPE_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.KEISHA_TYPE_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.KEISHA_TYPE_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.KEISHA_TYPE_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.RRKS_HOME_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.RRKS_HOME_TELNO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.RRKS_HOME_TELNO_ERR, templates[0].getString(EKK2691D010CBSMsg.RRKS_HOME_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.RRKS_KTAI_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.RRKS_KTAI_TELNO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.RRKS_KTAI_TELNO_ERR, templates[0].getString(EKK2691D010CBSMsg.RRKS_KTAI_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.RRKS_COMP_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.RRKS_COMP_TELNO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.RRKS_COMP_TELNO_ERR, templates[0].getString(EKK2691D010CBSMsg.RRKS_COMP_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.RRKS_MLAD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.RRKS_MLAD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.RRKS_MLAD_ERR, templates[0].getString(EKK2691D010CBSMsg.RRKS_MLAD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.CUST_BIRTHD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.CUST_BIRTHD_ERR, templates[0].getString(EKK2691D010CBSMsg.CUST_BIRTHD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.CUST_SEX_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.CUST_SEX_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.CUST_SEX_ERR, templates[0].getString(EKK2691D010CBSMsg.CUST_SEX_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.GSHU_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.GSHU_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.GSHU_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.GSHU_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.COMP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.COMP_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.COMP_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.COMP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.DIHYSHA_POST_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.DIHYSHA_POST_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.DIHYSHA_POST_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.DIHYSHA_POST_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.DIHYSHA_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.DIHYSHA_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.DIHYSHA_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.DIHYSHA_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_AD_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_AD_CD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_AD_CD_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_AD_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_PCD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_PCD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_PCD_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_PCD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_STATE_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_STATE_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_STATE_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_STATE_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_CITY_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_CITY_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_CITY_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_CITY_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_ADRTTM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_ADRTTM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_ADRTTM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_ADRTTM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MAP_CUST_PST_ADRRM_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MAP_CUST_PST_ADRRM_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MAP_CUST_PST_ADRRM_ERR, templates[0].getString(EKK2691D010CBSMsg.MAP_CUST_PST_ADRRM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MSKM_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MSKM_YMD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MSKM_YMD_ERR, templates[0].getString(EKK2691D010CBSMsg.MSKM_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MSKMSHO_NO_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MSKMSHO_NO_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MSKMSHO_NO_ERR, templates[0].getString(EKK2691D010CBSMsg.MSKMSHO_NO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.MSKM_UK_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.MSKM_UK_YMD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.MSKM_UK_YMD_ERR, templates[0].getString(EKK2691D010CBSMsg.MSKM_UK_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.SVC_STA_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.SVC_STA_YMD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.SVC_STA_YMD_ERR, templates[0].getString(EKK2691D010CBSMsg.SVC_STA_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691D010CBSMsg.SVC_END_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691D010CBSMsg.SVC_END_YMD_ERR))
			{
				inMap.put(EKK2691D010CBSMsg.SVC_END_YMD_ERR, templates[0].getString(EKK2691D010CBSMsg.SVC_END_YMD_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
	}
	
	
	/**
	 * 地図顧客位置ワーク変更を実施する
	 *
	 */
	private void executeEKK2691C010(
			HashMap<String, Object> mapCustPstWkMap, 
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String fixedText) throws Exception, Throwable
	{
		// SYSID
		String sysid = (String)mapCustPstWkMap.get(SYSID);
		// サービス契約番号
		String svcKeiNo = (String)mapCustPstWkMap.get(SVC_KEI_NO);
		// 現在工程コード
		String nowStepCd = (String)mapCustPstWkMap.get(NOW_STEP_CD);
		// 現在工程名
		String nowStepCdNm = (String)mapCustPstWkMap.get(NOW_STEP_CD_NM);
		// 料金グループコード
		String prcGrpCd = (String)mapCustPstWkMap.get(PRC_GRP_CD);
		// 料金グループコード名称
		String prcGrpCdNm = (String)mapCustPstWkMap.get(PRC_GRP_CD_NM);
		// X座標
		String xzahyo = (String)mapCustPstWkMap.get(XZAHYO);
		// Y座標
		String yzahyo = (String)mapCustPstWkMap.get(YZAHYO);
		// 経度
		String lgtd = (String)mapCustPstWkMap.get(LGTD);
		// 緯度
		String lttd = (String)mapCustPstWkMap.get(LTTD);
		// お客様名
		String custNm = (String)mapCustPstWkMap.get(CUST_NM);
		// お客様カナ名
		String custKana = (String)mapCustPstWkMap.get(CUST_KANA);
		// 契約者タイプコード名称
		String keishaTypeCdNm = (String)mapCustPstWkMap.get(KEISHA_TYPE_CD_NM);
		// 自宅電話番号
		String homeTelno = (String)mapCustPstWkMap.get(HOME_TELNO);
		// 携帯電話番号
		String ktaiTelno = (String)mapCustPstWkMap.get(KTAI_TELNO);
		// 会社電話番号
		String compTelno = (String)mapCustPstWkMap.get(COMP_TELNO);
		// メールアドレス
		String mlad = (String)mapCustPstWkMap.get(MLAD);
		// お客様生年月日
		String custBirthd = (String)mapCustPstWkMap.get(CUST_BIRTHD);
		// お客様性別コード名称
		String custSexCdNm = (String)mapCustPstWkMap.get(CUST_SEX_CD_NM);
		// 業種コード名称
		String gshuCdNm = (String)mapCustPstWkMap.get(GSHU_CD_NM);
		// 会社名
		String compNm = (String)mapCustPstWkMap.get(COMP_NM);
		// 代表者役職名
		String dihyshaPostNm = (String)mapCustPstWkMap.get(DIHYSHA_POST_NM);
		// 代表者名
		String dihyshaNm = (String)mapCustPstWkMap.get(DIHYSHA_NM);
		// 契約者住所コード
		String keishaAdCd = (String)mapCustPstWkMap.get(KEISHA_AD_CD);
		// 契約者郵便番号
		String keishaPcd = (String)mapCustPstWkMap.get(KEISHA_PCD);
		// 契約者都道府県名
		String keishaStateNm = (String)mapCustPstWkMap.get(KEISHA_STATE_NM);
		// 契約者市区町村名
		String keishaCityNm = (String)mapCustPstWkMap.get(KEISHA_CITY_NM);
		// 契約者大字通称名
		String keishaOaztsuNm = (String)mapCustPstWkMap.get(KEISHA_OAZTSU_NM);
		// 契約者字丁目名
		String keishaAzchoNm = (String)mapCustPstWkMap.get(KEISHA_AZCHO_NM);
		// 契約者番地号
		String keishaBnchigo = (String)mapCustPstWkMap.get(KEISHA_BNCHIGO);
		// 契約者住所補記・建物名
		String keishaAdrttm = (String)mapCustPstWkMap.get(KEISHA_ADRTTM);
		// 契約者住所補記・部屋番号
		String keishaAdrrm = (String)mapCustPstWkMap.get(KEISHA_ADRRM);
		// 申込年月日
		String mskmYmd = (String)mapCustPstWkMap.get(MSKM_YMD);
		// 申込書番号
		String mskmshoNo = (String)mapCustPstWkMap.get(MSKMSHO_NO);
		// 申込受付年月日
		String mskmUkYmd = (String)mapCustPstWkMap.get(MSKM_UK_YMD);
		// サービス開始年月日
		String svcStaYmd = (String)mapCustPstWkMap.get(SVC_STA_YMD);
		// サービス終了年月日
		String svcEndYmd = (String)mapCustPstWkMap.get(SVC_END_YMD);
		// 更新年月日時分秒
		String updDtmBf = (String)mapCustPstWkMap.get(UPD_DTM_BF);
		
		// 地図顧客位置ワーク変更
		String templateID = "EKK2691C010";
		String funcCd = "1";
		CAANMsg mapCustPstWkInfo = editInMsg(EKK2691C010CBSMsg.class.getName(), templateID, funcCd, param);
		
		// 地図顧客位置識別値 ← SYSID
		setSvcIFMapping(sysid ,EKK2691C010CBSMsg.MAP_CUST_PST_SKVAL, mapCustPstWkInfo);
		// 地図顧客位置詳細識別値 ← サービス契約番号
		setSvcIFMapping(svcKeiNo ,EKK2691C010CBSMsg.MAP_CUST_PST_DTL_SKVAL, mapCustPstWkInfo);
		// 現在工程コード ← 現在工程コード
		setSvcIFMapping(nowStepCd ,EKK2691C010CBSMsg.NOW_STEP_CD, mapCustPstWkInfo);
		// 現在工程名 ← 現在工程名
		setSvcIFMapping(nowStepCdNm ,EKK2691C010CBSMsg.NOW_STEP_NM, mapCustPstWkInfo);
		// 料金グループコード ← 料金グループコード
		setSvcIFMapping(prcGrpCd ,EKK2691C010CBSMsg.PRC_GRP_CD, mapCustPstWkInfo);
		// 料金グループコード名称 ← 料金グループコード名称
		setSvcIFMapping(prcGrpCdNm ,EKK2691C010CBSMsg.PRC_GRP_NM, mapCustPstWkInfo);
		// X座標 ← X座標
		setSvcIFMapping(xzahyo ,EKK2691C010CBSMsg.XZAHYO, mapCustPstWkInfo);
		// Y座標 ← Y座標
		setSvcIFMapping(yzahyo ,EKK2691C010CBSMsg.YZAHYO, mapCustPstWkInfo);
		// 経度 ← 経度
		setSvcIFMapping(lgtd ,EKK2691C010CBSMsg.LGTD, mapCustPstWkInfo);
		// 緯度 ← 緯度
		setSvcIFMapping(lttd ,EKK2691C010CBSMsg.LTTD, mapCustPstWkInfo);
		// お客様名 ← お客様名
		setSvcIFMapping(custNm ,EKK2691C010CBSMsg.CUST_NM, mapCustPstWkInfo);
		// お客様カナ名 ← お客様カナ名
		setSvcIFMapping(custKana ,EKK2691C010CBSMsg.CUST_KANA, mapCustPstWkInfo);
		// 契約者タイプ名 ← 契約者タイプコード名称
		setSvcIFMapping(keishaTypeCdNm ,EKK2691C010CBSMsg.KEISHA_TYPE_NM, mapCustPstWkInfo);
		// 連絡先自宅電話番号 ← 自宅電話番号
		setSvcIFMapping(homeTelno ,EKK2691C010CBSMsg.RRKS_HOME_TELNO, mapCustPstWkInfo);
		// 連絡先携帯電話番号 ← 携帯電話番号
		setSvcIFMapping(ktaiTelno ,EKK2691C010CBSMsg.RRKS_KTAI_TELNO, mapCustPstWkInfo);
		// 連絡先会社電話番号 ← 会社電話番号
		setSvcIFMapping(compTelno ,EKK2691C010CBSMsg.RRKS_COMP_TELNO, mapCustPstWkInfo);
		// 連絡先メールアドレス ← メールアドレス
		setSvcIFMapping(mlad ,EKK2691C010CBSMsg.RRKS_MLAD, mapCustPstWkInfo);
		// お客様生年月日 ← お客様生年月日
		setSvcIFMapping(custBirthd ,EKK2691C010CBSMsg.CUST_BIRTHD, mapCustPstWkInfo);
		// お客様性別 ← お客様性別コード名称
		setSvcIFMapping(custSexCdNm ,EKK2691C010CBSMsg.CUST_SEX, mapCustPstWkInfo);
		// 業種名 ← 業種コード名称
		setSvcIFMapping(gshuCdNm ,EKK2691C010CBSMsg.GSHU_NM, mapCustPstWkInfo);
		// 会社名 ← 会社名
		setSvcIFMapping(compNm ,EKK2691C010CBSMsg.COMP_NM, mapCustPstWkInfo);
		// 代表者役職名 ← 代表者役職名
		setSvcIFMapping(dihyshaPostNm ,EKK2691C010CBSMsg.DIHYSHA_POST_NM, mapCustPstWkInfo);
		// 代表者名 ← 代表者名
		setSvcIFMapping(dihyshaNm ,EKK2691C010CBSMsg.DIHYSHA_NM, mapCustPstWkInfo);
		// 地図顧客位置住所コード ← 契約者住所コード
		setSvcIFMapping(keishaAdCd ,EKK2691C010CBSMsg.MAP_CUST_PST_AD_CD, mapCustPstWkInfo);
		// 地図顧客位置郵便番号 ← 契約者郵便番号
		setSvcIFMapping(keishaPcd ,EKK2691C010CBSMsg.MAP_CUST_PST_PCD, mapCustPstWkInfo);
		// 地図顧客位置都道府県名 ← 契約者都道府県名
		setSvcIFMapping(keishaStateNm ,EKK2691C010CBSMsg.MAP_CUST_PST_STATE_NM, mapCustPstWkInfo);
		// 地図顧客位置市区町村名 ← 契約者市区町村名
		setSvcIFMapping(keishaCityNm ,EKK2691C010CBSMsg.MAP_CUST_PST_CITY_NM, mapCustPstWkInfo);
		// 地図顧客位置大字通称名 ← 契約者大字通称名
		setSvcIFMapping(keishaOaztsuNm ,EKK2691C010CBSMsg.MAP_CUST_PST_OAZTSU_NM, mapCustPstWkInfo);
		// 地図顧客位置字丁目名 ← 契約者字丁目名
		setSvcIFMapping(keishaAzchoNm ,EKK2691C010CBSMsg.MAP_CUST_PST_AZCHO_NM, mapCustPstWkInfo);
		// 地図顧客位置番地号 ← 契約者番地号
		setSvcIFMapping(keishaBnchigo ,EKK2691C010CBSMsg.MAP_CUST_PST_BNCHIGO, mapCustPstWkInfo);
		// 地図顧客位置住所補記・建物名 ← 契約者住所補記・建物名
		setSvcIFMapping(keishaAdrttm ,EKK2691C010CBSMsg.MAP_CUST_PST_ADRTTM, mapCustPstWkInfo);
		// 地図顧客位置住所補記・部屋番号 ← 契約者住所補記・部屋番号
		setSvcIFMapping(keishaAdrrm ,EKK2691C010CBSMsg.MAP_CUST_PST_ADRRM, mapCustPstWkInfo);
		// 申込年月日 ← 申込年月日
		setSvcIFMapping(mskmYmd ,EKK2691C010CBSMsg.MSKM_YMD, mapCustPstWkInfo);
		// 申込書番号 ← 申込書番号
		setSvcIFMapping(mskmshoNo ,EKK2691C010CBSMsg.MSKMSHO_NO, mapCustPstWkInfo);
		// 申込受付年月日 ← 申込受付年月日
		setSvcIFMapping(mskmUkYmd ,EKK2691C010CBSMsg.MSKM_UK_YMD, mapCustPstWkInfo);
		// サービス開始年月日 ← サービス開始年月日
		setSvcIFMapping(svcStaYmd ,EKK2691C010CBSMsg.SVC_STA_YMD, mapCustPstWkInfo);
		// サービス終了年月日 ← サービス終了年月日
		setSvcIFMapping(svcEndYmd ,EKK2691C010CBSMsg.SVC_END_YMD, mapCustPstWkInfo);
		// 更新年月日時分秒（更新前） ← 更新年月日時分秒
		setSvcIFMapping(updDtmBf ,EKK2691C010CBSMsg.UPD_DTM_BF, mapCustPstWkInfo);
		
		// サービスIFの実施
		ArrayList<CAANMsg> caanUpdateList = new ArrayList<CAANMsg>();
		caanUpdateList.add(mapCustPstWkInfo);
		Map<?, ?> msgList = executeSvcIF(caanUpdateList, param, handle);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		int returnCode = (Integer)return_code;
		// エラー共通部の設定
		setControlMap(param, templates, returnCode, EKK2691C010CBSMsg.STATUS);
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null) 
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_SKVAL_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_SKVAL_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_SKVAL_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_DTL_SKVAL_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.NOW_STEP_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.NOW_STEP_CD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.NOW_STEP_CD_ERR, templates[0].getString(EKK2691C010CBSMsg.NOW_STEP_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.NOW_STEP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.NOW_STEP_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.NOW_STEP_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.NOW_STEP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.PRC_GRP_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.PRC_GRP_CD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.PRC_GRP_CD_ERR, templates[0].getString(EKK2691C010CBSMsg.PRC_GRP_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.PRC_GRP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.PRC_GRP_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.PRC_GRP_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.PRC_GRP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.XZAHYO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.XZAHYO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.XZAHYO_ERR, templates[0].getString(EKK2691C010CBSMsg.XZAHYO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.YZAHYO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.YZAHYO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.YZAHYO_ERR, templates[0].getString(EKK2691C010CBSMsg.YZAHYO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.LGTD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.LGTD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.LGTD_ERR, templates[0].getString(EKK2691C010CBSMsg.LGTD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.LTTD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.LTTD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.LTTD_ERR, templates[0].getString(EKK2691C010CBSMsg.LTTD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.CUST_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.CUST_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.CUST_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.CUST_KANA_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.CUST_KANA_ERR, templates[0].getString(EKK2691C010CBSMsg.CUST_KANA_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.KEISHA_TYPE_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.KEISHA_TYPE_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.KEISHA_TYPE_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.KEISHA_TYPE_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.RRKS_HOME_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.RRKS_HOME_TELNO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.RRKS_HOME_TELNO_ERR, templates[0].getString(EKK2691C010CBSMsg.RRKS_HOME_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.RRKS_KTAI_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.RRKS_KTAI_TELNO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.RRKS_KTAI_TELNO_ERR, templates[0].getString(EKK2691C010CBSMsg.RRKS_KTAI_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.RRKS_COMP_TELNO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.RRKS_COMP_TELNO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.RRKS_COMP_TELNO_ERR, templates[0].getString(EKK2691C010CBSMsg.RRKS_COMP_TELNO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.RRKS_MLAD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.RRKS_MLAD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.RRKS_MLAD_ERR, templates[0].getString(EKK2691C010CBSMsg.RRKS_MLAD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.CUST_BIRTHD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.CUST_BIRTHD_ERR, templates[0].getString(EKK2691C010CBSMsg.CUST_BIRTHD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.CUST_SEX_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.CUST_SEX_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.CUST_SEX_ERR, templates[0].getString(EKK2691C010CBSMsg.CUST_SEX_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.GSHU_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.GSHU_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.GSHU_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.GSHU_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.COMP_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.COMP_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.COMP_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.COMP_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.DIHYSHA_POST_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.DIHYSHA_POST_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.DIHYSHA_POST_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.DIHYSHA_POST_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.DIHYSHA_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.DIHYSHA_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.DIHYSHA_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.DIHYSHA_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_AD_CD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_AD_CD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_AD_CD_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_AD_CD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_PCD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_PCD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_PCD_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_PCD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_STATE_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_STATE_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_STATE_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_STATE_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_CITY_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_CITY_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_CITY_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_CITY_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_OAZTSU_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_AZCHO_NM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_BNCHIGO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_ADRTTM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_ADRTTM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_ADRTTM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_ADRTTM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MAP_CUST_PST_ADRRM_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MAP_CUST_PST_ADRRM_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MAP_CUST_PST_ADRRM_ERR, templates[0].getString(EKK2691C010CBSMsg.MAP_CUST_PST_ADRRM_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MSKM_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MSKM_YMD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MSKM_YMD_ERR, templates[0].getString(EKK2691C010CBSMsg.MSKM_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MSKMSHO_NO_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MSKMSHO_NO_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MSKMSHO_NO_ERR, templates[0].getString(EKK2691C010CBSMsg.MSKMSHO_NO_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.MSKM_UK_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.MSKM_UK_YMD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.MSKM_UK_YMD_ERR, templates[0].getString(EKK2691C010CBSMsg.MSKM_UK_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.SVC_STA_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.SVC_STA_YMD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.SVC_STA_YMD_ERR, templates[0].getString(EKK2691C010CBSMsg.SVC_STA_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.SVC_END_YMD_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.SVC_END_YMD_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.SVC_END_YMD_ERR, templates[0].getString(EKK2691C010CBSMsg.SVC_END_YMD_ERR));
			}
		}
		if (!templates[0].isNull(EKK2691C010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(EKK2691C010CBSMsg.UPD_DTM_BF_ERR))
			{
				inMap.put(EKK2691C010CBSMsg.UPD_DTM_BF_ERR, templates[0].getString(EKK2691C010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		//エラー情報のマップを取得
		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));
		/* ◇処理結果の判定 */
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = return_code.toString();
		int status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
	}
// 2013/01/09 IT1-2012-0002379 add end
}