/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKKikiHktgiAddCC
*	ソースファイル名：JKKKikiHktgiAddCC.java
*	作成者			：FJ
*	日付			：2011年11月17日
*＜機能概要＞
*	機器引継登録共通コンポーネント
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/11/17	FJ			新規作成
*	v4.00.00	2012/11/19	FJ			ST1-2012-0000846 対応
*	v4.00.01	2013/01/30	FJ			ST4-2013-0000317 対応
*	v4.01.00	2013/03/15	FJ			IT1-2013-0000496 対応
*	v4.02.00	2013/07/03	FJ			【IT1-2013-0001330】障害対応
*	v4.03.00	2013/07/03	FJ			【IT1-2013-0001364】障害対応
*	v19.00.00	2015/09/25	FJ)余野木	【OM-2015-0001988】対応
*	v19.00.01	2015/10/07	FJ)余野木	【OM-2015-0001988】対応
*	v35.00.00	2017/11/28	FJ)宮下		【OM-2017-0001115】対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
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.SCCallException;
import com.fujitsu.futurity.bp.x21.sc.exception.SCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.common.constant.JKKStrConst;
import eo.ejb.cbs.cbsmsg.EDK0301A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EDK0301C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0321B507CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321E010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341C230CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C290CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C320CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C330CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C450CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341E010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKKA0020004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKKA0020004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341C380CBSMsg;
import eo.ejb.common.JKKModelCommon;

/**
 * 接続機器の引継登録を行う部品。<p>
 * 
 * @author 富士通
 *
 */
public class JKKKikiHktgiAddCC extends AbstractCommonComponent
{
	/**
	 * テンプレートID(EKK0341C290)機器提供サービス契約サービス契約変更
	 */
	private static final String TEMPLATE_ID_EKK0341C290 = "EKK0341C290";
	/**
	 * テンプレートID(EKK0341C320)機器提供サービス契約サービス契約回線内訳変更
	 */
	private static final String TEMPLATE_ID_EKK0341C320 = "EKK0341C320";
	/**
	 * テンプレートID(EKK0341C380)機器提供サービス契約回復
	 */
	private static final String TEMPLATE_ID_EKK0341C380 = "EKK0341C380";
	/**
	 * テンプレートID(EDK0301A010)返品機器一意照会
	 */
	private static final String TEMPLATE_ID_EDK0301A010 = "EDK0301A010";
	/**
	 * テンプレートID(EDK0301C040)返品機器取消
	 */
	private static final String TEMPLATE_ID_EDK0301C040 = "EDK0301C040";
	/**
	 * テンプレートID_EKK0341A010(機器提供サービス契約一意照会)
	 */
	private static final String TEMPLATE_ID_EKK0341A010 = "EKK0341A010";
	/**
	 * テンプレートID(EKK0341C330)機器提供サービス契約キャンセル
	 */
	private static final String TEMPLATE_ID_EKK0341C330 = "EKK0341C330";
	/**
	 * テンプレートID(EKK0341E010)機器提供サービス契約論理削除
	 */
	private static final String TEMPLATE_ID_EKK0341E010 = "EKK0341E010";
	/**
	 * テンプレートID(EKK0251B003)サービス契約回線内訳一覧照会
	 */
	private static final String TEMPLATE_ID_EKK0251B003 = "EKK0251B003";
	/**
	 * テンプレートID(EKKA0020004)機器場所番号変更
	 */
	private static final String TEMPLATE_ID_EKKA0020004 = "EKKA0020004";
	
	/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
	/**
	 * テンプレートID(EKK0341C230)機器提供サービス契約情報変更
	 */
	private static final String TEMPLATE_ID_EKK0341C230 = "EKK0341C230";
	/**
	 * テンプレートID(EKK0341C450)機器設置先場所反映
	 * */
	private static final String TEMPLATE_ID_EKK0341C450 = "EKK0341C450";
	/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
	
	// ++++++++++ v19.00.00 追加開始 ++++++++++
	/**
	 * テンプレートID(EKK0321D010)課金先登録
	 */
	private static final String TEMPLATE_ID_EKK0321D010 = "EKK0321D010";

	/**
	 * テンプレートID(EKK0491A010)請求契約一意照会
	 */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";
	// ++++++++++ v19.00.00 追加終了 ++++++++++

	// ++++++++++ v19.00.01 追加開始 ++++++++++
	/**
	 * テンプレートID(EKK0321B507)課金先照会
	 */
	private static final String TEMPLATE_ID_EKK0321B507 = "EKK0321B507";
	/**
	 * テンプレートID(EKK0321C010)課金先更新
	 */
	private static final String TEMPLATE_ID_EKK0321C010 = "EKK0321C010";
	// ++++++++++ v19.00.01 追加終了 ++++++++++
	
	//OM-2017-0001115 ADD START
	/**
	 * テンプレートID(EKK0321E010)課金先論理削除
	 * */
	private static final String TEMPLATE_ID_EKK0321E010 = "EKK0321E010";
	//OM-2017-0001115 ADD END
	/**
	 * 機能コード=1
	 * */
	private final String FUNC_CODE_1 = "1";
	/**
	 * 機能コード=2
	 * */
	private final String func_code_2 = "2";
	
	/**
	 * 親契約識別コード"01"（サービス契約）
	 */
	private static final String OYA_KEI_SKBT_CD_01 = "01";
	/**
	 * 親契約識別コード"02"（サービス契約回線内訳）
	 */
	private static final String OYA_KEI_SKBT_CD_02 = "02";
	/**
	 * サービス契約ステータス"010"(受付済)
	 */
	private static final String SVC_KEI_STAT_010 = "010";
	/**
	 * 機器提供サービス契約ステータス"010"(受付済)
	 */
	private static final String KKTK_SVC_KEI_STAT_010 = "010";
	
	/**
	 * 更新日付WORK
	 * */
	private String upd_dtm_work = "0";
	/**
	 * 更新日付WORK(照査前契約)
	 * */
	private String upd_dtm_work_saki = "0";
	/**
	 * 機能コード(ビューロジック設定値を保持)
	 */
	private String func_code ="";
	
	/* ++++++++++ v4.01.00 追加開始 ++++++++++ */
	/** 審査結果反映CC 連携キー */
	private static final String JUDGE_UPDATE_MAP = "judge_update_map";
	/* ++++++++++ v4.01.00 追加完了 ++++++++++ */
	
	/* ++++++++++ v4.02.00 追加開始 ++++++++++ */
	/** 申込画面入力支援ワーク更新CC */
	private static final String JKK_UPDMKMSCIN_SPRTWK_CC = "JKKUpdMkmScinsprtWkCC";
	/* ++++++++++ v4.02.00 追加完了 ++++++++++ */
	
	
	/**
	 * 選択された件数分、機器提供サービス契約サービス契約変更サービスインターフェイス、
	 * 機器提供サービス契約サービス契約回線内訳変更サービスインターフェイスを呼出し、
	 * 接続機器の引継登録を行う。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite addKikiHktgi(SessionHandle handle,
													IRequestParameterReadWrite param,
													String fixedText) throws Throwable
	{
		Map<?, ?> result = null;
		
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ユーザデータ情報
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		ArrayList kikiHktgiSelectList = (ArrayList)parentMap.get("kiki_hktgi_select_list");
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		
		/* 作業項目情報 */
		HashMap<String, Object> inWorkMap = (HashMap)workMap.get("WORK");
		
