/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JFUAddSvcKeiNetOpCC
*   ソースファイル名：JFUAddSvcKeiNetOpCC.java
*   作成者          ：富士通
*   日付            ：2011年04月01日
*＜機能概要＞
*   ｅｏ光ネットオプション登録部品です。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/04/01   FJ)馬場     新規作成
*   v4.00.00    2012/11/15   FJ)齋藤    【ANK-1224-00-00】サービス別宅内機器型式候補の変更対応
*   v4.01.00    2012/12/25   FJ)大村    「IT2-2012-0002142」サービス開始希望年月日設定値変更
*   v4.02.00    2013/04/23   FJ)大塚     No708 エラー情報マッピング不備対応
*   v7.00.00    2013/12/08   FJ)川瀬     【ANK-1578-00-00】多機能ルーター(機器追加) 
*   v7.00.00    2014/02/07   FJ)岡井     【障害対応】多機能ルーター電話機能判定修正
*  v50.00.00    2020/06/12   FJ)美濃原  【ANK-3825-00-00】メッシュWiFi導入対応
*  v52.00       2021/01/22   FJ) 張本   【ANK-3987-00-00】Netflix導入対応（STEP2）
*  v61.00       2023/04/03   FJ) 張本   【ANK-4315-00-00】【eo定期】eo光ホームゲートウェイ導入対応
*  v68.00       2023/12/01   FJ)三上    【ANK-4498-00-00】一般・訪販・量販Webからマンションサービスを申し込まれた場合の機器送付先住所変更
*  v71.00       2024/5/23    FJ)三上    【#84733】機器送付先住所でNullPointerExceptionが発生
 * v75.0.0      2025/04/10   FJ) 浅井   【ANK-4640-00-00】typeN：追加要件対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.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.JFUStrConst;
import eo.common.constant.JPCModelConstant;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0091A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0241B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0241B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B504CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B504CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341C330CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0391D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B503CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B503CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2811D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK3271D010CBSMsg;

/**
 * ｅｏ光ネットオプション登録部品
 * <br>
 * @author 富士通
 */
public class JFUAddSvcKeiNetOpCC extends AbstractCommonComponent
{
	/** RETURN_MESSAGE */
	static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** RETURN_MESSAGE_FORMAT */
	static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** CC_WORK_AREA_NAME */
	static final String CC_WORK_AREA_NAME = "JFUAddSvcKeiNetOpCCWork";
	/** サービスコンポーネントエラー */
	static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** エラー：1000 */
	static final int TMCK_ERR_STATUS = 1000;
	/** JFUAddKeishaServiceCCWork */
	static final String CC_WORK_AREA_NAME_KEISHA = "JFUAddKeishaServiceCCWork";
	/** JFUAddMskmSCWork */
	static final String CC_WORK_AREA_NAME_MSKM = "JFUAddMskmSCWork";
	/** JFUAddSkkSCWork */
	static final String CC_WORK_AREA_NAME_SKK = "JFUAddSkkSCWork";
	/** JFUAddUsePlaceInfoCCWork */
	static final String CC_WORK_AREA_NAME_USE = "JFUAddUsePlaceInfoCCWork";
	/** サービス契約回線内訳番号桁数 */
	static final int SVC_KEI_KAISEN_UW_NO_CNT = 12;
	

	/** 機能コード：１ */
	private static final String FUNC_1 = "1";
	/** 機能コード：２ */
	private static final String FUNC_2 = "2";
	/** 親契約識別コード:サービス契約回線内訳 */
	private static final String OYA_KEI_SKBT_CD_02 = "02";

	/**
	 * ｅｏ光ネットオプション登録処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite addNetOpTrk(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{

		JFUBPCommon.printBpDebugLog(this.getClass(), "■■■ addNetOpTrk start ■■■");

		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;

		HashMap inEKK0341 = null;
		HashMap inEKK0391 = null;
		HashMap inTakinoMap = null; // 2013.11.30 追加

		// ■機器提供サービス契約登録■
		int kikiCnt = 0;
		inEKK0341 = (HashMap)(param.getData("EKK0341D010"));
		inEKK0391 = (HashMap)(param.getData("EKK0391D010"));
		inTakinoMap = (HashMap)(param.getData("EKK0341D010Tkn")); // 2013.11.30 追加

		HashMap eKK2811D010Net02Map = (HashMap)param.getData("EKK2811D010Net02");

		if (inEKK0341 != null)
		{
			kikiCnt = ((ArrayList)inEKK0341.get("EKK0341D010List")).size();
			for (int i = 0; i < kikiCnt; i++)
			{
				/* 2012/11/15 ANK-1224-00-00 Y.Saitou ADD */
				// 宅内機器型式コード設定処理
				this.setTaknkikiModeCd(handle, param, i);