		// リクエストパラメータ．機器引継選択リストの要素数分、処理を繰り返し行う。
		for (int i = 0; i < kikiHktgiSelectList.size(); i++)
		{
			// ユーザデータ情報
			HashMap<String, Object> inMap = (HashMap<String, Object>)kikiHktgiSelectList.get(i);
			
			// 更新日付の設定
			updateDtmWork((String)inMap.get("upd_dtm_bf_kktk"));
			
			/**
			 * 解約機器の引継に対する処理
			 * */
			executeCancelKiki(inMap, inWorkMap, param, handle);
			
			// 機能コードによる処理読み飛ばし
			func_code = (String)inMap.get("func_code");
			
			if("1".equals(func_code))
			{
				
				// ◇ 親契約識別コードの判定
				String oya_kei_skbt_cd = (String)inMap.get("oya_kei_skbt_cd");
				
				// 親契約識別コードの値が、"01"（サービス契約）の場合
				if (OYA_KEI_SKBT_CD_01.equals(oya_kei_skbt_cd))
				{
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg template = editInMsg_EKK0341C290(param, inMap, inWorkMap);
					HashMap<String, Object> paramMap = getParamMsg(param, new CAANMsg[]{template});
					
					// ◇ SC呼出実行
					result = scCall.run(paramMap, handle);
					
					CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplate = templates[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0341C290(result, param, inMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result, parentTemplate);
				}
				// 親契約識別コードの値が、"02"（サービス契約回線内訳）の場合
				else if (OYA_KEI_SKBT_CD_02.equals(oya_kei_skbt_cd))
				{
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg template = editInMsg_EKK0341C320(param, inMap, inWorkMap);
					HashMap<String, Object> paramMap = getParamMsg(param, new CAANMsg[]{template});
					
					// ◇ SC呼出実行
					result = scCall.run(paramMap, handle);
					
					CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplate = templates[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0341C320(result, param, inMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result, parentTemplate);
				}
				
				/**
				 * 照査前契約への引継に対する処理を実装
				 * */
				executeSyousamaekei(inMap, param, handle);
				
				// ++++++++++ v19.00.00 追加開始 ++++++++++
				// 機器引継先請求契約番号が設定されてる(機器引継画面からの呼び出し)場合
				if ((String)parentMap.get("hktgi_saki_seiky_kei_no") != null && !"".equals((String)parentMap.get("hktgi_saki_seiky_kei_no")))
				{
					// ++++++++++ v19.00.01 追加開始 ++++++++++
					/**
					 * 課金先一覧照会処理を実装
					 * */
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg templateTh = editInMsg_EKK0321B507(param, inMap);
					HashMap<String, Object> paramMapTh = getParamMsg(param, new CAANMsg[]{templateTh});
					
					// ◇ SC呼出実行
					result = scCall.run(paramMapTh, handle);
					
					CAANMsg[] templatesTh = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplateTh = templatesTh[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0321B507(result, param, parentMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result, parentTemplateTh);
					
					CAANMsg[] msgList = parentTemplateTh.getCAANMsgList(EKK0321B507CBSMsg.EKK0321B507CBSMSG1LIST);
					// 機器提供サービス契約番号に紐付く課金先分、処理を行なう
					for (int j = 0; j < msgList.length; j++)
					{
						CAANMsg temp = msgList[j];
						
						/**
						 * 請求契約一意照会処理(引継元)処理を実装
						 * */
						// ◇ 上りマッピング処理
						// リクエストパラメータを引数に上りマッピング処理メソッドを実行
						CAANMsg templateFiMoto = editInMsg_EKK0491A010(param, temp.getString("seiky_kei_no"));
						HashMap<String, Object> paramMapFiMoto = getParamMsg(param, new CAANMsg[]{templateFiMoto});
						
						// ◇ SC呼出実行
						result = scCall.run(paramMapFiMoto, handle);
						
						CAANMsg[] templatesFiMoto = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
						CAANMsg parentTemplateFiMoto = templatesFiMoto[0];
						
						// ◇ 下りマッピング処理
						editOutMsg_EKK0491A010(result, param, parentMap);
						
						/* ◇処理結果の判定*/
						checkResultSC(result, parentTemplateFiMoto);
						
						String lastUpdDtmMoto = "";
						CAANMsg[] retMoto = parentTemplateFiMoto.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
						
						// 結果が取得できた場合
						if (retMoto != null && retMoto.length != 0)
						{
							// 対象の請求契約の最新の更新日付を取得
							lastUpdDtmMoto = retMoto[0].getString(EKK0491A010CBSMsg1List.LAST_UPD_DTM);
						}
						
						/**
						 * 課金先更新処理(引継元)を実装
						 * */
						// ◇ 上りマッピング処理
						// リクエストパラメータを引数に上りマッピング処理メソッドを実行
						CAANMsg templateFo = editInMsg_EKK0321C010(param, inMap, temp.getString(EKK0321C010CBSMsg.KAKINS_NO), lastUpdDtmMoto);
						HashMap<String, Object> paramMapFo = getParamMsg(param, new CAANMsg[]{templateFo});
						
						// ◇ SC呼出実行
						result = scCall.run(paramMapFo, handle);
						
						CAANMsg[] templatesFo = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
						CAANMsg parentTemplateFo = templatesFo[0];
						
						// ◇ 下りマッピング処理
						editOutMsg_EKK0321C010(result, param, parentMap);
						
						/* ◇処理結果の判定*/
						checkResultSC(result, parentTemplateFo);
					}
					// ++++++++++ v19.00.01 追加終了 ++++++++++
					
					/**
					 * 請求契約一意照会処理を実装
					 * */
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					// ++++++++++ v19.00.01 変更開始 ++++++++++
//					CAANMsg templateFi = editInMsg_EKK0491A010(param, parentMap);
					CAANMsg templateFi = editInMsg_EKK0491A010(param, (String)parentMap.get("hktgi_saki_seiky_kei_no"));
					// ++++++++++ v19.00.01 変更終了 ++++++++++
					HashMap<String, Object> paramMapFi = getParamMsg(param, new CAANMsg[]{templateFi});
					
					// ◇ SC呼出実行
					result = scCall.run(paramMapFi, handle);
					
					CAANMsg[] templatesFi = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplateFi = templatesFi[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0491A010(result, param, parentMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result, parentTemplateFi);
					
					String lastUpdDtm = "";
					CAANMsg[] ret = parentTemplateFi.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
					
					// 結果が取得できた場合
					if (ret != null && ret.length != 0)
					{
						// 対象の請求契約の最新の更新日付を取得
						lastUpdDtm = ret[0].getString(EKK0491A010CBSMsg1List.LAST_UPD_DTM);
					}
					
					/**
					 * 課金先登録処理を実装
					 * */
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg templateSe = editInMsg_EKK0321D010(param, parentMap, inMap, lastUpdDtm);
					HashMap<String, Object> paramMapSe = getParamMsg(param, new CAANMsg[]{templateSe});
					
					// ◇ SC呼出実行
					result = scCall.run(paramMapSe, handle);
					
					CAANMsg[] templatesSe = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplateSe = templatesSe[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0321D010(result, param, parentMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result, parentTemplateSe);
				}
				// ++++++++++ v19.00.00 追加終了 ++++++++++
			}
		}
		
		// 2012.06.15 引継先サービス契約ステータスが"010"受付済の場合は宅内機器更新処理を実行しない
		HashMap<String, Object> inMap = (HashMap<String, Object>)kikiHktgiSelectList.get(0);
		// 引継先サービス契約ステータスを取得する
		String svc_kei_stat_saki = (String)inMap.get("svc_kei_stat_saki");
		
		
		// 機能コードによる処理読み飛ばし
		if("1".equals(func_code))
		{
			/* ++++++++++ v4.03.00 修正開始 ++++++++++ */
//			if(!(SVC_KEI_STAT_010.equals(svc_kei_stat_saki)))
//			{
//				/**
//				 * 宅内機器の更新
//				 * */
//				executeTaknkikiUpdate(param, handle, fixedText);
//			}
			/**
			 * 引継機器(住所情報)、宅内機器の更新
			 * */
			executeTaknkikiUpdate(param, handle, fixedText);
			/* ++++++++++ v4.03.00 修正完了 ++++++++++ */
		}
		
		/* ++++++++++ v4.01.00 追加開始 ++++++++++ */
		// 機能コードによる処理読み飛ばし
		if("1".equals(func_code))
		{
			if(SVC_KEI_STAT_010.equals(svc_kei_stat_saki))
			{
				/* ++++++++++ v4.02.00 追加開始 ++++++++++ */
				// 申込入力画面支援ワークの実行
				execMkmScinsprtWk(handle, param);
				/* ++++++++++ v4.02.00 追加完了 ++++++++++ */
				
				/**
				 * 審査結果反映CCの実行
				 * */
				execUpdateJudge(handle, param);
			}
		}
		/* ++++++++++ v4.01.00 追加完了 ++++++++++ */
		
		return param;
	}
	
	/**
	 * チェック処理用のサービスインターフェイスを作成し、返却する。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object> サービスインターフェイスマップ
	 * @throws RequestParameterException
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, 
												IRequestParameterReadWrite param, 
												String fixedText) throws RequestParameterException
	{
		
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		
		// ユーザデータ情報
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		ArrayList kikiHktgiSelectList = (ArrayList)parentMap.get("kiki_hktgi_select_list");
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		
		/* 作業項目情報 */
		HashMap<String, Object> inWorkMap = (HashMap)workMap.get("WORK");
		
		// リクエストパラメータ．機器引継選択リストの要素数分、処理を繰り返し行う。
		for (int i = 0; i < kikiHktgiSelectList.size(); i++)
		{
			// ユーザデータ情報
			HashMap<String, Object> inMap = (HashMap<String, Object>)kikiHktgiSelectList.get(i);
			
			// 更新日付の設定
			updateDtmWork((String)inMap.get("upd_dtm_bf_kktk"));
			
			// ◇ 親契約識別コードの判定
			String oya_kei_skbt_cd = (String)inMap.get("oya_kei_skbt_cd");
			
			// 親契約識別コードの値が、"01"（サービス契約）の場合
			if ("01".equals(oya_kei_skbt_cd))
			{
				// ◇ 上りマッピング処理
				templateList.add(editInMsg_EKK0341C290(param, inMap, inWorkMap));
			}
			// 親契約識別コードの値が、"02"（サービス契約回線内訳）の場合
			else if ("02".equals(oya_kei_skbt_cd))
			{
				// ◇ 上りマッピング処理
				templateList.add(editInMsg_EKK0341C320(param, inMap, inWorkMap));
			}
		}
		
		// リストに追加されたCAANMsgを配列に変換する
		CAANMsg[] templates = templateList.toArray(new CAANMsg[0]);
		
		// サービスI/F実行用マップを取得
		HashMap<String, Object> paramMap = getParamMsg(param, templates);
		
		return paramMap;
	}
	
	
	/**
	 * 更新日付WORKと引数で指定した更新日付を比較し、更新日付WORKを再設定する。
	 * 
	 * @param upd_dtm
	 */
	private void updateDtmWork(String upd_dtm)
	{
		if(Long.parseLong(upd_dtm)  > Long.parseLong(upd_dtm_work))
		{
			// 更新日付を入れ替える
			upd_dtm_work = upd_dtm;
		}
	}
	
	/**
	 * 更新日付WORKと引数で指定した更新日付を比較し、更新日付WORK(照査前契約用)を再設定する。
	 * 
	 * @param upd_dtm
	 */
	private void updateDtmWork_saki(String upd_dtm)
	{
		if(Long.parseLong(upd_dtm)  > Long.parseLong(upd_dtm_work_saki))
		{
			// 更新日付を入れ替える
			upd_dtm_work_saki = upd_dtm;
		}
	}
	
	/**
	 * 解約済み機器に対する回復処理を行います。
	 * 
	 * @param inMap
	 * @param param
	 * @param handle
	 * @throws Exception
	 */
	private void executeCancelKiki(HashMap<String, Object> inMap,
									HashMap<String, Object> inWorkMap,
									IRequestParameterReadWrite param,
									SessionHandle handle) throws Exception
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 引継元＿機器提供サービス契約ステータスが"910":解約済みかチェックする。
		if("910".equals((String)inMap.get("kktk_svc_kei_stat_moto")))
		{
			/**
			 * 機器提供サービス契約回復の実行
			 * */
			Map<?, ?> result_EKK0341C380 = null;
			
			// ◇ 上りマッピング処理
			// リクエストパラメータを引数に上りマッピング処理メソッドを実行
			CAANMsg template_EKK0341C380 = editInMsg_EKK0341C380(param, inMap, inWorkMap);
			HashMap<String, Object> paramMap_EKK0341C380 = getParamMsg(param, new CAANMsg[]{template_EKK0341C380});
			
			// ◇ SC呼出実行
			result_EKK0341C380 = scCall.run(paramMap_EKK0341C380, handle);
			
			CAANMsg[] templates_EKK0341C380 = (CAANMsg[])result_EKK0341C380.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg parentTemplate_EKK0341C380 = templates_EKK0341C380[0];
			
			// ◇ 下りマッピング処理
			editOutMsg_EKK0341C380(result_EKK0341C380, param, inMap);
			
			/* ◇処理結果の判定*/
			checkResultSC(result_EKK0341C380, parentTemplate_EKK0341C380);
			
			// ＫＥＹ＿返品機器番号未設定の場合は処理終了
			String key_hmpin_kiki_no =(String)inMap.get("key_hmpin_kiki_no");
			
			if("".equals(key_hmpin_kiki_no) || key_hmpin_kiki_no == null)
			{
				return;
			}
			
			/**
			 * 機器返品一意照会サービスの実行
			 * */
			// TODO:返品機器番号未設定時は以下の処理を実行するのか確認する。
			Map<?, ?> result_EDK0301A010 = null;
			
			// ◇ 上りマッピング処理
			// リクエストパラメータを引数に上りマッピング処理メソッドを実行
			CAANMsg template_EDK0301A010 = editInMsg_EDK0301A010(param, inMap);
			HashMap<String, Object> paramMap_EDK0301A010 = getParamMsg(param, new CAANMsg[]{template_EDK0301A010});
			
			// ◇ SC呼出実行
			result_EDK0301A010 = scCall.run(paramMap_EDK0301A010, handle);
			
			CAANMsg[] templates_EDK0301A010 = (CAANMsg[])result_EDK0301A010.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg parentTemplate_EDK0301A010 = templates_EDK0301A010[0];
			
			// ◇ 下りマッピング処理
			editOutMsg_EDK0301A010(result_EDK0301A010, param, inMap);
			
			/* ◇処理結果の判定*/
			checkResultSC(result_EDK0301A010, parentTemplate_EDK0301A010);
			
			/**
			 * 機器返品取消の実行判定
			 * */
			// SCからの戻り値からCAANMsgを取得する
			CAANMsg[] templates = (CAANMsg[])result_EDK0301A010.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg parentTemplate = templates[0];
			
			CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EDK0301A010CBSMsg.EDK0301A010CBSMSG1LIST);
			
			// 件数のカウント
			int count = 0;
			
			if (templateArray != null)
			{
				for (int i = 0; i < templateArray.length; i++)
				{
					count++;
				}
			}
			
			// 返品機器一覧の件数確認作成
			if(count > 0)
			{
				/**
				 * 機器返品取消サービスの実行
				 * */
				Map<?, ?> result_EDK0301C040 = null;
				
				// ◇ 上りマッピング処理
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				CAANMsg template_EDK0301C040 = editInMsg_EDK0301C040(param, inMap);
				HashMap<String, Object> paramMap_EDK0301C040 = getParamMsg(param, new CAANMsg[]{template_EDK0301C040});
				
				// ◇ SC呼出実行
				result_EDK0301C040 = scCall.run(paramMap_EDK0301C040, handle);
				
				CAANMsg[] templates_EDK0301C040 = (CAANMsg[])result_EDK0301C040.get(JCMConstants.TEMPLATE_LIST_KEY);
				CAANMsg parentTemplate_EDK0301C040 = templates_EDK0301C040[0];
				
				// ◇ 下りマッピング処理
				editOutMsg_EDK0301C040(result_EDK0301C040, param, inMap);
				
				/* ◇処理結果の判定*/
				checkResultSC(result_EDK0301C040, parentTemplate_EDK0301C040);
				
			}
		}
	}

	private void executeSyousamaekei(HashMap<String, Object> inMap,
			IRequestParameterReadWrite param,
			SessionHandle handle) throws Exception
	{
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 引継先＿サービス契約ステータスが"010":受付済かチェック

		if(!(SVC_KEI_STAT_010.equals((String)inMap.get("svc_kei_stat_saki"))))
		{
			return;
		}
		
		// 引継元＿機器提供サービスコード
		String kktk_svc_cd_moto = (String)inMap.get("kktk_svc_cd");
		// 引継元＿親契約識別コード
		String oya_kei_skbt_cd_moto = (String)inMap.get("oya_kei_skbt_cd");
			
		// 引継先サービス契約の取得
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		ArrayList kikiHktgiSelect_saki_List = (ArrayList)parentMap.get("kiki_hktgi_select_saki_list");
		
		for(int i=0; i < kikiHktgiSelect_saki_List.size(); i++)
		{
			// １件取得
			// ユーザデータ情報
			HashMap<String, Object> inMap_saki = (HashMap<String, Object>)kikiHktgiSelect_saki_List.get(i);
			
			// 排他制御_更新年月日時分秒を取得
			updateDtmWork_saki((String)inMap_saki.get("last_upd_dtm"));
			
			/** EKK0341A010 機器提供サービス契約一意照会  **/
			
			Map<?, ?> result_EKK0341A010 = null;
			
			// ◇ 上りマッピング処理
			// リクエストパラメータを引数に上りマッピング処理メソッドを実行
			CAANMsg template = editInMsg_EKK0341A010(param, inMap, inMap_saki);
			// 共通設定部
			HashMap<String, Object> paramMap = getParamMsg(param, new CAANMsg[]{template});
			
			// ◇ SC呼出実行
			result_EKK0341A010 = scCall.run(paramMap, handle);
			CAANMsg[] templates = (CAANMsg[])result_EKK0341A010.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg parentTemplate = templates[0];
			
//			// ◇ 下りマッピング処理
//			editOutMsg_EKK0341A010(result_EKK0341A010, param, inMap);
			// ◇処理結果の判定
			checkResultSC(result_EKK0341A010, parentTemplate);
			
			HashMap<String, Object> kktk_saki_map = new HashMap<String, Object>();
			
			// 引継先機器提供サービス契約情報の取得
			kktk_saki_map = editOutMsg_EKK0341A010(result_EKK0341A010, param, inMap, kktk_saki_map);
			
			// 検索結果件数取得、０件(論理削除済み)の場合は処理終了
			if("0".equals((String)kktk_saki_map.get("result_count")))
			{
				continue;
			}
			
			// 引継先＿機器提供サービスコード
			String kktk_svc_cd_saki = (String)kktk_saki_map.get("kktk_svc_cd");
			// 引継先＿親契約識別コード
			String oya_kei_skbt_cd_saki = (String)kktk_saki_map.get("oya_kei_skbt_cd");
			// 引継先＿機器提供サービス契約ステータス
			String kktk_svc_kei_stat = (String)inMap_saki.get("kktk_svc_kei_stat");
			
			// 更新対象判定
			if( kktk_svc_cd_saki.equals(kktk_svc_cd_moto) 
				&& oya_kei_skbt_cd_saki.equals(oya_kei_skbt_cd_moto)
					&& KKTK_SVC_KEI_STAT_010.equals(kktk_svc_kei_stat))
			{
				/**
				 * 機器提供サービス契約キャンセル
				 * */
				Map<?, ?> result_EKK0341C330 = null;
				
				// ◇ 上りマッピング処理
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				CAANMsg template_EKK0341C330 = editInMsg_EKK0341C330(param, inMap, inMap_saki);
				HashMap<String, Object> paramMap_EKK0341C330 = getParamMsg(param, new CAANMsg[]{template_EKK0341C330});
					
				// ◇ SC呼出実行
				result_EKK0341C330 = scCall.run(paramMap_EKK0341C330, handle);
					
				CAANMsg[] templates_EKK0341C330 = (CAANMsg[])result_EKK0341C330.get(JCMConstants.TEMPLATE_LIST_KEY);
				CAANMsg parentTemplate_EKK0341C330 = templates_EKK0341C330[0];
					
				// ◇ 下りマッピング処理
				editOutMsg_EKK0341C330(result_EKK0341C330, param, inMap);
					
				/* ◇処理結果の判定*/
				checkResultSC(result_EKK0341C330, parentTemplate_EKK0341C330);
					
				/**
				 * 機器提供サービス契約論理削除
				 * */
				Map<?, ?> result_EKK0341E010 = null;
				
				// ◇ 上りマッピング処理
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				CAANMsg template_EKK0341E010 = editInMsg_EKK0341E010(param, inMap, inMap_saki);
				HashMap<String, Object> paramMap_EKK0341E010 = getParamMsg(param, new CAANMsg[]{template_EKK0341E010});
				
				// ◇ SC呼出実行
				result_EKK0341E010 = scCall.run(paramMap_EKK0341E010, handle);
				
				CAANMsg[] templates_EKK0341E010 = (CAANMsg[])result_EKK0341E010.get(JCMConstants.TEMPLATE_LIST_KEY);
				CAANMsg parentTemplate_EKK0341E010 = templates_EKK0341E010[0];
				
				// ◇ 下りマッピング処理
				editOutMsg_EKK0341E010(result_EKK0341E010, param, inMap);
				
				/* ◇処理結果の判定*/
				checkResultSC(result_EKK0341E010, parentTemplate_EKK0341E010);
				
				//OM-2017-0001115 ADD START
				/**
				 * 課金先一覧照会処理を実装
				 * */
				
				Map<?, ?> result_EKK0321B507 = null;
				
				// ◇ 上りマッピング処理
				// リクエストパラメータを引数に上りマッピング処理メソッドを実行
				inMap_saki.put("func_code", inMap.get("func_code"));
				CAANMsg template_EKK0321B507 = editInMsg_EKK0321B507(param, inMap_saki);
				HashMap<String, Object> paramMap_EKK0321B507 = getParamMsg(param, new CAANMsg[]{template_EKK0321B507});
				
				// ◇ SC呼出実行
				result_EKK0321B507 = scCall.run(paramMap_EKK0321B507, handle);
				
				CAANMsg[] templatesTh = (CAANMsg[])result_EKK0321B507.get(JCMConstants.TEMPLATE_LIST_KEY);
				CAANMsg parentTemplateTh = templatesTh[0];
				
				// ◇ 下りマッピング処理
				editOutMsg_EKK0321B507(result_EKK0321B507, param, parentMap);
				
				/* ◇処理結果の判定*/
				checkResultSC(result_EKK0321B507, parentTemplateTh);
				
				CAANMsg[] msgList = parentTemplateTh.getCAANMsgList(EKK0321B507CBSMsg.EKK0321B507CBSMSG1LIST);
				// 機器提供サービス契約番号に紐付く課金先分、処理を行なう
				for (int j = 0; j < msgList.length; j++)
				{
					CAANMsg temp = msgList[j];
					
					/**
					 * 請求契約一意照会処理(引継先)処理を実装
					 * */
					
					Map<?, ?> result_EKK0491A010 = null;
					
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg templateFiMoto = editInMsg_EKK0491A010(param, temp.getString("seiky_kei_no"));
					HashMap<String, Object> paramMapFiMoto = getParamMsg(param, new CAANMsg[]{templateFiMoto});
					
					// ◇ SC呼出実行
					result_EKK0491A010 = scCall.run(paramMapFiMoto, handle);
					
					CAANMsg[] templatesFiMoto = (CAANMsg[])result_EKK0491A010.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplateFiMoto = templatesFiMoto[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0491A010(result_EKK0491A010, param, parentMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result_EKK0491A010, parentTemplateFiMoto);
					
					String lastUpdDtmMoto = "";
					CAANMsg[] retMoto = parentTemplateFiMoto.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
					
					// 結果が取得できた場合
					if (retMoto != null && retMoto.length != 0)
					{
						// 対象の請求契約の最新の更新日付を取得
						lastUpdDtmMoto = retMoto[0].getString(EKK0491A010CBSMsg1List.LAST_UPD_DTM);
					}
					/**
					 * 課金先論理削除
					 * */
					Map<?, ?> result_EKK0321E010 = null;
					
					// ◇ 上りマッピング処理
					// リクエストパラメータを引数に上りマッピング処理メソッドを実行
					CAANMsg template_EKK0321E010 = editInMsg_EKK0321E010(param, inMap, temp.getString(EKK0321C010CBSMsg.KAKINS_NO), lastUpdDtmMoto);
					HashMap<String, Object> paramMap_EKK0321E010 = getParamMsg(param, new CAANMsg[]{template_EKK0321E010});
					
					// ◇ SC呼出実行
					result_EKK0321E010 = scCall.run(paramMap_EKK0321E010, handle);
					
					CAANMsg[] templates_EKK0321E010 = (CAANMsg[])result_EKK0321E010.get(JCMConstants.TEMPLATE_LIST_KEY);
					CAANMsg parentTemplate_EKK0321E010 = templates_EKK0321E010[0];
					
					// ◇ 下りマッピング処理
					editOutMsg_EKK0321E010(result_EKK0321E010, param, inMap);
					
					/* ◇処理結果の判定*/
					checkResultSC(result_EKK0321E010, parentTemplate_EKK0321E010);
				
				}
				//OM-2017-0001115 ADD END
			}
		}
	}
	
	/**
	 * 引継元先のサービス契約回線内訳情報を取得し、住所項目に差異があるか確認します。
	 * 差異があれば引継対象となる機器提供サービス契約の住所情報を変更し、宅内機器連携を実行します。
	 * <br>
	 * @param param
	 * @param handle
	 * @param fixedText
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void executeTaknkikiUpdate(IRequestParameterReadWrite param,
										SessionHandle handle,
										String fixedText) throws Exception
	{
		/**
		 * 引継登録マップを取得して処理する。
		 */
		
		Map<?, ?> result = null;
		
		// SC呼び出し部品のインスタンス生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ユーザデータ情報(上りマッピング)
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// ユーザデータ情報(前処理から取得)
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		// 引継元＿機器提供選択リスト
		ArrayList kikiHktgiSelectList = (ArrayList)parentMap.get("kiki_hktgi_select_list");
		
//		// 作業領域の取得
//		Map workMap = param.getMappingWorkArea();
//		
//		/* 作業項目情報 */
//		HashMap<String, Object> inWorkMap = (HashMap)workMap.get("WORK");
		
		
		// サービス契約番号判定のため１件目を取得する。
		HashMap<String, Object> checkMap = (HashMap<String, Object>)kikiHktgiSelectList.get(0);
		
		// 引継元＿サービス契約番号の取得
		String svc_kei_no_moto = (String)checkMap.get("svc_kei_no_moto");
		// 引継元＿サービス契約番号の取得
		String svc_kei_no_saki = (String)checkMap.get("svc_kei_no");
		
		/**
		 * サービス契約回線内訳一覧照会(引継元)
		 * */
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		CAANMsg template_EKK0251B003_moto = editInMsg_EKK0251B003(param, inMap, svc_kei_no_moto);
		HashMap<String, Object> paramMap_EKK0251B003_moto = getParamMsg(param, new CAANMsg[]{template_EKK0251B003_moto});
		
		// ◇ SC呼出実行
		result = scCall.run(paramMap_EKK0251B003_moto, handle);
		
		CAANMsg[] templates_EKK0251B003_moto = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate_EKK0251B003_moto = templates_EKK0251B003_moto[0];
		
		/* ◇処理結果の判定*/
		checkResultSC(result, parentTemplate_EKK0251B003_moto);
		
		// 住所情報の退避
		HashMap<String, Object> adrMap_moto = new HashMap<String, Object>();
		adrMap_moto = editOutMsg_EKK0251B003(result, param, inMap, adrMap_moto);
		
		/**
		 * サービス契約回線内訳一覧照会(引継先)
		 * */
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		CAANMsg template_EKK0251B003_saki = editInMsg_EKK0251B003(param, inMap, svc_kei_no_saki);
		HashMap<String, Object> paramMap_EKK0251B003_saki = getParamMsg(param, new CAANMsg[]{template_EKK0251B003_saki});
		
		// ◇ SC呼出実行
		result = scCall.run(paramMap_EKK0251B003_saki, handle);
		
		CAANMsg[] templates_EKK0251B003_saki = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate_EKK0251B003_saki = templates_EKK0251B003_saki[0];
		
		// ◇ 下りマッピング処理
		//editOutMsg_EKK0251B003(result, param, inMap);
		
		/* ◇処理結果の判定*/
		checkResultSC(result, parentTemplate_EKK0251B003_saki);

		// 住所情報の退避
		HashMap<String, Object> adrMap_saki = new HashMap<String, Object>();
		adrMap_saki = editOutMsg_EKK0251B003(result, param, inMap, adrMap_saki);
		
		/**
		 * 住所の差異があるかチェックし、差異があれば件数分更新処理を行う。
		 * */
		if(checkAddress(adrMap_moto, adrMap_saki))
		{
			/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
			
			// 引継機器分繰り返し処理実行
			for(int i=0; i < kikiHktgiSelectList.size(); i++)
			{
				// 一覧から1件取得
				// サービス契約番号判定のため１件目を取得する。
				HashMap<String, Object> hktgiMotoMap = (HashMap<String, Object>)kikiHktgiSelectList.get(i);
				
				// EKK0341C230_機器提供サービス契約情報変更の実行
				executeEKK0341C230(param, handle, scCall, hktgiMotoMap, adrMap_saki);
				
				String kaisen_place_no = (String)adrMap_saki.get("kaisen_place_no");
				
				if(!"".equals(kaisen_place_no))
				{
					// EKK0341C450_機器設置先場所反映の実行
					executeEKK0341C450(param, handle, scCall, hktgiMotoMap, adrMap_saki);
				}
			}
			
			// 引継先サービス契約ステータスを取得する
			HashMap<String, Object> inWorkMap = (HashMap<String, Object>)kikiHktgiSelectList.get(0);
			// 引継先サービス契約ステータスを取得する
			String svc_kei_stat_saki = (String)inWorkMap.get("svc_kei_stat_saki");
			
			
			// "010":受付済の場合は後続処理を実行しない。
			if((SVC_KEI_STAT_010.equals(svc_kei_stat_saki)))
			{
				return;
			}
			/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
			
			/**
			 * 機器場所番号変更サービスＩ／Ｆ
			 * */
			// ◇ 上りマッピング処理
			// リクエストパラメータを引数に上りマッピング処理メソッドを実行
			CAANMsg template_EKKA0020004 = editInMsg_EKKA0020004(param, inMap, kikiHktgiSelectList, adrMap_saki);
			HashMap<String, Object> paramMap_EKKA0020004 = getParamMsg(param, new CAANMsg[]{template_EKKA0020004});
			
			// ◇ SC呼出実行
			result = scCall.run(paramMap_EKKA0020004, handle);
			
			CAANMsg[] templates_EKKA0020004 = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			CAANMsg parentTemplate_EKKA0020004 = templates_EKKA0020004[0];
			
			// ◇ 下りマッピング処理
			editOutMsg_EKKA0020004(result, param, inMap);
			
			/* ◇処理結果の判定*/
			checkResultSC(result, parentTemplate_EKKA0020004);
		
		}
	}
	
	/* ++++++++++ v4.02.00 追加開始 ++++++++++ */
	/**
	 * 申込画面入力支援ワーク更新部品の実行
	 * <br>
	 * @param handle
	 * @param param
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execMkmScinsprtWk(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		param.setData(JKK_UPDMKMSCIN_SPRTWK_CC, new HashMap<String, Object>());
		
		HashMap<String, Object> outMap = (HashMap<String, Object>)param.getData(JKK_UPDMKMSCIN_SPRTWK_CC);
		
		// 引継元機器一覧に格納されている引継先サービス契約番号を取得する。
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		ArrayList kikiHktgiSelectList = (ArrayList)parentMap.get("kiki_hktgi_select_list");
		HashMap<String, Object> inMap = (HashMap<String, Object>)kikiHktgiSelectList.get(0);
		
		// サービス契約番号
		outMap.put("key_svc_kei_no", (String)inMap.get("svc_kei_no"));
		// 項目制御コード 非活性
		outMap.put("kiki_if_ctl_cd", "1");

		JKKUpdMkmScinsprtWkCC jkkUpdMkmScinsprtWkCC = new JKKUpdMkmScinsprtWkCC();
		jkkUpdMkmScinsprtWkCC.updMkmScinsprtWk(handle, param, JKK_UPDMKMSCIN_SPRTWK_CC);

		param.removeData(JKK_UPDMKMSCIN_SPRTWK_CC);
	}
	/* ++++++++++ v4.02.00 追加完了 ++++++++++ */
	
	/* ++++++++++ v4.01.00 追加開始 ++++++++++ */
	/**
	 * 審査結果反映CCの実行
	 * <br>
	 * @param handle
	 * @param param
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execUpdateJudge(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		// ユーザデータ情報
		HashMap<String, Object> parentMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		ArrayList kikiHktgiSelectList = (ArrayList)parentMap.get("kiki_hktgi_select_list");
		HashMap<String, Object> inMap = (HashMap<String, Object>)kikiHktgiSelectList.get(0);
		
		// 引継左記サービス契約番号を取得する。
		String svc_kei_no = (String)inMap.get("svc_kei_no");
		
		// 審査結果反映CCにセットする内容を取得
		param.setData(JUDGE_UPDATE_MAP, new HashMap<String, Object>());
		HashMap<String, Object> outMap = (HashMap<String, Object>)param.getData(JUDGE_UPDATE_MAP);
		
		// サービス契約番号1
		outMap.put("key_svc_kei_no1", svc_kei_no);
		// サービス契約番号2
		outMap.put("key_svc_kei_no2", "");
		// サービス契約番号3
		outMap.put("key_svc_kei_no3", "");
		// サービス契約番号4
		outMap.put("key_svc_kei_no4", "");
		
		// インスタンスの生成
		JKKUpdateJudgeTranCC jkkupdatejudgetrancc = new JKKUpdateJudgeTranCC();
		jkkupdatejudgetrancc.execUpdateJudge(handle, param, JUDGE_UPDATE_MAP);
	}
	/* ++++++++++ v4.01.00 追加完了 ++++++++++ */
	
	/**
	 * @param motoMap
	 * @param sakiMap
	 * @return true:住所項目に不一致あり、false:住所項目一致
	 */
	private boolean checkAddress(HashMap<String, Object> motoMap, HashMap<String, Object> sakiMap){
		
		// 一致チェック(回線場所住所コード)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD))
		{
			return true;
		}
		// 一致チェック(回線場所郵便番号)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD))
		{
			return true;
		}
		// 一致チェック(回線場所都道府県名)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM))
		{
			return true;
		}
		// 一致チェック(回線場所市区町村名)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM))
		{
			return true;
		}
		// 一致チェック(回線場所大字通称名)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM))
		{
			return true;
		}
		// 一致チェック(回線場所字丁目名)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM))
		{
			return true;
		}
		// 一致チェック(回線場所番地号)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO))
		{
			return true;
		}
		// 一致チェック(回線場所住所補記・建物名)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM))
		{
			return true;
		}
		// 一致チェック(回線場所住所補記・部屋番号)
		if(!checkData(motoMap, sakiMap, EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * 元・先の各HashMapから該当するデータを取得し、一致するかチェックします。
	 * 
	 * @param motoMap
	 * @param sakiMap
	 * @param target
	 * @return true:一致 false:不一致
	 */
	private boolean checkData(HashMap<String, Object> motoMap, HashMap<String, Object> sakiMap, String target)
	{
		String targetMoto = (String)motoMap.get(target);
		String targetSaki = (String)sakiMap.get(target);
		
		if(targetMoto.equals(targetSaki))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	

	/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
	/**
	 * EKK0341C230_機器提供サービス契約情報変更を実行します。
	 * <br>
	 * @param param
	 * @param handle
	 * @param scCall
	 * @param hktgiMotoMap
	 * @param adrMap_saki
	 * @throws RequestParameterException 
	 * @throws SCException 
	 */
	private void executeEKK0341C230(IRequestParameterReadWrite param,
										SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										HashMap<String, Object> hktgiMotoMap,
										HashMap<String, Object> adrMap_saki) throws Exception
	{
		/**
		 * 機器提供サービス契約一意照会（機器送付先住所手動入力フラグの取得）
		 * */
		/** EKK0341A010 機器提供サービス契約一意照会  **/
		
		Map<?, ?> result_EKK0341A010 = null;
		
		HashMap<String, Object> inMap = new HashMap<String, Object>();
		HashMap<String, Object> inWorkMap = new HashMap<String, Object>();
		
		// key値のセット
		inWorkMap.put("kktk_svc_kei_no", (String)hktgiMotoMap.get("kktk_svc_kei_no"));
		inWorkMap.put("key_rsv_aply_ymd", (String)hktgiMotoMap.get("rsv_aply_ymd"));
		inWorkMap.put("key_gene_add_dtm", "");
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		CAANMsg template = editInMsg_EKK0341A010(param, inMap, inWorkMap);
		// 共通設定部
		HashMap<String, Object> paramMap = getParamMsg(param, new CAANMsg[]{template});
		
		// ◇ SC呼出実行
		result_EKK0341A010 = scCall.run(paramMap, handle);
		CAANMsg[] templates = (CAANMsg[])result_EKK0341A010.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
//		// ◇ 下りマッピング処理
//		editOutMsg_EKK0341A010(result_EKK0341A010, param, inMap);
		// ◇処理結果の判定
		checkResultSC(result_EKK0341A010, parentTemplate);
		
		HashMap<String, Object> kktk_svc_kei_map = new HashMap<String, Object>();
		
		// 機器提供サービス契約情報の取得
		kktk_svc_kei_map = editOutMsg_EKK0341A010(result_EKK0341A010, param, inMap, kktk_svc_kei_map);
		
		
		// 機器送付先住所手動入力フラグの取得
		hktgiMotoMap.put("kiki_shs_ad_man_input_flg", (String)kktk_svc_kei_map.get("kiki_shs_ad_man_input_flg"));
		// 更新年月日時分秒の取得
		hktgiMotoMap.put("last_upd_dtm", (String)kktk_svc_kei_map.get("last_upd_dtm"));
		
		// その他退避情報の取得
		HashMap ekk0341a010Map = (HashMap)kktk_svc_kei_map.get("EKK0341A010_out");
		
		/**
		 * 機器提供サービス契約情報変更
		 * */
		Map<?, ?> result_EKK0341C230 = null;
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		CAANMsg template_EKK0341C230 = editInMsg_EKK0341C230(param, hktgiMotoMap, adrMap_saki, ekk0341a010Map);
		HashMap<String, Object> paramMap_EKK0341C230 = getParamMsg(param, new CAANMsg[]{template_EKK0341C230});
			
		// ◇ SC呼出実行
		result_EKK0341C230 = scCall.run(paramMap_EKK0341C230, handle);
			
		CAANMsg[] templates_EKK0341C230 = (CAANMsg[])result_EKK0341C230.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate_EKK0341C230 = templates_EKK0341C230[0];
			
		// ◇ 下りマッピング処理
		editOutMsg_EKK0341C230(result_EKK0341C230, param, hktgiMotoMap);
			
		/* ◇処理結果の判定*/
		checkResultSC(result_EKK0341C230, parentTemplate_EKK0341C230);
	}
	
	/**
	 * EKK0341C450_機器設置先場所反映を実行します。
	 * <br>
	 * @param param
	 * @param handle
	 * @param scCall
	 * @param hktgiMotoMap
	 * @param adrMap_saki
	 * @throws Exception
	 */
	private void executeEKK0341C450(IRequestParameterReadWrite param,
										SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										HashMap<String, Object> hktgiMotoMap,
										HashMap<String, Object> adrMap_saki) throws Exception
	{
		/**
		 * 機器設置先場所反映
		 * */
		Map<?, ?> result_EKK0341C450 = null;
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		CAANMsg template_EKK0341C450 = editInMsg_EKK0341C450(param, hktgiMotoMap, adrMap_saki);
		HashMap<String, Object> paramMap_EKK0341C450 = getParamMsg(param, new CAANMsg[]{template_EKK0341C450});
			
		// ◇ SC呼出実行
		result_EKK0341C450 = scCall.run(paramMap_EKK0341C450, handle);
			
		CAANMsg[] templates_EKK0341C450 = (CAANMsg[])result_EKK0341C450.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate_EKK0341C450 = templates_EKK0341C450[0];
			
		// ◇ 下りマッピング処理
		editOutMsg_EKK0341C450(result_EKK0341C450, param, hktgiMotoMap);
			
		/* ◇処理結果の判定*/
		checkResultSC(result_EKK0341C450, parentTemplate_EKK0341C450);
	}
	/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
	
	/**
	 * サービスインターフェース処理結果コードを確認します。
	 * @param result
	 * @param parentTemplate
	 * @throws Exception
	 */
	private void checkResultSC(Map<?, ?> result,
								CAANMsg parentTemplate) throws Exception
	{
		/* ◇処理結果の判定*/
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		Integer status = parentTemplate.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status.intValue()))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
	}
	
	
	/**
	 * サービスインターフェイスリスト(CAANMsg[])からサービスI/F実行用マップを作成します<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param templates サービスインターフェイスリスト
	 * @return HashMap<String, Object> サービスI/F実行用マップ
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> getParamMsg(IRequestParameterReadWrite param, CAANMsg[] templates) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		/* SCインプット共通データ */
		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文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, templates);
		
		return paramMap;
	}
	
	/**
	 * 業務パラメータと機器提供サービスコートを比較し、実行するサービスインターフェースを確定する。
	 * 
	 * @param work_param_sette_list
	 * @param kktk_svc_cd
	 * @return true:「EKK0341C320」を実行、false:「EKK0341C280」を実行
	 */
	private boolean checkKktkSvcCode(String[] work_param_sette_list, String kktk_svc_cd)
	{
		// 業務パラメータの設定件数分ループ
		for(int i =0; i < work_param_sette_list.length; i++)
		{
			// 業務パラメータから１件取得する
			String param_value = work_param_sette_list[i];
		
			if(kktk_svc_cd.equals(param_value)) 
			{
				// 一致する場合
				return true;
			}
		}
		// 一致しなかった場合
		return false;
	}
	
	/**
	 * 機器提供サービス契約サービス契約変更の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341C290(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inWorkMap) throws RequestParameterException
	{
		// 機器提供サービス契約サービス契約変更サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C290CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341C290CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C290);

		// 機能コード
		template.set(EKK0341C290CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器提供サービス契約サービス契約変更.機器提供サービス契約番号
		if ("".equals(inMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C290CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.KKTK_SVC_KEI_NO, (String)inMap.get("kktk_svc_kei_no"));
		}
		
		// 機器引継登録マップ.サービス契約番号 → 機器提供サービス契約サービス契約変更.サービス契約番号
		if ("".equals(inMap.get("svc_kei_no")))
		{
			template.setNull(EKK0341C290CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// 作業項目マップ.申込明細番号 → 機器提供サービス契約サービス契約変更.申込明細番号
		if (inWorkMap == null || "".equals(inWorkMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341C290CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.MSKM_DTL_NO, (String)inWorkMap.get("mskm_dtl_no"));
		}
		
		// 機器引継登録マップ.機器提供サービス契約引継発生年月日 → 機器提供サービス契約サービス契約変更.機器提供サービス契約引継発生年月日
		if ("".equals(inMap.get("kktk_svc_kei_hkhasymd")))
		{
			template.setNull(EKK0341C290CBSMsg.KKTK_SVC_KEI_HKHASYMD);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.KKTK_SVC_KEI_HKHASYMD, (String)inMap.get("kktk_svc_kei_hkhasymd"));
		}
		
		// 機器引継登録マップ.予約適用年月日 → 機器提供サービス契約サービス契約変更.予約適用年月日
		if ("".equals(inMap.get("rsv_aply_ymd")))
		{
			template.setNull(EKK0341C290CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.RSV_APLY_YMD, (String)inMap.get("rsv_aply_ymd"));
		}
		
		// 機器引継登録マップ.異動区分 → 機器提供サービス契約サービス契約変更.異動区分
		if ("".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0341C290CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器提供サービス契約サービス契約変更.更新年月日時分秒(更新前)
		/* ++++++++++ v4.01.00 修正開始 ++++++++++ */
//		if ("".equals(inMap.get("upd_dtm_bf_svc")))
//		{
//			template.setNull(EKK0341C290CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0341C290CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf_svc"));
//		}
		template.set(EKK0341C290CBSMsg.UPD_DTM_BF, upd_dtm_work);
		/* ++++++++++ v4.01.00 修正完了 ++++++++++ */
		
		// 巻取１から追加項目
		// 機器提供サービス契約サービス契約変更.機器移転先移動実施者識別コード
		if ("".equals(inMap.get("kiki_itens_mv_jssis_skcd")))
		{
			template.setNull(EKK0341C290CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD, (String)inMap.get("kiki_itens_mv_jssis_skcd"));
		}
		
		/* ++++++++++ v4.02.00 修正開始 ++++++++++ */
		// 機器提供サービス契約サービス契約変更.SYSID
		if("".equals(inMap.get("hktgi_saki_sysid")))
		{
			template.setNull(EKK0341C290CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.SYSID, inMap.get("hktgi_saki_sysid"));
		}
		/* ++++++++++ v4.02.00 修正完了 ++++++++++ */
		
		return template;
	}
	
	/**
	 * 機器提供サービス契約サービス契約回線内訳変更の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341C320(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inWorkMap) throws RequestParameterException
	{
		// 機器提供サービス契約サービス契約回線内訳変更サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C320CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341C320CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C320);

		// 機能コード
		template.set(EKK0341C320CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器提供サービス契約サービス契約回線内訳変更.機器提供サービス契約番号
		if ("".equals(inMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C320CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.KKTK_SVC_KEI_NO, (String)inMap.get("kktk_svc_kei_no"));
		}
		
		// 作業項目マップ.サービス契約回線内訳番号 → 機器提供サービス契約サービス契約回線内訳変更.サービス契約回線内訳番号
		if (inWorkMap == null || "".equals(inWorkMap.get("svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK0341C320CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)inWorkMap.get("svc_kei_kaisen_ucwk_no"));
		}
		
		// 作業項目マップ.申込明細番号 → 機器提供サービス契約サービス契約回線内訳変更.申込明細番号
		if (inWorkMap == null || "".equals(inWorkMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341C320CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.MSKM_DTL_NO, (String)inWorkMap.get("mskm_dtl_no"));
		}
		
		// 機器引継登録マップ.機器提供サービス契約引継発生年月日 → 機器提供サービス契約サービス契約回線内訳変更.機器提供サービス契約引継発生年月日
		if ("".equals(inMap.get("kktk_svc_kei_hkhasymd")))
		{
			template.setNull(EKK0341C320CBSMsg.KKTK_SVC_KEI_HKHASYMD);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.KKTK_SVC_KEI_HKHASYMD, (String)inMap.get("kktk_svc_kei_hkhasymd"));
		}
		
		// 機器引継登録マップ.予約適用年月日 → 機器提供サービス契約サービス契約回線内訳変更.予約適用年月日
		if ("".equals(inMap.get("rsv_aply_ymd")))
		{
			template.setNull(EKK0341C320CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.RSV_APLY_YMD, (String)inMap.get("rsv_aply_ymd"));
		}
		
		// 機器引継登録マップ.異動区分 → 機器提供サービス契約サービス契約回線内訳変更.異動区分
		if ("".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0341C320CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器提供サービス契約サービス契約回線内訳変更.更新年月日時分秒(更新前)
//		if ("".equals(inMap.get("upd_dtm_bf")))
//		{
//			template.setNull(EKK0341C320CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0341C320CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
//		}
		
		template.set(EKK0341C320CBSMsg.UPD_DTM_BF, upd_dtm_work);
		
		/* ++++++++++ v4.02.00 追加開始 ++++++++++ */
		// 機器提供サービス契約サービス契約回線内訳変更.SYSID
		if("".equals(inMap.get("hktgi_saki_sysid")))
		{
			template.setNull(EKK0341C320CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0341C320CBSMsg.SYSID, inMap.get("hktgi_saki_sysid"));
		}
		/* ++++++++++ v4.02.00 追加完了 ++++++++++ */
		