				template = editInEKK0341D010(param, "EKK0341D010", i); // 上りマッピング
				paramMap = putParamMap(paramMap, template);
				result = scCall.run(paramMap, handle); // SC呼び出し
				editRetEKK0341D010(result, param, "EKK0341D010", i); // 下りマッピング
				if (getReturnCode(param) >= TMCK_ERR_STATUS)
				{
					// ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
				// 端末購入通知書登録
				if (JFUStrConst.KK0771_KKTK_SVC_CD_C023.equals(template.getString(EKK0341D010CBSMsg.KKTK_SVC_CD)))
				{
					template = editInEKK3271D010(param, "EKK0341D010", i); // 上りマッピング
					paramMap = putParamMap(paramMap, template);
					result = scCall.run(paramMap, handle); // SC呼び出し
					editRetEKK3271D010(result, param, "EKK0341D010", i); // 下りマッピング
					if (getReturnCode(param) >= TMCK_ERR_STATUS)
					{
						// ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
			}
		}

		if (inTakinoMap != null)
		{
			// サービス契約回線内訳番号を取得
			String svcKeiKaisenUcwkNo = JFUStrConst.EMPTY;
			HashMap inTakinoList = null;
			inTakinoList = (HashMap)((ArrayList)inTakinoMap.get("EKK0341D010TknList")).get(0);
			svcKeiKaisenUcwkNo = (String)inTakinoList.get("svc_kei_kaisen_ucwk_no");
			if (null != svcKeiKaisenUcwkNo && !JFUStrConst.EMPTY.equals(svcKeiKaisenUcwkNo)
					&& SVC_KEI_KAISEN_UW_NO_CNT < svcKeiKaisenUcwkNo.length())
			{
				// ネットのサービス契約番号を取得
				String netSvcKeiNo = (String)inTakinoList.get("tg_svc_kei_no");
				
				// 回線対象サービス契約一覧照会（サービス契約番号）
				template = editInEKK0241B003(param, netSvcKeiNo); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0241B003(result, param, "EKK0241B003"); // 下りマッピング
				if (getReturnCode(param) >= TMCK_ERR_STATUS) // ステータスが単項目エラー以上であれば例外をスロー
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
				// サービス契約回線内訳番号を取得
				svcKeiKaisenUcwkNo = getNetSvcKeiKaisenUcwkNo(param);
				// 機器提供サービス契約登録(多機能ルーター)マップにサービス契約回線内訳番号を上書き
				inTakinoList.put("svc_kei_kaisen_ucwk_no", svcKeiKaisenUcwkNo);
				// 機器オプションサービス契約一覧照会(フロント)マップにサービス契約回線内訳番号を上書き
				HashMap dataMapEkk2811 = null;
				dataMapEkk2811 = (HashMap)param.getData("EKK2811B50302");
				if (null != dataMapEkk2811 && !JFUStrConst.EMPTY.equals(dataMapEkk2811))
				{
					dataMapEkk2811.put("key_svc_kei_kaisen_ucwk_no", svcKeiKaisenUcwkNo);
				}
			}
			// 機器オプションサービス契約一覧照会(フロント)
			template = editInEKK2811B503(param, "EKK2811B50302"); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK2811B503(result, param, "EKK2811B50302"); // 下りマッピング
			if (getReturnCode(param) >= TMCK_ERR_STATUS) // ステータスが単項目エラー以上であれば例外をスロー
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}

			// 機器提供サービス契約一覧照会(サービス契約回線内訳)
			HashMap kikiTkMap = (HashMap)param.getData("EKK2811B50302");
			ArrayList kikiTkList = (ArrayList)kikiTkMap.get("EKK2811B503CBSMsg1List");
			if(kikiTkList != null && kikiTkList.size() > 0 && eKK2811D010Net02Map != null && eKK2811D010Net02Map.size() > 0)
			{
				HashMap eKK2811D010Net02ChildMap = (HashMap)((ArrayList)eKK2811D010Net02Map.get("EKK2811D010Net02List")).get(0);
				String knykeiMskmJokenCd = (String)eKK2811D010Net02ChildMap.get("knykei_mskm_joken_cd");

				if(JFUStrConst.KNYKEI_MSKM_JOKEN_IKT.equals(knykeiMskmJokenCd))
				{
					// 多機能ルーター契約の場合、実行する
					template = setEKK0341B504(param, "EKK0341B504");
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					getEKK0341B504(result, param, "EKK0341B504");
					if (getReturnCode(param) >= TMCK_ERR_STATUS) // ステータスが単項目エラー以上であれば例外をスロー
					{
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
			}

			// 機器提供サービス契約一覧照会
			String nowSvcTel = (String)((HashMap)param.getData("EKK0341B00202")).get("nowSvcTel");
			if(JFUStrConst.NOW_SVC_TEL_KEI_CHU.equals(nowSvcTel))
			{
				template = editInEKK0341B002(param, "EKK0341B00202"); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0341B002(result, param, "EKK0341B00202"); // 下りマッピング
				if (getReturnCode(param) >= TMCK_ERR_STATUS) // ステータスが単項目エラー以上であれば例外をスロー
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			// 機器提供サービス契約キャンセル
			String mskmKbn = (String)((HashMap)param.getData("EKK2811B50302")).get("mskmKbn");
			if (JFUStrConst.MSKM_KBN_ADD.equals(mskmKbn) && checkRouterCancel(param))
			{
				template = editInEKK0341C330(param, "EKK0341C33002"); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0341C330(result, param, "EKK0341C33002"); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					// ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			// サービス契約一意照会
			template = editInEKK0091A010(param, "EKK0091A010"); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0091A010(result, param, "EKK0091A010"); // 下りマッピング
			if (getReturnCode(param) >= TMCK_ERR_STATUS) // ステータスが単項目エラー以上であれば例外をスロー
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}

			// 機器提供サービス契約登録(多機能ルーター)
			if (!checkTakinoRouter(param))
			{
				template = editInEKK0341D01002(param, "EKK0341D010Tkn"); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0341D01002(result, param, "EKK0341D010Tkn"); // 下りマッピング
				if (getReturnCode(param) >= TMCK_ERR_STATUS)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			// 機器オプションサービス契約登録(ネット)
			template = editInEKK2811D010(param, "EKK2811D010Net02", 0); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK2811D010(result, param, "EKK2811D010Net02", 0); // 下りマッピング
			if (getReturnCode(param) >= TMCK_ERR_STATUS)
			{
				// ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}

			// 機器オプションサービス契約登録(電話)
			mskmKbn = (String)((HashMap)param.getData("EKK2811B50302")).get("mskmKbn");
			if (JFUStrConst.MSKM_KBN_ADD.equals(mskmKbn) && checkAddKkopTel(param))
			{
				// 電話の請求契約情報取得
				getSeikyKeiTelInfo(scCall, handle, paramMap, param);
				// 電話のサービス契約情報取得
				getSvcKeiTelInfo(scCall, handle, paramMap, param);

				template = editInEKK2811D010Tel(param, "EKK2811D010Tel02", 0); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editOutEKK2811D010Tel(result, param, "EKK2811D010Tel02", 0); // 下りマッピング
				if (getReturnCode(param) >= TMCK_ERR_STATUS)
				{
					// ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}

		if (inEKK0391 != null)
		{
			// ■オプションサービス契約＜サポート＞登録■
			template = editInEKK0391D010(param, "EKK0391D010"); // 上りマッピング
			paramMap = putParamMap(paramMap, template);
			result = scCall.run(paramMap, handle); // SC呼び出し
			editRetEKK0391D010(result, param, "EKK0391D010"); // 下りマッピング
			if (getReturnCode(param) >= TMCK_ERR_STATUS)
			{
				// ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		JFUBPCommon.printBpDebugLog(this.getClass(), "■■■ addNetOpTrk end ■■■");

		return param;
	}

	/**
	 * ｅｏ光ネットオプション登録処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();
		HashMap inEKK0341 = null;
		HashMap inEKK0391 = null;
		HashMap inEKK0341Tkn = null;

		int kikiCnt = 0;

		// 機器提供サービス登録マップを取得します。
		inEKK0341 = (HashMap)(param.getData("EKK0341D010"));
		inEKK0391 = (HashMap)(param.getData("EKK0391D010"));
		inEKK0341Tkn = (HashMap)(param.getData("EKK0341D010Tkn"));

		// 機器提供サービス登録リストの件数を取得します。
		if (inEKK0341 != null)
		{
			kikiCnt = ((ArrayList)inEKK0341.get("EKK0341D010List")).size();
			// リストの件数分処理を行います。
			for (int i = 0; i < kikiCnt; i++)
			{
				//機器提供サービス契約登録のマップ項目をメッセージリストに設定します。
				msgList.add(editInEKK0341D010(param, "EKK0341D010", i));
			}
		}

		// 機器提供サービス登録(多機能ルーター用)マップを取得します。
		if (inEKK0341Tkn != null)
		{
			//機器提供サービス登録(多機能ルーター用)のマップ項目をメッセージリストに設定します。
			msgList.add(editInEKK0341D01002(param, "EKK0341D010Tkn"));
		}

		//オプションサービス契約＜サポート＞登録マップを取得します。
		//マップが空でなければ、処理を実行します。
		if (inEKK0391 != null)
		{
			//オプションサービス契約＜サポート＞登録のマップ項目をメッセージリストに設定します。
			msgList.add(editInEKK0391D010(param, "EKK0391D010"));
		}

		int msgCnt = msgList.size();
		CAANMsg[] templates = new CAANMsg[msgCnt];
		for (int i = 0; i < msgCnt; i++)
		{
			templates[i] = msgList.get(i);
		}

		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * SCインプット共通データ設定処理
	 * <br>
	 * @param param
	 * @param paramMap
	 * @return HashMap
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> setSCInputCommonData(IRequestParameterReadWrite param, HashMap<String, Object> paramMap)
			throws RequestParameterException
	{
		/* 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));

		return paramMap;
	}

	/**
	 * 機器提供サービス契約登録用上りマッピング処理<br>
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341D010(IRequestParameterReadWrite param, String fixedText, int index) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341D010CBSMsg.class.getName());

		HashMap inMap = null;
		HashMap inLstMap = null;
		HashMap inMapUpAf = null;
		HashMap useplaceAddressMap = null;
// ANK-4498-00-00 ADD START
		HashMap kikiSohusAddressMap = null;
// ANK-4498-00-00 ADD END

		// テンプレートID（機器提供サービス契約登録）
		template.set(EKK0341D010CBSMsg.TEMPLATEID, "EKK0341D010");

		// 機能コード（デフォルト：１（チェック＆登録）
		template.set(EKK0341D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(index);

		/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
		// 前回更新日時分秒を取得
		if (index > 0)
		{
			inMapUpAf = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(index - 1);
		}
		/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

		// 分割後利用場所住所情報  本登録
		useplaceAddressMap = (HashMap)param.getData("FUSV016006CC");

		// 分割後利用場所住所情報  仮登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV015211CC");
		}
		// 2012/09/25 add by Otsuka
		// 分割後利用場所住所情報  一括登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV016102CC");
		}
		
		//ANK-4498-00-00 ADD START
// ANK-4640-00-00 MOD START
//		//マンションの場合
//		if("1".equals(inMap.get("MSKM_MNS_TYPE")))
		//マンションまたはtypeNのメッシュWi-Fiの場合
		if("1".equals(inMap.get("MSKM_MNS_TYPE")) || (JFUStrConst.PCRS_CD_TYPEN.contains(inLstMap.get("kk1861_pcrs_cd")) && JFUStrConst.CD00134_CA2.equals(inLstMap.get("pcrs_cd"))))
// ANK-4640-00-00 MOD END
		{
			//分割後契約者住所情報 仮登録 一括登録
			kikiSohusAddressMap=(HashMap)param.getData("FUSV015212CC");
			//分割後契約者住所情報
			if (kikiSohusAddressMap == null)
			{
				kikiSohusAddressMap =(HashMap)param.getData("FUSV016007CC");
			}
		}
		//ホーム・メゾンの場合
		else
		{
			// 分割後利用場所住所情報  本登録
			kikiSohusAddressMap = (HashMap)param.getData("FUSV016006CC");
			//分割後利用場所住所情報 仮登録
			if (kikiSohusAddressMap == null)
			{
				kikiSohusAddressMap = (HashMap)param.getData("FUSV015211CC");
			}
			// 2012/09/25 add by Otsuka
			// 分割後利用場所住所情報  一括登録
			if (null == kikiSohusAddressMap)
			{
				kikiSohusAddressMap = (HashMap)param.getData("FUSV016102CC");
			}
		}
		
		// 2012/09/25 add by Otsuka
		//		// 2012/06/13 一括登録対応 IT2-2012-0000789 START
		//		if (null == useplaceAddressMap)
		//		{
		//			useplaceAddressMap = (HashMap)param.getData("FUSV015211CC");
		//		}
		//		// 2012/06/13 一括登録対応 IT2-2012-0000789 END

		// 機器提供サービス契約番号 → 機器提供サービス契約番号
		if ("".equals(inLstMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO, (String)inLstMap.get("kktk_svc_kei_no"));
		}
		// 世代登録年月日時分秒 → 世代登録年月日時分秒
		if ("".equals(inLstMap.get("gene_add_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.GENE_ADD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.GENE_ADD_DTM, (String)inLstMap.get("gene_add_dtm"));
		}
		// 機器提供サービス契約ステータス → 機器提供サービス契約ステータス
		if ("".equals(inLstMap.get("kktk_svc_kei_stat")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT, (String)inLstMap.get("kktk_svc_kei_stat"));
		}
		// 機器提供サービスコード → 機器提供サービスコード
		if ("".equals(inLstMap.get("kktk_svc_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_CD, (String)inLstMap.get("kktk_svc_cd"));
		}
		// 料金コースコード → 料金コースコード
		if ("".equals(inLstMap.get("pcrs_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PCRS_CD, (String)inLstMap.get("pcrs_cd"));
		}
		// 料金プランコード → 料金プランコード
		if ("".equals(inLstMap.get("pplan_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PPLAN_CD, (String)inLstMap.get("pplan_cd"));
		}
		// 機器提供種別コード → 機器提供種別コード
		if ("".equals(inLstMap.get("kktk_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SBT_CD, (String)inLstMap.get("kktk_sbt_cd"));
		}
		// HDD容量コード → HDD容量コード
		if ("".equals(inLstMap.get("hdd_capa_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HDD_CAPA_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HDD_CAPA_CD, (String)inLstMap.get("hdd_capa_cd"));
		}
		// サービス利用開始希望年月日 → サービス利用開始希望年月日
		//「IT2-2012-0002142」サービス開始希望年月日>>>値設定不要のため、空を無条件で設定する
		template.setNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD);
		//「IT2-2012-0002142」サービス開始希望年月日<<<E

		// 予約適用開始希望年月日 → 予約適用開始希望年月日
		if ("".equals(inLstMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inLstMap.get("rsv_tsta_kibo_ymd"));
		}
		// 希望メーカーコード → 希望メーカーコード
		if ("".equals(inLstMap.get("kibo_maker_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIBO_MAKER_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIBO_MAKER_CD, (String)inLstMap.get("kibo_maker_cd"));
		}
		// 販売種別コード → 販売種別コード
		if ("".equals(inLstMap.get("HAMBAI_SBT_CD")))
		{
			template.setNull(EKK0341D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAMBAI_SBT_CD, (String)inLstMap.get("hambai_sbt_cd"));
		}
		// 通信機器セットコード → 通信機器セットコード
		if ("".equals(inLstMap.get("tsushin_kiki_set_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD, (String)inLstMap.get("tsushin_kiki_set_cd"));
		}
		// 宅内機器種別コード → 宅内機器種別コード
		if ("".equals(inLstMap.get("taknkiki_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD, (String)inLstMap.get("taknkiki_sbt_cd"));
		}
		// 宅内機器型式コード → 宅内機器型式コード
		if ("".equals(inLstMap.get("taknkiki_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD, (String)inLstMap.get("taknkiki_model_cd"));
		}
		// 宅内機器セット品型コード → 宅内機器セット品型コード
		if ("".equals(inLstMap.get("taknkiki_sethin_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD, (String)inLstMap.get("taknkiki_sethin_model_cd"));
		}
		// 付属品種別コード → 付属品種別コード
		if ("".equals(inLstMap.get("huzokuhin_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD, (String)inLstMap.get("huzokuhin_sbt_cd"));
		}
		// 機器設置先場所番号 → 機器設置先場所番号
		if ("".equals(inLstMap.get("kiki_stc_saki_place_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO, (String)inLstMap.get("kiki_stc_saki_place_no"));
		}
		// 親契約識別コード → 親契約識別コード
		if ("".equals(inLstMap.get("oya_kei_skbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD, (String)inLstMap.get("oya_kei_skbt_cd"));
		}
		// サービス契約番号 → サービス契約番号
		if ("".equals(inLstMap.get("svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_NO, (String)inLstMap.get("svc_kei_no"));
		}
		// サービス契約内訳番号 → サービス契約内訳番号
		if ("".equals(inLstMap.get("svc_kei_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO, (String)inLstMap.get("svc_kei_ucwk_no"));
		}
		// サービス契約回線内訳番号 → サービス契約回線内訳番号
		if ("".equals(inLstMap.get("svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)inLstMap.get("svc_kei_kaisen_ucwk_no"));
		}
		// オプションサービス契約番号 → オプションサービス契約番号
		if ("".equals(inLstMap.get("op_svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.OP_SVC_KEI_NO, (String)inLstMap.get("op_svc_kei_no"));
		}
		// ＳＹＳＩＤ → ＳＹＳＩＤ
		if ("".equals(inLstMap.get("sysid")))
		{
			template.setNull(EKK0341D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SYSID, (String)inLstMap.get("sysid"));
		}
		// 申込明細番号 → 申込明細番号
		if ("".equals(inLstMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MSKM_DTL_NO, (String)inLstMap.get("mskm_dtl_no"));
		}
		// リンクSTBフラグ → リンクSTBフラグ
		if ("".equals(inLstMap.get("link_stb_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.LINK_STB_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.LINK_STB_FLG, (String)inLstMap.get("link_stb_flg"));
		}

		// ↓↓ ■2011/10/15 項目追加■ ↓↓ 
		// 機器提供サービス.機器引当指定倉庫コード → 機器引当指定倉庫コード
		if ("".equals(inLstMap.get("kiki_hkat_shitei_soko_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD, (String)inLstMap.get("kiki_hkat_shitei_soko_cd"));
		}

		// 機器提供サービス.機器引当指定倉庫棚コード → 機器引当指定倉庫棚コード
		if ("".equals(inLstMap.get("kiki_hkat_shitei_skdn_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD, (String)inLstMap.get("kiki_hkat_shitei_skdn_cd"));
		}
		// ↑↑ ■2011/10/15 項目追加■ ↑↑ 

		// 機器送料有無 → 機器送料有無
		if ("".equals(inLstMap.get("kiki_soryo_um")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_UM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_UM, (String)inLstMap.get("kiki_soryo_um"));
		}
		// 機器送料作成年月日 → 機器送料作成年月日
		if ("".equals(inLstMap.get("kiki_soryo_saksei_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD, (String)inLstMap.get("kiki_soryo_saksei_ymd"));
		}
		// 機器送付先名 → 機器送付先名
		if ("".equals(inLstMap.get("kiki_sohus_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_NM, (String)inLstMap.get("kiki_sohus_nm"));
		}
		// 機器送付先カナ名 → 機器送付先カナ名
		if ("".equals(inLstMap.get("kiki_sohus_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KANA, (String)inLstMap.get("kiki_sohus_kana"));
		}

		//========================= ↓↓住所分割処理後の値を設定するよう修正 2011/10/10 ↓↓ ===============================
		// 機器送付先住所コード → 機器送付先住所コード
		if ("".equals(kikiSohusAddressMap.get("ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD, (String)kikiSohusAddressMap.get("ad_cd"));
		}
		// 機器送付先郵便番号 → 機器送付先郵便番号
		if ("".equals(inLstMap.get("kiki_sohus_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_PCD, (String)inLstMap.get("kiki_sohus_pcd"));
		}
		// 機器送付先都道府県名 → 機器送付先都道府県名
		if ("".equals(kikiSohusAddressMap.get("state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM, (String)kikiSohusAddressMap.get("state_nm"));
		}
		// 機器送付先市区町村名 → 機器送付先市区町村名
		if ("".equals(kikiSohusAddressMap.get("city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM, (String)kikiSohusAddressMap.get("city_nm"));
		}
		// 機器送付先大字通称名 → 機器送付先大字通称名
		if ("".equals(kikiSohusAddressMap.get("oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM, (String)kikiSohusAddressMap.get("oaztsu_nm"));
		}
		// 機器送付先字丁目名 → 機器送付先字丁目名
		if ("".equals(kikiSohusAddressMap.get("azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM, (String)kikiSohusAddressMap.get("azcho_nm"));
		}
		// 機器送付先番地号 → 機器送付先番地号
		if ("".equals(kikiSohusAddressMap.get("after_bnchi")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO, (String)kikiSohusAddressMap.get("after_bnchi"));
		}
		//========================= ↑↑住所分割処理後の値を設定するよう修正 2011/10/10 ↑↑ ===============================

		// 機器送付先住所補記・建物名 → 機器送付先住所補記・建物名
		if ("".equals(inLstMap.get("kiki_sohus_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM, (String)inLstMap.get("kiki_sohus_adrttm"));
		}
		// 機器送付先住所補記・部屋番号 → 機器送付先住所補記・部屋番号
		if ("".equals(inLstMap.get("kiki_sohus_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM, (String)inLstMap.get("kiki_sohus_adrrm"));
		}
		// 機器送付先電話番号 → 機器送付先電話番号
		if ("".equals(inLstMap.get("kiki_sohus_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO, (String)inLstMap.get("kiki_sohus_telno"));
		}
		// マンション物件番号 → マンション物件番号
		if ("".equals(inLstMap.get("mansion_bukken_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MANSION_BUKKEN_NO, (String)inLstMap.get("mansion_bukken_no"));
		}
		// 機器送付先＿契約者住所差異フラグ → 機器送付先＿契約者住所差異フラグ
		if ("".equals(inLstMap.get("kiki_sohus_ksh_ad_sai_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG, (String)inLstMap.get("kiki_sohus_ksh_ad_sai_flg"));
		}
		// 機器送付先個別指定フラグ → 機器送付先個別指定フラグ
		if ("".equals(inLstMap.get("kiki_shs_kbt_shitei_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG, (String)inLstMap.get("kiki_shs_kbt_shitei_flg"));
		}
		// 機器送付先補足コード１ → 機器送付先補足コード１
		if ("".equals(inLstMap.get("kiki_shs_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1, (String)inLstMap.get("kiki_shs_hsk_cd_1"));
		}
		// 機器送付先補足コード２ → 機器送付先補足コード２
		if ("".equals(inLstMap.get("kiki_shs_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2, (String)inLstMap.get("kiki_shs_hsk_cd_2"));
		}
		// 機器送付先補足メモ → 機器送付先補足メモ
		if ("".equals(inLstMap.get("kiki_shs_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO, (String)inLstMap.get("kiki_shs_hsk_memo"));
		}
		// 機器設置先名 → 機器設置先名
		if ("".equals(inLstMap.get("kiki_stc_saki_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM, (String)inLstMap.get("kiki_stc_saki_nm"));
		}
		// 機器設置先カナ名 → 機器設置先カナ名
		if ("".equals(inLstMap.get("kiki_stc_saki_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA, (String)inLstMap.get("kiki_stc_saki_kana"));
		}

		// ============================= ↓↓住所分割処理後の値を設定するよう修正 2011/10/10 ↓↓ ============================
		// 機器設置先住所コード → 機器設置先住所コード
		if ("".equals(useplaceAddressMap.get("ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD, (String)useplaceAddressMap.get("ad_cd"));
		}
		// 機器設置先郵便番号 → 機器設置先郵便番号
		if ("".equals(inLstMap.get("kiki_stc_saki_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD, (String)inLstMap.get("kiki_stc_saki_pcd"));
		}
		// 機器設置先都道府県名 → 機器設置先都道府県名
		if ("".equals(useplaceAddressMap.get("kiki_stc_saki_state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM, (String)useplaceAddressMap.get("state_nm"));
		}
		// 機器設置先市区町村名 → 機器設置先市区町村名
		if ("".equals(useplaceAddressMap.get("city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM, (String)useplaceAddressMap.get("city_nm"));
		}
		// 機器設置先大字通称名 → 機器設置先大字通称名
		if ("".equals(useplaceAddressMap.get("oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM, (String)useplaceAddressMap.get("oaztsu_nm"));
		}
		// 機器設置先字丁目名 → 機器設置先字丁目名
		if ("".equals(useplaceAddressMap.get("azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM, (String)useplaceAddressMap.get("azcho_nm"));
		}
		// 機器設置先番地号 → 機器設置先番地号
		if ("".equals(useplaceAddressMap.get("after_bnchi")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO, (String)useplaceAddressMap.get("after_bnchi"));
		}
		// ============================= ↑↑住所分割処理後の値を設定するよう修正 2011/10/10 ↑↑ ============================

		// 機器設置先住所補記・建物名 → 機器設置先住所補記・建物名
		if ("".equals(inLstMap.get("kiki_stc_saki_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM, (String)inLstMap.get("kiki_stc_saki_adrttm"));
		}
		// 機器設置先住所補記・部屋番号 → 機器設置先住所補記・部屋番号
		if ("".equals(inLstMap.get("kiki_stc_saki_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM, (String)inLstMap.get("kiki_stc_saki_adrrm"));
		}
		// 機器設置先＿契約者住所差異フラグ → 機器設置先＿契約者住所差異フラグ
		if ("".equals(inLstMap.get("kiki_stc_sk_ksh_ad_sai_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG, (String)inLstMap.get("kiki_stc_sk_ksh_ad_sai_flg"));
		}
		// 機器設置先電話番号 → 機器設置先電話番号
		if ("".equals(inLstMap.get("kiki_stc_sk_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO, (String)inLstMap.get("kiki_stc_sk_telno"));
		}
		// 機器設置先区画整理中フラグ → 機器設置先区画整理中フラグ
		if ("".equals(inLstMap.get("kiki_sts_kkk_seiri_chu_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG, (String)inLstMap.get("kiki_sts_kkk_seiri_chu_flg"));
		}

		// ↓↓ ■2011/10/15 項目追加■ ↓↓ 
		// 機器提供サービス.住所未確定フラグ → 住所未確定フラグ
		if ("".equals(inLstMap.get("ad_mi_fix_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.AD_MI_FIX_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.AD_MI_FIX_FLG, (String)inLstMap.get("ad_mi_fix_flg"));
		}
		// ↑↑ ■2011/10/15 項目追加■ ↑↑ 

		// 機器設置先補足コード１ → 機器設置先補足コード１
		if ("".equals(inLstMap.get("kiki_sts_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1, (String)inLstMap.get("kiki_sts_hsk_cd_1"));
		}
		// 機器設置先補足コード２ → 機器設置先補足コード２
		if ("".equals(inLstMap.get("kiki_sts_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2, (String)inLstMap.get("kiki_sts_hsk_cd_2"));
		}
		// 機器設置先補足メモ → 機器設置先補足メモ
		if ("".equals(inLstMap.get("kiki_sts_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO, (String)inLstMap.get("kiki_sts_hsk_memo"));
		}
		// 配送区分 → 配送区分
		if ("".equals(inLstMap.get("haiso_div")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_DIV);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_DIV, (String)inLstMap.get("haiso_div"));
		}
		// 試用加入年月日 → 試用加入年月日
		if ("".equals(inLstMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD, (String)inLstMap.get("ftrial_kanyu_ymd"));
		}
		// 試用期間終了年月日 → 試用期間終了年月日
		if ("".equals(inLstMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inLstMap.get("ftrial_prd_endymd"));
		}
		// 本加入年月日 → 本加入年月日
		if ("".equals(inLstMap.get("honkanyu_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HONKANYU_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HONKANYU_YMD, (String)inLstMap.get("honkanyu_ymd"));
		}
		// 本加入移行期限年月日 → 本加入移行期限年月日
		if ("".equals(inLstMap.get("honkanyu_iko_kigen_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)inLstMap.get("honkanyu_iko_kigen_ymd"));
		}
		// 保証コード → 保証コード
		if ("".equals(inLstMap.get("hosho_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_CD, (String)inLstMap.get("hosho_cd"));
		}
		// 保証開始年月日 → 保証開始年月日
		if ("".equals(inLstMap.get("hosho_staymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_STAYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_STAYMD, (String)inLstMap.get("hosho_staymd"));
		}
		// 保証終了年月日 → 保証終了年月日
		if ("".equals(inLstMap.get("hosho_end_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_END_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_END_YMD, (String)inLstMap.get("hosho_end_ymd"));
		}
		// 予約適用年月日 → 予約適用年月日
		if ("".equals(inLstMap.get("rsv_aply_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_APLY_YMD, (String)inLstMap.get("rsv_aply_ymd"));
		}
		// 予約適用コード → 予約適用コード
		if ("".equals(inLstMap.get("rsv_aply_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_APLY_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_APLY_CD, (String)inLstMap.get("rsv_aply_cd"));
		}
		// 違約金発生コード → 違約金発生コード
		if ("".equals(inLstMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PNLTY_HASSEI_CD, (String)inLstMap.get("pnlty_hassei_cd"));
		}

		//  異動区分→ 異動区分
		if ("".equals(inLstMap.get("ido_div")))
		{
			template.setNull(EKK0341D010CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.IDO_DIV, (String)inLstMap.get("ido_div"));
		}

		// ↓↓ ■2011/10/15 項目追加■ ↓↓ 
		// 機器提供サービス.宅内機器異動コード → 宅内機器異動コード
		if ("".equals(inLstMap.get("taknkiki_ido_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD, (String)inLstMap.get("taknkiki_ido_cd"));
		}
		// ↑↑ ■2011/10/15 項目追加■ ↑↑

		//  CASカード使用許諾年月日→ CASカード使用許諾年月日
		if ("".equals(inLstMap.get("cas_card_use_kyodak_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD, (String)inLstMap.get("cas_card_use_kyodak_ymd"));
		}

		// ↓↓ ■2011/10/15 項目追加■ ↓↓ 
		// 機器提供サービス.機器付加情報コード → 機器付加情報コード
		if ("".equals(inLstMap.get("kiki_huka_info_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD, (String)inLstMap.get("kiki_huka_info_cd"));
		}
		// ↑↑ ■2011/10/15 項目追加■ ↑↑

		// 機器提供サービス.配送方法コード	
		if ("".equals(inLstMap.get("haiso_way_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_WAY_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_WAY_CD, (String)inLstMap.get("haiso_way_cd"));
		}

		//  課金先番号→ 課金先番号
		if ("".equals(inLstMap.get("kakins_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_NO, (String)inLstMap.get("kakins_no"));
		}
		// 請求契約番号 → 請求契約番号
		if ("".equals(inLstMap.get("seiky_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SEIKY_KEI_NO, (String)inLstMap.get("seiky_kei_no"));
		}
		//  料金項目コード→ 料金項目コード
		if ("".equals(inLstMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PRC_KMK_CD, (String)inLstMap.get("prc_kmk_cd"));
		}
		//  課金先適用開始年月日→ 課金先適用開始年月日
		if ("".equals(inLstMap.get("kakins_tstaymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_TSTAYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_TSTAYMD, (String)inLstMap.get("kakins_tstaymd"));
		}
		//  課金先適用終了年月日→ 課金先適用終了年月日
		if ("".equals(inLstMap.get("kakins_tendymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_TENDYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_TENDYMD, (String)inLstMap.get("kakins_tendymd"));
		}
		//  登録年月日時分秒→ 登録年月日時分秒
		if ("".equals(inLstMap.get("add_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.ADD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.ADD_DTM, (String)inLstMap.get("add_dtm"));
		}
		//  登録オペレータアカウント→ 登録オペレータアカウント
		if ("".equals(inLstMap.get("add_opeacnt")))
		{
			template.setNull(EKK0341D010CBSMsg.ADD_OPEACNT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.ADD_OPEACNT, (String)inLstMap.get("add_opeacnt"));
		}
		//  更新年月日時分秒→ 更新年月日時分秒
		if ("".equals(inLstMap.get("upd_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM, (String)inLstMap.get("upd_dtm"));
		}
		//  更新オペレータアカウント→ 更新オペレータアカウント
		if ("".equals(inLstMap.get("upd_opeacnt")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_OPEACNT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_OPEACNT, (String)inLstMap.get("upd_opeacnt"));
		}
		//  無効フラグ→ 無効フラグ
		if ("".equals(inLstMap.get("mk_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.MK_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MK_FLG, (String)inLstMap.get("mk_flg"));
		}

		// 機器提供サービス契約登録マップ.機器製造番号 → 機器製造番号
		if ("".equals(inLstMap.get("kiki_seizo_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SEIZO_NO, (String)inLstMap.get("kiki_seizo_no"));
		}

		// 機器提供サービス契約登録マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		if ("".equals(inLstMap.get("upd_dtm_bf")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_DTM_BF);
		}
		else if (index == 0)
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM_BF, (String)inLstMap.get("upd_dtm_bf"));
		}
		else if (index > 0)
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM_BF, (String)inMapUpAf.get("upd_dtm"));
		}

		// 2012/09/19 追加 Otsuka
		//  機器送付先住所手動入力フラグ→ 機器送付先住所手動入力フラグ
		if ("".equals(inLstMap.get("kiki_shs_ad_man_input_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG, (String)inLstMap.get("kiki_shs_ad_man_input_flg"));
		}

		return template;
	}

	/**
	 * 機器提供サービス契約登録の下りマッピング処理<br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, int index)
			throws Exception
	{

		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData("EKK0341D010");
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData("EKK0341D010", dataMap);
		}

		// ++++++++++++++++++++ v1.00.00 追加開始 ++++++++++++++++++++++++++ */
		ArrayList dataList = (ArrayList)dataMap.get("EKK0341D010List");
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0341D010List", dataList);
		}

		HashMap childMap = (HashMap)dataList.get(index);
		if (childMap == null)
		{
			childMap = new HashMap();
			dataList.add(index, childMap);
		}
		// +++++++++++++++++++ v1.00.00 追加終了 +++++++++++++++++++++++++++ */

		// 機器提供サービス契約登録マップ.機器提供サービス契約番号 ← 機器提供サービス契約番号
		if (template.isNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO))
		{
			childMap.put("kktk_svc_kei_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kktk_svc_kei_no", template.getString(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO));
		}

		// 機器提供サービス契約登録マップ.登録年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(EKK0341D010CBSMsg.UPD_DTM))
		{
			childMap.put("upd_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_dtm", template.getString(EKK0341D010CBSMsg.UPD_DTM));
			// ワークマップに登録
			workMap.put("upd_dtm", template.getString(EKK0341D010CBSMsg.UPD_DTM));
		}

		// エラー情報の設定
		param = editErrInfoEKK0341D010(param, template, (Integer)returnCode, fixedText, index); // No708 2013/04/24 Otsuka 

		//エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @param i
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText,
			int i) throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0341D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK0341D010");
		// No708 2013/04/24 Otsuka start
		inMap = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(i);

		// 機器提供サービスコード
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kktk_svc_cd_err"))
			{
				inMap.put("kktk_svc_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR));
			}
		}

		// 料金コースコード
		if (!template.isNull(EKK0341D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK0341D010CBSMsg.PCRS_CD_ERR));
			}
		}

		// 料金プランコード
		if (!template.isNull(EKK0341D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK0341D010CBSMsg.PPLAN_CD_ERR));
			}
		}

		// 機器提供種別コード
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR))
		{
			if (!inMap.containsKey("kktk_sbt_cd_err"))
			{
				inMap.put("kktk_sbt_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR));
			}
		}

		// HDD容量コード
		if (!template.isNull(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR))
		{
			if (!inMap.containsKey("hdd_capa_cd_err"))
			{
				inMap.put("hdd_capa_cd_err", template.getString(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR));
			}
		}

		// サービス利用開始希望年月日
		if (!template.isNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}

		// 予約適用開始希望年月日
		if (!template.isNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}

		// 希望メーカーコード
		if (!template.isNull(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR))
		{
			if (!inMap.containsKey("kibo_maker_cd_err"))
			{
				inMap.put("kibo_maker_cd_err", template.getString(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR));
			}
		}

		// 販売種別コード
		if (!template.isNull(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("hambai_sbt_cd_err"))
			{
				inMap.put("hambai_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR));
			}
		}

		// 通信機器セットコード
		if (!template.isNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR))
		{
			if (!inMap.containsKey("tsushin_kiki_set_cd_err"))
			{
				inMap.put("tsushin_kiki_set_cd_err", template.getString(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR));
			}
		}

		// 宅内機器種別コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sbt_cd_err"))
			{
				inMap.put("taknkiki_sbt_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR));
			}
		}

		// 宅内機器型式コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_model_cd_err"))
			{
				inMap.put("taknkiki_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR));
			}
		}

		// 宅内機器セット品型コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sethin_model_cd_err"))
			{
				inMap.put("taknkiki_sethin_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR));
			}
		}

		// 付属品種別コード
		if (!template.isNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("huzokuhin_sbt_cd_err"))
			{
				inMap.put("huzokuhin_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR));
			}
		}

		// 機器設置先場所番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_place_no_err"))
			{
				inMap.put("kiki_stc_saki_place_no_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR));
			}
		}

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

		// サービス契約内訳番号
		if (!template.isNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}

		// サービス契約回線内訳番号
		if (!template.isNull(EKK0341D010CBSMsg.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(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}

		// オプションサービス契約番号
		if (!template.isNull(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("op_svc_kei_no_err"))
			{
				inMap.put("op_svc_kei_no_err", template.getString(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR));
			}
		}

		// SYSID
		if (!template.isNull(EKK0341D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0341D010CBSMsg.SYSID_ERR));
			}
		}

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

		// リンクSTBフラグ
		if (!template.isNull(EKK0341D010CBSMsg.LINK_STB_FLG_ERR))
		{
			if (!inMap.containsKey("link_stb_flg_err"))
			{
				inMap.put("link_stb_flg_err", template.getString(EKK0341D010CBSMsg.LINK_STB_FLG_ERR));
			}
		}

		// 機器送料有無
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_um_err"))
			{
				inMap.put("kiki_soryo_um_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR));
			}
		}

		// 機器送料作成年月日
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_saksei_ymd_err"))
			{
				inMap.put("kiki_soryo_saksei_ymd_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR));
			}
		}

		// 機器送付先名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_nm_err"))
			{
				inMap.put("kiki_sohus_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR));
			}
		}

		// 機器送付先カナ名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_kana_err"))
			{
				inMap.put("kiki_sohus_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR));
			}
		}

		// 機器送付先住所コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ad_cd_err"))
			{
				inMap.put("kiki_sohus_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR));
			}
		}

		// 機器送付先郵便番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_pcd_err"))
			{
				inMap.put("kiki_sohus_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR));
			}
		}

		// 機器送付先都道府県名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_state_nm_err"))
			{
				inMap.put("kiki_sohus_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR));
			}
		}

		// 機器送付先市区町村名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_city_nm_err"))
			{
				inMap.put("kiki_sohus_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR));
			}
		}

		// 機器送付先大字通称名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_oaztsu_nm_err"))
			{
				inMap.put("kiki_sohus_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR));
			}
		}

		// 機器送付先字丁目名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_azcho_nm_err"))
			{
				inMap.put("kiki_sohus_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR));
			}
		}

		// 機器送付先番地号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_bnchigo_err"))
			{
				inMap.put("kiki_sohus_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR));
			}
		}

		// 機器送付先住所補記・建物名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrttm_err"))
			{
				inMap.put("kiki_sohus_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR));
			}
		}

		// 機器送付先住所補記・部屋番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrrm_err"))
			{
				inMap.put("kiki_sohus_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR));
			}
		}

		// 機器送付先電話番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_telno_err"))
			{
				inMap.put("kiki_sohus_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR));
			}
		}

		// マンション物件番号
		if (!template.isNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR))
		{
			if (!inMap.containsKey("mansion_bukken_no_err"))
			{
				inMap.put("mansion_bukken_no_err", template.getString(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR));
			}
		}