		return template;
	}
	
	
	/**
	 *  機器提供サービス契約回復の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341C380(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inWorkMap) throws RequestParameterException
	{
		// 機器提供サービス契約回復サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C380CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341C380CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C380);

		// 機能コード
		template.set(EKK0341C380CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器提供サービス契約回復.機器提供サービス契約番号
		if ("".equals(inMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO, (String)inMap.get("kktk_svc_kei_no"));
		}
		
		// 機器引継登録マップ.異動区分 → 機器提供サービス契約回復.機器提供サービス契約番号
		if ("".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0341C380CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C380CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}
		
		// 作業項目マップ.申込明細番号 → 機器提供サービス契約サービス契約変更.申込明細番号
		if (inWorkMap == null || "".equals(inWorkMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341C290CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341C290CBSMsg.MSKM_DTL_NO, (String)inWorkMap.get("mskm_dtl_no"));
		}
		
		// 機器引継登録マップ.運用日 → 機器提供サービス契約回復.回復年月日
		if ("".equals(inMap.get("kaihk_ymd")))
		{
			template.setNull(EKK0341C380CBSMsg.KAIHK_YMD);
		}
		else
		{
			template.set(EKK0341C380CBSMsg.KAIHK_YMD, (String)inMap.get("kaihk_ymd"));
		}
		
		// 更新年月日(更新前）→
//		if ("".equals(inMap.get("upd_dtm_bf")))
//		{
//			template.setNull(EKK0341C380CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0341C380CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
//		}
		template.set(EKK0341C380CBSMsg.UPD_DTM_BF, upd_dtm_work);
		
		
		return template;
	}
	
	/**
	 *  機器返品一意照会の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EDK0301A010(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 返品機器一覧照会サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EDK0301A010CBSMsg.class.getName());

		// テンプレートID
		template.set(EDK0301A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EDK0301A010);

		// 機能コード
		template.set(EDK0301A010CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.返品機器番号 → 返品機器一覧照会.ＫＥＹ＿返品機器番号
		if ("".equals(inMap.get("key_hmpin_kiki_no")))
		{
			template.setNull(EDK0301A010CBSMsg.KEY_HMPIN_KIKI_NO);
		}
		else
		{
			template.set(EDK0301A010CBSMsg.KEY_HMPIN_KIKI_NO, (String)inMap.get("key_hmpin_kiki_no"));
		}
		
		// 機器引継登録マップ.運用日 → 返品機器一覧照会.ＫＥＹ＿運用日付
		if ("".equals(inMap.get("key_unyo_ymd")))
		{
			template.setNull(EDK0301A010CBSMsg.KEY_UNYO_YMD);
		}
		else
		{
			template.set(EDK0301A010CBSMsg.KEY_UNYO_YMD, (String)inMap.get("key_unyo_ymd"));
		}
		
		// 機器引継登録マップ.運用日 → 返品機器一覧照会.ＫＥＹ＿物流保全番号
		if ("".equals(inMap.get("key_btryhozn_no")))
		{
			template.setNull(EDK0301A010CBSMsg.KEY_BTRYHOZN_NO);
		}
		else
		{
			template.set(EDK0301A010CBSMsg.KEY_BTRYHOZN_NO, (String)inMap.get("key_btryhozn_no"));
		}
		
		return template;
	}
	
	/**
	 *  返品機器取消の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EDK0301C040(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 返品機器取消サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EDK0301C040CBSMsg.class.getName());

		// テンプレートID
		template.set(EDK0301C040CBSMsg.TEMPLATEID, TEMPLATE_ID_EDK0301C040);

		// 機能コード
		template.set(EDK0301C040CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.返品機器番号 → 返品機器取消.ＫＥＹ＿返品機器番号
		if ("".equals(inMap.get("key_hmpin_kiki_no")))
		{
			template.setNull(EDK0301C040CBSMsg.KEY_HMPIN_KIKI_NO);
		}
		else
		{
			template.set(EDK0301C040CBSMsg.KEY_HMPIN_KIKI_NO, (String)inMap.get("key_hmpin_kiki_no"));
		}
		
		// 機器引継登録マップ.運用日 → 返品機器取消.更新前最終更新年月日時分秒
		if ("".equals(inMap.get("hktgi_moto_hmpin_upd_dtm_bf")))
		{
			template.setNull(EDK0301C040CBSMsg.LAST_UPD_DTM_BF);
		}
		else
		{
			template.set(EDK0301C040CBSMsg.LAST_UPD_DTM_BF, (String)inMap.get("hktgi_moto_hmpin_upd_dtm_bf"));
		}
		
		return template;
	}
	
	
	/**
	 * 機器提供サービス契約一意照会の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341A010(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inWorkMap) throws RequestParameterException
	{
		// 機器提供サービス契約一意照会サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341A010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341A010);

		// 機能コード
		template.set(EKK0341A010CBSMsg.FUNC_CODE, func_code_2);

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		// ◇ 業務データの設定
		// 作業項目マップ.機器提供サービス契約番号 → 機器提供サービス契約一意照会.ＫＥＹ＿機器提供サービス契約番号
		if ("".equals(inWorkMap.get("kktk_svc_kei_no")) || null == inWorkMap.get("kktk_svc_kei_no"))
		{
			template.setNull(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO, (String)inWorkMap.get("kktk_svc_kei_no"));
		}
		
		// 引継元接続機器情報取得マップ.ＫＥＹ＿世代登録年月日時分秒 → 機器提供サービス契約一意照会.ＫＥＹ＿世代登録年月日時分秒
		if ("".equals(inWorkMap.get("key_gene_add_dtm")) || null == inWorkMap.get("key_gene_add_dtm"))
		{
			template.setNull(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM);
		}
		else
		{
			template.set(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM, (String)inWorkMap.get("key_gene_add_dtm"));
		}
		
		// 引継元接続機器情報取得マップ.ＫＥＹ＿予約適用年月日 → 機器提供サービス契約一意照会.ＫＥＹ＿予約適用年月日
		if ("".equals(inWorkMap.get("key_rsv_aply_ymd")) || null == inWorkMap.get("key_rsv_aply_ymd"))
		{
			template.setNull(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD, (String)inWorkMap.get("key_rsv_aply_ymd"));
		}

		return template;
	}
	
	/**
	 *  機器提供サービス契約キャンセルの上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341C330(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inMap_saki) throws RequestParameterException
	{
		// 機器提供サービス契約キャンセルサービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C330CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341C330CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C330);

		// 機能コード
		template.set(EKK0341C330CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.返品機器番号 → 機器提供サービス契約キャンセル.機器提供サービス契約番号
		if ("".equals(inMap_saki.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO, (String)inMap_saki.get("kktk_svc_kei_no"));
		}
		
		// 機器引継登録マップ.異動区分 → 機器提供サービス契約キャンセル.異動区分
		if ("".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0341C330CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}
		
		// 申込明細番号
		template.setNull(EKK0341C330CBSMsg.MSKM_DTL_NO);
		
		
		// サービスキャンセル理由コード	svc_cancel_rsn_cd
		template.setNull(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD);
		
		
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器提供サービス契約キャンセル.更新年月日時分秒(更新前)
//		if ("".equals(inMap.get("upd_dtm_bf")))
//		{
//			template.setNull(EKK0341C330CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0341C330CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
//		}
		
		template.set(EKK0341C330CBSMsg.UPD_DTM_BF, upd_dtm_work_saki);
		
		return template;
	}
	
	
	/**
	 *  機器提供サービス契約論理削除の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341E010(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											HashMap<String, Object> inMap_saki) throws RequestParameterException
	{
		// 機器提供サービス契約論理削除サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341E010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341E010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341E010);

		// 機能コード
		template.set(EKK0341E010CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.返品機器番号 → 機器提供サービス契約論理削除.機器提供サービス契約番号
		if ("".equals(inMap_saki.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341E010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341E010CBSMsg.KKTK_SVC_KEI_NO, (String)inMap_saki.get("kktk_svc_kei_no"));
		}
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器提供サービス契約論理削除.更新年月日時分秒(更新前)
//		if ("".equals(inMap.get("upd_dtm_bf")))
//		{
//			template.setNull(EKK0341E010CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK0341E010CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
//		}
		template.set(EKK0341E010CBSMsg.UPD_DTM_BF, upd_dtm_work_saki);
		
		return template;
	}
	
	//OM-2017-0001115 ADD START
	/**
	 *  課金先論理削除の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0321E010(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											String kakinNo,
											String updDtm) throws RequestParameterException
	{
		// 機器提供サービス契約論理削除サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0321E010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0321E010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321E010);

		// 機能コード
		template.set(EKK0321E010CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));

		// オペレータ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);
		
		// 課金先番号
		template.set(EKK0321C010CBSMsg.KAKINS_NO, kakinNo);
		
		// 更新年月日時分秒
		template.set(EKK0321C010CBSMsg.UPD_DTM_BF, updDtm);
		
		return template;
	}
	//OM-2017-0001115 ADD END
	
	/**
	 * サービス契約回線内訳一覧照会の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param String 検索キー：サービス契約番号
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0251B003(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											String key_svc_kei_no) throws RequestParameterException
	{
		// 機器提供サービス契約サービス契約変更サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0251B003CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0251B003CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0251B003);

		// 機能コード
//		template.set(EKK0251B003CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));
		template.set(EKK0251B003CBSMsg.FUNC_CODE, FUNC_CODE_1);

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器提供サービス契約サービス契約変更.機器提供サービス契約番号
		if ("".equals(key_svc_kei_no))
		{
			template.setNull(EKK0251B003CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0251B003CBSMsg.KEY_SVC_KEI_NO, key_svc_kei_no);
		}
		
		return template;
	}
	
	/**
	 * 機器場所番号変更の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKKA0020004(IRequestParameterReadWrite param,
											HashMap<String, Object> inMap,
											ArrayList kikiHktgiSelectList,
											HashMap<String, Object> adrMap_saki) throws RequestParameterException
	{
		
		
		// 引継先回線場所番号の取得
		String setplace_no = (String)adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO);
		
		// 機器提供サービス契約サービス契約回線内訳変更サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKKA0020004CBSMsg.class.getName());

		// テンプレートID
		template.set(EKKA0020004CBSMsg.TEMPLATEID, TEMPLATE_ID_EKKA0020004);

		// 機能コード
//		template.set(EKKA0020004CBSMsg.FUNC_CODE, (String)inMap.get("func_code"));
		template.set(EKKA0020004CBSMsg.FUNC_CODE, FUNC_CODE_1);

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST);

		if (templateArray == null) {
			templateArray = new CAANMsg[kikiHktgiSelectList.size()];
		}
		
		// リクエストパラメータ．機器引継選択リストから更新処理用一覧を作成する。
		for (int i = 0; i < kikiHktgiSelectList.size(); i++)
		{
			// ユーザデータ情報
			// １件取得
			HashMap<String, Object> childMap = (HashMap<String, Object>)kikiHktgiSelectList.get(i);
			// １件設定
			HashMap<String, Object> outMap = new HashMap<String, Object>();
			
			CAANMsg childTemplate = templateArray[i];
			if (childTemplate == null) {
				childTemplate = new CAANMsg(EKKA0020004CBSMsg1List.class.getName());
			}
			
			// ＫＥＹ＿宅内機器型式コード
			if (childMap == null || childMap.get("taknkiki_model_cd_moto") == null || "".equals(childMap.get("taknkiki_model_cd_moto")))
			{
				childTemplate.setNull(EKKA0020004CBSMsg1List.KEY_TK_MDL_CD);
			}
			else
			{
				childTemplate.set(EKKA0020004CBSMsg1List.KEY_TK_MDL_CD, childMap.get("taknkiki_model_cd_moto"));
			}
			
			// ＫＥＹ＿機器製造番号
			if (childMap == null || childMap.get("seizo_no_moto") == null || "".equals(childMap.get("seizo_no_moto")))
			{
				childTemplate.setNull(EKKA0020004CBSMsg1List.KEY_KK_SEIZO_NO);
			}
			else
			{
				childTemplate.set(EKKA0020004CBSMsg1List.KEY_KK_SEIZO_NO, childMap.get("seizo_no_moto"));
			}
			
			// ＫＥＹ＿変更理由コード "1"固定
//			if (childMap == null || childMap.get("key_chg_rsn_cd") == null || "".equals(childMap.get("key_chg_rsn_cd")))
//			{
//				childTemplate.setNull(EKKA0020004CBSMsg1List.KEY_CHG_RSN_CD);
//			}
//			else
//			{
//				childTemplate.set(EKKA0020004CBSMsg1List.KEY_CHG_RSN_CD, childMap.get("key_chg_rsn_cd"));
//			}
			childTemplate.set(EKKA0020004CBSMsg1List.KEY_CHG_RSN_CD, "1");
			
			// ＫＥＹ＿宅内機器基本Ｔ更新日付
			if (childMap == null || childMap.get("btry_upd_dtm") == null || "".equals(childMap.get("btry_upd_dtm")))
			{
				childTemplate.setNull(EKKA0020004CBSMsg1List.KEY_BTRY_UPD_DTTM);
			}
			else
			{
				childTemplate.set(EKKA0020004CBSMsg1List.KEY_BTRY_UPD_DTTM, childMap.get("btry_upd_dtm"));
			}
			
			// 設置場所番号
//			if (childMap == null || childMap.get("setplace_no") == null || "".equals(childMap.get("setplace_no")))
//			{
//				childTemplate.setNull(EKKA0020004CBSMsg1List.SETPLACE_NO);
//			}
//			else
//			{
//				childTemplate.set(EKKA0020004CBSMsg1List.SETPLACE_NO, childMap.get("setplace_no"));
//			}
			childTemplate.set(EKKA0020004CBSMsg1List.SETPLACE_NO, setplace_no);
			
			// サービス契約番号
			if (childMap == null || childMap.get("svc_kei_no") == null || "".equals(childMap.get("svc_kei_no")))
			{
				childTemplate.setNull(EKKA0020004CBSMsg1List.SVC_KEI_NO);
			}
			else
			{
				childTemplate.set(EKKA0020004CBSMsg1List.SVC_KEI_NO, childMap.get("svc_kei_no"));
			}
		
			templateArray[i] = childTemplate;
		}
		// 出力用 CAANMsg にセットする
		
		template.set(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST, templateArray);
		
		return template;
	}
	
	/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
	/**
	 * 機器提供サービス契約サービス契約情報変更の上りマッピング処理です。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param inWorkMap 上り作業領域マップ
	 * @return CAANMsg サービスインターフェイス
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInMsg_EKK0341C230(IRequestParameterReadWrite param,
											HashMap<String, Object> hktgiMotoMap,
											HashMap<String, Object> adrMap_saki,
											HashMap ekk0341a010Map) throws RequestParameterException
	{
		// 機器提供サービス契約サービス契約情報変更サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C230CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0341C230CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C230);

		// 機能コード
		template.set(EKK0341C230CBSMsg.FUNC_CODE, (String)hktgiMotoMap.get("func_code"));

		// オペレータ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);
		
		// 未更新情報の設定
		Iterator<String> ite = template.getSchema().getSchemaKeySet().iterator();
		while (ite.hasNext())
		{
			String key = (String)ite.next();
			if(key.endsWith("_err"))
			{
				String tmpKey = key.substring(0, key.length() - 4);
				if(ekk0341a010Map.containsKey(tmpKey))
				{
//					map.put(tmpKey, custMap.get(tmpKey));
					template.set(tmpKey, ekk0341a010Map.get(tmpKey));
				}
			}
		}
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器提供サービス契約サービス契約情報変更.機器提供サービス契約番号
		if ("".equals(hktgiMotoMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C230CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KKTK_SVC_KEI_NO, (String)hktgiMotoMap.get("kktk_svc_kei_no"));
		}
		
		
		// 引継先サービス契約.回線場所住所コード → 機器提供サービス契約サービス契約情報変更.機器設置先住所コード
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_AD_CD);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_AD_CD, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD));
		}
		
		// 引継先サービス契約.回線場所郵便番号 → 機器提供サービス契約サービス契約情報変更.機器設置先郵便番号
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_PCD);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_PCD, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD));
		}
		
		// 引継先サービス契約.回線場所都道府県名 → 機器提供サービス契約サービス契約情報変更.機器設置先都道府県名
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_STATE_NM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_STATE_NM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM));
		}
		
		// 引継先サービス契約.回線場所市区町村名 → 機器提供サービス契約サービス契約情報変更.機器設置先市区町村名
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_CITY_NM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_CITY_NM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM));
		}
		
		// 引継先サービス契約.回線場所大字通称名 → 機器提供サービス契約サービス契約情報変更.機器設置先大字通称名
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_OAZTSU_NM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM));
		}
		
		// 引継先サービス契約.回線場所字丁目名 → 機器提供サービス契約サービス契約情報変更.機器設置先字丁目名
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_AZCHO_NM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM));
		}
		
		// 引継先サービス契約.回線場所番地号 → 機器提供サービス契約サービス契約情報変更.機器設置先番地号
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_BNCHIGO);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_BNCHIGO, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO));
		}
		
		// 引継先サービス契約.回線場所住所補記・建物名 → 機器提供サービス契約サービス契約情報変更.機器設置先住所補記・建物名
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRTTM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRTTM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM));
		}
		
		// 引継先サービス契約.回線場所住所補記・部屋番号 → 機器提供サービス契約サービス契約情報変更.機器設置先住所補記・部屋番号
		if("".equals(adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM)))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRRM);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRRM, adrMap_saki.get(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM));
		}
		
		// 入力.異動区分 → 機器提供サービス契約サービス契約情報変更.異動区分
		if("".equals(hktgiMotoMap.get("ido_div")))
		{
			template.setNull(EKK0341C230CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.IDO_DIV, hktgiMotoMap.get("ido_div"));
		}
		
		// 機器提供サービス契約サービス契約情報変更.機器送付先住所手動入力フラグ
		if("".equals(hktgiMotoMap.get("kiki_shs_ad_man_input_flg")))
		{
			template.setNull(EKK0341C230CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(EKK0341C230CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG, (String)hktgiMotoMap.get("kiki_shs_ad_man_input_flg"));
		}
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器提供サービス契約サービス契約情報変更.更新年月日時分秒(更新前)
//		template.set(EKK0341C230CBSMsg.UPD_DTM_BF, upd_dtm_work);
		
		updateDtmWork_saki((String)hktgiMotoMap.get("last_upd_dtm"));
		template.set(EKK0341C230CBSMsg.UPD_DTM_BF, upd_dtm_work_saki);
		
		return template;
	}
	
	/**
	 * 機器設置先場所反映の上りマッピング処理です。
	 * <br>
	 * @param param
	 * @param hktgiMotoMap
	 * @param adrMap_saki
	 * @return
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0341C450(IRequestParameterReadWrite param,
											HashMap<String, Object> hktgiMotoMap,
											HashMap<String, Object> adrMap_saki) throws RequestParameterException
	{
		
		// 機器設置先場所反映サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0341C450CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0341C450CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C450);
		
		// 機能コード
		template.set(EKK0341C450CBSMsg.FUNC_CODE, (String)hktgiMotoMap.get("func_code"));
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// ◇ 業務データの設定
		// 機器引継登録マップ.機器提供サービス契約番号 → 機器設置先場所反映.機器提供サービス契約番号
		if ("".equals(hktgiMotoMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C450CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C450CBSMsg.KKTK_SVC_KEI_NO, (String)hktgiMotoMap.get("kktk_svc_kei_no"));
		}
		
		// 機器引継登録マップ.機器設置先場所番号 → 機器設置先場所反映.機器設置先場所番号
		if ("".equals(adrMap_saki.get("kaisen_place_no")))
		{
			template.setNull(EKK0341C450CBSMsg.KIKI_STC_SAKI_PLACE_NO);
		}
		else
		{
			template.set(EKK0341C450CBSMsg.KIKI_STC_SAKI_PLACE_NO, (String)adrMap_saki.get("kaisen_place_no"));
		}
		
		// 機器引継登録マップ.更新年月日時分秒(更新前) → 機器設置先場所反映.更新年月日時分秒(更新前)
		template.set(EKK0341C450CBSMsg.UPD_DTM_BF, upd_dtm_work_saki);
		
		return template;
	}
	/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
	
	// ++++++++++ v19.00.00 追加開始 ++++++++++
	/**
	 * 課金先登録の上りマッピング処理です。
	 * <br>
	 * @param param
	 * @param hktgiMap
	 * @param kikiListMap
	 * @param updDtm
	 * @return template
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0321D010(IRequestParameterReadWrite param,
											HashMap<String, Object> hktgiMap,
											HashMap<String, Object> kikiListMap,
											String updDtm) throws RequestParameterException
	{
		
		// 課金先登録サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0321D010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0321D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321D010);
		
		// 機能コード
		template.set(EKK0321D010CBSMsg.FUNC_CODE, (String)kikiListMap.get("func_code"));
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// ◇ 業務データの設定
		// 請求契約番号
		if ("".equals(hktgiMap.get("seiky_kei_no")))
		{
			template.setNull(EKK0321D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0321D010CBSMsg.SEIKY_KEI_NO, (String)hktgiMap.get("hktgi_saki_seiky_kei_no"));
		}
		
		// 機器提供サービス契約番号
		if ("".equals(kikiListMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0321D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0321D010CBSMsg.KKTK_SVC_KEI_NO, (String)kikiListMap.get("kktk_svc_kei_no"));
		}
		
		// 課金先適用開始年月日
		template.set(EKK0321D010CBSMsg.KAKINS_TSTAYMD, JKKModelCommon.getOpeDate(template));

		// 課金先適用終了年月日
		template.set(EKK0321D010CBSMsg.KAKINS_TENDYMD, JKKStrConst.END_YMD_DEFAULT);

		// 更新年月日時分秒
		template.set(EKK0321D010CBSMsg.UPD_DTM_BF, updDtm);

		return template;
	}

	// ++++++++++ v19.00.01 変更開始 ++++++++++
//	/**
//	 * 請求契約一意照会の上りマッピング処理です。
//	 * <br>
//	 * @param param
//	 * @param hktgiMap
//	 * @return template
//	 * @throws RequestParameterException
//	 */
//	private CAANMsg editInMsg_EKK0491A010(IRequestParameterReadWrite param,
//											HashMap<String, Object> hktgiMap) throws RequestParameterException
//	{
	/**
	 * 請求契約一意照会の上りマッピング処理です。
	 * <br>
	 * @param param
	 * @param seikyKeiNo
	 * @return template
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0491A010(IRequestParameterReadWrite param,
											String seikyKeiNo) throws RequestParameterException
	{
	// ++++++++++ v19.00.01 変更終了 ++++++++++
		
		// 請求契約一意照会サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0491A010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010);
		
		// 機能コード
		template.set(EKK0491A010CBSMsg.FUNC_CODE, func_code_2);
		
		// オペレータ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);

		// ++++++++++ v19.00.01 変更開始 ++++++++++
		// KEY_請求契約番号
//		template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, (String)hktgiMap.get("hktgi_saki_seiky_kei_no"));
		template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		// ++++++++++ v19.00.01 変更終了 ++++++++++
		// KEY_適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, JKKStrConst.END_YMD_DEFAULT);

		return template;
	}
	// ++++++++++ v19.00.00 追加終了 ++++++++++
	
	// ++++++++++ v19.00.01 追加開始 ++++++++++
	/**
	 * 課金先照会の上りマッピング処理です。
	 * <br>
	 * @param param
	 * @param hktgiMap
	 * @return template
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0321B507(IRequestParameterReadWrite param,
											HashMap<String, Object> kikiListMap) throws RequestParameterException
	{
		
		// 請求契約一意照会サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0321B507CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0321B507CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321B507);
		
		// 機能コード
		template.set(EKK0321B507CBSMsg.FUNC_CODE, (String)kikiListMap.get("func_code"));
		
		// オペレータ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);

		// KEY_機器提供サービス契約番号
		template.set(EKK0321B507CBSMsg.KEY_KKTK_SVC_KEI_NO, (String)kikiListMap.get("kktk_svc_kei_no"));

		return template;
	}
	
	/**
	 * 課金先更新の上りマッピング処理です。
	 * <br>
	 * @param param
	 * @param kikiListMap
	 * @parcm kakinNo
	 * @parcm updDtm
	 * @return template
	 * @throws RequestParameterException
	 */
	private CAANMsg editInMsg_EKK0321C010(IRequestParameterReadWrite param,
											HashMap<String, Object> kikiListMap,
											String kakinNo,
											String updDtm) throws RequestParameterException
	{
		
		// 請求契約一意照会サービスインターフェイスを作成
		CAANMsg template = new CAANMsg(EKK0321C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0321C010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321C010);
		
		// 機能コード
		template.set(EKK0321C010CBSMsg.FUNC_CODE, (String)kikiListMap.get("func_code"));
		
		// オペレータ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);
		
		// 課金先番号
		template.set(EKK0321C010CBSMsg.KAKINS_NO, kakinNo);
		
		String endYmd = JKKModelCommon.addDay(JKKModelCommon.getOpeDate(template), -1);
		// 課金先終了年月日(引継先の課金先開始年月日(運用日)-1日を設定)
		template.set(EKK0321C010CBSMsg.KAKINS_TENDYMD, endYmd);
		
		// 更新年月日時分秒
		template.set(EKK0321C010CBSMsg.UPD_DTM_BF, updDtm);

		return template;
	}
	// ++++++++++ v19.00.01 追加終了 ++++++++++

	/**
	 * 機器提供サービス契約サービス契約変更の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C290(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C290CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork(parentTemplate.getString(EKK0341C290CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C290(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}

	/**
	 * 機器提供サービス契約サービス契約回線内訳変更の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C320(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C320CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork(parentTemplate.getString(EKK0341C320CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C320(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	/**
	 * 機器提供サービス契約回復の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C380(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C380CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork(parentTemplate.getString(EKK0341C380CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C380(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	
	/**
	 * 返品機器一覧照会の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EDK0301A010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// TODO:更新年月日時分秒の取得
		
		// エラー情報の設定
		editErrorInfo_EDK0301A010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	
	/**
	 * 返品機器取消の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EDK0301C040(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// TODO:更新年月日時分秒の取得
		
		// エラー情報の設定
		editErrorInfo_EDK0301C040(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	/**
	 * 機器提供サービス契約一意照会の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param fixedText サービスメッセージ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editOutMsg_EKK0341A010(Map<?, ?> msgList, 
															IRequestParameterReadWrite param,
															HashMap<String, Object> inMap,
															HashMap<String, Object> kktk_saki_map) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
		
		if (templateArray != null)
		{
			// 取得結果件数チェック、０件の場合は処理終了
			if(templateArray.length == 0)
			{
				kktk_saki_map.put("result_count", "0");
			}
			else
			{
				kktk_saki_map.put("result_count", "1");
			}
			
			CAANMsg childTemplate = templateArray[0];
				
			// 機器提供サービスコード
			if (childTemplate.isNull(EKK0341A010CBSMsg1List.KKTK_SVC_CD))
			{
				kktk_saki_map.put("kktk_svc_cd", "");
			}
			else
			{
				kktk_saki_map.put("kktk_svc_cd", childTemplate.getString(EKK0341A010CBSMsg1List.KKTK_SVC_CD));
			}
			
			// 親契約識別コード
			if (childTemplate.isNull(EKK0341A010CBSMsg1List.OYA_KEI_SKBT_CD))
			{
				kktk_saki_map.put("oya_kei_skbt_cd","");
			}
			else
			{
				kktk_saki_map.put("oya_kei_skbt_cd", childTemplate.getString(EKK0341A010CBSMsg1List.OYA_KEI_SKBT_CD));
			}
			
			/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
			// 機器送付先住所手動入力フラグ
			if (childTemplate.isNull(EKK0341A010CBSMsg1List.KIKI_SHS_AD_MAN_INPUT_FLG))
			{
				kktk_saki_map.put("kiki_shs_ad_man_input_flg","");
			}
			else
			{
				kktk_saki_map.put("kiki_shs_ad_man_input_flg", childTemplate.getString(EKK0341A010CBSMsg1List.KIKI_SHS_AD_MAN_INPUT_FLG));
			}
			
			// 更新年月日時分秒(引継先)
			if (childTemplate.isNull(EKK0341A010CBSMsg1List.LAST_UPD_DTM))
			{
				kktk_saki_map.put("last_upd_dtm","");
			}
			else
			{
				kktk_saki_map.put("last_upd_dtm", childTemplate.getString(EKK0341A010CBSMsg1List.LAST_UPD_DTM));
			}
			
			// W検索結果を退避する
			HashMap templateMap = parentTemplate.getCAANMsgList(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST)[0].getHashMap();
			kktk_saki_map.put("EKK0341A010_out", templateMap);
			/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
			
		}
		else
		{
			kktk_saki_map.put("result_count", "0");
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341A010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return kktk_saki_map;
	}
	
	/**
	 * 機器提供サービス契約キャンセルの下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C330(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C330CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork_saki(parentTemplate.getString(EKK0341C330CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C330(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	
	/**
	 * 機器提供サービス契約論理削除の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341E010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341E010CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork_saki(parentTemplate.getString(EKK0341E010CBSMsg.UPD_DTM));
		}

		
		// エラー情報の設定
		editErrorInfo_EKK0341E010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	//OM-2017-0001115 ADD START
	/**
	 * 課金先論理削除の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0321E010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0321E010CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork_saki(parentTemplate.getString(EKK0341E010CBSMsg.UPD_DTM));
		}

		
		// エラー情報の設定
		editErrorInfo_EKK0321E010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	//OM-2017-0001115 ADD END

	/**
	 * サービス契約回線内訳一覧照会の取得結果を指定したHashMapにセットします。
	 * 
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @param adrMap
	 * @return adrMap
	 * @throws Exception
	 */
	private HashMap<String, Object> editOutMsg_EKK0251B003(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap,
																HashMap<String, Object> adrMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg[] templateArray = parentTemplate.getCAANMsgList(EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST);
		
		/* ++++++++++ v4.00.00 修正開始 ++++++++++ */
//		if (templateArray != null)
		if (templateArray != null && templateArray.length > 0)
		/* ++++++++++ v4.00.00 修正完了 ++++++++++ */
		{
			CAANMsg childTemplate = templateArray[0];
			
			// 回線場所住所コード
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD));
			}
			
			// 回線場所郵便番号
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD));
			}
			
			// 回線場所都道府県名
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM));
			}
				
			// 回線場所市区町村名
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM));
			}
			
			// 回線場所大字通称名
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM));
			}
			
			// 回線場所字丁目名
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM));
			}
			
			// 回線場所番地号
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO));
			}
			
			// 回線場所住所補記・建物名
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM));
			}
			
			// 回線場所住所補記・部屋番号
			if (childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM));
			}
			
			// 回線場所番号
			if(childTemplate.isNull(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO))
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO, "");
			}
			else
			{
				adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO, childTemplate.getString(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO));
			}
		}
		/* ++++++++++ v4.00.00 追加開始 ++++++++++ */
		else
		{
			// 取得結果０件の場合は設定値空白とする。
			// 回線場所住所コード
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD, "");
			// 回線場所郵便番号
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD, "");
			// 回線場所都道府県名
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM, "");
			// 回線場所市区町村名
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM, "");
			// 回線場所大字通称名
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM, "");
			// 回線場所字丁目名
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM, "");
			// 回線場所番地号
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO, "");
			// 回線場所住所補記・建物名
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM, "");
			// 回線場所住所補記・部屋番号
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM, "");
			// 回線場所番号
			adrMap.put(EKK0251B003CBSMsg1List.KAISEN_PLACE_NO, "");
		}
		/* ++++++++++ v4.00.00 追加完了 ++++++++++ */
		
		// エラー情報の設定
		editErrorInfo_EKK0251B003(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return adrMap;
	}
	
	/**
	 * 機器場所番号変更の下りマッピング処理です。
	 * 
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKKA0020004(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		editErrorInfo_EKKA0020004(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
	/**
	 * 機器提供サービス契約サービス契約回線内訳変更の下りマッピング処理です。
	 * <br>
	 * @param msgList 結果CAANMsgリスト
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C230(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C230CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork_saki(parentTemplate.getString(EKK0341C230CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C230(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));

		return param;
	}
	
	/**
	 * 機器設置先場所反映の下りマッピング処理です。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @return
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0341C450(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 更新年月日時分秒の取得
		if(parentTemplate.isNull(EKK0341C450CBSMsg.UPD_DTM))
		{
			// 更新日付が未設定の場合
		}
		else
		{
			// 更新日付WORKの更新確認
			updateDtmWork_saki(parentTemplate.getString(EKK0341C450CBSMsg.UPD_DTM));
		}
		
		// エラー情報の設定
		editErrorInfo_EKK0341C450(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));
		
		return param;
	}
	/* ++++++++++ v4.03.00 追加完了 ++++++++++ */

	// ++++++++++ v19.00.00 追加開始 ++++++++++
	/**
	 * 課金先登録の下りマッピング処理です。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @return param
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0321D010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		editErrorInfo_EKK0321D010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));
		
		return param;
	}

	/**
	 * 請求契約一意照会の下りマッピング処理です。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @return param
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0491A010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		editErrorInfo_EKK0491A010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));
		
		return param;
	}
	// ++++++++++ v19.00.00 追加終了 ++++++++++
	
	// ++++++++++ v19.00.01 追加開始 ++++++++++
	/**
	 * 課金先照会の下りマッピング処理です。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @return param
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0321B507(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		editErrorInfo_EKK0321B507(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));
		
		return param;
	}
	
	/**
	 * 課金先更新の下りマッピング処理です。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param inMap
	 * @return param
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editOutMsg_EKK0321C010(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																HashMap<String, Object> inMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		editErrorInfo_EKK0321C010(param, inMap, templates, returnCode);
		
		//エラー情報のマップを取得
		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));
		
		return param;
	}
	// ++++++++++ v19.00.01 追加終了 ++++++++++

	/**
	 * 機器提供サービス契約サービス契約変更サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341C290(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C290CBSMsg.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);
		}

		// 機器提供サービス契約番号エラー
		if (!template.isNull(EKK0341C290CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C290CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}

		// サービス契約番号エラー
		if (!template.isNull(EKK0341C290CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK0341C290CBSMsg.SVC_KEI_NO_ERR));
			}
		}

		// 申込明細番号エラー
		if (!template.isNull(EKK0341C290CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C290CBSMsg.MSKM_DTL_NO_ERR));
			}
		}

		// 機器提供サービス契約引継発生年月日エラー
		if (!template.isNull(EKK0341C290CBSMsg.KKTK_SVC_KEI_HKHASYMD_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_hkhasymd_err"))
			{
				inMap.put("kktk_svc_kei_hkhasymd_err", template.getString(EKK0341C290CBSMsg.KKTK_SVC_KEI_HKHASYMD_ERR));
			}
		}

		// 予約適用年月日エラー
		if (!template.isNull(EKK0341C290CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_aply_ymd_err"))
			{
				inMap.put("rsv_aply_ymd_err", template.getString(EKK0341C290CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// 異動区分エラー
		if (!template.isNull(EKK0341C290CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C290CBSMsg.IDO_DIV_ERR));
			}
		}

		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0341C290CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C290CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		
		// 巻取１から追加項目
		// 機器提供サービス契約サービス契約変更.機器移転先移動実施者識別コード
		if (!template.isNull(EKK0341C290CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR))
		{
			if (!inMap.containsKey("kiki_itens_mv_jssis_skcd_err"))
			{
				inMap.put("kiki_itens_mv_jssis_skcd_err", template.getString(EKK0341C290CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR));
			}
		}
		
		return param;
	}

	/**
	 * 機器提供サービス契約サービス契約回線内訳変更サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341C320(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C320CBSMsg.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);
		}

		// 機器提供サービス契約番号エラー
		if (!template.isNull(EKK0341C320CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C320CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}

		// サービス契約回線内訳番号エラー
		if (!template.isNull(EKK0341C320CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("svc_kei_kaisen_ucwk_no_err", template.getString(EKK0341C320CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}

		// 申込明細番号エラー
		if (!template.isNull(EKK0341C320CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C320CBSMsg.MSKM_DTL_NO_ERR));
			}
		}

		// 機器提供サービス契約引継発生年月日エラー
		if (!template.isNull(EKK0341C320CBSMsg.KKTK_SVC_KEI_HKHASYMD_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_hkhasymd_err"))
			{
				inMap.put("kktk_svc_kei_hkhasymd_err", template.getString(EKK0341C320CBSMsg.KKTK_SVC_KEI_HKHASYMD_ERR));
			}
		}

		// 予約適用年月日エラー
		if (!template.isNull(EKK0341C320CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_aply_ymd_err"))
			{
				inMap.put("rsv_aply_ymd_err", template.getString(EKK0341C320CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// 異動区分エラー
		if (!template.isNull(EKK0341C320CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C320CBSMsg.IDO_DIV_ERR));
			}
		}

		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0341C320CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C320CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 器提供サービス契約回復サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341C380(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C380CBSMsg.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);
		}

		// 機器提供サービス契約番号エラー
		if (!template.isNull(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		
		// 申込明細番号エラー
		if (!template.isNull(EKK0341C380CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C380CBSMsg.MSKM_DTL_NO_ERR));
			}
		}

		// 回復年月日エラー
		if (!template.isNull(EKK0341C380CBSMsg.KAIHK_YMD_ERR))
		{
			if (!inMap.containsKey("kaihk_ymd_err"))
			{
				inMap.put("kaihk_ymd_err", template.getString(EKK0341C380CBSMsg.KAIHK_YMD_ERR));
			}
		}

		// 異動区分エラー
		if (!template.isNull(EKK0341C380CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C380CBSMsg.IDO_DIV_ERR));
			}
		}

		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0341C380CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C380CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 返品機器一覧照会サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EDK0301A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EDK0301A010CBSMsg.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);
		}

		// ＫＥＹ＿返品機器番号エラー
		if (!template.isNull(EDK0301A010CBSMsg.KEY_HMPIN_KIKI_NO_ERR))
		{
			if (!inMap.containsKey("key_hmpin_kiki_no_err"))
			{
				inMap.put("key_hmpin_kiki_no_err", template.getString(EDK0301A010CBSMsg.KEY_HMPIN_KIKI_NO_ERR));
			}
		}
		
		// ＫＥＹ＿運用日付エラー
		if (!template.isNull(EDK0301A010CBSMsg.KEY_UNYO_YMD_ERR))
		{
			if (!inMap.containsKey("key_unyo_ymd_err"))
			{
				inMap.put("key_unyo_ymd_err", template.getString(EDK0301A010CBSMsg.KEY_UNYO_YMD_ERR));
			}
		}

		// ＫＥＹ＿物流保全番号エラー
		if (!template.isNull(EDK0301A010CBSMsg.KEY_BTRYHOZN_NO_ERR))
		{
			if (!inMap.containsKey("key_btryhozn_no_err"))
			{
				inMap.put("key_btryhozn_no_err", template.getString(EDK0301A010CBSMsg.KEY_BTRYHOZN_NO_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 返品機器取消サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EDK0301C040(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EDK0301C040CBSMsg.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);
		}

		// ＫＥＹ＿返品機器番号エラー
		if (!template.isNull(EDK0301C040CBSMsg.KEY_HMPIN_KIKI_NO_ERR))
		{
			if (!inMap.containsKey("key_hmpin_kiki_no_err"))
			{
				inMap.put("key_hmpin_kiki_no_err", template.getString(EDK0301C040CBSMsg.KEY_HMPIN_KIKI_NO_ERR));
			}
		}
		
		// ＫＥＹ＿物流保全番号エラー
		if (!template.isNull(EDK0301C040CBSMsg.LAST_UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("last_upd_dtm_bf_err"))
			{
				inMap.put("last_upd_dtm_bf_err", template.getString(EDK0301C040CBSMsg.LAST_UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 宅内機器型式一意照会サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341A010CBSMsg.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);
		}

		if (!template.isNull(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kktk_svc_kei_no_err"))
			{
				inMap.put("key_kktk_svc_kei_no_err", template.getString(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR));
			}
		}

		if (!template.isNull(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		if (!template.isNull(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 機器提供サービス契約キャンセルサービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341C330(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C330CBSMsg.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);
		}

		// 機器提供サービス契約番号エラー
		if (!template.isNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		
		// 申込明細番号エラー
		if (!template.isNull(EKK0341C330CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C330CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		
		// サービスキャンセル理由コードエラー
		if (!template.isNull(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_cancel_rsn_cd_err"))
			{
				inMap.put("svc_cancel_rsn_cd_err", template.getString(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD_ERR));
			}
		}
		
		// 異動区分エラー
		if (!template.isNull(EKK0341C330CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C330CBSMsg.IDO_DIV_ERR));
			}
		}
		
		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0341C330CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C330CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * 機器提供サービス契約キャンセルサービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341E010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341E010CBSMsg.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);
		}

		// 機器提供サービス契約番号エラー
		if (!template.isNull(EKK0341E010CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341E010CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}

		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0341E010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341E010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	
	//OM-2017-0001115 ADD STRAT
	/**
	 * 課金先論理削除インターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0321E010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341E010CBSMsg.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);
		}

		// 課金先番号エラー
		if (!template.isNull(EKK0321E010CBSMsg.KAKINS_NO_ERR))
		{
			if (!inMap.containsKey("kakins_no_err"))
			{
				inMap.put("kakins_no_err", template.getString(EKK0321E010CBSMsg.KAKINS_NO_ERR));
			}
		}

		// 更新年月日時分秒(更新前)エラー
		if (!template.isNull(EKK0321E010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0321E010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	//OM-2017-0001115 ADD END
	
	/**
	 * サービス契約回線内訳一覧照会サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0251B003(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0251B003CBSMsg.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);
		}

		// サービス契約番号エラー
		if (!template.isNull(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0251B003CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * 機器場所番号変更のエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKKA0020004(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKKA0020004CBSMsg.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);
		}

		// サービス契約番号エラー
		if (!template.isNull(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("EKKA0020004CBSMsg1List_err"))
			{
				inMap.put("EKKA0020004CBSMsg1List_err", template.getString(EKKA0020004CBSMsg.EKKA0020004CBSMSG1LIST_ERR));
			}
		}
		
		return param;
	}
	
	/* ++++++++++ v4.03.00 追加開始 ++++++++++ */
	/**
	 * 機器提供サービス契約サービス契約情報変更サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0341C230(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C230CBSMsg.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);
		}
		
		EKK0341C230CBSMsg ekk0341c230cbsmsg = new EKK0341C230CBSMsg();
		Object[][] contents_EKK0341C230 = ekk0341c230cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0341C230.length; j++)
		{
			String key = (String)contents_EKK0341C230[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	
	
	private IRequestParameterReadWrite editErrorInfo_EKK0341C450(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0341C450CBSMsg.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);
		}
		
		EKK0341C450CBSMsg EKK0341C450cbsmsg = new EKK0341C450CBSMsg();
		Object[][] contents_EKK0341C450 = EKK0341C450cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0341C450.length; j++)
		{
			String key = (String)contents_EKK0341C450[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	/* ++++++++++ v4.03.00 追加完了 ++++++++++ */
	
	// ++++++++++ v19.00.00 追加開始 ++++++++++
	/**
	 * 課金先登録のエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0321D010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321D010CBSMsg.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);
		}
		
		EKK0321D010CBSMsg ekk0321d010cbsmsg = new EKK0321D010CBSMsg();
		Object[][] contents_EKK0321D010 = ekk0321d010cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0321D010.length; j++)
		{
			String key = (String)contents_EKK0321D010[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}

	/**
	 * 請求契約一意照会のエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0491A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0491A010CBSMsg.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);
		}
		
		EKK0491A010CBSMsg ekk0491a010cbsmsg = new EKK0491A010CBSMsg();
		Object[][] contents_EKK0491A010 = ekk0491a010cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0491A010.length; j++)
		{
			String key = (String)contents_EKK0491A010[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	// ++++++++++ v19.00.00 追加終了 ++++++++++
	
	// ++++++++++ v19.00.01 追加開始 ++++++++++
	/**
	 * 課金先照会のエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0321B507(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321B507CBSMsg.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);
		}
		
		EKK0321B507CBSMsg ekk0321b507cbsmsg = new EKK0321B507CBSMsg();
		Object[][] contents_EKK0321B507 = ekk0321b507cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0321B507.length; j++)
		{
			String key = (String)contents_EKK0321B507[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	
	/**
	 * 課金先更新のエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 上りマップ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0321C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321C010CBSMsg.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);
		}
		
		EKK0321C010CBSMsg ekk0321c010cbsmsg = new EKK0321C010CBSMsg();
		Object[][] contents_EKK0321C010 = ekk0321c010cbsmsg.getContents();
		
		for(int j=0; j < contents_EKK0321C010.length; j++)
		{
			String key = (String)contents_EKK0321C010[j][0];
			if(key.endsWith("_err"))
			{
				if (!inMap.containsKey(key))
				{
					inMap.put(key, template.getString(key));
				}
			}
		}
		
		return param;
	}
	// ++++++++++ v19.00.01 追加終了 ++++++++++

	/**
	 * サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param リクエストパラメータ
	 * @param templates サービスインターフェイスリスト
	 * @param returnCode リターンコード
	 * @param fixedText サービスメッセージ
	 * @return IRequestParameterReadWrite リクエストパラメータ
	 * @exception RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, 
													CAANMsg[] templates,
													int returnCode,
													String fixedText) throws RequestParameterException
	{
		
		// ユーザデータ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData("KKSV041905CC");
		
		for (int i = 0; i < templates.length; i++)
		{
			CAANMsg msg = templates[i];
			String templateID = msg.getString("templateID");
			
			if (TEMPLATE_ID_EKK0341C290.equals(templateID))
			{
				editErrorInfo_EKK0341C290(param, inMap, templates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0341C320.equals(templateID))
			{
				editErrorInfo_EKK0341C320(param, inMap, templates, returnCode);
			}
		}
		return param;
	}

}