		// 機器送付先_契約者住所差異フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_sohus_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR));
			}
		}

		// 機器送付先個別指定フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_shs_kbt_shitei_flg_err"))
			{
				inMap.put("kiki_shs_kbt_shitei_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR));
			}
		}

		// 機器送付先補足コード1
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_1_err"))
			{
				inMap.put("kiki_shs_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR));
			}
		}

		// 機器送付先補足コード2
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_2_err"))
			{
				inMap.put("kiki_shs_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR));
			}
		}

		// 機器送付先補足メモ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_memo_err"))
			{
				inMap.put("kiki_shs_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR));
			}
		}

		// 機器設置先名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_nm_err"))
			{
				inMap.put("kiki_stc_saki_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR));
			}
		}

		// 機器設置先カナ名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_kana_err"))
			{
				inMap.put("kiki_stc_saki_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR));
			}
		}

		// 機器設置先住所コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_ad_cd_err"))
			{
				inMap.put("kiki_stc_saki_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR));
			}
		}

		// 機器設置先郵便番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_pcd_err"))
			{
				inMap.put("kiki_stc_saki_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR));
			}
		}

		// 機器設置先都道府県名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_state_nm_err"))
			{
				inMap.put("kiki_stc_saki_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR));
			}
		}

		// 機器設置先市区町村名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_city_nm_err"))
			{
				inMap.put("kiki_stc_saki_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR));
			}
		}

		// 機器設置先大字通称名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_oaztsu_nm_err"))
			{
				inMap.put("kiki_stc_saki_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR));
			}
		}

		// 機器設置先字丁目名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_azcho_nm_err"))
			{
				inMap.put("kiki_stc_saki_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR));
			}
		}

		// 機器設置先番地号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_bnchigo_err"))
			{
				inMap.put("kiki_stc_saki_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR));
			}
		}

		// 機器設置先住所補記・建物名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrttm_err"))
			{
				inMap.put("kiki_stc_saki_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR));
			}
		}

		// 機器設置先住所補記・部屋番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrrm_err"))
			{
				inMap.put("kiki_stc_saki_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR));
			}
		}

		// 機器設置先_契約者住所差異フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_stc_sk_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR));
			}
		}

		// 機器設置先電話番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_telno_err"))
			{
				inMap.put("kiki_stc_sk_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR));
			}
		}

		// 機器設置先区画整理中フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sts_kkk_seiri_chu_flg_err"))
			{
				inMap.put("kiki_sts_kkk_seiri_chu_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR));
			}
		}

		// 機器設置先補足コード1
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_1_err"))
			{
				inMap.put("kiki_sts_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR));
			}
		}

		// 機器設置先補足コード2
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_2_err"))
			{
				inMap.put("kiki_sts_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR));
			}
		}

		// 機器設置先補足メモ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_memo_err"))
			{
				inMap.put("kiki_sts_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR));
			}
		}

		// 配送区分
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_DIV_ERR))
		{
			if (!inMap.containsKey("haiso_div_err"))
			{
				inMap.put("haiso_div_err", template.getString(EKK0341D010CBSMsg.HAISO_DIV_ERR));
			}
		}

		// 試用加入年月日
		if (!template.isNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}

		// 本加入年月日
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}

		// 本加入移行期限年月日
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}

		// 保証コード
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_CD_ERR))
		{
			if (!inMap.containsKey("hosho_cd_err"))
			{
				inMap.put("hosho_cd_err", template.getString(EKK0341D010CBSMsg.HOSHO_CD_ERR));
			}
		}

		// 保証開始年月日
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR))
		{
			if (!inMap.containsKey("hosho_staymd_err"))
			{
				inMap.put("hosho_staymd_err", template.getString(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR));
			}
		}

		// 違約金発生コード
		if (!template.isNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}

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

		// CASカード使用許諾年月日
		if (!template.isNull(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR))
		{
			if (!inMap.containsKey("cas_card_use_kyodak_ymd_err"))
			{
				inMap.put("cas_card_use_kyodak_ymd_err", template.getString(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR));
			}
		}

		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto START -----
		// 機器製造番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR))
		{
			if (!inMap.containsKey("kiki_seizo_no_err"))
			{
				inMap.put("kiki_seizo_no_err", template.getString(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR));
			}
		}

		// 機器移転先移動実施者識別コード
		if (!template.isNull(EKK0341D010CBSMsg.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(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR));
			}
		}

		// 配送依頼指定年月日
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR))
		{
			if (!inMap.containsKey("haiso_req_shitei_ymd_err"))
			{
				inMap.put("haiso_req_shitei_ymd_err", template.getString(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR));
			}
		}

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK0341D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto END -----
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_shs_ad_man_input_flg_err"))
			{
				inMap.put("kiki_shs_ad_man_input_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG_ERR));
			}
		}

		return param;
	}

	/**
	 * オプションサービス契約＜サポート＞登録上りマッピング処理.<br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0391D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0391D010CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0391D010CBSMsg.TEMPLATEID, "EKK0391D010");

		// 機能コード（デフォルト：１）
		template.set(EKK0391D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData("EKK0391D010");

		// 機能コード
		template.set(EKK0391D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// オプションサービス契約番号 → オプションサービス契約番号
		if ("".equals(inMap.get("op_svc_kei_no")))
		{
			template.setNull(EKK0391D010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.OP_SVC_KEI_NO, (String)inMap.get("op_svc_kei_no"));
		}

		// 世代登録年月日時分秒（オプションサービス契約） → 世代登録年月日時分秒（オプションサービス契約）
		if ("".equals(inMap.get("kk0351_gene_add_dtm")))
		{
			template.setNull(EKK0391D010CBSMsg.KK0351_GENE_ADD_DTM);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.KK0351_GENE_ADD_DTM, (String)inMap.get("kk0351_gene_add_dtm"));
		}
		// オプションサービス契約ステータス → オプションサービス契約ステータス
		if ("".equals(inMap.get("op_svc_kei_stat")))
		{
			template.setNull(EKK0391D010CBSMsg.OP_SVC_KEI_STAT);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.OP_SVC_KEI_STAT, (String)inMap.get("op_svc_kei_stat"));
		}
		// オプションサービスコード → オプションサービスコード
		if ("".equals(inMap.get("op_svc_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.OP_SVC_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.OP_SVC_CD, (String)inMap.get("op_svc_cd"));
		}

		// 料金コースコード → 料金コースコード
		if ("".equals(inMap.get("pcrs_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.PCRS_CD, (String)inMap.get("pcrs_cd"));
		}
		// 料金プランコード → 料金プランコード
		if ("".equals(inMap.get("pplan_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.PPLAN_CD, (String)inMap.get("pplan_cd"));
		}
		// 親契約識別コード → 親契約識別コード
		if ("".equals(inMap.get("oya_kei_skbt_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.OYA_KEI_SKBT_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.OYA_KEI_SKBT_CD, (String)inMap.get("oya_kei_skbt_cd"));
		}
		// サービス契約番号 → サービス契約番号
		if ("".equals(inMap.get("svc_kei_no")))
		{
			template.setNull(EKK0391D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		// サービス契約内訳番号 → サービス契約内訳番号
		if ("".equals(inMap.get("svc_kei_ucwk_no")))
		{
			template.setNull(EKK0391D010CBSMsg.SVC_KEI_UCWK_NO);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.SVC_KEI_UCWK_NO, (String)inMap.get("svc_kei_ucwk_no"));
		}
		// ＳＹＳＩＤ → ＳＹＳＩＤ
		if ("".equals(inMap.get("sysid")))
		{
			// 2012.09.21 Otsuka 追加 一括の場合にWORKから取得するように修正
			if (getWorkMapValue(param, "sysid", CC_WORK_AREA_NAME_KEISHA) != null)
			{
				template.set(EKK0391D010CBSMsg.SYSID, getWorkMapValue(param, "sysid", CC_WORK_AREA_NAME_KEISHA));
			}
			else
			{
				template.setNull(EKK0391D010CBSMsg.SYSID);
			}
		}
		else
		{
			template.set(EKK0391D010CBSMsg.SYSID, (String)inMap.get("sysid"));
		}
		// 申込明細番号 → 申込明細番号
		if ("".equals(inMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0391D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.MSKM_DTL_NO, (String)inMap.get("mskm_dtl_no"));
		}
		// 試用加入年月日 → 試用加入年月日
		if ("".equals(inMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK0391D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.FTRIAL_KANYU_YMD, (String)inMap.get("ftrial_kanyu_ymd"));
		}
		// 試用期間終了年月日 → 試用期間終了年月日
		if ("".equals(inMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK0391D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inMap.get("ftrial_prd_endymd"));
		}

		// 本加入年月日 → 本加入年月日
		if ("".equals(inMap.get("honkanyu_ymd")))
		{
			template.setNull(EKK0391D010CBSMsg.HONKANYU_YMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.HONKANYU_YMD, (String)inMap.get("honkanyu_ymd"));
		}

		// 本加入移行期限年月日 → 本加入移行期限年月日
		if ("".equals(inMap.get("honkanyu_iko_kigen_ymd")))
		{
			template.setNull(EKK0391D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)inMap.get("honkanyu_iko_kigen_ymd"));
		}

		// サービス利用開始希望年月日 → サービス利用開始希望年月日
		//「IT2-2012-0002142」サービス開始希望年月日>>>値設定不要のため、空を無条件で設定する
		template.setNull(EKK0391D010CBSMsg.SVC_USE_STA_KIBO_YMD);
		//「IT2-2012-0002142」サービス開始希望年月日<<<E

		// 予約適用開始希望年月日 → 予約適用開始希望年月日
		if ("".equals(inMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK0391D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inMap.get("rsv_tsta_kibo_ymd"));
		}
		// 予約適用年月日 → 予約適用年月日
		if ("".equals(inMap.get("rsv_aply_ymd")))
		{
			template.setNull(EKK0391D010CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.RSV_APLY_YMD, (String)inMap.get("rsv_aply_ymd"));
		}

		// 予約適用コード → 予約適用コード
		if ("".equals(inMap.get("rsv_aply_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.RSV_APLY_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.RSV_APLY_CD, (String)inMap.get("rsv_aply_cd"));
		}
		// 違約金発生コード → 違約金発生コード
		if ("".equals(inMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.PNLTY_HASSEI_CD, (String)inMap.get("pnlty_hassei_cd"));
		}

		// 異動区分 → 異動区分
		if ("".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0391D010CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}
		// 世代登録年月日時分秒（オプションサービス契約＜サポート＞） → 世代登録年月日時分秒（オプションサービス契約＜サポート＞）
		if ("".equals(inMap.get("kk0391_gene_add_dtm")))
		{
			template.setNull(EKK0391D010CBSMsg.KK0391_GENE_ADD_DTM);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.KK0391_GENE_ADD_DTM, (String)inMap.get("kk0391_gene_add_dtm"));
		}
		// 登録年月日時分秒 → 登録年月日時分秒
		if ("".equals(inMap.get("add_dtm")))
		{
			template.setNull(EKK0391D010CBSMsg.ADD_DTM);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.ADD_DTM, (String)inMap.get("add_dtm"));
		}
		// 登録オペレータアカウント → 登録オペレータアカウント
		if ("".equals(inMap.get("add_opeacnt")))
		{
			template.setNull(EKK0391D010CBSMsg.ADD_OPEACNT);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.ADD_OPEACNT, (String)inMap.get("add_opeacnt"));
		}
		// 更新年月日時分秒 → 更新年月日時分秒
		if ("".equals(inMap.get("upd_dtm")))
		{
			template.setNull(EKK0391D010CBSMsg.UPD_DTM);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.UPD_DTM, (String)inMap.get("upd_dtm"));
		}
		// 更新オペレータアカウント → 更新オペレータアカウント
		if ("".equals(inMap.get("upd_opeacnt")))
		{
			template.setNull(EKK0391D010CBSMsg.UPD_OPEACNT);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.UPD_OPEACNT, (String)inMap.get("upd_opeacnt"));
		}
		// 無効フラグ → 無効フラグ
		if ("".equals(inMap.get("mk_flg")))
		{
			template.setNull(EKK0391D010CBSMsg.MK_FLG);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.MK_FLG, (String)inMap.get("mk_flg"));
		}
		// 課金先番号 → 課金先番号
		if ("".equals(inMap.get("kakins_no")))
		{
			template.setNull(EKK0391D010CBSMsg.KAKINS_NO);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.KAKINS_NO, (String)inMap.get("kakins_no"));
		}
		// 請求契約番号 → 請求契約番号
		if ("".equals(inMap.get("seiky_kei_no")))
		{
			// 2012.09.21 Otsuka 追加 一括の場合にWORKから取得するように修正
			if (getWorkMapValue(param, "seiky_kei_no", CC_WORK_AREA_NAME_SKK) != null)
			{
				template.set(EKK0391D010CBSMsg.SEIKY_KEI_NO, getWorkMapValue(param, "seiky_kei_no", CC_WORK_AREA_NAME_SKK));
			}
			else
			{
				template.setNull(EKK0391D010CBSMsg.SEIKY_KEI_NO);
			}
		}
		else
		{
			template.set(EKK0391D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		// 料金項目コード → 料金項目コード
		if ("".equals(inMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK0391D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.PRC_KMK_CD, (String)inMap.get("prc_kmk_cd"));
		}
		// 課金先適用開始年月日 → 課金先適用開始年月日
		if ("".equals(inMap.get("kakins_tstaymd")))
		{
			template.setNull(EKK0391D010CBSMsg.KAKINS_TSTAYMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.KAKINS_TSTAYMD, (String)inMap.get("kakins_tstaymd"));
		}
		// 課金先適用終了年月日 → 課金先適用終了年月日
		if ("".equals(inMap.get("kakins_tendymd")))
		{
			template.setNull(EKK0391D010CBSMsg.KAKINS_TENDYMD);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.KAKINS_TENDYMD, (String)inMap.get("kakins_tendymd"));
		}

		// 更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		if ("".equals(inMap.get("upd_dtm_bf")))
		{
			template.setNull(EKK0391D010CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0391D010CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
		}

		return template;
	}

	/**
	 * オプションサービス契約＜サポート＞登録の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0391D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{

		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// オプションサービスコード
		if (template.isNull(EKK0391D010CBSMsg.OP_SVC_CD))
		{
			dataMap.put("op_svc_cd", "");
		}
		else
		{
			dataMap.put("op_svc_cd", template.getString(EKK0391D010CBSMsg.OP_SVC_CD));
		}
		// オプションサービス契約番号
		if (template.isNull(EKK0391D010CBSMsg.OP_SVC_KEI_NO))
		{
			dataMap.put("op_svc_kei_no", "");
		}
		else
		{
			dataMap.put("op_svc_kei_no", template.getString(EKK0391D010CBSMsg.OP_SVC_KEI_NO));
		}
		// 世代登録年月日時分秒(オプションサービス契約)
		if (template.isNull(EKK0391D010CBSMsg.KK0351_GENE_ADD_DTM))
		{
			dataMap.put("kk0351_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("kk0351_gene_add_dtm", template.getString(EKK0391D010CBSMsg.KK0351_GENE_ADD_DTM));
		}
		// オプションサービス契約ステータス
		if (template.isNull(EKK0391D010CBSMsg.OP_SVC_KEI_STAT))
		{
			dataMap.put("op_svc_kei_stat", "");
		}
		else
		{
			dataMap.put("op_svc_kei_stat", template.getString(EKK0391D010CBSMsg.OP_SVC_KEI_STAT));
		}
		// 更新年月日時分秒
		if (template.isNull(EKK0391D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0391D010CBSMsg.UPD_DTM));
		}

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		param = editErrInfoEKK0391D010(param, template, (Integer)returnCode, fixedText);

		//エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0391D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0391D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK0391D010");

		// オプションサービス契約＜サポート＞登録マップ.オプションサービスコード → オプションサービスコード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.OP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("op_svc_cd_err"))
			{
				inMap.put("op_svc_cd_err", template.getString(EKK0391D010CBSMsg.OP_SVC_CD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.料金コースコード → 料金コースコード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK0391D010CBSMsg.PCRS_CD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.料金プランコード → 料金プランコード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK0391D010CBSMsg.PPLAN_CD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.親契約識別コード → 親契約識別コード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.OYA_KEI_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("oya_kei_skbt_cd_err"))
			{
				inMap.put("oya_kei_skbt_cd_err", template.getString(EKK0391D010CBSMsg.OYA_KEI_SKBT_CD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK0391D010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK0391D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0391D010CBSMsg.SYSID_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0391D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0391D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK0391D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.本加入年月日 → 本加入年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK0391D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0391D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.サービス利用開始希望年月日 → サービス利用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0391D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0391D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0391D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0391D010CBSMsg.IDO_DIV_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK0391D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// オプションサービス契約＜サポート＞登録マップ.料金項目コード → 料金項目コード のエラー情報返却
		if (!template.isNull(EKK0391D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK0391D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}
		// No708 2013/04/24 Otsuka end
		return param;
	}

	/**
	 * 単一CAANMsgのマッピング処理
	 * <br>
	 * @param paramMap
	 * @param template
	 * @return HashMap
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> putParamMap(HashMap<String, Object> paramMap, CAANMsg template) throws RequestParameterException
	{
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * SCの実行ステータスの取得処理
	 * <br>
	 * @param param
	 * @return int
	 * @throws Exception
	 */
	private int getReturnCode(IRequestParameterReadWrite param) throws Exception
	{
		return Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
	}

	/**
	 * エラー情報のマッピング処理<br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, Integer returnCode)
			throws RequestParameterException
	{
		int i = 0;
		int kikiCnt = 0;
		HashMap inMap = (HashMap<String, Object>)param.getData("EKK0341D010");
		if (inMap == null)
		{
			return param;
		}

		kikiCnt = ((ArrayList)inMap.get("EKK0341D010List")).size();
		// No708 2013/04/24 Otsuka start
		for (i = 0; i < kikiCnt; i++)
		{
			editErrInfoEKK0341D010(param, templates[i], returnCode, "EKK0341D010", i);
		}

		inMap = (HashMap)(param.getData("EKK0391D010"));
		if (inMap != null)
		{
			editErrInfoEKK0391D010(param, templates[templates.length - 1], returnCode, "EKK0391D010"); // 2013/04/23 Otsuka
		}
		// No708 2013/04/24 Otsuka end

		return param;
	}

	/**
	 * 作業エリア<br>
	 * @param param
	 * @param key
	 * @param fixText
	 * @return String
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getWorkMapValue(IRequestParameterReadWrite param, String key, String fixText) throws RequestParameterException
	{
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();

		HashMap inMap = null;
		/* 作業項目情報 */
		if (workMap != null)
		{
			inMap = (HashMap)workMap.get(fixText);
		}
		else
		{
			inMap = null;
		}

		String result = null;
		if (inMap != null)
		{
			result = (String)inMap.get(key);
		}

		if ("".equals(result))
		{
			result = null;
		}

		return result;
	}

	/* 2012/11/15 ANK-1224-00-00 Y.Saitou ADD-START */

	/**
	 * 宅内機器型式コード設定処理
	 * 
	 * @param handle
	 * @param param リクエストパラメータ
	 * @param index 機器提供サービス契約登録用情報リストインデックス
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setTaknkikiModeCd(SessionHandle handle, IRequestParameterReadWrite param, int index) throws Exception
	{
		HashMap inMap = null;
		HashMap inLstMap = null;
		HashMap inMapUpAf = null;
		HashMap map = null;
		ArrayList list = null;

		/* 機器提供サービス契約登録用情報取得 */
		inMap = (HashMap)param.getData("EKK0341D010");
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(index);

		// 宅内機器型式情報取得部品処理
		JFUGetTaknkikiModelInfoUtil util = new JFUGetTaknkikiModelInfoUtil();
		inMapUpAf = new HashMap();
		// 宅内機器種別コード
		inMapUpAf.put("taknkiki_sbt_cd", inLstMap.get("taknkiki_sbt_cd"));
		// 保有ルーターコード
		inMapUpAf.put("hoyu_router_cd", inLstMap.get("kk1861_hoyu_router_cd"));
		// 料金コースコード
		inMapUpAf.put("pcrs_cd", inLstMap.get("kk1861_pcrs_cd"));

		String taknkiki = (String)inLstMap.get("taknkiki_sbt_cd");
		// 宅内機器種別コードが多機能ルーターの場合、該当宅内機器型式コードを取得しない
		if (!JFUStrConst.CD01262_R0.equals(taknkiki))
		{
// ANK-3529-00-00 MOD START
			// 該当宅内機器型式コードを取得
			list = util.getTaknkiki(handle, param, inMapUpAf);
			// ■宅内機器種別コード＝G0：ＰＬＣモデム（PLC、無線LAN中継機、eoメッシュWi-Fi）の場合、
			//   PLCは廃止、無線LAN中継機とeoメッシュWi-Fiは、型が１つのみのため、入力パラメータから取得。
			//   ※本来はサービス契約の料金コースを考慮して機器の候補一覧から宅内機器型式コードを取得。
			if (JFUStrConst.CD01262_G0.equals(taknkiki))
			{
				inLstMap.put("taknkiki_model_cd", (String)inLstMap.get("taknkiki_model_cd"));
			}
			else if (JFUStrConst.CD01262_Q0.equals(taknkiki))
			{
				inLstMap.put("taknkiki_model_cd", (String)inLstMap.get("taknkiki_model_cd"));
			}
			else
			{
				// 宅内機器型式コード設定
				map = (HashMap)list.get(0);
				inLstMap.put("taknkiki_model_cd", (String)map.get("taknkiki_model_cd"));
			}
// ANK-3529-00-00 MOD END
		}
	}
	/* 2012/11/15 ANK-1224-00-00 Y.Saitou ADD-END */

	/**
	 * 契約者情報取得処理
	 * @param param
	 * @param key
	 * @return String
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getKeishaWorkMapValue(IRequestParameterReadWrite param, String key) throws RequestParameterException
	{
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();

		HashMap inMap = null;
		/* 契約者作業項目情報 */
		if (workMap != null)
		{
			inMap = (HashMap)workMap.get(CC_WORK_AREA_NAME_KEISHA);
		}
		else
		{
			inMap = null;
		}

		String result = null;
		if (inMap != null)
		{
			result = (String)inMap.get(key);
		}

		if ("".equals(result))
		{
			result = null;
		}

		return result;
	}

	/**
	 * 回線対象サービス契約一覧照会（サービス契約番号）の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0241B003(IRequestParameterReadWrite param, String svcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0241B003CBSMsg.class.getName());

		// テンプレートID
		template.set(EKK0241B003CBSMsg.TEMPLATEID, "EKK0241B003");

		// 機能コード（デフォルト：１）
		template.set(EKK0241B003CBSMsg.FUNC_CODE, FUNC_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 (JFUStrConst.EMPTY.equals(svcKeiNo))
		{
			template.setNull(EKK0241B003CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0241B003CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}

		return template;
	}

	/**
	 * 回線対象サービス契約一覧照会（サービス契約番号）の下りマッピング処理 <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0241B003(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		templateArray = template.getCAANMsgList(EKK0241B003CBSMsg.EKK0241B003CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0241B003CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap childMap = new HashMap();
				CAANMsg childTemplate = templateArray[i];

				// サービス契約回線内訳番号
				if (childTemplate.isNull(EKK0241B003CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO))
				{
					childMap.put("svc_kei_kaisen_ucwk_no", JFUStrConst.EMPTY);
				}
				else
				{
					childMap.put("svc_kei_kaisen_ucwk_no", childTemplate.getString(EKK0241B003CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
				}
				dataList.add(childMap);

			}
		}
		dataMap.put("EKK0241B003CBSMsg1List", dataList);

		// エラー情報の設定
		editErrInfoEKK0241B003(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0241B003(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0241B003CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// ＫＥＹ＿サービス契約番号のエラー情報返却
		if (!template.isNull(EKK0241B003CBSMsg.KEY_SVC_KEI_NO))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0241B003CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 機器オプションサービス契約一覧照会(フロント)の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2811B503(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811B503CBSMsg.class.getName());

		HashMap inMap = null;

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

		// 機能コード（デフォルト：１）
		template.set(EKK2811B503CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);

		// お客様登録.SYSID → ＫＥＹ＿SYSID
		if (inMap == null || inMap.get("key_sysid") == null || "".equals(inMap.get("key_sysid")))
		{
			HashMap ekk0341Map = (HashMap)param.getData("EKK0341D010Tkn");
			ArrayList ekk0341List = (ArrayList)ekk0341Map.get("EKK0341D010TknList");
			HashMap ekk0341D010TknMap = (HashMap)ekk0341List.get(0);
			String sysid = (String)ekk0341D010TknMap.get(EKK0341D010CBSMsg.SYSID);
			template.set(EKK2811B503CBSMsg.KEY_SYSID, sysid);
		}
		else
		{
			template.set(EKK2811B503CBSMsg.KEY_SYSID, (String)inMap.get("key_sysid"));
		}

		// ＫＥＹ＿サービス契約回線内訳番号
		if (inMap == null || inMap.get("key_svc_kei_kaisen_ucwk_no") == null || "".equals(inMap.get("key_svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO);
			/* ++++++++++++++++ v1.00.00 追加開始 +++++++++++++++++++++++++ */
			if (inMap.get("oya_kei_skbt_cd").equals(OYA_KEI_SKBT_CD_02))
			{
				String svc_kei_kaisen_ucwk_no = getWorkMapValue(param, "svc_kei_kaisen_ucwk_no", CC_WORK_AREA_NAME_USE);
				if (svc_kei_kaisen_ucwk_no == null)
				{
					template.setNull(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO);
				}
				else
				{
					template.set(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, svc_kei_kaisen_ucwk_no);
				}
			}
			/* ++++++++++++++++ v1.00.00 追加終了 +++++++++++++++++++++++++ */
		}
		else
		{
			template.set(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, (String)inMap.get("key_svc_kei_kaisen_ucwk_no"));
		}

		// ＫＥＹ＿宅内機器種別コード
		if (inMap == null || inMap.get("key_taknkiki_sbt_cd") == null || "".equals(inMap.get("key_taknkiki_sbt_cd")))
		{
			template.setNull(EKK2811B503CBSMsg.KEY_TAKNKIKI_SBT_CD);
		}
		else
		{
			template.set(EKK2811B503CBSMsg.KEY_TAKNKIKI_SBT_CD, (String)inMap.get("key_taknkiki_sbt_cd"));
		}

		return template;
	}

	/**
	 * 機器オプションサービス契約一覧照会(フロント)の下りマッピング処理 <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK2811B503(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		templateArray = template.getCAANMsgList(EKK2811B503CBSMsg.EKK2811B503CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK2811B503CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap childMap = new HashMap();
				CAANMsg childTemplate = templateArray[i];

				// 機器提供サービス契約ステータス
				if (childTemplate.isNull(EKK2811B503CBSMsg1List.KKTK_SVC_KEI_STAT))
				{
					childMap.put("kktk_svc_kei_stat", JFUStrConst.EMPTY);
				}
				else
				{
					childMap.put("kktk_svc_kei_stat", childTemplate.getString(EKK2811B503CBSMsg1List.KKTK_SVC_KEI_STAT));
				}

				// 機器提供サービスコード
				if (childTemplate.isNull(EKK2811B503CBSMsg1List.KKTK_SVC_CD))
				{
					childMap.put("kktk_svc_cd", JFUStrConst.EMPTY);
				}
				else
				{
					childMap.put("kktk_svc_cd", childTemplate.getString(EKK2811B503CBSMsg1List.KKTK_SVC_CD));
				}

				// 機器提供サービス契約番号
				if (childTemplate.isNull(EKK2811B503CBSMsg1List.KKTK_SVC_KEI_NO))
				{
					childMap.put("kktk_svc_kei_no", JFUStrConst.EMPTY);
				}
				else
				{
					childMap.put("kktk_svc_kei_no", childTemplate.getString(EKK2811B503CBSMsg1List.KKTK_SVC_KEI_NO));
				}

				dataList.add(childMap);

			}
		}
		dataMap.put("EKK2811B503CBSMsg1List", dataList);

		// エラー情報の設定
		editErrInfoEKK2811B503(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @return boolean
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean checkTakinoRouter(IRequestParameterReadWrite param) throws Exception
	{
		boolean checkFlg = false;

		HashMap dataMap = (HashMap)param.getData("EKK2811B50302");
		if (dataMap == null)
		{
			return checkFlg;
		}

		ArrayList dataList = (ArrayList)dataMap.get("EKK2811B503CBSMsg1List");

		for (int i = 0; i < dataList.size(); i++)
		{
			HashMap childMap = (HashMap)dataList.get(i);

			// 機器提供サービスコード
			String kktkSvcSd = (String)childMap.get("kktk_svc_cd");
			// 多機能ルータまたはホームゲートウェイ
			if (JFUStrConst.KK0771_KKTK_SVC_CD_C024.equals(kktkSvcSd) || JFUStrConst.KK0771_KKTK_SVC_CD_C025.equals(kktkSvcSd))
			{
				checkFlg = true;
				break;
			}
		}
		return checkFlg;

	}

	/**
	 * 機器オプションサービス契約一覧照会(フロント)のエラー情報マッピング処理 <br>
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK2811B503(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK2811B503CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// ＫＥＹ＿SYSIDのエラー情報返却
		if (!template.isNull(EKK2811B503CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey("key_sysid_err"))
			{
				inMap.put("key_sysid_err", template.getString(EKK2811B503CBSMsg.KEY_SYSID_ERR));
			}
		}

		// ＫＥＹ＿サービス契約回線内訳番号のエラー情報返却
		if (!template.isNull(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("key_svc_kei_kaisen_ucwk_no_err", template.getString(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}

		// ＫＥＹ＿宅内機器種別コードのエラー情報返却
		if (!template.isNull(EKK2811B503CBSMsg.KEY_TAKNKIKI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("key_taknkiki_sbt_cd_err"))
			{
				inMap.put("key_taknkiki_sbt_cd_err", template.getString(EKK2811B503CBSMsg.KEY_TAKNKIKI_SBT_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * 機器提供サービス契約一覧照会の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341B002(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B002CBSMsg.class.getName());

		HashMap inMap = null;

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

		// 機能コード（デフォルト：１）
		template.set(EKK0341B002CBSMsg.FUNC_CODE, FUNC_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);
		/* ユーザデータ情報 */
		
		inMap = (HashMap)param.getData(fixedText);

		// サービス契約番号
		if (inMap == null || inMap.get("key_svc_kei_no") == null || "".equals(inMap.get("key_svc_kei_no")))
		{
			template.setNull(EKK0341B002CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341B002CBSMsg.KEY_SVC_KEI_NO, (String)inMap.get("key_svc_kei_no"));
		}

		return template;
	}


	/**
	 * 機器提供サービス契約一覧照会の下りマッピング処理 <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341B002(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		templateArray = template.getCAANMsgList(EKK0341B002CBSMsg.EKK0341B002CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0341B002CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap childMap = new HashMap();
				CAANMsg childTemplate = templateArray[i];

				//機器提供サービスコードがC004のデータだけを取る
				String kktkSvcCd = childTemplate.getString(EKK0341B002CBSMsg1List.KKTK_SVC_CD);
				//機器提供サービス契約ステータスが910、920以外のデータだけ取る
				String kktkSvcKeiStat = childTemplate.getString(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_STAT);
				if(JFUStrConst.KK0771_KKTK_SVC_CD_C004.equals(kktkSvcCd) && (!JFUStrConst.CD00056_910.equals(kktkSvcKeiStat) && !JFUStrConst.CD00056_920.equals(kktkSvcKeiStat)))
				{
					// 機器提供サービス契約番号
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_NO))
					{
						childMap.put("kktk_svc_kei_no", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("kktk_svc_kei_no", childTemplate.getString(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_NO));
					}

					// 機器提供サービスコード
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.KKTK_SVC_CD))
					{
						childMap.put("kktk_svc_cd", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("kktk_svc_cd", childTemplate.getString(EKK0341B002CBSMsg1List.KKTK_SVC_CD));
					}

					// 機器提供サービス契約ステータス
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_STAT))
					{
						childMap.put("kktk_svc_kei_stat", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("kktk_svc_kei_stat", childTemplate.getString(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_STAT));
					}

					// 料金コースコード
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.PCRS_CD))
					{
						childMap.put("pcrs_cd", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("pcrs_cd", childTemplate.getString(EKK0341B002CBSMsg1List.PCRS_CD));
					}

					// 料金プランコード
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.PPLAN_CD))
					{
						childMap.put("pplan_cd", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("pplan_cd", childTemplate.getString(EKK0341B002CBSMsg1List.PPLAN_CD));
					}

					// 最終更新年月日時分秒
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.LAST_UPD_DTM))
					{
						childMap.put("last_upd_dtm", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("last_upd_dtm", childTemplate.getString(EKK0341B002CBSMsg1List.LAST_UPD_DTM));
					}

					// 申込明細番号
					if (childTemplate.isNull(EKK0341B002CBSMsg1List.MSKM_DTL_NO))
					{
						childMap.put("mskm_dtl_no", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("mskm_dtl_no", childTemplate.getString(EKK0341B002CBSMsg1List.MSKM_DTL_NO));
					}

					dataList.add(childMap);

				}

			}
		}
		dataMap.put("EKK0341B002CBSMsg1List", dataList);

		// エラー情報の設定
		editErrInfoEKK0341B002(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @return boolean
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean checkRouterCancel(IRequestParameterReadWrite param) throws Exception
	{
		boolean checkFlg = false;

		HashMap dataMap = (HashMap)param.getData("EKK0341B00202");
		String nowSvcTel = (String)((HashMap)param.getData("EKK0341B00202")).get("nowSvcTel");
		if(JFUStrConst.NOW_SVC_TEL_MI_KEI.equals(nowSvcTel) || dataMap == null)
		{
			return checkFlg;
		}

		ArrayList dataList = (ArrayList)dataMap.get("EKK0341B002CBSMsg1List");

		if (null == dataList)
		{
			return checkFlg;
		}
			
		for (int i = 0; i < dataList.size(); i++)
		{
			HashMap childMap = (HashMap)dataList.get(i);

			// 機器提供サービス契約ステータス
			String kktkSvcKeiStat = (String)childMap.get("kktk_svc_kei_stat");

			// 機器提供サービスコード
			String kktkSvcSd = (String)childMap.get("kktk_svc_cd");

			//機器提供サービスコードが光電話用VAを持っていて、そのステータスが受付済みの場合。
			if (JFUStrConst.KK0771_KKTK_SVC_CD_C004.equals(kktkSvcSd) && JFUStrConst.CD00056_010.equals(kktkSvcKeiStat))
			{
				checkFlg = true;
				break;
			}
		}
		return checkFlg;

	}

	/**
	 * 機器提供サービス契約一覧照会のエラー情報マッピング処理 <br>
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0341B002(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0341B002CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// サービス契約番号のエラー情報返却
		if (!template.isNull(EKK0341B002CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0341B002CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 機器提供サービス契約キャンセルの上りマッピング処理
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341C330(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C330CBSMsg.class.getName());

		HashMap inMap = null;

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

		// 機能コード（デフォルト：１）
		template.set(EKK0341C330CBSMsg.FUNC_CODE, FUNC_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);

		// ユーザデータ情報
		inMap = (HashMap)param.getData(fixedText);

		HashMap kikiMap = (HashMap)param.getData("EKK0341B00202");
		ArrayList kikiCanList = (ArrayList)kikiMap.get("EKK0341B002CBSMsg1List");
		HashMap kikiCanMap = (HashMap)kikiCanList.get(0);
		// 機器提供サービス契約キャンセル.機器提供サービス契約番号（機器提供サービス契約） → 機器提供サービス契約番号
		String kktk_svc_kei_no = (String)kikiCanMap.get(EKK0341B002CBSMsg1List.KKTK_SVC_KEI_NO);
		if (kktk_svc_kei_no == null)
		{
			template.setNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO, kktk_svc_kei_no);
		}

		// 機器提供サービス契約キャンセル.申込明細番号（機器提供サービス契約） → 申込明細番号
		String mskm_dtl_no = (String)kikiCanMap.get(EKK0341B002CBSMsg1List.MSKM_DTL_NO);
		if (mskm_dtl_no == null)
		{
			template.setNull(EKK0341C330CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.MSKM_DTL_NO, mskm_dtl_no);
		}

		// 機器提供サービス契約キャンセル.サービスキャンセル理由コード（機器提供サービス契約） → サービスキャンセル理由コード
		if (inMap == null || inMap.get("svc_cancel_rsn_cd") == null || "".equals(inMap.get("svc_cancel_rsn_cd")))
		{
			template.setNull(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD, (String)inMap.get("svc_cancel_rsn_cd"));
		}

		// 機器提供サービス契約キャンセル.異動区分（機器提供サービス契約） → 異動区分
		if (inMap == null || inMap.get("ido_div") == null || "".equals(inMap.get("ido_div")))
		{
			template.setNull(EKK0341C330CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.IDO_DIV, (String)inMap.get("ido_div"));
		}

		// 機器提供サービス契約キャンセル.更新年月日時分秒（更新前）（機器提供サービス契約） → 更新年月日時分秒(更新前)
		String upd_dtm = (String)kikiCanMap.get(EKK0341B002CBSMsg1List.LAST_UPD_DTM);
		if (upd_dtm == null)
		{
			template.setNull(EKK0341C330CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.UPD_DTM_BF, upd_dtm);
		}

		return template;
	}

	/**
	 * 機器提供サービス契約キャンセルの下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341C330(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText)
			throws Exception
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		HashMap childMap = new HashMap();

		dataList = (ArrayList)dataMap.get("EKK0341C330CBSMsg");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		// 機器提供サービス契約キャンセルマップ.機器提供サービス契約ステータス ← 機器提供サービス契約ステータス
		if (template.isNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_STAT))
		{
			childMap.put("kktk_svc_kei_stat", "");
		}
		else
		{
			childMap.put("kktk_svc_kei_stat", template.getString(EKK0341C330CBSMsg.KKTK_SVC_KEI_STAT));
		}

		// 機器提供サービス契約キャンセルマップ.更新年月日時分秒（機器提供サービス契約） ← 更新年月日時分秒
		if (template.isNull(EKK0341C330CBSMsg.UPD_DTM))
		{
			childMap.put("upd_dtm", "");
		}
		else
		{
			childMap.put("upd_dtm", template.getString(EKK0341C330CBSMsg.UPD_DTM));
		}


		dataList.add(childMap);
		dataMap.put("EKK0341C330CBSMsg", dataList);

		// エラー情報の設定
		editErrInfoEKK0341C330(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @return boolean
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean checkAddKkopTel(IRequestParameterReadWrite param) throws Exception
	{
		boolean checkFlg = false;

		HashMap dataMap = (HashMap)param.getData("EKK0341B00202");
		String mskmKbn = (String)((HashMap)param.getData("EKK2811B50302")).get("mskmKbn");
		String nowSvcTel = (String)((HashMap)param.getData("EKK0341B00202")).get("nowSvcTel");
		if (JFUStrConst.MSKM_KBN_NEW.equals(mskmKbn) || JFUStrConst.NOW_SVC_TEL_MI_KEI.equals(nowSvcTel) || dataMap == null)
		{
			return checkFlg;
		}
		
		ArrayList dataList = (ArrayList)dataMap.get("EKK0341B002CBSMsg1List");

		if (dataList != null && dataList.size() > 0)
		{
			checkFlg = true;
		}

		return checkFlg;

	}


	/**
	 * 機器提供サービス契約キャンセルのエラー情報マッピング処理を行います。
	 * <br>
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0341C330(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		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);
		}

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 機器提供サービス契約キャンセルマップ.機器提供サービス契約番号（機器提供サービス契約） → 機器提供サービス契約番号 のエラー情報返却
		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;
	}

	/**
	 * サービス契約一意照会の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0091A010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0091A010CBSMsg.class.getName());

		HashMap inMap = null;

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

		// 機能コード（デフォルト：２）
		template.set(EKK0341B002CBSMsg.FUNC_CODE, FUNC_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);
		/* ユーザデータ情報 */
		
		inMap = (HashMap)param.getData(fixedText);

		// サービス契約番号
		if (inMap == null || inMap.get("key_svc_kei_no") == null || "".equals(inMap.get("key_svc_kei_no")))
		{
			
			HashMap workMap = (HashMap)param.getMappingWorkArea();
			HashMap addSvcKeiNetCcWorkMap = (HashMap)workMap.get("JFUAddSvcKeiNetCCWork");
			if (addSvcKeiNetCcWorkMap != null || addSvcKeiNetCcWorkMap.get("svc_kei_no") != null || !"".equals(addSvcKeiNetCcWorkMap.get("svc_kei_no")))
			{
				template.set(EKK0091A010CBSMsg.KEY_SVC_KEI_NO, (String)addSvcKeiNetCcWorkMap.get("svc_kei_no"));
			}
			else
			{
				template.setNull(EKK0091A010CBSMsg.KEY_SVC_KEI_NO);
			}
		}
		else
		{
			template.set(EKK0091A010CBSMsg.KEY_SVC_KEI_NO, (String)inMap.get("key_svc_kei_no"));
		}

		return template;
	}


	/**
	 * サービス契約一意照会の下りマッピング処理 <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0091A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		templateArray = template.getCAANMsgList(EKK0091A010CBSMsg.EKK0091A010CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0091A010CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap childMap = new HashMap();
				CAANMsg childTemplate = templateArray[i];
				// 最終更新年月日時分秒
				if (childTemplate.isNull(EKK0091A010CBSMsg1List.LAST_UPD_DTM))
				{
					childMap.put("last_upd_dtm", JFUStrConst.EMPTY);
				}
				else
				{
					childMap.put("last_upd_dtm", childTemplate.getString(EKK0091A010CBSMsg1List.LAST_UPD_DTM));
				}

				dataList.add(childMap);
			}
		}
		dataMap.put("EKK0091A010CBSMsg1List", dataList);

		// エラー情報の設定
		editErrInfoEKK0091A010(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0091A010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0091A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// サービス契約番号のエラー情報返却
		if (!template.isNull(EKK0091A010CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0091A010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 機器提供サービス契約登録(多機能ルーター用)の上りマッピング処理
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341D01002(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341D010CBSMsg.class.getName());

		HashMap inMap = null;
		HashMap inLstMap = null;
		HashMap useplaceAddressMap = null;
//ANK-4498-00-00 ADD START
		HashMap kikiSohusAddressMap = null;
//ANK-4498-00-00 ADD END

		// テンプレートID（機器提供サービス契約登録）
		template.set(EKK0341D010CBSMsg.TEMPLATEID, "EKK0341D010Tkn");

		// 機能コード（デフォルト：１（チェック＆登録）
		template.set(EKK0341D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK0341D010TknList")).get(0);

		// 分割後利用場所住所情報  本登録
		useplaceAddressMap = (HashMap)param.getData("FUSV016006CC");

		// 分割後利用場所住所情報  仮登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV015211CC");
		}
		// 2012/09/25 add by Otsuka
		// 分割後利用場所住所情報  一括登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV016102CC");
		}

//ANK-4498-00-00 ADD START
		//機器送付先用住所Map
		//マンションの場合
		if("1".equals(inMap.get("MSKM_MNS_TYPE")))
		{
			//分割後契約者住所情報 仮登録 一括登録
			kikiSohusAddressMap=(HashMap)param.getData("FUSV015212CC");
	
			if (kikiSohusAddressMap == null)
			{
				//分割後契約者住所情報 本登録
				kikiSohusAddressMap =(HashMap)param.getData("FUSV016007CC");
			}
		}
		//ホーム・メゾンの場合
		else
		{
			// 分割後利用場所住所情報  本登録
			kikiSohusAddressMap = (HashMap)param.getData("FUSV016006CC");

			// 分割後利用場所住所情報  仮登録
			if (null == kikiSohusAddressMap)
			{
				kikiSohusAddressMap = (HashMap)param.getData("FUSV015211CC");
			}
			// 2012/09/25 add by Otsuka
			// 分割後利用場所住所情報  一括登録
			if (null == kikiSohusAddressMap)
			{
				kikiSohusAddressMap = (HashMap)param.getData("FUSV016102CC");
			}
		}
		// 2012/09/25 add by Otsuka
//ANK-4498-00-00 ADD END	
		// 機器提供サービス契約番号 → 機器提供サービス契約番号
		if ("".equals(inLstMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO, (String)inLstMap.get("kktk_svc_kei_no"));
		}
		// 世代登録年月日時分秒 → 世代登録年月日時分秒
		if ("".equals(inLstMap.get("gene_add_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.GENE_ADD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.GENE_ADD_DTM, (String)inLstMap.get("gene_add_dtm"));
		}
		// 機器提供サービス契約ステータス → 機器提供サービス契約ステータス
		if ("".equals(inLstMap.get("kktk_svc_kei_stat")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT, (String)inLstMap.get("kktk_svc_kei_stat"));
		}
		// 機器提供サービスコード → 機器提供サービスコード
		if ("".equals(inLstMap.get("kktk_svc_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_CD, (String)inLstMap.get("kktk_svc_cd"));
		}
		// 料金コースコード → 料金コースコード
		if ("".equals(inLstMap.get("pcrs_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PCRS_CD, (String)inLstMap.get("pcrs_cd"));
		}
		// 料金プランコード → 料金プランコード
		if ("".equals(inLstMap.get("pplan_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PPLAN_CD, (String)inLstMap.get("pplan_cd"));
		}
		// 機器提供種別コード → 機器提供種別コード
		if ("".equals(inLstMap.get("kktk_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SBT_CD, (String)inLstMap.get("kktk_sbt_cd"));
		}
		// HDD容量コード → HDD容量コード
		if ("".equals(inLstMap.get("hdd_capa_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HDD_CAPA_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HDD_CAPA_CD, (String)inLstMap.get("hdd_capa_cd"));
		}
		// サービス利用開始希望年月日 → サービス利用開始希望年月日
		template.setNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD);

		// 予約適用開始希望年月日 → 予約適用開始希望年月日
		if ("".equals(inLstMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inLstMap.get("rsv_tsta_kibo_ymd"));
		}
		// 希望メーカーコード → 希望メーカーコード
		if ("".equals(inLstMap.get("kibo_maker_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIBO_MAKER_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIBO_MAKER_CD, (String)inLstMap.get("kibo_maker_cd"));
		}
		// 販売種別コード → 販売種別コード
		if ("".equals(inLstMap.get("HAMBAI_SBT_CD")))
		{
			template.setNull(EKK0341D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAMBAI_SBT_CD, (String)inLstMap.get("hambai_sbt_cd"));
		}
		// 通信機器セットコード → 通信機器セットコード
		if ("".equals(inLstMap.get("tsushin_kiki_set_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD, (String)inLstMap.get("tsushin_kiki_set_cd"));
		}
		// 宅内機器種別コード → 宅内機器種別コード
		if ("".equals(inLstMap.get("taknkiki_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD, (String)inLstMap.get("taknkiki_sbt_cd"));
		}
		// 宅内機器型式コード → 宅内機器型式コード
		if ("".equals(inLstMap.get("taknkiki_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD, (String)inLstMap.get("taknkiki_model_cd"));
		}
		// 宅内機器セット品型コード → 宅内機器セット品型コード
		if ("".equals(inLstMap.get("taknkiki_sethin_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD, (String)inLstMap.get("taknkiki_sethin_model_cd"));
		}
		// 付属品種別コード → 付属品種別コード
		if ("".equals(inLstMap.get("huzokuhin_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD, (String)inLstMap.get("huzokuhin_sbt_cd"));
		}
		// 機器設置先場所番号 → 機器設置先場所番号
		if ("".equals(inLstMap.get("kiki_stc_saki_place_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO, (String)inLstMap.get("kiki_stc_saki_place_no"));
		}
		// 親契約識別コード → 親契約識別コード
		if ("".equals(inLstMap.get("oya_kei_skbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD, (String)inLstMap.get("oya_kei_skbt_cd"));
		}
		// サービス契約番号 → サービス契約番号
		if ("".equals(inLstMap.get("svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_NO, (String)inLstMap.get("svc_kei_no"));
		}
		// サービス契約内訳番号 → サービス契約内訳番号
		if ("".equals(inLstMap.get("svc_kei_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO, (String)inLstMap.get("svc_kei_ucwk_no"));
		}
		// サービス契約回線内訳番号 → サービス契約回線内訳番号
		// 機器提供サービス.サービス契約回線内訳番号 → サービス契約回線内訳番号
		String svc_kei_kaisen_ucwk_no = JFUStrConst.EMPTY;
		if ("".equals(inLstMap.get("svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
			if (inLstMap.get("oya_kei_skbt_cd").equals(OYA_KEI_SKBT_CD_02))
			{
				svc_kei_kaisen_ucwk_no = getWorkMapValue(param, "svc_kei_kaisen_ucwk_no", CC_WORK_AREA_NAME_USE);
				if (svc_kei_kaisen_ucwk_no == null)
				{
					template.setNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
				}
				else
				{
					template.set(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, svc_kei_kaisen_ucwk_no);
				}
			}
		}
		else
		{
			svc_kei_kaisen_ucwk_no = (String)inLstMap.get("svc_kei_kaisen_ucwk_no");
			if (svc_kei_kaisen_ucwk_no.length() == SVC_KEI_KAISEN_UW_NO_CNT)
			{
				template.set(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)inLstMap.get("svc_kei_kaisen_ucwk_no"));
			}
			else
			{
				template.setNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
			}
		}
		
		// オプションサービス契約番号 → オプションサービス契約番号
		if ("".equals(inLstMap.get("op_svc_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.OP_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.OP_SVC_KEI_NO, (String)inLstMap.get("op_svc_kei_no"));
		}
		// ＳＹＳＩＤ → ＳＹＳＩＤ
		if ("".equals(inLstMap.get("sysid")))
		{
			template.setNull(EKK0341D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SYSID, (String)inLstMap.get("sysid"));
		}
		// 申込明細番号 → 申込明細番号
		if ("".equals(inLstMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MSKM_DTL_NO, (String)inLstMap.get("mskm_dtl_no"));
		}
		// リンクSTBフラグ → リンクSTBフラグ
		if ("".equals(inLstMap.get("link_stb_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.LINK_STB_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.LINK_STB_FLG, (String)inLstMap.get("link_stb_flg"));
		}

		// 機器提供サービス.機器引当指定倉庫コード → 機器引当指定倉庫コード
		if ("".equals(inLstMap.get("kiki_hkat_shitei_soko_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD, (String)inLstMap.get("kiki_hkat_shitei_soko_cd"));
		}

		// 機器提供サービス.機器引当指定倉庫棚コード → 機器引当指定倉庫棚コード
		if ("".equals(inLstMap.get("kiki_hkat_shitei_skdn_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD, (String)inLstMap.get("kiki_hkat_shitei_skdn_cd"));
		}

		// 機器送料有無 → 機器送料有無
		if ("".equals(inLstMap.get("kiki_soryo_um")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_UM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_UM, (String)inLstMap.get("kiki_soryo_um"));
		}
		// 機器送料作成年月日 → 機器送料作成年月日
		if ("".equals(inLstMap.get("kiki_soryo_saksei_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD, (String)inLstMap.get("kiki_soryo_saksei_ymd"));
		}
		// 機器送付先名 → 機器送付先名
		if ("".equals(inLstMap.get("kiki_sohus_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_NM, (String)inLstMap.get("kiki_sohus_nm"));
		}
		// 機器送付先カナ名 → 機器送付先カナ名
		if ("".equals(inLstMap.get("kiki_sohus_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KANA, (String)inLstMap.get("kiki_sohus_kana"));
		}
//ANK4498-00-00 MOD START
		// 機器送付先住所コード → 機器送付先住所コード
		if ("".equals(kikiSohusAddressMap.get("ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD, (String)kikiSohusAddressMap.get("ad_cd"));
		}
		// 機器送付先郵便番号 → 機器送付先郵便番号
		if ("".equals(inLstMap.get("kiki_sohus_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_PCD, (String)inLstMap.get("kiki_sohus_pcd"));
		}
		// 機器送付先都道府県名 → 機器送付先都道府県名
		if ("".equals(kikiSohusAddressMap.get("state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM, (String)kikiSohusAddressMap.get("state_nm"));
		}
		// 機器送付先市区町村名 → 機器送付先市区町村名
		if ("".equals(kikiSohusAddressMap.get("city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM, (String)kikiSohusAddressMap.get("city_nm"));
		}
		// 機器送付先大字通称名 → 機器送付先大字通称名
		if ("".equals(kikiSohusAddressMap.get("oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM, (String)kikiSohusAddressMap.get("oaztsu_nm"));
		}
		// 機器送付先字丁目名 → 機器送付先字丁目名
		if ("".equals(kikiSohusAddressMap.get("azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM, (String)kikiSohusAddressMap.get("azcho_nm"));
		}
		// 機器送付先番地号 → 機器送付先番地号
		if ("".equals(kikiSohusAddressMap.get("after_bnchi")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO, (String)kikiSohusAddressMap.get("after_bnchi"));
		}

		// 機器送付先住所補記・建物名 → 機器送付先住所補記・建物名
		if ("".equals(inLstMap.get("kiki_sohus_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM, (String)inLstMap.get("kiki_sohus_adrttm"));
		}
		// 機器送付先住所補記・部屋番号 → 機器送付先住所補記・部屋番号
		if ("".equals(inLstMap.get("kiki_sohus_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM, (String)inLstMap.get("kiki_sohus_adrrm"));
		}
		// 機器送付先電話番号 → 機器送付先電話番号
		if ("".equals(inLstMap.get("kiki_sohus_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO, (String)inLstMap.get("kiki_sohus_telno"));
		}
		// マンション物件番号 → マンション物件番号
		if ("".equals(inLstMap.get("mansion_bukken_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MANSION_BUKKEN_NO, (String)inLstMap.get("mansion_bukken_no"));
		}
		// 機器送付先＿契約者住所差異フラグ → 機器送付先＿契約者住所差異フラグ
		if ("".equals(inLstMap.get("kiki_sohus_ksh_ad_sai_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG, (String)inLstMap.get("kiki_sohus_ksh_ad_sai_flg"));
		}
		// 機器送付先個別指定フラグ → 機器送付先個別指定フラグ
		if ("".equals(inLstMap.get("kiki_shs_kbt_shitei_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG, (String)inLstMap.get("kiki_shs_kbt_shitei_flg"));
		}
		// 機器送付先補足コード１ → 機器送付先補足コード１
		if ("".equals(inLstMap.get("kiki_shs_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1, (String)inLstMap.get("kiki_shs_hsk_cd_1"));
		}
		// 機器送付先補足コード２ → 機器送付先補足コード２
		if ("".equals(inLstMap.get("kiki_shs_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2, (String)inLstMap.get("kiki_shs_hsk_cd_2"));
		}
		// 機器送付先補足メモ → 機器送付先補足メモ
		if ("".equals(inLstMap.get("kiki_shs_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO, (String)inLstMap.get("kiki_shs_hsk_memo"));
		}
		// 機器設置先名 → 機器設置先名
		if ("".equals(inLstMap.get("kiki_stc_saki_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM, (String)inLstMap.get("kiki_stc_saki_nm"));
		}
		// 機器設置先カナ名 → 機器設置先カナ名
		if ("".equals(inLstMap.get("kiki_stc_saki_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA, (String)inLstMap.get("kiki_stc_saki_kana"));
		}
		// 機器設置先住所コード → 機器設置先住所コード
		if ("".equals(useplaceAddressMap.get("ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD, (String)useplaceAddressMap.get("ad_cd"));
		}
		// 機器設置先郵便番号 → 機器設置先郵便番号
		if ("".equals(inLstMap.get("kiki_stc_saki_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD, (String)inLstMap.get("kiki_stc_saki_pcd"));
		}
		// 機器設置先都道府県名 → 機器設置先都道府県名
		if ("".equals(useplaceAddressMap.get("kiki_stc_saki_state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM, (String)useplaceAddressMap.get("state_nm"));
		}
		// 機器設置先市区町村名 → 機器設置先市区町村名
		if ("".equals(useplaceAddressMap.get("city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM, (String)useplaceAddressMap.get("city_nm"));
		}
		// 機器設置先大字通称名 → 機器設置先大字通称名
		if ("".equals(useplaceAddressMap.get("oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM, (String)useplaceAddressMap.get("oaztsu_nm"));
		}
		// 機器設置先字丁目名 → 機器設置先字丁目名
		if ("".equals(useplaceAddressMap.get("azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM, (String)useplaceAddressMap.get("azcho_nm"));
		}
		// 機器設置先番地号 → 機器設置先番地号
		if ("".equals(useplaceAddressMap.get("after_bnchi")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO, (String)useplaceAddressMap.get("after_bnchi"));
		}

		// 機器設置先住所補記・建物名 → 機器設置先住所補記・建物名
		if ("".equals(inLstMap.get("kiki_stc_saki_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM, (String)inLstMap.get("kiki_stc_saki_adrttm"));
		}
		// 機器設置先住所補記・部屋番号 → 機器設置先住所補記・部屋番号
		if ("".equals(inLstMap.get("kiki_stc_saki_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM, (String)inLstMap.get("kiki_stc_saki_adrrm"));
		}
		// 機器設置先＿契約者住所差異フラグ → 機器設置先＿契約者住所差異フラグ
		if ("".equals(inLstMap.get("kiki_stc_sk_ksh_ad_sai_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG, (String)inLstMap.get("kiki_stc_sk_ksh_ad_sai_flg"));
		}
		// 機器設置先電話番号 → 機器設置先電話番号
		if ("".equals(inLstMap.get("kiki_stc_sk_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO, (String)inLstMap.get("kiki_stc_sk_telno"));
		}
		// 機器設置先区画整理中フラグ → 機器設置先区画整理中フラグ
		if ("".equals(inLstMap.get("kiki_sts_kkk_seiri_chu_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG, (String)inLstMap.get("kiki_sts_kkk_seiri_chu_flg"));
		}
		// 機器提供サービス.住所未確定フラグ → 住所未確定フラグ
		if ("".equals(inLstMap.get("ad_mi_fix_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.AD_MI_FIX_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.AD_MI_FIX_FLG, (String)inLstMap.get("ad_mi_fix_flg"));
		}

		// 機器設置先補足コード１ → 機器設置先補足コード１
		if ("".equals(inLstMap.get("kiki_sts_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1, (String)inLstMap.get("kiki_sts_hsk_cd_1"));
		}
		// 機器設置先補足コード２ → 機器設置先補足コード２
		if ("".equals(inLstMap.get("kiki_sts_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2, (String)inLstMap.get("kiki_sts_hsk_cd_2"));
		}
		// 機器設置先補足メモ → 機器設置先補足メモ
		if ("".equals(inLstMap.get("kiki_sts_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO, (String)inLstMap.get("kiki_sts_hsk_memo"));
		}
		// 配送区分 → 配送区分
		if ("".equals(inLstMap.get("haiso_div")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_DIV);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_DIV, (String)inLstMap.get("haiso_div"));
		}
		// 試用加入年月日 → 試用加入年月日
		if ("".equals(inLstMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD, (String)inLstMap.get("ftrial_kanyu_ymd"));
		}
		// 試用期間終了年月日 → 試用期間終了年月日
		if ("".equals(inLstMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inLstMap.get("ftrial_prd_endymd"));
		}
		// 本加入年月日 → 本加入年月日
		if ("".equals(inLstMap.get("honkanyu_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HONKANYU_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HONKANYU_YMD, (String)inLstMap.get("honkanyu_ymd"));
		}
		// 本加入移行期限年月日 → 本加入移行期限年月日
		if ("".equals(inLstMap.get("honkanyu_iko_kigen_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)inLstMap.get("honkanyu_iko_kigen_ymd"));
		}
		// 保証コード → 保証コード
		if ("".equals(inLstMap.get("hosho_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_CD, (String)inLstMap.get("hosho_cd"));
		}
		// 保証開始年月日 → 保証開始年月日
		if ("".equals(inLstMap.get("hosho_staymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_STAYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_STAYMD, (String)inLstMap.get("hosho_staymd"));
		}
		// 保証終了年月日 → 保証終了年月日
		if ("".equals(inLstMap.get("hosho_end_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_END_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_END_YMD, (String)inLstMap.get("hosho_end_ymd"));
		}
		// 予約適用年月日 → 予約適用年月日
		if ("".equals(inLstMap.get("rsv_aply_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_APLY_YMD, (String)inLstMap.get("rsv_aply_ymd"));
		}
		// 予約適用コード → 予約適用コード
		if ("".equals(inLstMap.get("rsv_aply_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_APLY_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_APLY_CD, (String)inLstMap.get("rsv_aply_cd"));
		}
		// 違約金発生コード → 違約金発生コード
		if ("".equals(inLstMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PNLTY_HASSEI_CD, (String)inLstMap.get("pnlty_hassei_cd"));
		}

		//  異動区分→ 異動区分
		if ("".equals(inLstMap.get("ido_div")))
		{
			template.setNull(EKK0341D010CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.IDO_DIV, (String)inLstMap.get("ido_div"));
		}

		// 機器提供サービス.宅内機器異動コード → 宅内機器異動コード
		if ("".equals(inLstMap.get("taknkiki_ido_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD, (String)inLstMap.get("taknkiki_ido_cd"));
		}

		//  CASカード使用許諾年月日→ CASカード使用許諾年月日
		if ("".equals(inLstMap.get("cas_card_use_kyodak_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD, (String)inLstMap.get("cas_card_use_kyodak_ymd"));
		}

		// 機器提供サービス.機器付加情報コード → 機器付加情報コード
		if ("".equals(inLstMap.get("kiki_huka_info_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD, (String)inLstMap.get("kiki_huka_info_cd"));
		}

		// 機器提供サービス.配送方法コード	
		if ("".equals(inLstMap.get("haiso_way_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_WAY_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_WAY_CD, (String)inLstMap.get("haiso_way_cd"));
		}

		//  課金先番号→ 課金先番号
		if ("".equals(inLstMap.get("kakins_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_NO, (String)inLstMap.get("kakins_no"));
		}
		// 請求契約番号 → 請求契約番号
		if ("".equals(inLstMap.get("seiky_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SEIKY_KEI_NO, (String)inLstMap.get("seiky_kei_no"));
		}
		//  料金項目コード→ 料金項目コード
		if ("".equals(inLstMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PRC_KMK_CD, (String)inLstMap.get("prc_kmk_cd"));
		}
		//  課金先適用開始年月日→ 課金先適用開始年月日
		if ("".equals(inLstMap.get("kakins_tstaymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_TSTAYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_TSTAYMD, (String)inLstMap.get("kakins_tstaymd"));
		}
		//  課金先適用終了年月日→ 課金先適用終了年月日
		if ("".equals(inLstMap.get("kakins_tendymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KAKINS_TENDYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KAKINS_TENDYMD, (String)inLstMap.get("kakins_tendymd"));
		}
		//  登録年月日時分秒→ 登録年月日時分秒
		if ("".equals(inLstMap.get("add_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.ADD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.ADD_DTM, (String)inLstMap.get("add_dtm"));
		}
		//  登録オペレータアカウント→ 登録オペレータアカウント
		if ("".equals(inLstMap.get("add_opeacnt")))
		{
			template.setNull(EKK0341D010CBSMsg.ADD_OPEACNT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.ADD_OPEACNT, (String)inLstMap.get("add_opeacnt"));
		}
		//  更新年月日時分秒→ 更新年月日時分秒
		if ("".equals(inLstMap.get("upd_dtm")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_DTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM, (String)inLstMap.get("upd_dtm"));
		}
		//  更新オペレータアカウント→ 更新オペレータアカウント
		if ("".equals(inLstMap.get("upd_opeacnt")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_OPEACNT);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_OPEACNT, (String)inLstMap.get("upd_opeacnt"));
		}
		//  無効フラグ→ 無効フラグ
		if ("".equals(inLstMap.get("mk_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.MK_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MK_FLG, (String)inLstMap.get("mk_flg"));
		}

		// 機器提供サービス契約登録マップ.機器製造番号 → 機器製造番号
		if ("".equals(inLstMap.get("kiki_seizo_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SEIZO_NO, (String)inLstMap.get("kiki_seizo_no"));
		}

		// 機器提供サービス契約登録マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String updDtmBf = null;
		HashMap updDtmMap = (HashMap)param.getData("EKK0091A010");
		ArrayList updDtmList = (ArrayList)updDtmMap.get("EKK0091A010CBSMsg1List");

		HashMap kktkCanMap = (HashMap)param.getData("EKK0341C33002");
		ArrayList kktkCanList = (ArrayList)kktkCanMap.get("EKK0341C330CBSMsg");

		// VAアダプターのキャンセルを行った場合
		if(kktkCanList != null)
		{
			HashMap kktkCanselMap = (HashMap)kktkCanList.get(0);
			updDtmBf  = (String)kktkCanselMap.get(EKK0341C330CBSMsg.UPD_DTM);
		}
		else if(updDtmList != null)
		{
			HashMap updDtmBfMap = (HashMap)updDtmList.get(0);
			updDtmBf  = (String)updDtmBfMap.get(EKK0091A010CBSMsg1List.LAST_UPD_DTM);
		}

		if (updDtmBf == null)
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM_BF, updDtmBf);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM_BF, updDtmBf);
		}

		//  機器送付先住所手動入力フラグ→ 機器送付先住所手動入力フラグ
		if ("".equals(inLstMap.get("kiki_shs_ad_man_input_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG, (String)inLstMap.get("kiki_shs_ad_man_input_flg"));
		}

		return template;
	}

	/**
	 * 機器提供サービス契約登録(多機能ルーター用)の下りマッピング処理 <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341D01002(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText)
			throws Exception
	{

		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData("EKK0341D010Tkn");
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData("EKK0341D010", dataMap);
		}

		// ++++++++++++++++++++ v1.00.00 追加開始 ++++++++++++++++++++++++++ */
		ArrayList dataList = (ArrayList)dataMap.get("EKK0341D010TknList");
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0341D010TknList", dataList);
		}

		HashMap childMap = (HashMap)dataList.get(0);
		if (childMap == null)
		{
			childMap = new HashMap();
			dataList.add(0, childMap);
		}
		// +++++++++++++++++++ v1.00.00 追加終了 +++++++++++++++++++++++++++ */

		// 機器提供サービス契約登録マップ.機器提供サービス契約番号 ← 機器提供サービス契約番号
		if (template.isNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO))
		{
			childMap.put("kktk_svc_kei_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kktk_svc_kei_no", template.getString(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO));
		}

		// 機器提供サービス契約登録マップ.登録年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(EKK0341D010CBSMsg.UPD_DTM))
		{
			childMap.put("upd_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			String updDtm = template.getString(EKK0341D010CBSMsg.UPD_DTM);
			childMap.put("upd_dtm", updDtm);
			// ワークマップに登録
			workMap.put("upd_dtm", updDtm);
			// 共有マップに保持（後続のＣＣ・ＳＣで使用）※テレビ分だけ・ネット、電話は後続のEKK2811D010で保持
			JFUBPCommon.setTvSvkeiLastUpdDtm(param, updDtm);
		}

		// エラー情報の設定
		param = editErrInfoEKK0341D01002(param, template, (Integer)returnCode, fixedText); // No708 2013/04/24 Otsuka 

		//エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @param i
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341D01002(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText
			) throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0341D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK0341D010Tkn");
		// No708 2013/04/24 Otsuka start
		inMap = (HashMap)((ArrayList)inMap.get("EKK0341D010TknList")).get(0);

		// 機器提供サービスコード
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kktk_svc_cd_err"))
			{
				inMap.put("kktk_svc_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR));
			}
		}

		// 料金コースコード
		if (!template.isNull(EKK0341D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK0341D010CBSMsg.PCRS_CD_ERR));
			}
		}

		// 料金プランコード
		if (!template.isNull(EKK0341D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK0341D010CBSMsg.PPLAN_CD_ERR));
			}
		}

		// 機器提供種別コード
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR))
		{
			if (!inMap.containsKey("kktk_sbt_cd_err"))
			{
				inMap.put("kktk_sbt_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR));
			}
		}

		// HDD容量コード
		if (!template.isNull(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR))
		{
			if (!inMap.containsKey("hdd_capa_cd_err"))
			{
				inMap.put("hdd_capa_cd_err", template.getString(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR));
			}
		}

		// サービス利用開始希望年月日
		if (!template.isNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}

		// 予約適用開始希望年月日
		if (!template.isNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}

		// 希望メーカーコード
		if (!template.isNull(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR))
		{
			if (!inMap.containsKey("kibo_maker_cd_err"))
			{
				inMap.put("kibo_maker_cd_err", template.getString(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR));
			}
		}

		// 販売種別コード
		if (!template.isNull(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("hambai_sbt_cd_err"))
			{
				inMap.put("hambai_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR));
			}
		}

		// 通信機器セットコード
		if (!template.isNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR))
		{
			if (!inMap.containsKey("tsushin_kiki_set_cd_err"))
			{
				inMap.put("tsushin_kiki_set_cd_err", template.getString(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR));
			}
		}

		// 宅内機器種別コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sbt_cd_err"))
			{
				inMap.put("taknkiki_sbt_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR));
			}
		}

		// 宅内機器型式コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_model_cd_err"))
			{
				inMap.put("taknkiki_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR));
			}
		}

		// 宅内機器セット品型コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sethin_model_cd_err"))
			{
				inMap.put("taknkiki_sethin_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR));
			}
		}

		// 付属品種別コード
		if (!template.isNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("huzokuhin_sbt_cd_err"))
			{
				inMap.put("huzokuhin_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR));
			}
		}

		// 機器設置先場所番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_place_no_err"))
			{
				inMap.put("kiki_stc_saki_place_no_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR));
			}
		}

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

		// サービス契約内訳番号
		if (!template.isNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}

		// サービス契約回線内訳番号
		if (!template.isNull(EKK0341D010CBSMsg.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(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}

		// オプションサービス契約番号
		if (!template.isNull(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("op_svc_kei_no_err"))
			{
				inMap.put("op_svc_kei_no_err", template.getString(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR));
			}
		}

		// SYSID
		if (!template.isNull(EKK0341D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0341D010CBSMsg.SYSID_ERR));
			}
		}

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

		// リンクSTBフラグ
		if (!template.isNull(EKK0341D010CBSMsg.LINK_STB_FLG_ERR))
		{
			if (!inMap.containsKey("link_stb_flg_err"))
			{
				inMap.put("link_stb_flg_err", template.getString(EKK0341D010CBSMsg.LINK_STB_FLG_ERR));
			}
		}

		// 機器送料有無
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_um_err"))
			{
				inMap.put("kiki_soryo_um_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR));
			}
		}

		// 機器送料作成年月日
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_saksei_ymd_err"))
			{
				inMap.put("kiki_soryo_saksei_ymd_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR));
			}
		}

		// 機器送付先名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_nm_err"))
			{
				inMap.put("kiki_sohus_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR));
			}
		}

		// 機器送付先カナ名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_kana_err"))
			{
				inMap.put("kiki_sohus_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR));
			}
		}

		// 機器送付先住所コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ad_cd_err"))
			{
				inMap.put("kiki_sohus_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR));
			}
		}

		// 機器送付先郵便番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_pcd_err"))
			{
				inMap.put("kiki_sohus_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR));
			}
		}

		// 機器送付先都道府県名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_state_nm_err"))
			{
				inMap.put("kiki_sohus_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR));
			}
		}

		// 機器送付先市区町村名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_city_nm_err"))
			{
				inMap.put("kiki_sohus_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR));
			}
		}

		// 機器送付先大字通称名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_oaztsu_nm_err"))
			{
				inMap.put("kiki_sohus_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR));
			}
		}

		// 機器送付先字丁目名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_azcho_nm_err"))
			{
				inMap.put("kiki_sohus_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR));
			}
		}

		// 機器送付先番地号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_bnchigo_err"))
			{
				inMap.put("kiki_sohus_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR));
			}
		}

		// 機器送付先住所補記・建物名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrttm_err"))
			{
				inMap.put("kiki_sohus_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR));
			}
		}

		// 機器送付先住所補記・部屋番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrrm_err"))
			{
				inMap.put("kiki_sohus_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR));
			}
		}

		// 機器送付先電話番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_telno_err"))
			{
				inMap.put("kiki_sohus_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR));
			}
		}

		// マンション物件番号
		if (!template.isNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR))
		{
			if (!inMap.containsKey("mansion_bukken_no_err"))
			{
				inMap.put("mansion_bukken_no_err", template.getString(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR));
			}
		}

		// 機器送付先_契約者住所差異フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_sohus_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR));
			}
		}

		// 機器送付先個別指定フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_shs_kbt_shitei_flg_err"))
			{
				inMap.put("kiki_shs_kbt_shitei_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR));
			}
		}

		// 機器送付先補足コード1
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_1_err"))
			{
				inMap.put("kiki_shs_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR));
			}
		}

		// 機器送付先補足コード2
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_2_err"))
			{
				inMap.put("kiki_shs_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR));
			}
		}

		// 機器送付先補足メモ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_memo_err"))
			{
				inMap.put("kiki_shs_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR));
			}
		}

		// 機器設置先名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_nm_err"))
			{
				inMap.put("kiki_stc_saki_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR));
			}
		}

		// 機器設置先カナ名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_kana_err"))
			{
				inMap.put("kiki_stc_saki_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR));
			}
		}

		// 機器設置先住所コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_ad_cd_err"))
			{
				inMap.put("kiki_stc_saki_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR));
			}
		}

		// 機器設置先郵便番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_pcd_err"))
			{
				inMap.put("kiki_stc_saki_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR));
			}
		}

		// 機器設置先都道府県名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_state_nm_err"))
			{
				inMap.put("kiki_stc_saki_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR));
			}
		}

		// 機器設置先市区町村名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_city_nm_err"))
			{
				inMap.put("kiki_stc_saki_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR));
			}
		}

		// 機器設置先大字通称名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_oaztsu_nm_err"))
			{
				inMap.put("kiki_stc_saki_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR));
			}
		}

		// 機器設置先字丁目名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_azcho_nm_err"))
			{
				inMap.put("kiki_stc_saki_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR));
			}
		}

		// 機器設置先番地号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_bnchigo_err"))
			{
				inMap.put("kiki_stc_saki_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR));
			}
		}

		// 機器設置先住所補記・建物名
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrttm_err"))
			{
				inMap.put("kiki_stc_saki_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR));
			}
		}

		// 機器設置先住所補記・部屋番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrrm_err"))
			{
				inMap.put("kiki_stc_saki_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR));
			}
		}

		// 機器設置先_契約者住所差異フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_stc_sk_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR));
			}
		}

		// 機器設置先電話番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_telno_err"))
			{
				inMap.put("kiki_stc_sk_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR));
			}
		}

		// 機器設置先区画整理中フラグ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sts_kkk_seiri_chu_flg_err"))
			{
				inMap.put("kiki_sts_kkk_seiri_chu_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR));
			}
		}

		// 機器設置先補足コード1
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_1_err"))
			{
				inMap.put("kiki_sts_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR));
			}
		}

		// 機器設置先補足コード2
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_2_err"))
			{
				inMap.put("kiki_sts_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR));
			}
		}

		// 機器設置先補足メモ
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_memo_err"))
			{
				inMap.put("kiki_sts_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR));
			}
		}

		// 配送区分
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_DIV_ERR))
		{
			if (!inMap.containsKey("haiso_div_err"))
			{
				inMap.put("haiso_div_err", template.getString(EKK0341D010CBSMsg.HAISO_DIV_ERR));
			}
		}

		// 試用加入年月日
		if (!template.isNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}

		// 本加入年月日
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}

		// 本加入移行期限年月日
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}

		// 保証コード
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_CD_ERR))
		{
			if (!inMap.containsKey("hosho_cd_err"))
			{
				inMap.put("hosho_cd_err", template.getString(EKK0341D010CBSMsg.HOSHO_CD_ERR));
			}
		}

		// 保証開始年月日
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR))
		{
			if (!inMap.containsKey("hosho_staymd_err"))
			{
				inMap.put("hosho_staymd_err", template.getString(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR));
			}
		}

		// 違約金発生コード
		if (!template.isNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}

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

		// CASカード使用許諾年月日
		if (!template.isNull(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR))
		{
			if (!inMap.containsKey("cas_card_use_kyodak_ymd_err"))
			{
				inMap.put("cas_card_use_kyodak_ymd_err", template.getString(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR));
			}
		}

		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto START -----
		// 機器製造番号
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR))
		{
			if (!inMap.containsKey("kiki_seizo_no_err"))
			{
				inMap.put("kiki_seizo_no_err", template.getString(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR));
			}
		}

		// 機器移転先移動実施者識別コード
		if (!template.isNull(EKK0341D010CBSMsg.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(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR));
			}
		}

		// 配送依頼指定年月日
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR))
		{
			if (!inMap.containsKey("haiso_req_shitei_ymd_err"))
			{
				inMap.put("haiso_req_shitei_ymd_err", template.getString(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR));
			}
		}

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK0341D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto END -----

		return param;
	}

	/**
	 * 機器オプションサービス契約登録(ネット)の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2811D010(IRequestParameterReadWrite param, String fixedText, int index) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811D010CBSMsg.class.getName());

		HashMap inMap = null;
		HashMap inLstMap = null;
//		HashMap useplaceAddressMap = null;

		// テンプレートID（機器オプションサービス契約登録(ネット)）
		template.set(EKK2811D010CBSMsg.TEMPLATEID, "EKK2811D010Net02");

		// 機能コード（デフォルト：１（チェック＆登録）
		template.set(EKK2811D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK2811D010Net02List")).get(index);

//		// 分割後利用場所住所情報  本登録
//		useplaceAddressMap = (HashMap)param.getData("FUSV016006CC");
//
//		// 分割後利用場所住所情報  仮登録
//		if (null == useplaceAddressMap)
//		{
//			useplaceAddressMap = (HashMap)param.getData("FUSV015211CC");
//		}
//		// 2012/09/25 add by Otsuka
//		// 分割後利用場所住所情報  一括登録
//		if (null == useplaceAddressMap)
//		{
//			useplaceAddressMap = (HashMap)param.getData("FUSV016102CC");
//		}

		// 機器オプションサービスコード
		if ("".equals(inLstMap.get("kkop_svc_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.KKOP_SVC_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KKOP_SVC_CD, (String)inLstMap.get("kkop_svc_cd"));
		}
		// 料金コースコード → 料金コースコード
		if ("".equals(inLstMap.get("pcrs_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PCRS_CD, (String)inLstMap.get("pcrs_cd"));
		}
		// 料金プランコード → 料金プランコード
		if ("".equals(inLstMap.get("pplan_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PPLAN_CD, (String)inLstMap.get("pplan_cd"));
		}
		// 機器提供サービス契約番号
		String kktkSvcKeiNo = null;

		HashMap kikiTkMap = (HashMap)param.getData("EKK2811B50302");
		ArrayList kikiTkList = (ArrayList)kikiTkMap.get("EKK2811B503CBSMsg1List");
		if (kikiTkList != null && kikiTkList.size() > 0)
		{
			HashMap kikiTkSvcMap = (HashMap)kikiTkList.get(0);
			kktkSvcKeiNo = (String)kikiTkSvcMap.get(EKK2811B503CBSMsg1List.KKTK_SVC_KEI_NO);
		}
		else
		{
			HashMap kikiMap = (HashMap)param.getData("EKK0341D010Tkn");
			ArrayList kikiList = (ArrayList)kikiMap.get("EKK0341D010TknList");
			HashMap kikiSvcMap = (HashMap)kikiList.get(0);
			kktkSvcKeiNo = (String)kikiSvcMap.get(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		if (kktkSvcKeiNo == null)
		{
			template.set(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);
		}
		// ＳＹＳＩＤ → ＳＹＳＩＤ
		if ("".equals(inLstMap.get("sysid")))
		{
			template.setNull(EKK2811D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.SYSID, (String)inLstMap.get("sysid"));
		}
		// 申込明細番号 → 申込明細番号
		if ("".equals(inLstMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK2811D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.MSKM_DTL_NO, (String)inLstMap.get("mskm_dtl_no"));
		}
		// 試用加入年月日 → 試用加入年月日
		if ("".equals(inLstMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD, (String)inLstMap.get("ftrial_kanyu_ymd"));
		}
		// 試用期間終了年月日 → 試用期間終了年月日
		if ("".equals(inLstMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inLstMap.get("ftrial_prd_endymd"));
		}
		// 本加入年月日
		if ("".equals(inLstMap.get("honkanyu_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.HONKANYU_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.HONKANYU_YMD, (String)inLstMap.get("honkanyu_ymd"));
		}
		// 本加入移行期限年月日
		if ("".equals(inLstMap.get("honkanyu_iko_kigen_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)inLstMap.get("honkanyu_iko_kigen_ymd"));
		}
		// サービス利用開始希望年月日 → サービス利用開始希望年月日
		//「IT2-2012-0002142」サービス開始希望年月日>>>値設定不要のため、空を無条件で設定する
		template.setNull(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD);
		//「IT2-2012-0002142」サービス開始希望年月日<<<E

		// 予約適用開始希望年月日
		if ("".equals(inLstMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inLstMap.get("rsv_tsta_kibo_ymd"));
		}
		// 違約金発生コード
		if ("".equals(inLstMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PNLTY_HASSEI_CD, (String)inLstMap.get("pnlty_hassei_cd"));
		}

		// 異動区分
		if ("".equals(inLstMap.get("ido_div")))
		{
			template.setNull(EKK2811D010CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.IDO_DIV, (String)inLstMap.get("ido_div"));
		}
		// 機器連帯契約変更手続中フラグ
		if ("".equals(inLstMap.get("kiki_rntai_kei_chgechu_flg")))
		{
			template.setNull(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG, (String)inLstMap.get("kiki_rntai_kei_chgechu_flg"));
		}
		// 請求契約番号
		if ("".equals(inLstMap.get("seiky_kei_no")))
		{
			template.setNull(EKK2811D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.SEIKY_KEI_NO, (String)inLstMap.get("seiky_kei_no"));
		}
		//  料金項目コード
		if ("".equals(inLstMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PRC_KMK_CD, (String)inLstMap.get("prc_kmk_cd"));
		}
		// 更新年月日時分秒(更新前)
		String mskmKbn = (String)((HashMap)param.getData("EKK2811B50302")).get("mskmKbn");
		String updDtmBf = null;
		// 新規申し込みの場合
		if (JFUStrConst.MSKM_KBN_NEW.equals(mskmKbn))
		{
			HashMap updDtmMap = (HashMap)param.getData("EKK0341D010Tkn");
			ArrayList updDtmList = (ArrayList)updDtmMap.get("EKK0341D010TknList");
			HashMap updDtmBfMap = (HashMap)updDtmList.get(0);
			updDtmBf = (String)updDtmBfMap.get(EKK0341D010CBSMsg.UPD_DTM);
			
			if (updDtmBf == null)
			{
				HashMap ekk2811Map = (HashMap)param.getData("EKK2811B50302");
				ArrayList ekk2811List = (ArrayList)ekk2811Map.get("EKK2811B503CBSMsg1List");
				// 多機能を持っている場合
				if (ekk2811List != null && ekk2811List.size() > 0)
				{
					if (inLstMap.get("upd_dtm_bf").equals(JFUStrConst.EMPTY) || null == inLstMap.get("upd_dtm_bf"))
					{
						HashMap ekk0091Map = (HashMap)param.getData("EKK0091A010");
						ArrayList ekk0091List = (ArrayList)ekk0091Map.get("EKK0091A010CBSMsg1List");
						HashMap ekk0091A010Map = (HashMap)ekk0091List.get(0);
						updDtmBf = (String)ekk0091A010Map.get(EKK0091A010CBSMsg1List.LAST_UPD_DTM);
						template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);
					}
					else
					{
						template.set(EKK2811D010CBSMsg.UPD_DTM_BF, (String)inLstMap.get("upd_dtm_bf"));
					}
				}
				else
				{
					template.setNull(EKK2811D010CBSMsg.UPD_DTM_BF);
				}
			}
			else
			{
				template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);
			}
		}
		// 追加申し込みの場合
		else
		{
			HashMap updDtmMap = (HashMap)param.getData("EKK2811B50302");
			ArrayList updDtmList = (ArrayList)updDtmMap.get("EKK2811B503CBSMsg1List");

			// 機器提供サービス契約一覧照会(サービス契約回線内訳)
			HashMap eKK0341B504Map = (HashMap)param.getData("EKK0341B504");
			ArrayList eKK0341B504List = null;
			HashMap eKK0341B504ChildMap = null;
			if(eKK0341B504Map != null)
			{
				eKK0341B504List = (ArrayList)eKK0341B504Map.get("EKK0341B504CBSMsg1List");
				eKK0341B504ChildMap = (HashMap)eKK0341B504List.get(0);
			}

			HashMap zenkoInfoMap = (HashMap)param.getData("EKK2811D010Net02");
			ArrayList zenkoInfoList = (ArrayList)zenkoInfoMap.get("EKK2811D010Net02List");
			HashMap zenkoChildMap = (HashMap)zenkoInfoList.get(0);

			// 多機能を持っている場合
			if (updDtmList != null && updDtmList.size() > 0)
			{
				if(JFUStrConst.KNYKEI_MSKM_JOKEN_IKT.equals((String)zenkoChildMap.get("knykei_mskm_joken_cd"))
					&& eKK0341B504List != null && eKK0341B504ChildMap != null)
				{
					template.set(EKK2811D010CBSMsg.UPD_DTM_BF, (String)eKK0341B504ChildMap.get("last_upd_dtm"));
				}
				else
				{
					template.set(EKK2811D010CBSMsg.UPD_DTM_BF, (String)inLstMap.get("upd_dtm_bf"));
				}
			}
			// 多機能を持っていない場合
			else
			{
				updDtmMap = (HashMap)param.getData("EKK0341D010Tkn");
				updDtmList = (ArrayList)updDtmMap.get("EKK0341D010TknList");
				HashMap updDtmBfMap = (HashMap)updDtmList.get(0);
				updDtmBf = (String)updDtmBfMap.get(EKK0341D010CBSMsg.UPD_DTM);
				
				if (updDtmBf == null)
				{
					template.setNull(EKK2811D010CBSMsg.UPD_DTM_BF);
				}
				else
				{
					template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);
				}
			}
		}

		return template;
	}

	/**
	 * 機器オプションサービス契約登録(ネット)の下りマッピング処理 <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK2811D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, int index)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData("EKK2811D010Net02");
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData("EKK2811D010", dataMap);
		}

		// ++++++++++++++++++++ v1.00.00 追加開始 ++++++++++++++++++++++++++ */
		ArrayList dataList = (ArrayList)dataMap.get("EKK2811D010Net02List");
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK2811D010Net02List", dataList);
		}

		HashMap childMap = (HashMap)dataList.get(index);
		if (childMap == null)
		{
			childMap = new HashMap();
			dataList.add(index, childMap);
		}
		// +++++++++++++++++++ v1.00.00 追加終了 +++++++++++++++++++++++++++ */

		// 世代登録年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.GENE_ADD_DTM))
		{
			childMap.put("gene_add_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("gene_add_dtm", template.getString(EKK2811D010CBSMsg.GENE_ADD_DTM));
		}

		// 機器オプションサービス契約ステータス
		if (template.isNull(EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT))
		{
			childMap.put("kkop_svc_kei_stat", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kkop_svc_kei_stat", template.getString(EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT));
		}

		// 予約適用年月日
		if (template.isNull(EKK2811D010CBSMsg.RSV_APLY_YMD))
		{
			childMap.put("rsv_aply_ymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("rsv_aply_ymd", template.getString(EKK2811D010CBSMsg.RSV_APLY_YMD));
		}

		// 予約適用コード
		if (template.isNull(EKK2811D010CBSMsg.RSV_APLY_CD))
		{
			childMap.put("rsv_aply_cd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("rsv_aply_cd", template.getString(EKK2811D010CBSMsg.RSV_APLY_CD));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.ADD_DTM))
		{
			childMap.put("add_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("add_dtm", template.getString(EKK2811D010CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK2811D010CBSMsg.ADD_OPEACNT))
		{
			childMap.put("add_opeacnt", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("add_opeacnt", template.getString(EKK2811D010CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.UPD_DTM))
		{
			childMap.put("upd_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_dtm", template.getString(EKK2811D010CBSMsg.UPD_DTM));
		}
		// ■更新年月日時分秒を、共有マップに設定
		String updDtm = (String)childMap.get("upd_dtm");
		JFUBPCommon.setNetSvkeiLastUpdDtm(param, updDtm);

		// 更新オペレータアカウント
		if (template.isNull(EKK2811D010CBSMsg.UPD_OPEACNT))
		{
			childMap.put("upd_opeacnt", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_opeacnt", template.getString(EKK2811D010CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK2811D010CBSMsg.MK_FLG))
		{
			childMap.put("mk_flg", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("mk_flg", template.getString(EKK2811D010CBSMsg.MK_FLG));
		}

		// 課金先番号
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_NO))
		{
			childMap.put("kakins_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_no", template.getString(EKK2811D010CBSMsg.ADD_OPEACNT));
		}

		// 課金先適用開始年月日
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_TSTAYMD))
		{
			childMap.put("kakins_tstaymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_tstaymd", template.getString(EKK2811D010CBSMsg.KAKINS_TSTAYMD));
		}

		//  課金先適用終了年月日
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_TENDYMD))
		{
			childMap.put("kakins_tendymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_tendymd", template.getString(EKK2811D010CBSMsg.KAKINS_TENDYMD));
		}

		// 機器提供サービス契約番号
		if (template.isNull(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO))
		{
			childMap.put("kktk_svc_kei_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kktk_svc_kei_no", template.getString(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO));
		}

		// 更新年月日時分秒(更新前)
		if (template.isNull(EKK2811D010CBSMsg.UPD_DTM_BF))
		{
			childMap.put("upd_dtm_bf", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_dtm_bf", template.getString(EKK2811D010CBSMsg.UPD_DTM_BF));
		}

		// エラー情報の設定
		param = editErrInfoEKK2811D010(param, template, (Integer)returnCode, fixedText, index); // No708 2013/04/24 Otsuka 

		//エラー情報のマップを取得
		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));

		//paramにデータをセット
		param.setData("OutEKK2811D010Net", childMap);

		return param;
	}

	/**
	 * 機器オプションサービス契約登録(ネット)のエラー情報マッピング処理<br>
	 * 
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @param i
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText,
			int i) throws RequestParameterException
	{

		int templateStatus = template.getInt(EKK2811D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK2811D010Net02");
		// No708 2013/04/24 Otsuka start
		inMap = (HashMap)((ArrayList)inMap.get("EKK2811D010Net02List")).get(i);

		// 機器オプションサービスコード
		if (!template.isNull(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kkop_svc_cd_err"))
			{
				inMap.put("kkop_svc_cd_err", template.getString(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR));
			}
		}

		// 料金コースコード
		if (!template.isNull(EKK2811D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK2811D010CBSMsg.PCRS_CD_ERR));
			}
		}

		// 料金プランコード
		if (!template.isNull(EKK2811D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK2811D010CBSMsg.PPLAN_CD_ERR));
			}
		}

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

		// SYSID
		if (!template.isNull(EKK2811D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK2811D010CBSMsg.SYSID_ERR));
			}
		}

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

		// 試用加入年月日
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}

		// 試用期間終了年月日
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}

		// 本加入年月日
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}

		// 本加入移行期限年月日
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}

		// サービス利用開始希望年月日
		if (!template.isNull(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}

		// 予約適用開始希望年月日
		if (!template.isNull(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}

		// 違約金発生コード
		if (!template.isNull(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}

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

		// 機器連帯契約変更手続中フラグ
		if (!template.isNull(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_rntai_kei_chgechu_flg_err"))
			{
				inMap.put("kiki_rntai_kei_chgechu_flg_err", template.getString(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR));
			}
		}

		// 請求契約番号
		if (!template.isNull(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}

		// 料金項目コード
		if (!template.isNull(EKK2811D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK2811D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK2811D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto END -----

		return param;
	}

	/**
	 * 機器オプションサービス契約登録(電話)の上りマッピング処理 <br>
	 * 
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2811D010Tel(IRequestParameterReadWrite param, String fixedText, int index) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811D010CBSMsg.class.getName());

		HashMap inMap = null;
		HashMap inLstMap = null;
		HashMap useplaceAddressMap = null;

		// テンプレートID（機器オプションサービス契約登録(電話)）
		template.set(EKK2811D010CBSMsg.TEMPLATEID, "EKK2811D010Tel02");

		// 機能コード（デフォルト：１（チェック＆登録）
		template.set(EKK2811D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK2811D010Tel02List")).get(index);

		// 分割後利用場所住所情報  本登録
		useplaceAddressMap = (HashMap)param.getData("FUSV016006CC");
		// 請求契約(電話)情報マップ
		HashMap seikyKeiTelInfoMap = (HashMap)param.getData("EKK0321B00501SC");
		// サービス契約契約(電話)情報マップ
		HashMap svcKeiTelMap = (HashMap)param.getData("EKK0081A010Tel");

		// 分割後利用場所住所情報  仮登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV015211CC");
		}
		// 2012/09/25 add by Otsuka
		// 分割後利用場所住所情報  一括登録
		if (null == useplaceAddressMap)
		{
			useplaceAddressMap = (HashMap)param.getData("FUSV016102CC");
		}
		// 請求契約(電話)情報マップ
		if(seikyKeiTelInfoMap == null || seikyKeiTelInfoMap.size() == 0)
		{
			seikyKeiTelInfoMap = new HashMap();
		}
		// サービス契約(電話)情報マップ
		if(svcKeiTelMap == null || svcKeiTelMap.size() == 0)
		{
			svcKeiTelMap = new HashMap();
		}

		// サービス契約.料金コースコード
		String svcKeiPcrsCd = (String)svcKeiTelMap.get(EKK0081A010CBSMsg1List.PCRS_CD);
		// サービス契約.料金プランコード
		String svcKeiPplanCd = (String)svcKeiTelMap.get(EKK0081A010CBSMsg1List.PPLAN_CD);

		// 1番号料金プランコードリスト
		List<String> telOnePplanCdList =
				Arrays.asList(JFUStrConst.CD00565_PA3101, JFUStrConst.CD00565_PA3102, JFUStrConst.CD00565_PA3103, JFUStrConst.CD00565_PA3104);
		// 2番号料金プランコードリスト
		List<String> telTwoPplanCdList =
				Arrays.asList(JFUStrConst.CD00565_PA3201, JFUStrConst.CD00565_PA3202, JFUStrConst.CD00565_PA3203, JFUStrConst.CD00565_PA3204);

		// 機器オプションサービスコード
		if ("".equals(inLstMap.get("kkop_svc_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.KKOP_SVC_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KKOP_SVC_CD, (String)inLstMap.get("kkop_svc_cd"));
		}

		// 料金コースコード＆料金プランコード
		if (JFUStrConst.CD00134_A31.equals(svcKeiPcrsCd) && telOnePplanCdList.contains(svcKeiPplanCd))
		{
			// 1番号
			template.set(EKK2811D010CBSMsg.PCRS_CD, JFUStrConst.CD00134_G03);
			template.set(EKK2811D010CBSMsg.PPLAN_CD, JFUStrConst.CD00565_PG0301);
		}
		else if(JFUStrConst.CD00134_A32.equals(svcKeiPcrsCd) && telTwoPplanCdList.contains(svcKeiPplanCd))
		{
			// 2番号
			template.set(EKK2811D010CBSMsg.PCRS_CD, JFUStrConst.CD00134_G04);
			template.set(EKK2811D010CBSMsg.PPLAN_CD, JFUStrConst.CD00565_PG0401);
		}
		else
		{
			template.setNull(EKK2811D010CBSMsg.PCRS_CD);
			template.setNull(EKK2811D010CBSMsg.PPLAN_CD);
		}

		// 機器提供サービス契約番号
		HashMap kikiMap = (HashMap)param.getData("EKK0341D010Tkn");
		ArrayList kikiList = (ArrayList)kikiMap.get("EKK0341D010TknList");
		HashMap kikiSvcMap = (HashMap)kikiList.get(0);

		String kktk_svc_kei_no = (String)kikiSvcMap.get(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO);
		if (kktk_svc_kei_no == null)
		{
			template.setNull(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO, kktk_svc_kei_no);
		}
		// ＳＹＳＩＤ → ＳＹＳＩＤ
		if ("".equals(inLstMap.get("sysid")))
		{
			template.setNull(EKK2811D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.SYSID, (String)inLstMap.get("sysid"));
		}

		// 申込明細番号 → 申込明細番号
		// 旧VAを持っている人がルーターを申し込んで機器オプションを登録するとき、ネットと同じ申込明細番号と同じ値を入れる
		HashMap inMapNet = (HashMap)param.getData("EKK2811D010Net02");
		HashMap inLstMapNet = (HashMap)((ArrayList)inMapNet.get("EKK2811D010Net02List")).get(index);
		if ("".equals(inLstMapNet.get("mskm_dtl_no")))
		{
			template.setNull(EKK2811D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.MSKM_DTL_NO, (String)inLstMapNet.get("mskm_dtl_no"));
		}
		// 試用加入年月日 → 試用加入年月日
		if ("".equals(inLstMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD, (String)inLstMap.get("ftrial_kanyu_ymd"));
		}
		// 試用期間終了年月日 → 試用期間終了年月日
		if ("".equals(inLstMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inLstMap.get("ftrial_prd_endymd"));
		}
		// 本加入年月日 → 本加入年月日
		if ("".equals(inLstMap.get("honkanyu_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.HONKANYU_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.HONKANYU_YMD, (String)inLstMap.get("honkanyu_ymd"));
		}
		// 本加入移行期限年月日 → 本加入移行期限年月日
		if ("".equals(inLstMap.get("honkanyu_iko_kigen_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)inLstMap.get("honkanyu_iko_kigen_ymd"));
		}
		// サービス利用開始希望年月日 → サービス利用開始希望年月日
		//「IT2-2012-0002142」サービス開始希望年月日>>>値設定不要のため、空を無条件で設定する
		template.setNull(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD);
		//「IT2-2012-0002142」サービス開始希望年月日<<<E

		// 予約適用開始希望年月日 → 予約適用開始希望年月日
		if ("".equals(inLstMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inLstMap.get("rsv_tsta_kibo_ymd"));
		}
		// 違約金発生コード → 違約金発生コード
		if ("".equals(inLstMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PNLTY_HASSEI_CD, (String)inLstMap.get("pnlty_hassei_cd"));
		}

		//  異動区分→ 異動区分
		if ("".equals(inLstMap.get("ido_div")))
		{
			template.setNull(EKK2811D010CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.IDO_DIV, (String)inLstMap.get("ido_div"));
		}
		// 機器連帯契約変更手続中フラグ
		if ("".equals(inLstMap.get("kiki_rntai_kei_chgechu_flg")))
		{
			template.setNull(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG, (String)inLstMap.get("kiki_rntai_kei_chgechu_flg"));
		}

		// ●既契約電話対応
		// 請求契約番号 → 請求契約番号
		if(seikyKeiTelInfoMap.containsKey(EKK0321B005CBSMsg1List.SEIKY_KEI_NO)
				&& !JFUBPCommon.isNull((String)seikyKeiTelInfoMap.get(EKK0321B005CBSMsg1List.SEIKY_KEI_NO)))
		{
			template.set(EKK2811D010CBSMsg.SEIKY_KEI_NO, (String)seikyKeiTelInfoMap.get(EKK0321B005CBSMsg1List.SEIKY_KEI_NO));
		}
		else if ("".equals(inLstMap.get("seiky_kei_no")))
		{
			template.setNull(EKK2811D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.SEIKY_KEI_NO, (String)inLstMap.get("seiky_kei_no"));
		}

		//  料金項目コード→ 料金項目コード
		if ("".equals(inLstMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK2811D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK2811D010CBSMsg.PRC_KMK_CD, (String)inLstMap.get("prc_kmk_cd"));
		}
		// 更新年月日時分秒(更新前)
		String updDtmBf = null;

		HashMap upddtmMap = (HashMap)param.getData("EKK0341D010Tkn");
		ArrayList upddtmList = (ArrayList)upddtmMap.get("EKK0341D010TknList");
		if (upddtmList != null && upddtmList.size() > 0)
		{
			HashMap updDtmBfMap = (HashMap)upddtmList.get(0);
			updDtmBf = (String)updDtmBfMap.get(EKK0341D010CBSMsg.UPD_DTM);
		}
		template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);

		return template;
	}

	/**
	 * 機器オプションサービス契約登録(電話)の下りマッピング処理 <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK2811D010Tel(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, int index)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData("EKK2811D010Tel02");
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData("EKK2811D010", dataMap);
		}

		// ++++++++++++++++++++ v1.00.00 追加開始 ++++++++++++++++++++++++++ */
		ArrayList dataList = (ArrayList)dataMap.get("EKK2811D010Tel02List");
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK2811D010Tel02List", dataList);
		}

		HashMap childMap = (HashMap)dataList.get(index);
		if (childMap == null)
		{
			childMap = new HashMap();
			dataList.add(index, childMap);
		}
		// +++++++++++++++++++ v1.00.00 追加終了 +++++++++++++++++++++++++++ */

		// 世代登録年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.GENE_ADD_DTM))
		{
			childMap.put("gene_add_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("gene_add_dtm", template.getString(EKK2811D010CBSMsg.GENE_ADD_DTM));
		}

		// 機器オプションサービス契約ステータス
		if (template.isNull(EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT))
		{
			childMap.put("kkop_svc_kei_stat", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kkop_svc_kei_stat", template.getString(EKK2811D010CBSMsg.KKOP_SVC_KEI_STAT));
		}

		// 予約適用年月日
		if (template.isNull(EKK2811D010CBSMsg.RSV_APLY_YMD))
		{
			childMap.put("rsv_aply_ymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("rsv_aply_ymd", template.getString(EKK2811D010CBSMsg.RSV_APLY_YMD));
		}

		// 予約適用コード
		if (template.isNull(EKK2811D010CBSMsg.RSV_APLY_CD))
		{
			childMap.put("rsv_aply_cd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("rsv_aply_cd", template.getString(EKK2811D010CBSMsg.RSV_APLY_CD));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.ADD_DTM))
		{
			childMap.put("add_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("add_dtm", template.getString(EKK2811D010CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK2811D010CBSMsg.ADD_OPEACNT))
		{
			childMap.put("add_opeacnt", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("add_opeacnt", template.getString(EKK2811D010CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK2811D010CBSMsg.UPD_DTM))
		{
			childMap.put("upd_dtm", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_dtm", template.getString(EKK2811D010CBSMsg.UPD_DTM));
		}
		// ■更新年月日時分秒を、共有マップに設定
		String updDtm = (String)childMap.get("upd_dtm");
		JFUBPCommon.setTelSvkeiLastUpdDtm(param, updDtm);

		// 更新オペレータアカウント
		if (template.isNull(EKK2811D010CBSMsg.UPD_OPEACNT))
		{
			childMap.put("upd_opeacnt", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("upd_opeacnt", template.getString(EKK2811D010CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK2811D010CBSMsg.MK_FLG))
		{
			childMap.put("mk_flg", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("mk_flg", template.getString(EKK2811D010CBSMsg.MK_FLG));
		}

		// 課金先番号
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_NO))
		{
			childMap.put("kakins_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_no", template.getString(EKK2811D010CBSMsg.ADD_OPEACNT));
		}

		// 課金先適用開始年月日
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_TSTAYMD))
		{
			childMap.put("kakins_tstaymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_tstaymd", template.getString(EKK2811D010CBSMsg.KAKINS_TSTAYMD));
		}

		//  課金先適用終了年月日
		if (template.isNull(EKK2811D010CBSMsg.KAKINS_TENDYMD))
		{
			childMap.put("kakins_tendymd", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("kakins_tendymd", template.getString(EKK2811D010CBSMsg.KAKINS_TENDYMD));
		}

		// エラー情報の設定
		param = editErrInfoEKK2811D010Tel(param, template, (Integer)returnCode, fixedText, index); // No708 2013/04/24 Otsuka 

		//エラー情報のマップを取得
		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));

		//paramにデータをセット
		param.setData("OutEKK2811D010Tel", childMap);

		return param;
	}

	/**
	 * 機器オプションサービス契約登録(電話)のエラー情報マッピング処理<br>
	 * 
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @param i
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811D010Tel(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText,
			int i) throws RequestParameterException
	{

		int templateStatus = template.getInt(EKK2811D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK2811D010Tel02");
		// No708 2013/04/24 Otsuka start
		inMap = (HashMap)((ArrayList)inMap.get("EKK2811D010Tel02List")).get(i);

		// 機器オプションサービスコード
		if (!template.isNull(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kkop_svc_cd_err"))
			{
				inMap.put("kkop_svc_cd_err", template.getString(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR));
			}
		}

		// 料金コースコード
		if (!template.isNull(EKK2811D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK2811D010CBSMsg.PCRS_CD_ERR));
			}
		}

		// 料金プランコード
		if (!template.isNull(EKK2811D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK2811D010CBSMsg.PPLAN_CD_ERR));
			}
		}

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

		// SYSID
		if (!template.isNull(EKK2811D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK2811D010CBSMsg.SYSID_ERR));
			}
		}

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

		// 試用加入年月日
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}

		// 試用期間終了年月日
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}

		// 本加入年月日
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}

		// 本加入移行期限年月日
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}

		// サービス利用開始希望年月日
		if (!template.isNull(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}

		// 予約適用開始希望年月日
		if (!template.isNull(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}

		// 違約金発生コード
		if (!template.isNull(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}

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

		// 機器連帯契約変更手続中フラグ
		if (!template.isNull(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_rntai_kei_chgechu_flg_err"))
			{
				inMap.put("kiki_rntai_kei_chgechu_flg_err", template.getString(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR));
			}
		}

		// 請求契約番号
		if (!template.isNull(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}

		// 料金項目コード
		if (!template.isNull(EKK2811D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK2811D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}

		// 更新年月日時分秒(更新前)
		if (!template.isNull(EKK2811D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// ----- 2012/05/07 サービスインターフェイス取込対応 h.iwamoto END -----


		return param;
		/* ADD 2013/12/03 ANK-1578-00-00 END */
	}
	
	/**
	 * ネットのサービス契約番号取得処理<br>
	 * 
	 * @param param
	 * @return String
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private String getNetSvcKeiNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// サービス契約番号
		String netSvcKeiNo = JFUStrConst.EMPTY;
		
		// 結果を詰めるマップを取得。
		HashMap dataMapEkk0081 = null;
		ArrayList dataListEkk0081 = null;
		HashMap dataEkk0081 = null;
		// サービスコード
		String ekk0081SvcCd = JFUStrConst.EMPTY;
		// 料金グループコード
		String ekk0081prcGrpCd = JFUStrConst.EMPTY;
		// サービス契約一覧照会（SYSID）3の明細を取得
		dataMapEkk0081 = (HashMap)param.getData("EKK0081B519");
		dataListEkk0081 = (ArrayList)dataMapEkk0081.get("EKK0081B519CBSMsg1List");
		// 明細件数分、処理を繰り返す
		for (int i = 0; i < dataListEkk0081.size(); i++)
		{
			// サービスコードと料金グループコードを取得
			dataEkk0081 = (HashMap)dataListEkk0081.get(i);
			
			ekk0081SvcCd = (String)dataEkk0081.get("svc_cd");
			ekk0081prcGrpCd = (String)dataEkk0081.get("prc_grp_cd");
			// サービスコードがネットかつ
			if (JFUStrConst.CD00130_01.equals(ekk0081SvcCd) &&
					// 料金グループコードがネットホームか、ネットメゾン、ネットマンションのいずれか
					(JFUStrConst.CD00133_02.equals(ekk0081prcGrpCd) || 
							JFUStrConst.CD00133_03.equals(ekk0081prcGrpCd) ||
							JFUStrConst.CD00133_04.equals(ekk0081prcGrpCd)))
			{
				netSvcKeiNo = (String)dataEkk0081.get("svc_kei_no");
				break;
			}
		}
		return netSvcKeiNo;
	}
	/**
	 * ネットのサービス契約回線内訳番号取得処理<br>
	 * 
	 * @param param
	 * @return String
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private String getNetSvcKeiKaisenUcwkNo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// サービス契約回線内訳番号
		String neSvcKeiKaisenUcwkNo = JFUStrConst.EMPTY;
		
		// 結果を詰めるマップを取得。
		HashMap dataMapEkk0241 = null;
		ArrayList dataListEkk0241 = null;
		HashMap dataEkk0241 = null;
		// 回線対象サービス契約一覧照会（サービス契約番号）の明細を取得
		dataMapEkk0241 = (HashMap)param.getData("EKK0241B003");
		dataListEkk0241 = (ArrayList)dataMapEkk0241.get("EKK0241B003CBSMsg1List");
		// 明細件数分、処理を繰り返す
		for (int i = 0; i < dataListEkk0241.size(); i++)
		{
			// サービスコードと料金グループコードを取得
			dataEkk0241 = (HashMap)dataListEkk0241.get(i);
			neSvcKeiKaisenUcwkNo = (String)dataEkk0241.get("svc_kei_kaisen_ucwk_no");
			break;
		}
		return neSvcKeiKaisenUcwkNo;
	}

	/**
	 * 機器提供サービス契約一覧照会(サービス契約回線内訳)
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg setEKK0341B504(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B504CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0341B504CBSMsg.FUNC_CODE, FUNC_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);

		// 
		HashMap kikiTkMap = (HashMap)param.getData("EKK2811B50302");

		String svc_kei_kaisen_ucwk_no = (String)kikiTkMap.get(EKK2811B503CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO);
		if (svc_kei_kaisen_ucwk_no == null)
		{
			template.setNull(EKK0341B504CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO);
		}
		else
		{
			template.set(EKK0341B504CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, svc_kei_kaisen_ucwk_no);
		}

		return template;
	}

	/**
	 * 機器提供サービス契約一覧照会(サービス契約回線内訳)の下りマッピング処理
	 * <br>
	 * 
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite getEKK0341B504(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		templateArray = template.getCAANMsgList(EKK0341B504CBSMsg.EKK0341B504CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0341B504CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap childMap = new HashMap();
				CAANMsg childTemplate = templateArray[i];

				//機器提供サービスコードがC004のデータだけを取る
				String kktkSvcCd = childTemplate.getString(EKK0341B504CBSMsg1List.KKTK_SVC_CD);
				//機器提供サービス契約ステータスが910、920以外のデータだけ取る
				String kktkSvcKeiStat = childTemplate.getString(EKK0341B504CBSMsg1List.KKTK_SVC_KEI_STAT);

				if ((JFUStrConst.KK0771_KKTK_SVC_CD_C024.equals(kktkSvcCd) || JFUStrConst.KK0771_KKTK_SVC_CD_C025.equals(kktkSvcCd))
						&& (!JFUStrConst.CD00056_910.equals(kktkSvcKeiStat) && !JFUStrConst.CD00056_920.equals(kktkSvcKeiStat)))
				{
					if (childTemplate.isNull(EKK0341B504CBSMsg1List.LAST_UPD_DTM))
					{
						childMap.put("last_upd_dtm", JFUStrConst.EMPTY);
					}
					else
					{
						childMap.put("last_upd_dtm", childTemplate.getString(EKK0341B504CBSMsg1List.LAST_UPD_DTM));
					}

					dataList.add(childMap);
				}

			}
		}
		dataMap.put("EKK0341B504CBSMsg1List", dataList);

		// エラー情報の設定
		editErrInfoEKK0341B504(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrInfoEKK0341B504(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0341B504CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// エラー情報返却
		if (!template.isNull(EKK0341B504CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO))
		{
			if (!inMap.containsKey("key_svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("key_svc_kei_kaisen_ucwk_no_err", template.getString(EKK0341B504CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 請求契約情報(電話)取得処理です。
	 * 
	 * <br>
	 * @param scCall
	 * @param handle
	 * @param paramMap
	 * @param param
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getSeikyKeiTelInfo(ServiceComponentRequestInvoker scCall, SessionHandle handle, HashMap<String, Object> paramMap,
			IRequestParameterReadWrite param) throws Exception
	{
		Map<?, ?> result = null;
		CAANMsg template = null;

		String nowKeiSvcTel = (String)((HashMap)param.getData("EKK0341B00202")).get("nowSvcTel");
		String svcKeiNoTel = (String)((HashMap)param.getData("EKK0341B00202")).get("svc_kei_no_tel");

		if(JFUStrConst.NOW_SVC_TEL_MI_KEI.equals(nowKeiSvcTel) || JFUBPCommon.isNull(svcKeiNoTel))
		{
			// 電話が既契約でない、または、電話のサービス契約番号がNULLの場合、処理しない
			return;
		}

		// 上りマッピング
		template = setEKK0321B005(param, "EKK0321B00501SC", svcKeiNoTel);
		// SC呼び出し
		result = scCall.run(putParamMap(paramMap, template), handle);
		// 下りマッピング
		getEKK0321B005(result, param, "EKK0321B00501SC"); 
		// エラー処理
		if (getReturnCode(param) >= TMCK_ERR_STATUS)
		{
			// ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}

	/**
	 * 課金先一覧照会（サービス契約番号）の上りマッピング処理です。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @throws Exception 
	 */
	private CAANMsg setEKK0321B005(IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws Exception
	{
		CAANMsg template = new CAANMsg(EKK0321B005CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0321B005CBSMsg.FUNC_CODE, FUNC_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 (JFUBPCommon.isNull(svcKeiNo))
		{
			template.setNull(EKK0321B005CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0321B005CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}

		return template;
	}

	/**
	 * 課金先一覧照会（サービス契約番号）の下りマッピング処理です。
	 * 
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getEKK0321B005(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateList = template.getCAANMsgList(EKK0321B005CBSMsg.EKK0321B005CBSMSG1LIST);

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// ●必要な情報のみマッピングする
		if(templateList != null && templateList.length > 0)
		{
			for (int i = 0; i < templateList.length; i++)
			{
				CAANMsg msg = templateList[i];

				// 請求契約番号
				if (JFUBPCommon.isNull(msg.getString(EKK0321B005CBSMsg1List.SEIKY_KEI_NO)))
				{
					dataMap.put(EKK0321B005CBSMsg1List.SEIKY_KEI_NO, JFUStrConst.EMPTY);
				}
				else
				{
					dataMap.put(EKK0321B005CBSMsg1List.SEIKY_KEI_NO, msg.getString(EKK0321B005CBSMsg1List.SEIKY_KEI_NO));
				}
				// 課金先番号
				if (JFUBPCommon.isNull(msg.getString(EKK0321B005CBSMsg1List.KAKINS_NO)))
				{
					dataMap.put(EKK0321B005CBSMsg1List.KAKINS_NO, JFUStrConst.EMPTY);
				}
				else
				{
					dataMap.put(EKK0321B005CBSMsg1List.KAKINS_NO, template.getString(EKK0321B005CBSMsg1List.KAKINS_NO));
				}

				break;
			}
		}

		// エラー情報の設定
		editErrInfoEKK0321B005(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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));
	}

	/**
	 * 課金先一覧照会（サービス契約番号）のエラーマッピング処理です。
	 * 
	 * <br>
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void editErrInfoEKK0321B005(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
		throws Exception
	{
		int templateStatus = template.getInt(EKK0341B504CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// エラー情報返却
		if (!template.isNull(EKK0321B005CBSMsg.KEY_SVC_KEI_NO))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
	}

	/**
	 * サービス契約(電話)情報取得処理です。
	 * 
	 * <br>
	 * @param scCall
	 * @param handle
	 * @param paramMap
	 * @param param
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getSvcKeiTelInfo(ServiceComponentRequestInvoker scCall, SessionHandle handle, HashMap<String, Object> paramMap,
			IRequestParameterReadWrite param) throws Exception
	{
		Map<?, ?> result = null;
		CAANMsg template = null;

		String nowKeiSvcTel = (String)((HashMap)param.getData("EKK0341B00202")).get("nowSvcTel");
		String svcKeiNoTel = (String)((HashMap)param.getData("EKK0341B00202")).get("svc_kei_no_tel");

		if(JFUStrConst.NOW_SVC_TEL_MI_KEI.equals(nowKeiSvcTel) || JFUBPCommon.isNull(svcKeiNoTel))
		{
			// 電話が既契約でない、または、電話のサービス契約番号がNULLの場合、処理しない
			return;
		}

		// ●サービス契約一意照会
		// 上りマッピング
		template = setEKK0081A010(param, "EKK0081A010Tel", svcKeiNoTel);
		// SC呼び出し
		result = scCall.run(putParamMap(paramMap, template), handle);
		// 下りマッピング
		getEKK0081A010(result, param, "EKK0081A010Tel"); 
		// エラー処理
		if (getReturnCode(param) >= TMCK_ERR_STATUS)
		{
			// ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}

	/**
	 * サービス契約一意照会の上りマッピング処理です。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @throws Exception 
	 */
	private CAANMsg setEKK0081A010(IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws Exception
	{
		CAANMsg template = new CAANMsg(EKK0081A010CBSMsg.class.getName());

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

		// 機能コード
		template.set(EKK0081A010CBSMsg.FUNC_CODE, FUNC_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 (JFUBPCommon.isNull(svcKeiNo))
		{
			template.setNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}
		// ＫＥＹ＿予約適用年月日
		template.set(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, JFUBPCommon.getOpeDate(null));

		return template;
	}

	/**
	 * サービス契約一意照会の下りマッピング処理です。
	 * 
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getEKK0081A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateList = template.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// ●必要な情報のみマッピングする
		if(templateList != null && templateList.length > 0)
		{
			for (int i = 0; i < templateList.length; i++)
			{
				CAANMsg msg = templateList[i];

				// 料金グループコード
				if (JFUBPCommon.isNull(msg.getString(EKK0081A010CBSMsg1List.PRC_GRP_CD)))
				{
					dataMap.put(EKK0081A010CBSMsg1List.PRC_GRP_CD, JFUStrConst.EMPTY);
				}
				else
				{
					dataMap.put(EKK0081A010CBSMsg1List.PRC_GRP_CD, msg.getString(EKK0081A010CBSMsg1List.PRC_GRP_CD));
				}
				// 料金コースコード
				if (JFUBPCommon.isNull(msg.getString(EKK0081A010CBSMsg1List.PCRS_CD)))
				{
					dataMap.put(EKK0081A010CBSMsg1List.PCRS_CD, JFUStrConst.EMPTY);
				}
				else
				{
					dataMap.put(EKK0081A010CBSMsg1List.PCRS_CD, msg.getString(EKK0081A010CBSMsg1List.PCRS_CD));
				}
				// 料金プランコード
				if (JFUBPCommon.isNull(msg.getString(EKK0081A010CBSMsg1List.PPLAN_CD)))
				{
					dataMap.put(EKK0081A010CBSMsg1List.PPLAN_CD, JFUStrConst.EMPTY);
				}
				else
				{
					dataMap.put(EKK0081A010CBSMsg1List.PPLAN_CD, msg.getString(EKK0081A010CBSMsg1List.PPLAN_CD));
				}

				break;
			}
		}

		// エラー情報の設定
		editErrInfoEKK0081A010(param, template, (Integer)returnCode, fixedText);

		// エラー情報のマップを取得
		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));
	}

	/**
	 * サービス契約一意照会のエラーマッピング処理です。
	 * 
	 * <br>
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void editErrInfoEKK0081A010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
		throws Exception
	{
		int templateStatus = template.getInt(EKK0341B504CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// エラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
	}

	/**
	 * 端末購入通知書登録用上りマッピング処理<br>
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK3271D010(IRequestParameterReadWrite param, String fixedText, int index) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK3271D010CBSMsg.class.getName());

		HashMap inMap = null;
		HashMap inLstMap = null;

		// テンプレートID（端末購入通知書登録）
		template.set(EKK3271D010CBSMsg.TEMPLATEID, "EKK3271D010");

		// 機能コード（デフォルト：１（チェック＆登録）
		template.set(EKK3271D010CBSMsg.FUNC_CODE, FUNC_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);

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		inLstMap = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(index);

		// 機器提供契約番号 → 機器提供契約番号
		if ("".equals(inLstMap.get("kktk_svc_kei_no")))
		{
			template.setNull(EKK3271D010CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.KKTK_SVC_KEI_NO, (String)inLstMap.get("kktk_svc_kei_no"));
		}
		// 端末購入通知書出力識別コード → 端末購入通知書出力識別コード
		if ("".equals(inLstMap.get("tnmt_buy_tchisho_oput_skcd")))
		{
			template.setNull(EKK3271D010CBSMsg.TNMT_BUY_TCHISHO_OPUT_SKCD);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.TNMT_BUY_TCHISHO_OPUT_SKCD, (String)inLstMap.get("tnmt_buy_tchisho_oput_skcd"));
		}
		// 端末購入受付担当者名 → 端末購入受付担当者名
		if ("".equals(inLstMap.get("tnmt_buy_uk_tntsha_nm")))
		{
			template.setNull(EKK3271D010CBSMsg.TNMT_BUY_UK_TNTSHA_NM);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.TNMT_BUY_UK_TNTSHA_NM, (String)inLstMap.get("tnmt_buy_uk_tntsha_nm"));
		}
		// 申込明細番号 → 申込明細番号
		if ("".equals(inLstMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK3271D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.MSKM_DTL_NO, (String)inLstMap.get("mskm_dtl_no"));
		}
		//  登録年月日時分秒→ 登録年月日時分秒
		if ("".equals(inLstMap.get("add_dtm")))
		{
			template.setNull(EKK3271D010CBSMsg.ADD_DTM);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.ADD_DTM, (String)inLstMap.get("add_dtm"));
		}
		//  登録オペレータアカウント→ 登録オペレータアカウント
		if ("".equals(inLstMap.get("add_opeacnt")))
		{
			template.setNull(EKK3271D010CBSMsg.ADD_OPEACNT);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.ADD_OPEACNT, (String)inLstMap.get("add_opeacnt"));
		}
		//  更新年月日時分秒→ 更新年月日時分秒
		if ("".equals(inLstMap.get("upd_dtm")))
		{
			template.setNull(EKK3271D010CBSMsg.UPD_DTM);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.UPD_DTM, (String)inLstMap.get("upd_dtm"));
		}
		//  更新オペレータアカウント→ 更新オペレータアカウント
		if ("".equals(inLstMap.get("upd_opeacnt")))
		{
			template.setNull(EKK3271D010CBSMsg.UPD_OPEACNT);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.UPD_OPEACNT, (String)inLstMap.get("upd_opeacnt"));
		}
		//  無効フラグ→ 無効フラグ
		if ("".equals(inLstMap.get("mk_flg")))
		{
			template.setNull(EKK3271D010CBSMsg.MK_FLG);
		}
		else
		{
			template.set(EKK3271D010CBSMsg.MK_FLG, (String)inLstMap.get("mk_flg"));
		}

//		// 機器提供サービス契約登録マップ.更新年月日時分秒 → 更新年月日時分秒(更新前)
//		if ("".equals(inLstMap.get("upd_dtm")))
//		{
//			template.setNull(EKK3271D010CBSMsg.UPD_DTM_BF);
//		}
//		else
//		{
//			template.set(EKK3271D010CBSMsg.UPD_DTM_BF, (String)inLstMap.get("upd_dtm"));
//		}

		return template;
	}

	/**
	 * 端末購入通知書登録の下りマッピング処理<br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param index
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK3271D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, int index)
			throws Exception
	{

		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData("EKK0341D010");
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData("EKK0341D010", dataMap);
		}

		ArrayList dataList = (ArrayList)dataMap.get("EKK0341D010List");
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0341D010List", dataList);
		}

		HashMap childMap = (HashMap)dataList.get(index);
		if (childMap == null)
		{
			childMap = new HashMap();
			dataList.add(index, childMap);
		}

		// 端末購入通知書登録マップ.端末購入通知書情報番号 ← 端末購入通知書情報番号
		if (template.isNull(EKK3271D010CBSMsg.TMKNTSHO_INF_NO))
		{
			childMap.put("tmkntsho_inf_no", JFUStrConst.EMPTY);
		}
		else
		{
			childMap.put("tmkntsho_inf_no", template.getString(EKK3271D010CBSMsg.TMKNTSHO_INF_NO));
		}

//		// 端末購入通知書登録マップ.登録年月日時分秒 ← 更新年月日時分秒
//		if (template.isNull(EKK3271D010CBSMsg.UPD_DTM))
//		{
//			childMap.put("upd_dtm", JFUStrConst.EMPTY);
//		}
//		else
//		{
//			childMap.put("upd_dtm", template.getString(EKK3271D010CBSMsg.UPD_DTM));
//			// ワークマップに登録
//			workMap.put("upd_dtm", template.getString(EKK3271D010CBSMsg.UPD_DTM));
//		}

		// エラー情報の設定
		param = editErrInfoEKK3271D010(param, template, (Integer)returnCode, fixedText, index);

		//エラー情報のマップを取得
		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 param
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @param i
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK3271D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText,
			int i) throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK3271D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, 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)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap inMap = (HashMap<String, Object>)param.getData("EKK0341D010");
		inMap = (HashMap)((ArrayList)inMap.get("EKK0341D010List")).get(i);


		return param;
	}
}