/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKKeishaServiceCC
*   ソースファイル名：JKKKeishaServiceCC.java
*   作成者          ：富士通
*   日付            ：2011年06月03日
*＜機能概要＞
*   契約者情報登録部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/06/03   FJ）山川    新規作成
*   v4.00.00    2012/07/13   FJ）谷口    【ANK-0398-00-00】住所管理に伴う「例外登録」の管理追加対応
*   v4.00.00    2012/09/10   FJ）岡野    【ANK-0384-00-00】契約者住所を利用場所住所で上書きを行う機能の作成対応
*   v5.00.00    2013/02/22   FJ）谷口    【ANK-1402-00-00】法人のお客様名設定見直し対応
*   v8.00.00    2014/03/12   FJ）松田    【ANK-1962-00-00】関電グループCRMに向けた取り組み対応
*   v37.00.00	2018/03/30   FJ）平野    【ANK-3366-00-00】eo光設備卸対応
*   v57.00.00	2022/01/14   FJ) 平野    【ANK-4075-00-00】マンション卸回線(WI-FIスキーム)の不備対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

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

import eo.common.constant.JPCModelConstant;
import eo.ejb.cbs.cbsmsg.ECK0021D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0031D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0031D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0201D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341D010CBSMsg;

/**
 * 契約者情報登録部品.
 * <br>
 * @author 富士通
 */
public class JKKAddKeishaServiceCC extends AbstractCommonComponent
{
	/** テンプレートID */
	public static final String TEMPLATE_ID = "ECK0021D010";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** エラー用 */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME = "JKKAddKeishaServiceCCWork";
	/** 作業マップ名：請求オプションサービス契約 */
	private static final String CC_WORK_AREA_APLY_SEIOPSVC_KEI  = "JKKAplySeiopsvcKeiCC";
	/** 契約種別 1:個人 */
	private static final String KEISHA_TYPE_CD_KOJIN = "1";
//	/** 契約種別 2:法人 */
//	private static final String KEISHA_TYPE_CD_HOJIN = "2";

	/*
	 *  各サービスIFのマップ用プレフィックス
	 */
	/** 個人の電話番号レコード登録用プレフィックス */
	private static final String PREFIX_KOZIN = "";
	/** メールアドレスレコード登録用プレフィックス */
	private static final String PREFIX_MLAD = "ck020101_";
	/** 法人の電話番号（電話番号）レコード登録用プレフィックス */
	private static final String PREFIX_HOZIN_TEL = "ck020102_";
	/** 法人の電話番号（携帯）レコード登録用プレフィックス */
	private static final String PREFIX_HOZIN_KEITAI = "ck020103_";
	/** 法人の電話番号（内線番号）レコード登録用プレフィックス */
	private static final String PREFIX_HOZIN_NISNNO = "ck020104_";

	/**
	 * 契約者情報登録処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite addKeisha(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{

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

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

		// 登録用のCCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		// 機能コード
		String funcCd = (String)inMap.get(JCMConstants.FUNC_CODE_KEY);

		String keisha_type_cd = (String)inMap.get("keisha_type_cd");			// 契約種別
		String mlad = (String)inMap.get("ck020101_mlad");						// 連絡先メールアドレス
		String kikiSohusPcd = (String)inMap.get("kiki_sohus_pcd");				// 機器送付先郵便番号
		boolean kktkChkFlg = (inMap.get("kktk_chk_flg") == null ? true : (Boolean)inMap.get("kktk_chk_flg"));	// 機器提供チェックフラグ

		// 契約種別が個人の場合設定する
		if (KEISHA_TYPE_CD_KOJIN.equals(keisha_type_cd))
		{
			// お客様＜個人＞登録
			template = editInECK0021D010(param, fixedText);						// 上りマッピング
			paramMap = putParamMap(paramMap, template);
			result = scCall.run(paramMap, handle);								// SC呼び出し
			editRetECK0021D010(result, param, fixedText);						// 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 連絡先登録(個人の電話番号)
			template = editInECK0201D010(param, fixedText, PREFIX_KOZIN);		// 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
			editRetECK0201D010(result, param, fixedText, PREFIX_KOZIN);			// 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		// 契約種別が個人以外の場合
		else
		{
			// お客様＜法人＞登録
			template = editInECK0031D010(param, fixedText);						// 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
			editRetECK0031D010(result, param, fixedText);						// 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			if(null != inMap.get(PREFIX_HOZIN_TEL + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_TEL + "telno")).length())
			{
				// 連絡先登録(法人の電話番号)
				template = editInECK0201D010(param, fixedText, PREFIX_HOZIN_TEL);// 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
				editRetECK0201D010(result, param, fixedText, PREFIX_HOZIN_TEL);	// 下りマッピング
				// ステータスが単項目エラー以上であれば例外をスロー
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			if(null != inMap.get(PREFIX_HOZIN_KEITAI + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_KEITAI + "telno")).length())
			{
				// 連絡先登録(法人の携帯電話番号)
				template = editInECK0201D010(param, fixedText, PREFIX_HOZIN_KEITAI);// 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
				editRetECK0201D010(result, param, fixedText, PREFIX_HOZIN_KEITAI);	// 下りマッピング
				// ステータスが単項目エラー以上であれば例外をスロー
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			if(null != inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")).length())
			{
				// 連絡先登録(法人の内線番号)
				template = editInECK0201D010(param, fixedText, PREFIX_HOZIN_NISNNO);// 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
				editRetECK0201D010(result, param, fixedText, PREFIX_HOZIN_NISNNO);	// 下りマッピング
				// ステータスが単項目エラー以上であれば例外をスロー
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}

		// メールアドレスが入力されている場合
		if (!"".equals(mlad) && mlad != null)
		{
			// 連絡先登録(メールアドレス)
			template = editInECK0201D010(param, fixedText, PREFIX_MLAD);		// 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
			editRetECK0201D010(result, param, fixedText, PREFIX_MLAD);			// 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 機能コードが"2"(チェックのみ)かつ
		// 機器送付先に値が入っている場合かつ
		// 機器提供チェックフラグ（kktk_chk_flg）がfalseの場合
		if (JPCModelConstant.FUNC_CD_2.equals(funcCd) && kikiSohusPcd != null && !"".equals(kikiSohusPcd) && kktkChkFlg == false)
		{
			// 機器提供サービス契約登録
			template = editInEKK0341D010(param, fixedText);		// 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
			editRetEKK0341D010(result, param, fixedText);			// 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		// 機能コードが"2"(チェックのみ)かつ
		// 契約者住所変更希望年月日がnull以外かつ
		// 契約者住所変更希望年月日が空以外
		if (JPCModelConstant.FUNC_CD_2.equals(funcCd) && inMap.get("kshad_chg_kibo_ymd") != null 
				&& !"".equals((String)inMap.get("kshad_chg_kibo_ymd")))
		{
			// サービス回線内訳登録
			template = editInEKK0251D010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0251D010(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		return param;
	}

	/**
	 * チェック処理を行います。
	 * <br>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterExceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();

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

		// 登録用のCCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return JKKBpCommon.createBpNotCheckParam();
		}

		String keisha_type_cd = (String)inMap.get("keisha_type_cd");				// 契約種別
		String mlad = (String)inMap.get("ck020101_mlad");							// 連絡先メールアドレス
		String kikiSohusAdCd = (String)inMap.get("kiki_sohus_ad_cd");			// 機器送付先住所コード
		boolean kktkChkFlg = (inMap.get("kktk_chk_flg") == null ? true : (Boolean)inMap.get("kktk_chk_flg"));	// 機器提供チェックフラグ

		// 契約種別が個人
		if (KEISHA_TYPE_CD_KOJIN.equals(keisha_type_cd))
		{
			msgList.add(editInECK0021D010(param, fixedText));						// お客様＜個人＞登録
			msgList.add(editInECK0201D010(param, fixedText, PREFIX_KOZIN));			// 連絡先登録(個人の電話番号)
		}
		// 契約種別が個人以外
		else
		{
			msgList.add(editInECK0031D010(param, fixedText));						// お客様＜法人＞登録
			
			if(null != (String)inMap.get(PREFIX_HOZIN_TEL + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_TEL + "telno")).length())
			{
				msgList.add(editInECK0201D010(param, fixedText, PREFIX_HOZIN_TEL));	// 連絡先登録(法人の電話番号)
			}
			
			if(null != (String)inMap.get(PREFIX_HOZIN_KEITAI + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_KEITAI + "telno")).length())
			{
				msgList.add(editInECK0201D010(param, fixedText, PREFIX_HOZIN_KEITAI));	// 連絡先登録(法人の携帯電話番号)
			}
			if(null != (String)inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")).length())
			{
				msgList.add(editInECK0201D010(param, fixedText, PREFIX_HOZIN_NISNNO));	// 連絡先登録(法人の内線番号)
			}
		}

		// メールアドレスが入力されている場合
		if (!"".equals(mlad) && mlad != null)
		{
			msgList.add(editInECK0201D010(param, fixedText, PREFIX_MLAD)); // 連絡先登録(メールアドレス)
		}

		// 機器送付先住所コード（kiki_sohus_ad_cd）が設定されている且つ、
		// 機器提供チェックフラグ（kktk_chk_flg）がfalseの場合
		if (kikiSohusAdCd != null && !"".equals(kikiSohusAdCd) && kktkChkFlg == false)
		{
			msgList.add(editInEKK0341D010(param, fixedText));						// 機器提供サービス契約登録
		}
		
		// 契約者住所変更希望年月日がnull以外かつ
		// 契約者住所変更希望年月日が空以外
		if (inMap.get("kshad_chg_kibo_ymd") != null && !"".equals((String)inMap.get("kshad_chg_kibo_ymd")))
		{
			msgList.add(editInEKK0251D010(param, fixedText));						// サービス回線内訳登録
		}

		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 パラメータマップ
	 * @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
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0021D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

		CAANMsg template = new CAANMsg(ECK0021D010CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(ECK0021D010CBSMsg.FUNC_CODE, "1");

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

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

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

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

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

		// お客様＜個人＞登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ
		// 契約新規にはSYSIDを入力する欄が存在しないため
		template.setNull(ECK0021D010CBSMsg.SYSID);
//		if ("".equals(inMap.get("sysid")))
//		{
//			template.setNull(ECK0021D010CBSMsg.SYSID);
//		}
//		else
//		{
//			template.set(ECK0021D010CBSMsg.SYSID, (String)inMap.get("sysid"));
//		}

		// お客様＜個人＞登録マップ.お客様名 → お客様名
		if ("".equals(inMap.get("cust_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_NM, (String)inMap.get("cust_nm"));
		}

		// お客様＜個人＞登録マップ.お客様カナ名 → お客様カナ名
		if ("".equals(inMap.get("cust_kana")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_KANA);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_KANA, (String)inMap.get("cust_kana"));
		}

		// お客様＜個人＞登録マップ.お客様性別コード → お客様性別コード
		if ("".equals(inMap.get("cust_sex_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_SEX_CD, (String)inMap.get("cust_sex_cd"));
		}

		// お客様＜個人＞登録マップ.お客様生年月日 → お客様生年月日
		if ("".equals(inMap.get("cust_birthd")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_BIRTHD, (String)inMap.get("cust_birthd"));
		}

		// お客様＜個人＞登録マップ.氏名敬称 → 氏名敬称
		if ("".equals(inMap.get("nm_kisho")))
		{
			template.setNull(ECK0021D010CBSMsg.NM_KISHO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NM_KISHO, (String)inMap.get("nm_kisho"));
		}

		// お客様＜個人＞登録マップ.お客様確認備考 → お客様確認備考
		if ("".equals(inMap.get("cust_cfm_biko")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_CFM_BIKO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_CFM_BIKO, (String)inMap.get("cust_cfm_biko"));
		}

		// お客様＜個人＞登録マップ.契約者住所コード → 契約者住所コード
		if ("".equals(inMap.get("keisha_ad_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_AD_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_AD_CD, (String)inMap.get("keisha_ad_cd"));
		}

		// お客様＜個人＞登録マップ.契約者郵便番号 → 契約者郵便番号
		if ("".equals(inMap.get("keisha_pcd")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_PCD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_PCD, (String)inMap.get("keisha_pcd"));
		}

		// お客様＜個人＞登録マップ.契約者都道府県名 → 契約者都道府県名
		if ("".equals(inMap.get("keisha_state_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_STATE_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_STATE_NM, (String)inMap.get("keisha_state_nm"));
		}

		// お客様＜個人＞登録マップ.契約者市区町村名 → 契約者市区町村名
		if ("".equals(inMap.get("keisha_city_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_CITY_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_CITY_NM, (String)inMap.get("keisha_city_nm"));
		}

		// お客様＜個人＞登録マップ.契約者大字通称名 → 契約者大字通称名
		if ("".equals(inMap.get("keisha_oaztsu_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_OAZTSU_NM, (String)inMap.get("keisha_oaztsu_nm"));
		}

		// お客様＜個人＞登録マップ.契約者字丁目名 → 契約者字丁目名
		if ("".equals(inMap.get("keisha_azcho_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_AZCHO_NM, (String)inMap.get("keisha_azcho_nm"));
		}

		// お客様＜個人＞登録マップ.契約者番地号 → 契約者番地号
		if ("".equals(inMap.get("keisha_bnchigo")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_BNCHIGO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_BNCHIGO, (String)inMap.get("keisha_bnchigo"));
		}

		// お客様＜個人＞登録マップ.契約者住所補記・建物名 → 契約者住所補記・建物名
		if ("".equals(inMap.get("keisha_adrttm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_ADRTTM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_ADRTTM, (String)inMap.get("keisha_adrttm"));
		}

		// お客様＜個人＞登録マップ.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号
		if ("".equals(inMap.get("keisha_adrrm")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_ADRRM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_ADRRM, (String)inMap.get("keisha_adrrm"));
		}

		// お客様＜個人＞登録マップ.契約者電話番号 → 契約者電話番号
		if ("".equals(inMap.get("keisha_telno")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_TELNO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_TELNO, (String)inMap.get("keisha_telno"));
		}

		// お客様＜個人＞登録マップ.お客様ランクコード → お客様ランクコード
		if ("".equals(inMap.get("cust_rank_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_RANK_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_RANK_CD, (String)inMap.get("cust_rank_cd"));
		}

		// お客様＜個人＞登録マップ.連絡手段コード → 連絡手段コード
		if ("".equals(inMap.get("ck0021_rrk_way_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.RRK_WAY_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.RRK_WAY_CD, (String)inMap.get("ck0021_rrk_way_cd"));
		}

		// お客様＜個人＞登録マップ.連絡手段補記 → 連絡手段補記
		if ("".equals(inMap.get("rrk_way_hoki")))
		{
			template.setNull(ECK0021D010CBSMsg.RRK_WAY_HOKI);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.RRK_WAY_HOKI, (String)inMap.get("rrk_way_hoki"));
		}

		// お客様＜個人＞登録マップ.コンテンツお客様名 → コンテンツお客様名
		if ("".equals(inMap.get("cont_cust_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_CUST_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_CUST_NM, (String)inMap.get("cont_cust_nm"));
		}

		// お客様＜個人＞登録マップ.コンテンツお客様カナ名 → コンテンツお客様カナ名
		if ("".equals(inMap.get("cont_cust_kana")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_CUST_KANA);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_CUST_KANA, (String)inMap.get("cont_cust_kana"));
		}

		// お客様＜個人＞登録.コンテンツお客様性別コード → コンテンツお客様性別コード
		if (inMap == null || inMap.get("cont_cust_sex_cd") == null || "".equals(inMap.get("cont_cust_sex_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_CUST_SEX_CD, (String)inMap.get("cont_cust_sex_cd"));
		}

		// お客様＜個人＞登録.コンテンツお客様生年月日 → コンテンツお客様生年月日
		if (inMap == null || inMap.get("cont_cust_birthd") == null || "".equals(inMap.get("cont_cust_birthd")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_CUST_BIRTHD, (String)inMap.get("cont_cust_birthd"));
		}

		// お客様＜個人＞登録.コンテンツ住所コード → コンテンツ住所コード
		if (inMap == null || inMap.get("cont_ad_cd") == null || "".equals(inMap.get("cont_ad_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_AD_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_AD_CD, (String)inMap.get("cont_ad_cd"));
		}

		// お客様＜個人＞登録.コンテンツ郵便番号 → コンテンツ郵便番号
		if (inMap == null || inMap.get("cont_pcd") == null || "".equals(inMap.get("cont_pcd")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_PCD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_PCD, (String)inMap.get("cont_pcd"));
		}

		// お客様＜個人＞登録.コンテンツ都道府県名 → コンテンツ都道府県名
		if (inMap == null || inMap.get("cont_state_nm") == null || "".equals(inMap.get("cont_state_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_STATE_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_STATE_NM, (String)inMap.get("cont_state_nm"));
		}

		// お客様＜個人＞登録.コンテンツ市区町村名 → コンテンツ市区町村名
		if (inMap == null || inMap.get("cont_city_nm") == null || "".equals(inMap.get("cont_city_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_CITY_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_CITY_NM, (String)inMap.get("cont_city_nm"));
		}

		// お客様＜個人＞登録.コンテンツ大字通称名 → コンテンツ大字通称名
		if (inMap == null || inMap.get("cont_oaztsu_nm") == null || "".equals(inMap.get("cont_oaztsu_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_OAZTSU_NM, (String)inMap.get("cont_oaztsu_nm"));
		}

		// お客様＜個人＞登録.コンテンツ字丁目名 → コンテンツ字丁目名
		if (inMap == null || inMap.get("cont_azcho_nm") == null || "".equals(inMap.get("cont_azcho_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_AZCHO_NM, (String)inMap.get("cont_azcho_nm"));
		}

		// お客様＜個人＞登録.コンテンツ番地号 → コンテンツ番地号
		if (inMap == null || inMap.get("cont_bnchigo") == null || "".equals(inMap.get("cont_bnchigo")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_BNCHIGO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_BNCHIGO, (String)inMap.get("cont_bnchigo"));
		}

		// お客様＜個人＞登録.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名
		if (inMap == null || inMap.get("cont_adrttm") == null || "".equals(inMap.get("cont_adrttm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_ADRTTM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_ADRTTM, (String)inMap.get("cont_adrttm"));
		}

		// お客様＜個人＞登録.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号
		if (inMap == null || inMap.get("cont_adrrm") == null || "".equals(inMap.get("cont_adrrm")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_ADRRM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_ADRRM, (String)inMap.get("cont_adrrm"));
		}

		// お客様＜個人＞登録.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置
		if (inMap == null || inMap.get("cont_ad_bnkt_sta_pst") == null || "".equals(inMap.get("cont_ad_bnkt_sta_pst")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_AD_BNKT_STA_PST);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_AD_BNKT_STA_PST, (String)inMap.get("cont_ad_bnkt_sta_pst"));
		}

		// お客様＜個人＞登録マップ.会員種別コード → 会員種別コード
		if ("".equals(inMap.get("member_sbt_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.MEMBER_SBT_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.MEMBER_SBT_CD, (String)inMap.get("member_sbt_cd"));
		}

		// お客様＜個人＞登録マップ.コンテンツＩＳＰ利用不可フラグ → コンテンツＩＳＰ利用不可フラグ
		if ("".equals(inMap.get("cont_isp_use_fail_flg")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_ISP_USE_FAIL_FLG);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_ISP_USE_FAIL_FLG, (String)inMap.get("cont_isp_use_fail_flg"));
		}

		// お客様＜個人＞登録マップ.コンテンツＩＳＰ利用停止年月日 → コンテンツＩＳＰ利用停止年月日
		if ("".equals(inMap.get("cont_isp_use_stp_ymd")))
		{
			template.setNull(ECK0021D010CBSMsg.CONT_ISP_USE_STP_YMD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CONT_ISP_USE_STP_YMD, (String)inMap.get("cont_isp_use_stp_ymd"));
		}

		// お客様＜個人＞登録マップ.入会年月日 → 入会年月日
		if ("".equals(inMap.get("join_ymd")))
		{
			template.setNull(ECK0021D010CBSMsg.JOIN_YMD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.JOIN_YMD, (String)inMap.get("join_ymd"));
		}

		// お客様＜個人＞登録マップ.パスワードリマインダ用質問コード → パスワードリマインダ用質問コード
		if ("".equals(inMap.get("pwd_reminder_qs_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.PWD_REMINDER_QS_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.PWD_REMINDER_QS_CD, (String)inMap.get("pwd_reminder_qs_cd"));
		}

		// お客様＜個人＞登録マップ.パスワードリマインダ用回答 → パスワードリマインダ用回答
		if ("".equals(inMap.get("pwd_reminder_ans")))
		{
			template.setNull(ECK0021D010CBSMsg.PWD_REMINDER_ANS);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.PWD_REMINDER_ANS, (String)inMap.get("pwd_reminder_ans"));
		}

		// お客様＜個人＞登録マップ.ニックネーム → ニックネーム
		if ("".equals(inMap.get("nkname")))
		{
			template.setNull(ECK0021D010CBSMsg.NKNAME);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NKNAME, (String)inMap.get("nkname"));
		}

		// お客様＜個人＞登録マップ.ニックネーム変更年月日 → ニックネーム変更年月日
		if ("".equals(inMap.get("nkname_chge_ymd")))
		{
			template.setNull(ECK0021D010CBSMsg.NKNAME_CHGE_YMD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NKNAME_CHGE_YMD, (String)inMap.get("nkname_chge_ymd"));
		}

		// お客様＜個人＞登録マップ.内販外販コード → 内販外販コード
		if ("".equals(inMap.get("naihan_gaihan_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.NAIHAN_GAIHAN_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NAIHAN_GAIHAN_CD, (String)inMap.get("naihan_gaihan_cd"));
		}

		// お客様＜個人＞登録マップ.内販企業識別コード → 内販企業識別コード
		if ("".equals(inMap.get("naihan_comp_skbt_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.NAIHAN_COMP_SKBT_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NAIHAN_COMP_SKBT_CD, (String)inMap.get("naihan_comp_skbt_cd"));
		}

		// お客様＜個人＞登録マップ.要補助コード → 要補助コード
		if ("".equals(inMap.get("necessary_hojo_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.NECESSARY_HOJO_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NECESSARY_HOJO_CD, (String)inMap.get("necessary_hojo_cd"));
		}

		// お客様＜個人＞登録マップ.ｅｏｎｅｔＩＤ未移行フラグ → ｅｏｎｅｔＩＤ未移行フラグ
		if ("".equals(inMap.get("eonetid_mi_iko_flg")))
		{
			template.setNull(ECK0021D010CBSMsg.EONETID_MI_IKO_FLG);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.EONETID_MI_IKO_FLG, (String)inMap.get("eonetid_mi_iko_flg"));
		}

		// お客様＜個人＞登録マップ.ログイン認証可否 → ログイン認証可否
		if ("".equals(inMap.get("login_ninsho_kh")))
		{
			template.setNull(ECK0021D010CBSMsg.LOGIN_NINSHO_KH);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.LOGIN_NINSHO_KH, (String)inMap.get("login_ninsho_kh"));
		}

		// お客様＜個人＞登録マップ.お客様特記事項コード → お客様特記事項コード
		if ("".equals(inMap.get("cust_tkjk_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_TKJK_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_TKJK_CD, (String)inMap.get("cust_tkjk_cd"));
		}

		// お客様＜個人＞登録マップ.お客様入退会コード → お客様入退会コード
		if ("".equals(inMap.get("cust_ntaikai_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_NTAIKAI_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_NTAIKAI_CD, (String)inMap.get("cust_ntaikai_cd"));
		}

		// お客様＜個人＞登録マップ.会員種別特定フラグ → 会員種別特定フラグ
		if ("".equals(inMap.get("mmb_sbt_tokut_flg")))
		{
			template.setNull(ECK0021D010CBSMsg.MMB_SBT_TOKUT_FLG);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.MMB_SBT_TOKUT_FLG, (String)inMap.get("mmb_sbt_tokut_flg"));
		}

		// お客様＜個人＞登録マップ.名寄せ先ＳＹＳＩＤ → 名寄せ先ＳＹＳＩＤ
		if ("".equals(inMap.get("nayose_saki_sysid")))
		{
			template.setNull(ECK0021D010CBSMsg.NAYOSE_SAKI_SYSID);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.NAYOSE_SAKI_SYSID, (String)inMap.get("nayose_saki_sysid"));
		}

		// お客様＜個人＞登録マップ.ｅｏＩＤ通知書発行実績コード → ｅｏＩＤ通知書発行実績コード
		if ("".equals(inMap.get("eoid_tchisho_hakkojski_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD, (String)inMap.get("eoid_tchisho_hakkojski_cd"));
		}

		// お客様＜個人＞登録.旧eonet会員認証用ID → 旧eonet会員認証用ID
		if (inMap == null || inMap.get("old_eonetmb_ninsho_id") == null || "".equals(inMap.get("old_eonetmb_ninsho_id")))
		{
			template.setNull(ECK0021D010CBSMsg.OLD_EONETMB_NINSHO_ID);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OLD_EONETMB_NINSHO_ID, (String)inMap.get("old_eonetmb_ninsho_id"));
		}

		// お客様＜個人＞登録マップ.会員ISP決済状態コード → 会員ISP決済状態コード
		if ("".equals(inMap.get("mmb_isp_kssai_stat_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.MMB_ISP_KSSAI_STAT_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.MMB_ISP_KSSAI_STAT_CD, (String)inMap.get("mmb_isp_kssai_stat_cd"));
		}

		// お客様＜個人＞登録マップ.職業コード → 職業コード
		if ("".equals(inMap.get("shokugyo_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.SHOKUGYO_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SHOKUGYO_CD, (String)inMap.get("shokugyo_cd"));
		}

		// お客様＜個人＞登録マップ.職業その他 → 職業その他
		if ("".equals(inMap.get("shokugyo_other")))
		{
			template.setNull(ECK0021D010CBSMsg.SHOKUGYO_OTHER);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SHOKUGYO_OTHER, (String)inMap.get("shokugyo_other"));
		}

		// お客様＜個人＞登録マップ.勤務先名 → 勤務先名
		if ("".equals(inMap.get("offc_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_NM, (String)inMap.get("offc_nm"));
		}

		// お客様＜個人＞登録マップ.学校名 → 学校名
		if ("".equals(inMap.get("school_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SCHOOL_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SCHOOL_NM, (String)inMap.get("school_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先業種コード → 勤務先業種コード
		if ("".equals(inMap.get("offc_gshu_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_GSHU_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_GSHU_CD, (String)inMap.get("offc_gshu_cd"));
		}

		// お客様＜個人＞登録マップ.勤務先部署名 → 勤務先部署名
		if ("".equals(inMap.get("offc_busho_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_BUSHO_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_BUSHO_NM, (String)inMap.get("offc_busho_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先住所コード → 勤務先住所コード
		if ("".equals(inMap.get("offc_ad_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_AD_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_AD_CD, (String)inMap.get("offc_ad_cd"));
		}

		// お客様＜個人＞登録マップ.勤務先郵便番号 → 勤務先郵便番号
		if ("".equals(inMap.get("offc_pcd")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_PCD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_PCD, (String)inMap.get("offc_pcd"));
		}

		// お客様＜個人＞登録マップ.勤務先都道府県名 → 勤務先都道府県名
		if ("".equals(inMap.get("offc_state_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_STATE_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_STATE_NM, (String)inMap.get("offc_state_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先市区町村名 → 勤務先市区町村名
		if ("".equals(inMap.get("offc_city_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_CITY_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_CITY_NM, (String)inMap.get("offc_city_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先大字通称名 → 勤務先大字通称名
		if ("".equals(inMap.get("offc_oaztsu_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_OAZTSU_NM, (String)inMap.get("offc_oaztsu_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先字丁目名 → 勤務先字丁目名
		if ("".equals(inMap.get("offc_azcho_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_AZCHO_NM, (String)inMap.get("offc_azcho_nm"));
		}

		// お客様＜個人＞登録マップ.勤務先番地号 → 勤務先番地号
		if ("".equals(inMap.get("offc_bnchigo")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_BNCHIGO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_BNCHIGO, (String)inMap.get("offc_bnchigo"));
		}

		// お客様＜個人＞登録マップ.勤務先住所補記・建物名 → 勤務先住所補記・建物名
		if ("".equals(inMap.get("offc_adrttm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_ADRTTM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_ADRTTM, (String)inMap.get("offc_adrttm"));
		}

		// お客様＜個人＞登録マップ.勤務先住所補記・部屋番号 → 勤務先住所補記・部屋番号
		if ("".equals(inMap.get("offc_adrrm")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_ADRRM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_ADRRM, (String)inMap.get("offc_adrrm"));
		}

		// お客様＜個人＞登録マップ.勤務先電話番号 → 勤務先電話番号
		if ("".equals(inMap.get("offc_telno")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_TELNO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_TELNO, (String)inMap.get("offc_telno"));
		}

		// お客様＜個人＞登録マップ.勤務先内線番号 → 勤務先内線番号
		if ("".equals(inMap.get("offc_nisnno")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_NISNNO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_NISNNO, (String)inMap.get("offc_nisnno"));
		}

		// お客様＜個人＞登録マップ.勤務先従業員数（規模） → 勤務先従業員数（規模）
		if ("".equals(inMap.get("offc_worker_cnt_scale")))
		{
			template.setNull(ECK0021D010CBSMsg.OFFC_WORKER_CNT_SCALE);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.OFFC_WORKER_CNT_SCALE, (String)inMap.get("offc_worker_cnt_scale"));
		}

		// お客様＜個人＞登録マップ.お客様年収 → お客様年収
		if ("".equals(inMap.get("cust_salary")))
		{
			template.setNull(ECK0021D010CBSMsg.CUST_SALARY);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.CUST_SALARY, (String)inMap.get("cust_salary"));
		}

		// お客様＜個人＞登録マップ.親権者名 → 親権者名
		if ("".equals(inMap.get("sksha_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_NM, (String)inMap.get("sksha_nm"));
		}

		// お客様＜個人＞登録マップ.親権者カナ名 → 親権者カナ名
		if ("".equals(inMap.get("sksha_kana")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_KANA);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_KANA, (String)inMap.get("sksha_kana"));
		}

		// お客様＜個人＞登録マップ.親権者生年月日 → 親権者生年月日
		if ("".equals(inMap.get("sksha_birthd")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_BIRTHD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_BIRTHD, (String)inMap.get("sksha_birthd"));
		}

		// お客様＜個人＞登録マップ.親権者続柄コード → 親権者続柄コード
		if ("".equals(inMap.get("sksha_zokugara_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_ZOKUGARA_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_ZOKUGARA_CD, (String)inMap.get("sksha_zokugara_cd"));
		}

		// お客様＜個人＞登録マップ.続柄その他 → 続柄その他
		if ("".equals(inMap.get("zokugara_other")))
		{
			template.setNull(ECK0021D010CBSMsg.ZOKUGARA_OTHER);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.ZOKUGARA_OTHER, (String)inMap.get("zokugara_other"));
		}

		// お客様＜個人＞登録マップ.親権者住所コード → 親権者住所コード
		if ("".equals(inMap.get("sksha_ad_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_AD_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_AD_CD, (String)inMap.get("sksha_ad_cd"));
		}

		// お客様＜個人＞登録マップ.親権者郵便番号 → 親権者郵便番号
		if ("".equals(inMap.get("sksha_pcd")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_PCD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_PCD, (String)inMap.get("sksha_pcd"));
		}

		// お客様＜個人＞登録マップ.親権者都道府県名 → 親権者都道府県名
		if ("".equals(inMap.get("sksha_state_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_STATE_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_STATE_NM, (String)inMap.get("sksha_state_nm"));
		}

		// お客様＜個人＞登録マップ.親権者市区町村名 → 親権者市区町村名
		if ("".equals(inMap.get("sksha_city_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_CITY_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_CITY_NM, (String)inMap.get("sksha_city_nm"));
		}

		// お客様＜個人＞登録マップ.親権者大字通称名 → 親権者大字通称名
		if ("".equals(inMap.get("sksha_oaztsu_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_OAZTSU_NM, (String)inMap.get("sksha_oaztsu_nm"));
		}

		// お客様＜個人＞登録マップ.親権者字丁目名 → 親権者字丁目名
		if ("".equals(inMap.get("sksha_azcho_nm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_AZCHO_NM, (String)inMap.get("sksha_azcho_nm"));
		}

		// お客様＜個人＞登録マップ.親権者住所番地号 → 親権者住所番地号
		if ("".equals(inMap.get("sksha_ad_bnchigo")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_AD_BNCHIGO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_AD_BNCHIGO, (String)inMap.get("sksha_ad_bnchigo"));
		}

		// お客様＜個人＞登録マップ.親権者住所補記・建物名 → 親権者住所補記・建物名
		if ("".equals(inMap.get("sksha_adrttm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_ADRTTM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_ADRTTM, (String)inMap.get("sksha_adrttm"));
		}

		// お客様＜個人＞登録マップ.親権者住所補記・部屋番号 → 親権者住所補記・部屋番号
		if ("".equals(inMap.get("sksha_adrrm")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_ADRRM);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_ADRRM, (String)inMap.get("sksha_adrrm"));
		}

		// お客様＜個人＞登録マップ.親権者電話番号 → 親権者電話番号
		if ("".equals(inMap.get("sksha_telno")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_TELNO);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_TELNO, (String)inMap.get("sksha_telno"));
		}

		// お客様<個人>登録.契約者タイプコード → 契約者タイプコード
		if (inMap == null || inMap.get("keisha_type_cd") == null || "".equals(inMap.get("keisha_type_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_TYPE_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_TYPE_CD, (String)inMap.get("keisha_type_cd"));
		}

		// お客様<個人>登録.eoID → eoID
		if (inMap == null || inMap.get("eoid") == null || "".equals(inMap.get("eoid")))
		{
			template.setNull(ECK0021D010CBSMsg.EOID);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.EOID, (String)inMap.get("eoid"));
		}

		// お客様<個人>登録.eoID変更年月日 → eoID変更年月日
		if (inMap == null || inMap.get("eoid_chge_ymd") == null || "".equals(inMap.get("eoid_chge_ymd")))
		{
			template.setNull(ECK0021D010CBSMsg.EOID_CHGE_YMD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.EOID_CHGE_YMD, (String)inMap.get("eoid_chge_ymd"));
		}

		// お客様<個人>登録.契約者住所手動入力フラグ → 契約者住所手動入力フラグ
		if (inMap == null || inMap.get("keisha_ad_man_input_flg") == null || "".equals(inMap.get("keisha_ad_man_input_flg")))
		{
			template.setNull(ECK0021D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG, (String)inMap.get("keisha_ad_man_input_flg"));
		}
		
		// お客様<個人>登録.親権者住所手動入力フラグ → 親権者住所手動入力フラグ
		if (inMap == null || inMap.get("sksha_ad_man_input_flg") == null || "".equals(inMap.get("sksha_ad_man_input_flg")))
		{
			template.setNull(ECK0021D010CBSMsg.SKSHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.SKSHA_AD_MAN_INPUT_FLG, (String)inMap.get("sksha_ad_man_input_flg"));
		}
		
// ANK-3366-00-00 ADD START
		// お客様<個人>登録.卸先事業者コード → 卸先事業者コード
		if (inMap == null || inMap.get("orsjgs_cd") == null || "".equals(inMap.get("orsjgs_cd")))
		{
			template.setNull(ECK0021D010CBSMsg.ORSJGS_CD);
		}
		else
		{
			template.set(ECK0021D010CBSMsg.ORSJGS_CD, (String)inMap.get("orsjgs_cd"));
		}
// ANK-3366-00-00 ADD END
		
		// お客様<個人>登録.契約者住所チェックレベル → 契約者住所チェックレベル
		setTemplate(template, ECK0021D010CBSMsg.KEISHA_AD_CHK_LV, inMap, "", ECK0021D010CBSMsg.KEISHA_AD_CHK_LV);
		// お客様<個人>登録.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル
		setTemplate(template, ECK0021D010CBSMsg.CONT_AD_CHK_LV, inMap, "", ECK0021D010CBSMsg.CONT_AD_CHK_LV);
		// お客様<個人>登録.勤務先住所チェックレベル → 勤務先住所チェックレベル
		setTemplate(template, ECK0021D010CBSMsg.OFFC_AD_CHK_LV, inMap, "", ECK0021D010CBSMsg.OFFC_AD_CHK_LV);
		// お客様<個人>登録.親権者住所チェックレベル → 親権者住所チェックレベル
		setTemplate(template, ECK0021D010CBSMsg.SKSHA_AD_CHK_LV, inMap, "", ECK0021D010CBSMsg.SKSHA_AD_CHK_LV);
		// お客様<個人>登録.関電G個人情報取扱同意有無 → 関電G個人情報取扱同意有無
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM);
		// お客様<個人>登録.関電G個人情報取扱同意年月日 → 関電G個人情報取扱同意年月日
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD);
		// お客様<個人>登録.関電G個人情報提供不可フラグ → 関電G個人情報提供不可フラグ
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_FFG, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_FFG);
		// お客様<個人>登録.関電G個人情報提供不可フラグ変更年月日 → 関電G個人情報提供不可フラグ変更年月日
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD);
		// お客様<個人>登録.関電G個人情報提供不可フラグ変更受付方法コード → 関電G個人情報提供不可フラグ変更受付方法コード
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD);
		// お客様<個人>登録.関電G個人情報提供状況コード → 関電G個人情報提供状況コード
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_JOKYO_CD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_JOKYO_CD);
		// お客様<個人>登録.関電G個人情報提供開始年月日 → 関電G個人情報提供開始年月日
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_STAYMD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_STAYMD);
		// お客様<個人>登録.関電G個人情報提供連携状態コード → 関電G個人情報提供連携状態コード
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_RSCD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_RSCD);
		// お客様<個人>登録.関電G個人情報提供連携状態コード変更年月日 → 関電G個人情報提供連携状態コード変更年月日
		setTemplate(template, ECK0021D010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD, inMap, "", ECK0021D010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD);
		// ANK-4075-00-00 ADD START
		// お客様<個人>登録.スキームタイプコード → スキームタイプコード
		setTemplate(template, ECK0021D010CBSMsg.SCM_TYPE_CD, inMap, "", ECK0021D010CBSMsg.SCM_TYPE_CD);
		// お客様<個人>登録.スキーム事業者コード → スキーム事業者コード
		setTemplate(template, ECK0021D010CBSMsg.SCM_JGS_CD, inMap, "", ECK0021D010CBSMsg.SCM_JGS_CD);
		// ANK-4075-00-00 ADD END
		return template;
	}

	/**
	 * お客様＜個人＞登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0021D010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, String fixedText) throws Exception
	{

		//		CAANMsg template = new CAANMsg(ECK0021D010CBSMsg.class.getName());

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

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

		// 作業領域のマップを取得
		Map workMap = iparam.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			iparam.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)iparam.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			iparam.setData(fixedText, dataMap);
		}

		// お客様＜個人＞登録マップ.ＳＹＳＩＤ ← ＳＹＳＩＤ（出力）
		if (template.isNull(ECK0021D010CBSMsg.SYSID_O))
		{
			dataMap.put("sysid", "");
			workDataMap.put("sysid", "");
		}
		else
		{
			dataMap.put("sysid", template.getString(ECK0021D010CBSMsg.SYSID_O));
			workDataMap.put("sysid", template.getString(ECK0021D010CBSMsg.SYSID_O));
			setSiopsvcKeiWork(iparam, "sysid", template.getString(ECK0021D010CBSMsg.SYSID_O));
			// 契約新規申込ワークエリアへ登録
			JKKBpCommon.setWkSysid(iparam, template.getString(ECK0021D010CBSMsg.SYSID_O));
		}

		// お客様＜個人＞登録マップ.世代登録年月日時分秒（お客様） ← 世代登録年月日時分秒(お客様)
		if (template.isNull(ECK0021D010CBSMsg.CK0011_GENE_ADD_DTM))
		{
			dataMap.put("ck0011_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0011_gene_add_dtm", template.getString(ECK0021D010CBSMsg.CK0011_GENE_ADD_DTM));
		}

		// お客様＜個人＞登録マップ.世代登録年月日時分秒（お客様＜個人＞） ← 世代登録年月日時分秒(お客様<個人>)
		if (template.isNull(ECK0021D010CBSMsg.CK0021_GENE_ADD_DTM))
		{
			dataMap.put("ck0021_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0021_gene_add_dtm", template.getString(ECK0021D010CBSMsg.CK0021_GENE_ADD_DTM));
		}

		// お客様＜個人＞登録マップ.お客様ステータス ← お客様ステータス
		if (template.isNull(ECK0021D010CBSMsg.CUST_STAT))
		{
			dataMap.put("cust_stat", "");
		}
		else
		{
			dataMap.put("cust_stat", template.getString(ECK0021D010CBSMsg.CUST_STAT));
		}

		// お客様＜個人＞登録マップ.登録年月日時分秒 ← 登録年月日時分秒
		if (template.isNull(ECK0021D010CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(ECK0021D010CBSMsg.ADD_DTM));
		}

		// お客様＜個人＞登録マップ.登録オペレータアカウント ← 登録オペレータアカウント
		if (template.isNull(ECK0021D010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(ECK0021D010CBSMsg.ADD_OPEACNT));
		}

		// お客様＜個人＞登録マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(ECK0021D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(ECK0021D010CBSMsg.UPD_DTM));
			workDataMap.put("upd_dtm", template.getString(ECK0021D010CBSMsg.UPD_DTM));
		}

		// お客様＜個人＞登録マップ.更新オペレータアカウント ← 更新オペレータアカウント
		if (template.isNull(ECK0021D010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(ECK0021D010CBSMsg.UPD_OPEACNT));
		}

		// お客様＜個人＞登録マップ.無効フラグ ← 無効フラグ
		if (template.isNull(ECK0021D010CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(ECK0021D010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0021D010(iparam, 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 リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECK0021D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0021D010CBSMsg.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(fixedText);

		// お客様＜個人＞登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(ECK0021D010CBSMsg.SYSID_ERR));
			}
		}

		// お客様＜個人＞登録マップ.お客様名 → お客様名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey("cust_nm_err"))
			{
				inMap.put("cust_nm_err", template.getString(ECK0021D010CBSMsg.CUST_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様カナ名 → お客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey("cust_kana_err"))
			{
				inMap.put("cust_kana_err", template.getString(ECK0021D010CBSMsg.CUST_KANA_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様性別コード → お客様性別コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("cust_sex_cd_err"))
			{
				inMap.put("cust_sex_cd_err", template.getString(ECK0021D010CBSMsg.CUST_SEX_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様生年月日 → お客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("cust_birthd_err"))
			{
				inMap.put("cust_birthd_err", template.getString(ECK0021D010CBSMsg.CUST_BIRTHD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.氏名敬称 → 氏名敬称 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NM_KISHO_ERR))
		{
			if (!inMap.containsKey("nm_kisho_err"))
			{
				inMap.put("nm_kisho_err", template.getString(ECK0021D010CBSMsg.NM_KISHO_ERR));
			}
		}

		// お客様＜個人＞登録.お客様確認備考 → お客様確認備考 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_CFM_BIKO_ERR))
		{
			if (!inMap.containsKey("cust_cfm_biko_err"))
			{
				inMap.put("cust_cfm_biko_err", template.getString(ECK0021D010CBSMsg.CUST_CFM_BIKO_ERR));
			}
		}

		// お客様＜個人＞登録マップ.契約者住所コード → 契約者住所コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("keisha_ad_cd_err"))
			{
				inMap.put("keisha_ad_cd_err", template.getString(ECK0021D010CBSMsg.KEISHA_AD_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者郵便番号 → 契約者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_PCD_ERR))
		{
			if (!inMap.containsKey("keisha_pcd_err"))
			{
				inMap.put("keisha_pcd_err", template.getString(ECK0021D010CBSMsg.KEISHA_PCD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者都道府県名 → 契約者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("keisha_state_nm_err"))
			{
				inMap.put("keisha_state_nm_err", template.getString(ECK0021D010CBSMsg.KEISHA_STATE_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者市区町村名 → 契約者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("keisha_city_nm_err"))
			{
				inMap.put("keisha_city_nm_err", template.getString(ECK0021D010CBSMsg.KEISHA_CITY_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者大字通称名 → 契約者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("keisha_oaztsu_nm_err"))
			{
				inMap.put("keisha_oaztsu_nm_err", template.getString(ECK0021D010CBSMsg.KEISHA_OAZTSU_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者字丁目名 → 契約者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("keisha_azcho_nm_err"))
			{
				inMap.put("keisha_azcho_nm_err", template.getString(ECK0021D010CBSMsg.KEISHA_AZCHO_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者番地号 → 契約者番地号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("keisha_bnchigo_err"))
			{
				inMap.put("keisha_bnchigo_err", template.getString(ECK0021D010CBSMsg.KEISHA_BNCHIGO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者住所補記・建物名 → 契約者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("keisha_adrttm_err"))
			{
				inMap.put("keisha_adrttm_err", template.getString(ECK0021D010CBSMsg.KEISHA_ADRTTM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("keisha_adrrm_err"))
			{
				inMap.put("keisha_adrrm_err", template.getString(ECK0021D010CBSMsg.KEISHA_ADRRM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.契約者電話番号 → 契約者電話番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_TELNO_ERR))
		{
			if (!inMap.containsKey("keisha_telno_err"))
			{
				inMap.put("keisha_telno_err", template.getString(ECK0021D010CBSMsg.KEISHA_TELNO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様ランクコード → お客様ランクコード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_RANK_CD_ERR))
		{
			if (!inMap.containsKey("cust_rank_cd_err"))
			{
				inMap.put("cust_rank_cd_err", template.getString(ECK0021D010CBSMsg.CUST_RANK_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.連絡手段コード → 連絡手段コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_rrk_way_cd_err"))
			{
				inMap.put("ck0021_rrk_way_cd_err", template.getString(ECK0021D010CBSMsg.RRK_WAY_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.連絡手段補記 → 連絡手段補記 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.RRK_WAY_HOKI_ERR))
		{
			if (!inMap.containsKey("rrk_way_hoki_err"))
			{
				inMap.put("rrk_way_hoki_err", template.getString(ECK0021D010CBSMsg.RRK_WAY_HOKI_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツお客様名 → コンテンツお客様名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_CUST_NM_ERR))
		{
			if (!inMap.containsKey("cont_cust_nm_err"))
			{
				inMap.put("cont_cust_nm_err", template.getString(ECK0021D010CBSMsg.CONT_CUST_NM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツお客様カナ名 → コンテンツお客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_CUST_KANA_ERR))
		{
			if (!inMap.containsKey("cont_cust_kana_err"))
			{
				inMap.put("cont_cust_kana_err", template.getString(ECK0021D010CBSMsg.CONT_CUST_KANA_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツお客様性別コード → コンテンツお客様性別コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("cont_cust_sex_cd_err"))
			{
				inMap.put("cont_cust_sex_cd_err", template.getString(ECK0021D010CBSMsg.CONT_CUST_SEX_CD_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツお客様生年月日 → コンテンツお客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("cont_cust_birthd_err"))
			{
				inMap.put("cont_cust_birthd_err", template.getString(ECK0021D010CBSMsg.CONT_CUST_BIRTHD_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ住所コード → コンテンツ住所コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_AD_CD_ERR))
		{
			if (!inMap.containsKey("cont_ad_cd_err"))
			{
				inMap.put("cont_ad_cd_err", template.getString(ECK0021D010CBSMsg.CONT_AD_CD_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ郵便番号 → コンテンツ郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_PCD_ERR))
		{
			if (!inMap.containsKey("cont_pcd_err"))
			{
				inMap.put("cont_pcd_err", template.getString(ECK0021D010CBSMsg.CONT_PCD_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ都道府県名 → コンテンツ都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_STATE_NM_ERR))
		{
			if (!inMap.containsKey("cont_state_nm_err"))
			{
				inMap.put("cont_state_nm_err", template.getString(ECK0021D010CBSMsg.CONT_STATE_NM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ市区町村名 → コンテンツ市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_CITY_NM_ERR))
		{
			if (!inMap.containsKey("cont_city_nm_err"))
			{
				inMap.put("cont_city_nm_err", template.getString(ECK0021D010CBSMsg.CONT_CITY_NM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ大字通称名 → コンテンツ大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("cont_oaztsu_nm_err"))
			{
				inMap.put("cont_oaztsu_nm_err", template.getString(ECK0021D010CBSMsg.CONT_OAZTSU_NM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ字丁目名 → コンテンツ字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("cont_azcho_nm_err"))
			{
				inMap.put("cont_azcho_nm_err", template.getString(ECK0021D010CBSMsg.CONT_AZCHO_NM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ番地号 → コンテンツ番地号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("cont_bnchigo_err"))
			{
				inMap.put("cont_bnchigo_err", template.getString(ECK0021D010CBSMsg.CONT_BNCHIGO_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_ADRTTM_ERR))
		{
			if (!inMap.containsKey("cont_adrttm_err"))
			{
				inMap.put("cont_adrttm_err", template.getString(ECK0021D010CBSMsg.CONT_ADRTTM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_ADRRM_ERR))
		{
			if (!inMap.containsKey("cont_adrrm_err"))
			{
				inMap.put("cont_adrrm_err", template.getString(ECK0021D010CBSMsg.CONT_ADRRM_ERR));
			}
		}

		// お客様＜個人＞登録.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_AD_BNKT_STA_PST_ERR))
		{
			if (!inMap.containsKey("cont_ad_bnkt_sta_pst_err"))
			{
				inMap.put("cont_ad_bnkt_sta_pst_err", template.getString(ECK0021D010CBSMsg.CONT_AD_BNKT_STA_PST_ERR));
			}
		}
		
		// お客様＜個人＞登録マップ.会員種別コード → 会員種別コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.MEMBER_SBT_CD_ERR))
		{
			if (!inMap.containsKey("member_sbt_cd_err"))
			{
				inMap.put("member_sbt_cd_err", template.getString(ECK0021D010CBSMsg.MEMBER_SBT_CD_ERR));
			}
		}

		// お客様＜個人＞登録マップ.コンテンツＩＳＰ利用不可フラグ → コンテンツＩＳＰ利用不可フラグ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_ISP_USE_FAIL_FLG_ERR))
		{
			if (!inMap.containsKey("cont_isp_use_fail_flg_err"))
			{
				inMap.put("cont_isp_use_fail_flg_err", template.getString(ECK0021D010CBSMsg.CONT_ISP_USE_FAIL_FLG_ERR));
			}
		}

		// お客様＜個人＞登録マップ.コンテンツＩＳＰ利用停止年月日 → コンテンツＩＳＰ利用停止年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CONT_ISP_USE_STP_YMD_ERR))
		{
			if (!inMap.containsKey("cont_isp_use_stp_ymd_err"))
			{
				inMap.put("cont_isp_use_stp_ymd_err", template.getString(ECK0021D010CBSMsg.CONT_ISP_USE_STP_YMD_ERR));
			}
		}

		// お客様＜個人＞登録マップ.入会年月日 → 入会年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.JOIN_YMD_ERR))
		{
			if (!inMap.containsKey("join_ymd_err"))
			{
				inMap.put("join_ymd_err", template.getString(ECK0021D010CBSMsg.JOIN_YMD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.パスワードリマインダ用質問コード → パスワードリマインダ用質問コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.PWD_REMINDER_QS_CD_ERR))
		{
			if (!inMap.containsKey("pwd_reminder_qs_cd_err"))
			{
				inMap.put("pwd_reminder_qs_cd_err", template.getString(ECK0021D010CBSMsg.PWD_REMINDER_QS_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.パスワードリマインダ用回答 → パスワードリマインダ用回答 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.PWD_REMINDER_ANS_ERR))
		{
			if (!inMap.containsKey("pwd_reminder_ans_err"))
			{
				inMap.put("pwd_reminder_ans_err", template.getString(ECK0021D010CBSMsg.PWD_REMINDER_ANS_ERR));
			}
		}
		// お客様＜個人＞登録マップ.ニックネーム → ニックネーム のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NKNAME_ERR))
		{
			if (!inMap.containsKey("nkname_err"))
			{
				inMap.put("nkname_err", template.getString(ECK0021D010CBSMsg.NKNAME_ERR));
			}
		}

		// お客様＜個人＞登録マップ.ニックネーム変更年月日 → ニックネーム変更年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NKNAME_CHGE_YMD_ERR))
		{
			if (!inMap.containsKey("nkname_chge_ymd_err"))
			{
				inMap.put("nkname_chge_ymd_err", template.getString(ECK0021D010CBSMsg.NKNAME_CHGE_YMD_ERR));
			}
		}

		// お客様＜個人＞登録マップ.内販外販コード → 内販外販コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NAIHAN_GAIHAN_CD_ERR))
		{
			if (!inMap.containsKey("naihan_gaihan_cd_err"))
			{
				inMap.put("naihan_gaihan_cd_err", template.getString(ECK0021D010CBSMsg.NAIHAN_GAIHAN_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.内販企業識別コード → 内販企業識別コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("naihan_comp_skbt_cd_err"))
			{
				inMap.put("naihan_comp_skbt_cd_err", template.getString(ECK0021D010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.要補助コード → 要補助コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NECESSARY_HOJO_CD_ERR))
		{
			if (!inMap.containsKey("necessary_hojo_cd_err"))
			{
				inMap.put("necessary_hojo_cd_err", template.getString(ECK0021D010CBSMsg.NECESSARY_HOJO_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.ｅｏｎｅｔＩＤ未移行フラグ → ｅｏｎｅｔＩＤ未移行フラグ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.EONETID_MI_IKO_FLG_ERR))
		{
			if (!inMap.containsKey("eonetid_mi_iko_flg_err"))
			{
				inMap.put("eonetid_mi_iko_flg_err", template.getString(ECK0021D010CBSMsg.EONETID_MI_IKO_FLG_ERR));
			}
		}
		// お客様＜個人＞登録マップ.ログイン認証可否 → ログイン認証可否 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.LOGIN_NINSHO_KH_ERR))
		{
			if (!inMap.containsKey("login_ninsho_kh_err"))
			{
				inMap.put("login_ninsho_kh_err", template.getString(ECK0021D010CBSMsg.LOGIN_NINSHO_KH_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様特記事項コード → お客様特記事項コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_TKJK_CD_ERR))
		{
			if (!inMap.containsKey("cust_tkjk_cd_err"))
			{
				inMap.put("cust_tkjk_cd_err", template.getString(ECK0021D010CBSMsg.CUST_TKJK_CD_ERR));
			}
		}

		// お客様＜個人＞登録マップ.お客様入退会コード → お客様入退会コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_NTAIKAI_CD_ERR))
		{
			if (!inMap.containsKey("cust_ntaikai_cd_err"))
			{
				inMap.put("cust_ntaikai_cd_err", template.getString(ECK0021D010CBSMsg.CUST_NTAIKAI_CD_ERR));
			}
		}

		// お客様＜個人＞登録マップ.会員種別特定フラグ → 会員種別特定フラグ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.MMB_SBT_TOKUT_FLG_ERR))
		{
			if (!inMap.containsKey("mmb_sbt_tokut_flg_err"))
			{
				inMap.put("mmb_sbt_tokut_flg_err", template.getString(ECK0021D010CBSMsg.MMB_SBT_TOKUT_FLG_ERR));
			}
		}
		// お客様＜個人＞登録マップ.名寄せ先ＳＹＳＩＤ → 名寄せ先ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.NAYOSE_SAKI_SYSID_ERR))
		{
			if (!inMap.containsKey("nayose_saki_sysid_err"))
			{
				inMap.put("nayose_saki_sysid_err", template.getString(ECK0021D010CBSMsg.NAYOSE_SAKI_SYSID_ERR));
			}
		}
		// お客様＜個人＞登録マップ.ｅｏＩＤ通知書発行実績コード → ｅｏＩＤ通知書発行実績コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD_ERR))
		{
			if (!inMap.containsKey("eoid_tchisho_hakkojski_cd_err"))
			{
				inMap.put("eoid_tchisho_hakkojski_cd_err", template.getString(ECK0021D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD_ERR));
			}
		}

		// お客様＜個人＞登録.旧eonet会員認証用ID → 旧eonet会員認証用ID のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("old_eonetmb_ninsho_id_err"))
			{
				inMap.put("old_eonetmb_ninsho_id_err", template.getString(ECK0021D010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR));
			}
		}

		// お客様＜個人＞登録.会員ISP決済状態コード → 会員ISP決済状態コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.MMB_ISP_KSSAI_STAT_CD))
		{
			if (!inMap.containsKey("mmb_isp_kssai_stat_cd"))
			{
				inMap.put("mmb_isp_kssai_stat_cd", template.getString(ECK0021D010CBSMsg.MMB_ISP_KSSAI_STAT_CD));
			}
		}

		// お客様＜個人＞登録マップ.職業コード → 職業コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SHOKUGYO_CD_ERR))
		{
			if (!inMap.containsKey("shokugyo_cd_err"))
			{
				inMap.put("shokugyo_cd_err", template.getString(ECK0021D010CBSMsg.SHOKUGYO_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.職業コード → 職業コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SHOKUGYO_OTHER_ERR))
		{
			if (!inMap.containsKey("shokugyo_other_err"))
			{
				inMap.put("shokugyo_other_err", template.getString(ECK0021D010CBSMsg.SHOKUGYO_OTHER_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先名 → 勤務先名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_NM_ERR))
		{
			if (!inMap.containsKey("offc_nm_err"))
			{
				inMap.put("offc_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.学校名 → 学校名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SCHOOL_NM_ERR))
		{
			if (!inMap.containsKey("school_nm_err"))
			{
				inMap.put("school_nm_err", template.getString(ECK0021D010CBSMsg.SCHOOL_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先業種コード → 勤務先業種コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_GSHU_CD_ERR))
		{
			if (!inMap.containsKey("offc_gshu_cd_err"))
			{
				inMap.put("offc_gshu_cd_err", template.getString(ECK0021D010CBSMsg.OFFC_GSHU_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先部署名 → 勤務先部署名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_BUSHO_NM_ERR))
		{
			if (!inMap.containsKey("offc_busho_nm_err"))
			{
				inMap.put("offc_busho_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_BUSHO_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先住所コード → 勤務先住所コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_AD_CD_ERR))
		{
			if (!inMap.containsKey("offc_ad_cd_err"))
			{
				inMap.put("offc_ad_cd_err", template.getString(ECK0021D010CBSMsg.OFFC_AD_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先郵便番号 → 勤務先郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_PCD_ERR))
		{
			if (!inMap.containsKey("offc_pcd_err"))
			{
				inMap.put("offc_pcd_err", template.getString(ECK0021D010CBSMsg.OFFC_PCD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先都道府県名 → 勤務先都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_STATE_NM_ERR))
		{
			if (!inMap.containsKey("offc_state_nm_err"))
			{
				inMap.put("offc_state_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_STATE_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先市区町村名 → 勤務先市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_CITY_NM_ERR))
		{
			if (!inMap.containsKey("offc_city_nm_err"))
			{
				inMap.put("offc_city_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_CITY_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先大字通称名 → 勤務先大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("offc_oaztsu_nm_err"))
			{
				inMap.put("offc_oaztsu_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_OAZTSU_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先字丁目名 → 勤務先字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("offc_azcho_nm_err"))
			{
				inMap.put("offc_azcho_nm_err", template.getString(ECK0021D010CBSMsg.OFFC_AZCHO_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先番地号 → 勤務先番地号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("offc_bnchigo_err"))
			{
				inMap.put("offc_bnchigo_err", template.getString(ECK0021D010CBSMsg.OFFC_BNCHIGO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先住所補記・建物名 → 勤務先住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_ADRTTM_ERR))
		{
			if (!inMap.containsKey("offc_adrttm_err"))
			{
				inMap.put("offc_adrttm_err", template.getString(ECK0021D010CBSMsg.OFFC_ADRTTM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先住所補記・部屋番号 → 勤務先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_ADRRM_ERR))
		{
			if (!inMap.containsKey("offc_adrrm_err"))
			{
				inMap.put("offc_adrrm_err", template.getString(ECK0021D010CBSMsg.OFFC_ADRRM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先電話番号 → 勤務先電話番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_TELNO_ERR))
		{
			if (!inMap.containsKey("offc_telno_err"))
			{
				inMap.put("offc_telno_err", template.getString(ECK0021D010CBSMsg.OFFC_TELNO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先内線番号 → 勤務先内線番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_NISNNO_ERR))
		{
			if (!inMap.containsKey("offc_nisnno_err"))
			{
				inMap.put("offc_nisnno_err", template.getString(ECK0021D010CBSMsg.OFFC_NISNNO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.勤務先従業員数（規模） → 勤務先従業員数（規模） のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.OFFC_WORKER_CNT_SCALE_ERR))
		{
			if (!inMap.containsKey("offc_worker_cnt_scale_err"))
			{
				inMap.put("offc_worker_cnt_scale_err", template.getString(ECK0021D010CBSMsg.OFFC_WORKER_CNT_SCALE_ERR));
			}
		}
		// お客様＜個人＞登録マップ.お客様年収 → お客様年収 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.CUST_SALARY_ERR))
		{
			if (!inMap.containsKey("cust_salary_err"))
			{
				inMap.put("cust_salary_err", template.getString(ECK0021D010CBSMsg.CUST_SALARY_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者名 → 親権者名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_NM_ERR))
		{
			if (!inMap.containsKey("sksha_nm_err"))
			{
				inMap.put("sksha_nm_err", template.getString(ECK0021D010CBSMsg.SKSHA_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者カナ名 → 親権者カナ名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_KANA_ERR))
		{
			if (!inMap.containsKey("sksha_kana_err"))
			{
				inMap.put("sksha_kana_err", template.getString(ECK0021D010CBSMsg.SKSHA_KANA_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者生年月日 → 親権者生年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_BIRTHD_ERR))
		{
			if (!inMap.containsKey("sksha_birthd_err"))
			{
				inMap.put("sksha_birthd_err", template.getString(ECK0021D010CBSMsg.SKSHA_BIRTHD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者続柄コード → 親権者続柄コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_ZOKUGARA_CD_ERR))
		{
			if (!inMap.containsKey("sksha_zokugara_cd_err"))
			{
				inMap.put("sksha_zokugara_cd_err", template.getString(ECK0021D010CBSMsg.SKSHA_ZOKUGARA_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.続柄その他 → 続柄その他 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.ZOKUGARA_OTHER_ERR))
		{
			if (!inMap.containsKey("zokugara_other_err"))
			{
				inMap.put("zokugara_other_err", template.getString(ECK0021D010CBSMsg.ZOKUGARA_OTHER_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者住所コード → 親権者住所コード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("sksha_ad_cd_err"))
			{
				inMap.put("sksha_ad_cd_err", template.getString(ECK0021D010CBSMsg.SKSHA_AD_CD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者郵便番号 → 親権者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_PCD_ERR))
		{
			if (!inMap.containsKey("sksha_pcd_err"))
			{
				inMap.put("sksha_pcd_err", template.getString(ECK0021D010CBSMsg.SKSHA_PCD_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者都道府県名 → 親権者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("sksha_state_nm_err"))
			{
				inMap.put("sksha_state_nm_err", template.getString(ECK0021D010CBSMsg.SKSHA_STATE_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者市区町村名 → 親権者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("sksha_city_nm_err"))
			{
				inMap.put("sksha_city_nm_err", template.getString(ECK0021D010CBSMsg.SKSHA_CITY_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者大字通称名 → 親権者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("sksha_oaztsu_nm_err"))
			{
				inMap.put("sksha_oaztsu_nm_err", template.getString(ECK0021D010CBSMsg.SKSHA_OAZTSU_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者字丁目名 → 親権者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("sksha_azcho_nm_err"))
			{
				inMap.put("sksha_azcho_nm_err", template.getString(ECK0021D010CBSMsg.SKSHA_AZCHO_NM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者住所番地号 → 親権者住所番地号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_AD_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("sksha_ad_bnchigo_err"))
			{
				inMap.put("sksha_ad_bnchigo_err", template.getString(ECK0021D010CBSMsg.SKSHA_AD_BNCHIGO_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者住所補記・建物名 → 親権者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("sksha_adrttm_err"))
			{
				inMap.put("sksha_adrttm_err", template.getString(ECK0021D010CBSMsg.SKSHA_ADRTTM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者住所補記・部屋番号 → 親権者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("sksha_adrrm_err"))
			{
				inMap.put("sksha_adrrm_err", template.getString(ECK0021D010CBSMsg.SKSHA_ADRRM_ERR));
			}
		}
		// お客様＜個人＞登録マップ.親権者電話番号 → 親権者電話番号 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_TELNO_ERR))
		{
			if (!inMap.containsKey("sksha_telno_err"))
			{
				inMap.put("sksha_telno_err", template.getString(ECK0021D010CBSMsg.SKSHA_TELNO_ERR));
			}
		}

		// お客様<個人>登録.契約者タイプコード → 契約者タイプコード のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_TYPE_CD_ERR))
		{
			if (!inMap.containsKey("keisha_type_cd_err"))
			{
				inMap.put("keisha_type_cd_err", template.getString(ECK0021D010CBSMsg.KEISHA_TYPE_CD_ERR));
			}
		}

		// お客様<個人>登録.eoID → eoID のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.EOID_ERR))
		{
			if (!inMap.containsKey("eoid_err"))
			{
				inMap.put("eoid_err", template.getString(ECK0021D010CBSMsg.EOID_ERR));
			}
		}

		// お客様<個人>登録.eoID変更年月日 → eoID変更年月日 のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.EOID_CHGE_YMD_ERR))
		{
			if (!inMap.containsKey("eoid_chge_ymd_err"))
			{
				inMap.put("eoid_chge_ymd_err", template.getString(ECK0021D010CBSMsg.EOID_CHGE_YMD_ERR));
			}
		}

		// お客様<個人>登録.契約者住所手動入力フラグ → 契約者住所手動入力フラグ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("keisha_ad_man_input_flg_err"))
			{
				inMap.put("keisha_ad_man_input_flg_err", template.getString(ECK0021D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR));
			}
		}

		// お客様<個人>登録.親権者住所手動入力フラグ → 親権者住所手動入力フラグ のエラー情報返却
		if (!template.isNull(ECK0021D010CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("sksha_ad_man_input_flg_err"))
			{
				inMap.put("sksha_ad_man_input_flg_err", template.getString(ECK0021D010CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR));
			}
		}
		
		//お客様<個人>登録.契約者住所チェックレベル → 契約者住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "", ECK0021D010CBSMsg.KEISHA_AD_CHK_LV_ERR, template, ECK0021D010CBSMsg.KEISHA_AD_CHK_LV_ERR);
		//お客様<個人>登録.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "", ECK0021D010CBSMsg.CONT_AD_CHK_LV_ERR, template, ECK0021D010CBSMsg.CONT_AD_CHK_LV_ERR);
		//お客様<個人>登録.勤務先住所チェックレベル → 勤務先住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "", ECK0021D010CBSMsg.OFFC_AD_CHK_LV_ERR, template, ECK0021D010CBSMsg.OFFC_AD_CHK_LV_ERR);
		//お客様<個人>登録.親権者住所チェックレベル → 親権者住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "", ECK0021D010CBSMsg.SKSHA_AD_CHK_LV_ERR, template, ECK0021D010CBSMsg.SKSHA_AD_CHK_LV_ERR);

		return param;
	}

	/**
	 * お客様＜法人＞登録用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0031D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

		CAANMsg template = new CAANMsg(ECK0031D010CBSMsg.class.getName());
		CAANMsg[] templateArray = null;

		ArrayList inList = null;

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

		// 機能コード（デフォルト：１）
		template.set(ECK0031D010CBSMsg.FUNC_CODE, "1");

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

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

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

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

		// 機能コード
		template.set(ECK0031D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		
		// お客様＜法人＞登録マップ.契約者タイプコード → 契約者タイプコード
		if (inMap == null || inMap.get("keisha_type_cd") == null || "".equals(inMap.get("keisha_type_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_TYPE_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_TYPE_CD, (String)inMap.get("keisha_type_cd"));
		}
		
		// お客様＜法人＞登録マップ.お客様名 → お客様名
		if ("".equals(inMap.get("cust_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_NM, (String)inMap.get("cust_nm"));
		}

		// お客様＜法人＞登録マップ.お客様カナ名 → お客様カナ名
		if ("".equals(inMap.get("cust_kana")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_KANA);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_KANA, (String)inMap.get("cust_kana"));
		}

		// お客様＜法人＞登録マップ.お客様性別コード → お客様性別コード
		if ("".equals(inMap.get("cust_sex_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_SEX_CD, (String)inMap.get("cust_sex_cd"));
		}

		// お客様＜法人＞登録マップ.お客様生年月日 → お客様生年月日
		if ("".equals(inMap.get("cust_birthd")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_BIRTHD, (String)inMap.get("cust_birthd"));
		}

		// お客様＜法人＞登録マップ.氏名敬称 → 氏名敬称
		if ("".equals(inMap.get("nm_kisho")))
		{
			template.setNull(ECK0031D010CBSMsg.NM_KISHO);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NM_KISHO, (String)inMap.get("nm_kisho"));
		}

		// お客様＜法人＞登録.お客様確認備考 → お客様確認備考
		if (inMap == null || inMap.get("cust_cfm_biko") == null || "".equals(inMap.get("cust_cfm_biko")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_CFM_BIKO);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_CFM_BIKO, (String)inMap.get("cust_cfm_biko"));
		}

		// お客様＜法人＞登録マップ.契約者住所コード → 契約者住所コード
		if ("".equals(inMap.get("keisha_ad_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_AD_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_AD_CD, (String)inMap.get("keisha_ad_cd"));
		}

		// お客様＜法人＞登録マップ.契約者郵便番号 → 契約者郵便番号
		if ("".equals(inMap.get("keisha_pcd")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_PCD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_PCD, (String)inMap.get("keisha_pcd"));
		}

		// お客様＜法人＞登録マップ.契約者都道府県名 → 契約者都道府県名
		if ("".equals(inMap.get("keisha_state_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_STATE_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_STATE_NM, (String)inMap.get("keisha_state_nm"));
		}

		// お客様＜法人＞登録マップ.契約者市区町村名 → 契約者市区町村名
		if ("".equals(inMap.get("keisha_city_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_CITY_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_CITY_NM, (String)inMap.get("keisha_city_nm"));
		}

		// お客様＜法人＞登録マップ.契約者大字通称名 → 契約者大字通称名
		if ("".equals(inMap.get("keisha_oaztsu_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_OAZTSU_NM, (String)inMap.get("keisha_oaztsu_nm"));
		}

		// お客様＜法人＞登録マップ.契約者字丁目名 → 契約者字丁目名
		if ("".equals(inMap.get("keisha_azcho_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_AZCHO_NM, (String)inMap.get("keisha_azcho_nm"));
		}

		// お客様＜法人＞登録マップ.契約者番地号 → 契約者番地号
		if ("".equals(inMap.get("keisha_bnchigo")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_BNCHIGO);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_BNCHIGO, (String)inMap.get("keisha_bnchigo"));
		}

		// お客様＜法人＞登録マップ.契約者住所補記・建物名 → 契約者住所補記・建物名
		if ("".equals(inMap.get("keisha_adrttm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_ADRTTM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_ADRTTM, (String)inMap.get("keisha_adrttm"));
		}

		// お客様＜法人＞登録マップ.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号
		if ("".equals(inMap.get("keisha_adrrm")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_ADRRM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_ADRRM, (String)inMap.get("keisha_adrrm"));
		}

		// お客様＜法人＞登録マップ.契約者電話番号 → 契約者電話番号
		if ("".equals(inMap.get("keisha_telno")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_TELNO);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_TELNO, (String)inMap.get("keisha_telno"));
		}

		// お客様＜法人＞登録マップ.お客様ランクコード → お客様ランクコード
		if ("".equals(inMap.get("cust_rank_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_RANK_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_RANK_CD, (String)inMap.get("cust_rank_cd"));
		}

		// お客様＜法人＞登録マップ.連絡手段コード → 連絡手段コード
		if ("".equals(inMap.get("ck0031_rrk_way_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.RRK_WAY_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.RRK_WAY_CD, (String)inMap.get("ck0031_rrk_way_cd"));
		}

		// お客様＜法人＞登録マップ.連絡手段補記 → 連絡手段補記
		if ("".equals(inMap.get("rrk_way_hoki")))
		{
			template.setNull(ECK0031D010CBSMsg.RRK_WAY_HOKI);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.RRK_WAY_HOKI, (String)inMap.get("rrk_way_hoki"));
		}
		
		// お客様＜法人＞登録.eoID → eoID
		if ("".equals(inMap.get("eoid")))
		{
			template.setNull(ECK0031D010CBSMsg.EOID);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.EOID, (String)inMap.get("eoid"));
		}


		// お客様＜法人＞登録.コンテンツお客様名 → コンテンツお客様名
		if (inMap == null || inMap.get("cont_cust_nm") == null || "".equals(inMap.get("cont_cust_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_CUST_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_CUST_NM, (String)inMap.get("cont_cust_nm"));
		}

		// お客様＜法人＞登録.コンテンツお客様カナ名 → コンテンツお客様カナ名
		if (inMap == null || inMap.get("cont_cust_kana") == null || "".equals(inMap.get("cont_cust_kana")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_CUST_KANA);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_CUST_KANA, (String)inMap.get("cont_cust_kana"));
		}

		// お客様＜法人＞登録.コンテンツお客様性別コード → コンテンツお客様性別コード
		if (inMap == null || inMap.get("cont_cust_sex_cd") == null || "".equals(inMap.get("cont_cust_sex_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_CUST_SEX_CD, (String)inMap.get("cont_cust_sex_cd"));
		}

		// お客様＜法人＞登録.コンテンツお客様生年月日 → コンテンツお客様生年月日
		if (inMap == null || inMap.get("cont_cust_birthd") == null || "".equals(inMap.get("cont_cust_birthd")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_CUST_BIRTHD, (String)inMap.get("cont_cust_birthd"));
		}

		// お客様＜法人＞登録.コンテンツ住所コード → コンテンツ住所コード
		if (inMap == null || inMap.get("cont_ad_cd") == null || "".equals(inMap.get("cont_ad_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_AD_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_AD_CD, (String)inMap.get("cont_ad_cd"));
		}

		// お客様＜法人＞登録.コンテンツ郵便番号 → コンテンツ郵便番号
		if (inMap == null || inMap.get("cont_pcd") == null || "".equals(inMap.get("cont_pcd")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_PCD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_PCD, (String)inMap.get("cont_pcd"));
		}

		// お客様＜法人＞登録.コンテンツ都道府県名 → コンテンツ都道府県名
		if (inMap == null || inMap.get("cont_state_nm") == null || "".equals(inMap.get("cont_state_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_STATE_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_STATE_NM, (String)inMap.get("cont_state_nm"));
		}

		// お客様＜法人＞登録.コンテンツ市区町村名 → コンテンツ市区町村名
		if (inMap == null || inMap.get("cont_city_nm") == null || "".equals(inMap.get("cont_city_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_CITY_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_CITY_NM, (String)inMap.get("cont_city_nm"));
		}

		// お客様＜法人＞登録.コンテンツ大字通称名 → コンテンツ大字通称名
		if (inMap == null || inMap.get("cont_oaztsu_nm") == null || "".equals(inMap.get("cont_oaztsu_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_OAZTSU_NM, (String)inMap.get("cont_oaztsu_nm"));
		}

		// お客様＜法人＞登録.コンテンツ字丁目名 → コンテンツ字丁目名
		if (inMap == null || inMap.get("cont_azcho_nm") == null || "".equals(inMap.get("cont_azcho_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_AZCHO_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_AZCHO_NM, (String)inMap.get("cont_azcho_nm"));
		}

		// お客様＜法人＞登録.コンテンツ番地号 → コンテンツ番地号
		if (inMap == null || inMap.get("cont_bnchigo") == null || "".equals(inMap.get("cont_bnchigo")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_BNCHIGO);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_BNCHIGO, (String)inMap.get("cont_bnchigo"));
		}

		// お客様＜法人＞登録.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名
		if (inMap == null || inMap.get("cont_adrttm") == null || "".equals(inMap.get("cont_adrttm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_ADRTTM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_ADRTTM, (String)inMap.get("cont_adrttm"));
		}

		// お客様＜法人＞登録.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号
		if (inMap == null || inMap.get("cont_adrrm") == null || "".equals(inMap.get("cont_adrrm")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_ADRRM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_ADRRM, (String)inMap.get("cont_adrrm"));
		}

		// お客様＜法人＞登録.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置
		if (inMap == null || inMap.get("cont_ad_bnkt_sta_pst") == null || "".equals(inMap.get("cont_ad_bnkt_sta_pst")))
		{
			template.setNull(ECK0031D010CBSMsg.CONT_AD_BNKT_STA_PST);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CONT_AD_BNKT_STA_PST, (String)inMap.get("cont_ad_bnkt_sta_pst"));
		}

		// お客様＜法人＞登録マップ.会員種別コード → 会員種別コード
		if ("".equals(inMap.get("member_sbt_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.MEMBER_SBT_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.MEMBER_SBT_CD, (String)inMap.get("member_sbt_cd"));
		}

		// お客様＜法人＞登録マップ.入会年月日 → 入会年月日
		if ("".equals(inMap.get("join_ymd")))
		{
			template.setNull(ECK0031D010CBSMsg.JOIN_YMD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.JOIN_YMD, (String)inMap.get("join_ymd"));
		}

		// お客様＜法人＞登録マップ.パスワードリマインダ用質問コード → パスワードリマインダ用質問コード
		if ("".equals(inMap.get("pwd_reminder_qs_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.PWD_REMINDER_QS_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.PWD_REMINDER_QS_CD, (String)inMap.get("pwd_reminder_qs_cd"));
		}

		// お客様＜法人＞登録マップ.パスワードリマインダ用回答 → パスワードリマインダ用回答
		if ("".equals(inMap.get("pwd_reminder_ans")))
		{
			template.setNull(ECK0031D010CBSMsg.PWD_REMINDER_ANS);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.PWD_REMINDER_ANS, (String)inMap.get("pwd_reminder_ans"));
		}

		// お客様＜法人＞登録マップ.ニックネーム → ニックネーム
		if ("".equals(inMap.get("nkname")))
		{
			template.setNull(ECK0031D010CBSMsg.NKNAME);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NKNAME, (String)inMap.get("nkname"));
		}

		// お客様＜法人＞登録マップ.内販外販コード → 内販外販コード
		if ("".equals(inMap.get("naihan_gaihan_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.NAIHAN_GAIHAN_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NAIHAN_GAIHAN_CD, (String)inMap.get("naihan_gaihan_cd"));
		}

		// お客様＜法人＞登録マップ.内販企業識別コード → 内販企業識別コード
		if ("".equals(inMap.get("naihan_comp_skbt_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.NAIHAN_COMP_SKBT_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NAIHAN_COMP_SKBT_CD, (String)inMap.get("naihan_comp_skbt_cd"));
		}

		// お客様＜法人＞登録マップ.要補助コード → 要補助コード
		if ("".equals(inMap.get("necessary_hojo_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.NECESSARY_HOJO_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NECESSARY_HOJO_CD, (String)inMap.get("necessary_hojo_cd"));
		}

		// お客様＜法人＞登録マップ.ｅｏｎｅｔＩＤ未移行フラグ → ｅｏｎｅｔＩＤ未移行フラグ
		if ("".equals(inMap.get("eonetid_mi_iko_flg")))
		{
			template.setNull(ECK0031D010CBSMsg.EONETID_MI_IKO_FLG);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.EONETID_MI_IKO_FLG, (String)inMap.get("eonetid_mi_iko_flg"));
		}

		// お客様＜法人＞登録マップ.ログイン認証可否 → ログイン認証可否
		if ("".equals(inMap.get("login_ninsho_kh")))
		{
			template.setNull(ECK0031D010CBSMsg.LOGIN_NINSHO_KH);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.LOGIN_NINSHO_KH, (String)inMap.get("login_ninsho_kh"));
		}

		// お客様＜法人＞登録マップ.お客様特記事項コード → お客様特記事項コード
		if ("".equals(inMap.get("cust_tkjk_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.CUST_TKJK_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.CUST_TKJK_CD, (String)inMap.get("cust_tkjk_cd"));
		}

		// お客様＜法人＞登録マップ.会員種別特定フラグ → 会員種別特定フラグ
		if ("".equals(inMap.get("mmb_sbt_tokut_flg")))
		{
			template.setNull(ECK0031D010CBSMsg.MMB_SBT_TOKUT_FLG);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.MMB_SBT_TOKUT_FLG, (String)inMap.get("mmb_sbt_tokut_flg"));
		}

		// お客様＜法人＞登録マップ.名寄せ先ＳＹＳＩＤ → 名寄せ先ＳＹＳＩＤ
		if ("".equals(inMap.get("nayose_saki_sysid")))
		{
			template.setNull(ECK0031D010CBSMsg.NAYOSE_SAKI_SYSID);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.NAYOSE_SAKI_SYSID, (String)inMap.get("nayose_saki_sysid"));
		}

		// お客様＜法人＞登録マップ.ｅｏＩＤ通知書発行実績コード → ｅｏＩＤ通知書発行実績コード
		if ("".equals(inMap.get("eoid_tchisho_hakkojski_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD, (String)inMap.get("eoid_tchisho_hakkojski_cd"));
		}

		// お客様＜法人＞登録.旧eonet会員認証用ID → 旧eonet会員認証用ID
		if (inMap == null || inMap.get("old_eonetmb_ninsho_id") == null || "".equals(inMap.get("old_eonetmb_ninsho_id")))
		{
			template.setNull(ECK0031D010CBSMsg.OLD_EONETMB_NINSHO_ID);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.OLD_EONETMB_NINSHO_ID, (String)inMap.get("old_eonetmb_ninsho_id"));
		}

		// お客様＜法人＞登録.会員ISP決済状態コード → 会員ISP決済状態コード
		if (inMap == null || inMap.get("mmb_isp_kssai_stat_cd") == null || "".equals(inMap.get("mmb_isp_kssai_stat_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.MMB_ISP_KSSAI_STAT_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.MMB_ISP_KSSAI_STAT_CD, (String)inMap.get("mmb_isp_kssai_stat_cd"));
		}

		// お客様＜法人＞登録マップ.法人格種別コード → 法人格種別コード
		if ("".equals(inMap.get("hojin_sbt_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.HOJIN_SBT_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.HOJIN_SBT_CD, (String)inMap.get("hojin_sbt_cd"));
		}

		// お客様＜法人＞登録マップ.法人格前後指定コード → 法人格前後指定コード
		if ("".equals(inMap.get("hojin_zengo_shitei_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.HOJIN_ZENGO_SHITEI_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.HOJIN_ZENGO_SHITEI_CD, (String)inMap.get("hojin_zengo_shitei_cd"));
		}

		// お客様＜法人＞登録マップ.会社名 → 会社名
		if ("".equals(inMap.get("comp_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.COMP_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.COMP_NM, (String)inMap.get("comp_nm"));
		}

		// お客様＜法人＞登録マップ.会社カナ名 → 会社カナ名
		if ("".equals(inMap.get("comp_kana")))
		{
			template.setNull(ECK0031D010CBSMsg.COMP_KANA);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.COMP_KANA, (String)inMap.get("comp_kana"));
		}

		// お客様＜法人＞登録マップ.代表者役職名 → 代表者役職名
		if ("".equals(inMap.get("dihysha_post_nm")))
		{
			template.setNull(ECK0031D010CBSMsg.DIHYSHA_POST_NM);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.DIHYSHA_POST_NM, (String)inMap.get("dihysha_post_nm"));
		}

		// お客様＜法人＞登録マップ.業種コード → 業種コード
		if ("".equals(inMap.get("gshu_cd")))
		{
			template.setNull(ECK0031D010CBSMsg.GSHU_CD);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.GSHU_CD, (String)inMap.get("gshu_cd"));
		}
		
		// お客様＜法人＞登録マップ.法人連絡先住所手動入力フラグ → 契約者住所手動入力フラグ
		if ("".equals(inMap.get("hjrrks_ad_man_input_flg")))
		{
			template.setNull(ECK0031D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0031D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG, (String)inMap.get("hjrrks_ad_man_input_flg"));
		}
		
		// お客様＜法人＞登録マップ.契約者住所チェックレベル → 契約者住所チェックレベル
		setTemplate(template, ECK0031D010CBSMsg.KEISHA_AD_CHK_LV, inMap, "", ECK0031D010CBSMsg.KEISHA_AD_CHK_LV);
		// お客様＜法人＞登録マップ.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル
		setTemplate(template, ECK0031D010CBSMsg.CONT_AD_CHK_LV, inMap, "", ECK0031D010CBSMsg.CONT_AD_CHK_LV);
		
		// お客様＜法人＞登録マップ.代表者名 → 代表者名
		setTemplate(template, ECK0031D010CBSMsg.DIHYSHA_NM, inMap, "", ECK0031D010CBSMsg.DIHYSHA_NM);
		// お客様＜法人＞登録マップ.代表者カナ名 → 代表者カナ名
		setTemplate(template, ECK0031D010CBSMsg.DIHYSHA_KANA, inMap, "", ECK0031D010CBSMsg.DIHYSHA_KANA);
		// お客様<法人>登録.関電G個人情報取扱同意有無 → 関電G個人情報取扱同意有無
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM);
		// お客様<法人>登録.関電G個人情報取扱同意年月日 → 関電G個人情報取扱同意年月日
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD);
		// お客様<法人>登録.関電G個人情報提供不可フラグ → 関電G個人情報提供不可フラグ
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_FFG, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_FFG);
		// お客様<法人>登録.関電G個人情報提供不可フラグ変更年月日 → 関電G個人情報提供不可フラグ変更年月日
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD);
		// お客様<法人>登録.関電G個人情報提供不可フラグ変更受付方法コード → 関電G個人情報提供不可フラグ変更受付方法コード
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD);
		// お客様<法人>登録.関電G個人情報提供状況コード → 関電G個人情報提供状況コード
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_JOKYO_CD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_JOKYO_CD);
		// お客様<法人>登録.関電G個人情報提供開始年月日 → 関電G個人情報提供開始年月日
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_STAYMD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_STAYMD);
		// お客様<法人>登録.関電G個人情報提供連携状態コード → 関電G個人情報提供連携状態コード
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_RSCD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_RSCD);
		// お客様<法人>登録.関電G個人情報提供連携状態コード変更年月日 → 関電G個人情報提供連携状態コード変更年月日
		setTemplate(template, ECK0031D010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD, inMap, "", ECK0031D010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD);
		// ANK-4075-00-00 ADD START
		// お客様<法人>登録.スキームタイプコード → スキームタイプコード
		setTemplate(template, ECK0031D010CBSMsg.SCM_TYPE_CD, inMap, "", ECK0031D010CBSMsg.SCM_TYPE_CD);
		// お客様<法人>登録.スキーム事業者コード → スキーム事業者コード
		setTemplate(template, ECK0031D010CBSMsg.SCM_JGS_CD, inMap, "", ECK0031D010CBSMsg.SCM_JGS_CD);
		// ANK-4075-00-00 ADD END
		
		inList = (ArrayList)inMap.get("ECK0031D010CBSMsg1List");
		templateArray = template.getCAANMsgList(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST);

		if (templateArray == null)
		{
			templateArray = new CAANMsg[inList.size()];
		}

		if (inList != null)
		{
			for (int i = 0; i < inList.size(); i++)
			{
				HashMap childMap = (HashMap)inList.get(i);

				CAANMsg childTemplate = templateArray[i];
				if (childTemplate == null)
				{
					childTemplate = new CAANMsg(ECK0031D010CBSMsg1List.class.getName());
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.連絡先コード → 法人連絡先明細.連絡先コード
				if ("".equals(childMap.get("rrks_cd")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.RRKS_CD);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.RRKS_CD, (String)childMap.get("rrks_cd"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先名 → 法人連絡先明細.法人連絡先名
				if ("".equals(childMap.get("hjrrks_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_NM, (String)childMap.get("hjrrks_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所コード → 法人連絡先明細.法人連絡先住所コード
				if ("".equals(childMap.get("hjrrks_ad_cd")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_AD_CD);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_AD_CD, (String)childMap.get("hjrrks_ad_cd"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先郵便番号 → 法人連絡先明細.法人連絡先郵便番号
				if ("".equals(childMap.get("hjrrks_pcd")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_PCD);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_PCD, (String)childMap.get("hjrrks_pcd"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先都道府県名 → 法人連絡先明細.法人連絡先都道府県名
				if ("".equals(childMap.get("hjrrks_state_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_STATE_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_STATE_NM, (String)childMap.get("hjrrks_state_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先市区町村名 → 法人連絡先明細.法人連絡先市区町村名
				if ("".equals(childMap.get("hjrrks_city_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_CITY_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_CITY_NM, (String)childMap.get("hjrrks_city_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先大字通称名 → 法人連絡先明細.法人連絡先大字通称名
				if ("".equals(childMap.get("hjrrks_oaztsu_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_OAZTSU_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_OAZTSU_NM, (String)childMap.get("hjrrks_oaztsu_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先字丁目名 → 法人連絡先明細.法人連絡先字丁目名
				if ("".equals(childMap.get("hjrrks_azcho_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_AZCHO_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_AZCHO_NM, (String)childMap.get("hjrrks_azcho_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先番地号 → 法人連絡先明細.法人連絡先番地号
				if ("".equals(childMap.get("hjrrks_bnchigo")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_BNCHIGO);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_BNCHIGO, (String)childMap.get("hjrrks_bnchigo"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所補記・建物名 → 法人連絡先明細.法人連絡先住所補記・建物名
				if ("".equals(childMap.get("hjrrks_adrttm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_ADRTTM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_ADRTTM, (String)childMap.get("hjrrks_adrttm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所補記・部屋番号 → 法人連絡先明細.法人連絡先住所補記・部屋番号
				if ("".equals(childMap.get("hjrrks_adrrm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_ADRRM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_ADRRM, (String)childMap.get("hjrrks_adrrm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者名 → 法人連絡先明細.法人連絡先担当者名
				if ("".equals(childMap.get("hjrrks_tntsha_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_NM, (String)childMap.get("hjrrks_tntsha_nm"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者カナ名 → 法人連絡先明細.法人連絡先担当者カナ名
				if ("".equals(childMap.get("hjrrks_tntsha_kana")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_KANA);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_KANA, (String)childMap.get("hjrrks_tntsha_kana"));
				}

				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者所属部署名 → 法人連絡先明細.法人連絡先担当者所属部署名
				if ("".equals(childMap.get("hjrrks_tntsha_shozkbsho_nm")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM, (String)childMap.get("hjrrks_tntsha_shozkbsho_nm"));
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所チェックレベル → 法人連絡先明細.法人連絡先住所チェックレベル
				if ("".equals(childMap.get("hjrrks_ad_chk_lv")))
				{
					childTemplate.setNull(ECK0031D010CBSMsg1List.HJRRKS_AD_CHK_LV);
				}
				else
				{
					childTemplate.set(ECK0031D010CBSMsg1List.HJRRKS_AD_CHK_LV, (String)childMap.get("hjrrks_ad_chk_lv"));
				}

				templateArray[i] = childTemplate;
			}
		}
		template.set(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST, templateArray);

		return template;
	}

	/**
	 * お客様＜法人＞登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText 
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0031D010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, 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);

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

		// 作業領域のマップを取得
		Map workMap = iparam.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			iparam.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)iparam.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			iparam.setData(fixedText, dataMap);
		}

		// お客様＜法人＞登録マップ.ＳＹＳＩＤ ← SYSID
		if (template.isNull(ECK0031D010CBSMsg.SYSID))
		{
			dataMap.put("sysid", "");
			workDataMap.put("sysid", "");
		}
		else
		{
			dataMap.put("sysid", template.getString(ECK0031D010CBSMsg.SYSID));
			workDataMap.put("sysid", template.getString(ECK0031D010CBSMsg.SYSID));
			setSiopsvcKeiWork(iparam, "sysid", template.getString(ECK0031D010CBSMsg.SYSID));
			// 契約新規申込ワークエリアへ登録
			JKKBpCommon.setWkSysid(iparam, template.getString(ECK0031D010CBSMsg.SYSID));
		}

		// お客様＜法人＞登録マップ.世代登録年月日時分秒（お客様） ← 世代登録年月日時分秒(お客様)
		if (template.isNull(ECK0031D010CBSMsg.CK0011_GENE_ADD_DTM))
		{
			dataMap.put("ck0011_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0011_gene_add_dtm", template.getString(ECK0031D010CBSMsg.CK0011_GENE_ADD_DTM));
		}

		// お客様＜法人＞登録マップ.世代登録年月日時分秒（お客様＜法人＞） ← 世代登録年月日時分秒(お客様<法人>)
		if (template.isNull(ECK0031D010CBSMsg.CK0031_GENE_ADD_DTM))
		{
			dataMap.put("ck0031_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0031_gene_add_dtm", template.getString(ECK0031D010CBSMsg.CK0031_GENE_ADD_DTM));
		}

		// お客様＜法人＞登録マップ.お客様ステータス ← お客様ステータス
		if (template.isNull(ECK0031D010CBSMsg.CUST_STAT))
		{
			dataMap.put("cust_stat", "");
		}
		else
		{
			dataMap.put("cust_stat", template.getString(ECK0031D010CBSMsg.CUST_STAT));
		}

		// お客様＜法人＞登録マップ.契約者タイプコード ← 契約者タイプコード
		if (template.isNull(ECK0031D010CBSMsg.UPD_DTM))
		{
			workDataMap.put("upd_dtm", "");
		}
		else
		{
			workDataMap.put("upd_dtm", template.getString(ECK0031D010CBSMsg.UPD_DTM));
		}

		templateArray = template.getCAANMsgList(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("ECK0031D010CBSMsg1List");

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

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

				// お客様＜法人＞登録マップ.法人連絡先明細.世代登録年月日時分秒（法人連絡先） ← 法人連絡先明細.世代登録年月日時分秒(法人連絡先)
				if (childTemplate.isNull(ECK0031D010CBSMsg1List.CK0041_GENE_ADD_DTM))
				{
					childMap.put("ck0041_gene_add_dtm", "");
				}
				else
				{
					childMap.put("ck0041_gene_add_dtm", childTemplate.getString(ECK0031D010CBSMsg1List.CK0041_GENE_ADD_DTM));
				}
			}
		}
		dataMap.put("ECK0031D010CBSMsg1List", dataList);

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0031D010(iparam, 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 リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECK0031D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		CAANMsg[] templateArray = null;
		ArrayList inList = null;

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

		// お客様＜法人＞登録マップ.契約者タイプコード → 契約者タイプコード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_TYPE_CD_ERR))
		{
			if (!inMap.containsKey("keisha_type_cd_err"))
			{
				inMap.put("keisha_type_cd_err", template.getString(ECK0031D010CBSMsg.KEISHA_TYPE_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様名 → お客様名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey("cust_nm_err"))
			{
				inMap.put("cust_nm_err", template.getString(ECK0031D010CBSMsg.CUST_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様カナ名 → お客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey("cust_kana_err"))
			{
				inMap.put("cust_kana_err", template.getString(ECK0031D010CBSMsg.CUST_KANA_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様性別コード → お客様性別コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("cust_sex_cd_err"))
			{
				inMap.put("cust_sex_cd_err", template.getString(ECK0031D010CBSMsg.CUST_SEX_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様生年月日 → お客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("cust_birthd_err"))
			{
				inMap.put("cust_birthd_err", template.getString(ECK0031D010CBSMsg.CUST_BIRTHD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.氏名敬称 → 氏名敬称 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NM_KISHO_ERR))
		{
			if (!inMap.containsKey("nm_kisho_err"))
			{
				inMap.put("nm_kisho_err", template.getString(ECK0031D010CBSMsg.NM_KISHO_ERR));
			}
		}

		// お客様＜法人＞登録.お客様確認備考 → お客様確認備考 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_CFM_BIKO_ERR))
		{
			if (!inMap.containsKey("cust_cfm_biko_err"))
			{
				inMap.put("cust_cfm_biko_err", template.getString(ECK0031D010CBSMsg.CUST_CFM_BIKO_ERR));
			}
		}

		// お客様＜法人＞登録マップ.契約者住所コード → 契約者住所コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("keisha_ad_cd_err"))
			{
				inMap.put("keisha_ad_cd_err", template.getString(ECK0031D010CBSMsg.KEISHA_AD_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者郵便番号 → 契約者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_PCD_ERR))
		{
			if (!inMap.containsKey("keisha_pcd_err"))
			{
				inMap.put("keisha_pcd_err", template.getString(ECK0031D010CBSMsg.KEISHA_PCD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者都道府県名 → 契約者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("keisha_state_nm_err"))
			{
				inMap.put("keisha_state_nm_err", template.getString(ECK0031D010CBSMsg.KEISHA_STATE_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者市区町村名 → 契約者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("keisha_city_nm_err"))
			{
				inMap.put("keisha_city_nm_err", template.getString(ECK0031D010CBSMsg.KEISHA_CITY_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者大字通称名 → 契約者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("keisha_oaztsu_nm_err"))
			{
				inMap.put("keisha_oaztsu_nm_err", template.getString(ECK0031D010CBSMsg.KEISHA_OAZTSU_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者字丁目名 → 契約者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("keisha_azcho_nm_err"))
			{
				inMap.put("keisha_azcho_nm_err", template.getString(ECK0031D010CBSMsg.KEISHA_AZCHO_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者番地号 → 契約者番地号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("keisha_bnchigo_err"))
			{
				inMap.put("keisha_bnchigo_err", template.getString(ECK0031D010CBSMsg.KEISHA_BNCHIGO_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者住所補記・建物名 → 契約者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("keisha_adrttm_err"))
			{
				inMap.put("keisha_adrttm_err", template.getString(ECK0031D010CBSMsg.KEISHA_ADRTTM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("keisha_adrrm_err"))
			{
				inMap.put("keisha_adrrm_err", template.getString(ECK0031D010CBSMsg.KEISHA_ADRRM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者電話番号 → 契約者電話番号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_TELNO_ERR))
		{
			if (!inMap.containsKey("keisha_telno_err"))
			{
				inMap.put("keisha_telno_err", template.getString(ECK0031D010CBSMsg.KEISHA_TELNO_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様ランクコード → お客様ランクコード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_RANK_CD_ERR))
		{
			if (!inMap.containsKey("cust_rank_cd_err"))
			{
				inMap.put("cust_rank_cd_err", template.getString(ECK0031D010CBSMsg.CUST_RANK_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.連絡手段コード → 連絡手段コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_rrk_way_cd_err"))
			{
				inMap.put("ck0031_rrk_way_cd_err", template.getString(ECK0031D010CBSMsg.RRK_WAY_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.連絡手段補記 → 連絡手段補記 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.RRK_WAY_HOKI_ERR))
		{
			if (!inMap.containsKey("rrk_way_hoki_err"))
			{
				inMap.put("rrk_way_hoki_err", template.getString(ECK0031D010CBSMsg.RRK_WAY_HOKI_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツお客様名 → コンテンツお客様名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_CUST_NM_ERR))
		{
			if (!inMap.containsKey("cont_cust_nm_err"))
			{
				inMap.put("cont_cust_nm_err", template.getString(ECK0031D010CBSMsg.CONT_CUST_NM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツお客様カナ名 → コンテンツお客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_CUST_KANA_ERR))
		{
			if (!inMap.containsKey("cont_cust_kana_err"))
			{
				inMap.put("cont_cust_kana_err", template.getString(ECK0031D010CBSMsg.CONT_CUST_KANA_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツお客様性別コード → コンテンツお客様性別コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("cont_cust_sex_cd_err"))
			{
				inMap.put("cont_cust_sex_cd_err", template.getString(ECK0031D010CBSMsg.CONT_CUST_SEX_CD_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツお客様生年月日 → コンテンツお客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("cont_cust_birthd_err"))
			{
				inMap.put("cont_cust_birthd_err", template.getString(ECK0031D010CBSMsg.CONT_CUST_BIRTHD_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ住所コード → コンテンツ住所コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_AD_CD_ERR))
		{
			if (!inMap.containsKey("cont_ad_cd_err"))
			{
				inMap.put("cont_ad_cd_err", template.getString(ECK0031D010CBSMsg.CONT_AD_CD_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ郵便番号 → コンテンツ郵便番号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_PCD_ERR))
		{
			if (!inMap.containsKey("cont_pcd_err"))
			{
				inMap.put("cont_pcd_err", template.getString(ECK0031D010CBSMsg.CONT_PCD_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ都道府県名 → コンテンツ都道府県名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_STATE_NM_ERR))
		{
			if (!inMap.containsKey("cont_state_nm_err"))
			{
				inMap.put("cont_state_nm_err", template.getString(ECK0031D010CBSMsg.CONT_STATE_NM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ市区町村名 → コンテンツ市区町村名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_CITY_NM_ERR))
		{
			if (!inMap.containsKey("cont_city_nm_err"))
			{
				inMap.put("cont_city_nm_err", template.getString(ECK0031D010CBSMsg.CONT_CITY_NM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ大字通称名 → コンテンツ大字通称名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("cont_oaztsu_nm_err"))
			{
				inMap.put("cont_oaztsu_nm_err", template.getString(ECK0031D010CBSMsg.CONT_OAZTSU_NM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ字丁目名 → コンテンツ字丁目名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("cont_azcho_nm_err"))
			{
				inMap.put("cont_azcho_nm_err", template.getString(ECK0031D010CBSMsg.CONT_AZCHO_NM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ番地号 → コンテンツ番地号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("cont_bnchigo_err"))
			{
				inMap.put("cont_bnchigo_err", template.getString(ECK0031D010CBSMsg.CONT_BNCHIGO_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_ADRTTM_ERR))
		{
			if (!inMap.containsKey("cont_adrttm_err"))
			{
				inMap.put("cont_adrttm_err", template.getString(ECK0031D010CBSMsg.CONT_ADRTTM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_ADRRM_ERR))
		{
			if (!inMap.containsKey("cont_adrrm_err"))
			{
				inMap.put("cont_adrrm_err", template.getString(ECK0031D010CBSMsg.CONT_ADRRM_ERR));
			}
		}

		// お客様＜法人＞登録.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CONT_AD_BNKT_STA_PST_ERR))
		{
			if (!inMap.containsKey("cont_ad_bnkt_sta_pst_err"))
			{
				inMap.put("cont_ad_bnkt_sta_pst_err", template.getString(ECK0031D010CBSMsg.CONT_AD_BNKT_STA_PST_ERR));
			}
		}

		// お客様＜法人＞登録マップ.会員種別コード → 会員種別コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.MEMBER_SBT_CD_ERR))
		{
			if (!inMap.containsKey("member_sbt_cd_err"))
			{
				inMap.put("member_sbt_cd_err", template.getString(ECK0031D010CBSMsg.MEMBER_SBT_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.入会年月日 → 入会年月日 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.JOIN_YMD_ERR))
		{
			if (!inMap.containsKey("join_ymd_err"))
			{
				inMap.put("join_ymd_err", template.getString(ECK0031D010CBSMsg.JOIN_YMD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.パスワードリマインダ用質問コード → パスワードリマインダ用質問コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.PWD_REMINDER_QS_CD_ERR))
		{
			if (!inMap.containsKey("pwd_reminder_qs_cd_err"))
			{
				inMap.put("pwd_reminder_qs_cd_err", template.getString(ECK0031D010CBSMsg.PWD_REMINDER_QS_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.パスワードリマインダ用回答 → パスワードリマインダ用回答 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.PWD_REMINDER_ANS_ERR))
		{
			if (!inMap.containsKey("pwd_reminder_ans_err"))
			{
				inMap.put("pwd_reminder_ans_err", template.getString(ECK0031D010CBSMsg.PWD_REMINDER_ANS_ERR));
			}
		}
		// お客様＜法人＞登録マップ.ニックネーム → ニックネーム のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NKNAME_ERR))
		{
			if (!inMap.containsKey("nkname_err"))
			{
				inMap.put("nkname_err", template.getString(ECK0031D010CBSMsg.NKNAME_ERR));
			}
		}
		// お客様＜法人＞登録マップ.内販外販コード → 内販外販コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NAIHAN_GAIHAN_CD_ERR))
		{
			if (!inMap.containsKey("naihan_gaihan_cd_err"))
			{
				inMap.put("naihan_gaihan_cd_err", template.getString(ECK0031D010CBSMsg.NAIHAN_GAIHAN_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.内販企業識別コード → 内販企業識別コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("naihan_comp_skbt_cd_err"))
			{
				inMap.put("naihan_comp_skbt_cd_err", template.getString(ECK0031D010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.要補助コード → 要補助コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NECESSARY_HOJO_CD_ERR))
		{
			if (!inMap.containsKey("necessary_hojo_cd_err"))
			{
				inMap.put("necessary_hojo_cd_err", template.getString(ECK0031D010CBSMsg.NECESSARY_HOJO_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.ｅｏｎｅｔＩＤ未移行フラグ → ｅｏｎｅｔＩＤ未移行フラグ のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.EONETID_MI_IKO_FLG_ERR))
		{
			if (!inMap.containsKey("eonetid_mi_iko_flg_err"))
			{
				inMap.put("eonetid_mi_iko_flg_err", template.getString(ECK0031D010CBSMsg.EONETID_MI_IKO_FLG_ERR));
			}
		}
		// お客様＜法人＞登録マップ.ログイン認証可否 → ログイン認証可否 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.LOGIN_NINSHO_KH_ERR))
		{
			if (!inMap.containsKey("login_ninsho_kh_err"))
			{
				inMap.put("login_ninsho_kh_err", template.getString(ECK0031D010CBSMsg.LOGIN_NINSHO_KH_ERR));
			}
		}
		// お客様＜法人＞登録マップ.お客様特記事項コード → お客様特記事項コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.CUST_TKJK_CD_ERR))
		{
			if (!inMap.containsKey("cust_tkjk_cd_err"))
			{
				inMap.put("cust_tkjk_cd_err", template.getString(ECK0031D010CBSMsg.CUST_TKJK_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.会員種別特定フラグ → 会員種別特定フラグ のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.MMB_SBT_TOKUT_FLG_ERR))
		{
			if (!inMap.containsKey("mmb_sbt_tokut_flg_err"))
			{
				inMap.put("mmb_sbt_tokut_flg_err", template.getString(ECK0031D010CBSMsg.MMB_SBT_TOKUT_FLG_ERR));
			}
		}
		// お客様＜法人＞登録マップ.名寄せ先ＳＹＳＩＤ → 名寄せ先ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.NAYOSE_SAKI_SYSID_ERR))
		{
			if (!inMap.containsKey("nayose_saki_sysid_err"))
			{
				inMap.put("nayose_saki_sysid_err", template.getString(ECK0031D010CBSMsg.NAYOSE_SAKI_SYSID_ERR));
			}
		}
		// お客様＜法人＞登録マップ.ｅｏＩＤ通知書発行実績コード → ｅｏＩＤ通知書発行実績コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD_ERR))
		{
			if (!inMap.containsKey("eoid_tchisho_hakkojski_cd_err"))
			{
				inMap.put("eoid_tchisho_hakkojski_cd_err", template.getString(ECK0031D010CBSMsg.EOID_TCHISHO_HAKKOJSKI_CD_ERR));
			}
		}

		// お客様＜法人＞登録.旧eonet会員認証用ID → 旧eonet会員認証用ID のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("old_eonetmb_ninsho_id_err"))
			{
				inMap.put("old_eonetmb_ninsho_id_err", template.getString(ECK0031D010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR));
			}
		}

		// お客様＜法人＞登録.会員ISP決済状態コード → 会員ISP決済状態コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR))
		{
			if (!inMap.containsKey("mmb_isp_kssai_stat_cd_err"))
			{
				inMap.put("mmb_isp_kssai_stat_cd_err", template.getString(ECK0031D010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR));
			}
		}

		// お客様＜法人＞登録マップ.法人格種別コード → 法人格種別コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.HOJIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("hojin_sbt_cd_err"))
			{
				inMap.put("hojin_sbt_cd_err", template.getString(ECK0031D010CBSMsg.HOJIN_SBT_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.法人格前後指定コード → 法人格前後指定コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR))
		{
			if (!inMap.containsKey("hojin_zengo_shitei_cd_err"))
			{
				inMap.put("hojin_zengo_shitei_cd_err", template.getString(ECK0031D010CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.会社名 → 会社名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.COMP_NM_ERR))
		{
			if (!inMap.containsKey("comp_nm_err"))
			{
				inMap.put("comp_nm_err", template.getString(ECK0031D010CBSMsg.COMP_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.会社カナ名 → 会社カナ名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.COMP_KANA_ERR))
		{
			if (!inMap.containsKey("comp_kana_err"))
			{
				inMap.put("comp_kana_err", template.getString(ECK0031D010CBSMsg.COMP_KANA_ERR));
			}
		}
		// お客様＜法人＞登録マップ.代表者役職名 → 代表者役職名 のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.DIHYSHA_POST_NM_ERR))
		{
			if (!inMap.containsKey("dihysha_post_nm_err"))
			{
				inMap.put("dihysha_post_nm_err", template.getString(ECK0031D010CBSMsg.DIHYSHA_POST_NM_ERR));
			}
		}
		// お客様＜法人＞登録マップ.業種コード → 業種コード のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.GSHU_CD_ERR))
		{
			if (!inMap.containsKey("gshu_cd_err"))
			{
				inMap.put("gshu_cd_err", template.getString(ECK0031D010CBSMsg.GSHU_CD_ERR));
			}
		}
		// お客様＜法人＞登録マップ.契約者住所手動入力フラグ → 法人連絡先住所手動入力フラグ のエラー情報返却
		if (!template.isNull(ECK0031D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("hjrrks_ad_man_input_flg"))
			{
				inMap.put("hjrrks_ad_man_input_flg", template.getString(ECK0031D010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR));
			}
		}
		
		// お客様＜法人＞登録マップ.契約者住所手動入力フラグ → 法人連絡先住所手動入力フラグ のエラー情報返却
		setErrInfo(inMap, "", ECK0031D010CBSMsg.KEISHA_AD_CHK_LV_ERR, template, ECK0031D010CBSMsg.KEISHA_AD_CHK_LV_ERR);
		// お客様＜法人＞登録マップ.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "", ECK0031D010CBSMsg.CONT_AD_CHK_LV_ERR, template, ECK0031D010CBSMsg.CONT_AD_CHK_LV_ERR);
		
		inList = (ArrayList)inMap.get("ECK0031D010CBSMsg1List");
		templateArray = template.getCAANMsgList(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST);

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

				// お客様＜法人＞登録マップ.法人連絡先明細.連絡先コード → 法人連絡先明細.連絡先コード のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.RRKS_CD_ERR))
				{
					if (!childMap.containsKey("rrks_cd_err"))
					{
						childMap.put("rrks_cd_err", childTemplate.getString(ECK0031D010CBSMsg1List.RRKS_CD_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先名 → 法人連絡先明細.法人連絡先名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_nm_err"))
					{
						childMap.put("hjrrks_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所コード → 法人連絡先明細.法人連絡先住所コード のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_AD_CD_ERR))
				{
					if (!childMap.containsKey("hjrrks_ad_cd_err"))
					{
						childMap.put("hjrrks_ad_cd_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_AD_CD_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先郵便番号 → 法人連絡先明細.法人連絡先郵便番号 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_PCD_ERR))
				{
					if (!childMap.containsKey("hjrrks_pcd_err"))
					{
						childMap.put("hjrrks_pcd_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_PCD_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先都道府県名 → 法人連絡先明細.法人連絡先都道府県名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_STATE_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_state_nm_err"))
					{
						childMap.put("hjrrks_state_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_STATE_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先市区町村名 → 法人連絡先明細.法人連絡先市区町村名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_CITY_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_city_nm_err"))
					{
						childMap.put("hjrrks_city_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_CITY_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先大字通称名 → 法人連絡先明細.法人連絡先大字通称名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_OAZTSU_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_oaztsu_nm_err"))
					{
						childMap.put("hjrrks_oaztsu_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_OAZTSU_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先字丁目名 → 法人連絡先明細.法人連絡先字丁目名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_AZCHO_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_azcho_nm_err"))
					{
						childMap.put("hjrrks_azcho_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_AZCHO_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先番地号 → 法人連絡先明細.法人連絡先番地号 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_BNCHIGO_ERR))
				{
					if (!childMap.containsKey("hjrrks_bnchigo_err"))
					{
						childMap.put("hjrrks_bnchigo_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_BNCHIGO_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所補記・建物名 → 法人連絡先明細.法人連絡先住所補記・建物名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_ADRTTM_ERR))
				{
					if (!childMap.containsKey("hjrrks_adrttm_err"))
					{
						childMap.put("hjrrks_adrttm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_ADRTTM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所補記・部屋番号 → 法人連絡先明細.法人連絡先住所補記・部屋番号 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_ADRRM_ERR))
				{
					if (!childMap.containsKey("hjrrks_adrrm_err"))
					{
						childMap.put("hjrrks_adrrm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_ADRRM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者名 → 法人連絡先明細.法人連絡先担当者名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_tntsha_nm_err"))
					{
						childMap.put("hjrrks_tntsha_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_NM_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者カナ名 → 法人連絡先明細.法人連絡先担当者カナ名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR))
				{
					if (!childMap.containsKey("hjrrks_tntsha_kana_err"))
					{
						childMap.put("hjrrks_tntsha_kana_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR));
					}
				}
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先担当者所属部署名 → 法人連絡先明細.法人連絡先担当者所属部署名 のエラー情報返却
				if (!childTemplate.isNull(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR))
				{
					if (!childMap.containsKey("hjrrks_tntsha_shozkbsho_nm_err"))
					{
						childMap
								.put("hjrrks_tntsha_shozkbsho_nm_err", childTemplate.getString(ECK0031D010CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR));
					}
				}
				
				// お客様＜法人＞登録マップ.法人連絡先明細.法人連絡先住所チェックレベル → 法人連絡先明細.法人連絡先住所チェックレベル のエラー情報返却
				setErrInfo(childMap, "", ECK0031D010CBSMsg1List.HJRRKS_AD_CHK_LV_ERR, childTemplate, ECK0031D010CBSMsg1List.HJRRKS_AD_CHK_LV_ERR);
			}
		}
		if (!template.isNull(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST_ERR))
		{
			if (!inMap.containsKey("ECK0031D010CBSMsg1List_err"))
			{
				inMap.put("ECK0031D010CBSMsg1List_err", template.getString(ECK0031D010CBSMsg.ECK0031D010CBSMSG1LIST_ERR));
			}
		}
		return param;
	}

	/**
	 * 連絡先登録用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param prefix
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0201D010(IRequestParameterReadWrite param, String fixedText, String prefix) throws RequestParameterException
	{

		CAANMsg template = new CAANMsg(ECK0201D010CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(ECK0201D010CBSMsg.FUNC_CODE, "1");

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

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

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

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

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

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

		// 連絡先登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ
		if (inMap == null || inMap.get(prefix + "sysid") == null || "".equals(inMap.get(prefix + "sysid")))
		{
			if (workDataMap == null || workDataMap.get("sysid") == null || "".equals(workDataMap.get("sysid")))
			{
				template.setNull(ECK0201D010CBSMsg.SYSID);
			}
			else
			{
				template.set(ECK0201D010CBSMsg.SYSID, (String)workDataMap.get("sysid"));
			}
		}
		else
		{
			template.set(ECK0201D010CBSMsg.SYSID, (String)inMap.get(prefix + "sysid"));
		}

		// 連絡先登録マップ.連絡先コード → 連絡先コード
		if ("".equals(inMap.get(prefix + "rrks_cd")))
		{
			template.setNull(ECK0201D010CBSMsg.RRKS_CD);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.RRKS_CD, (String)inMap.get(prefix + "rrks_cd"));
		}

		// 連絡先登録マップ.連絡方法コード → 連絡方法コード
		if ("".equals(inMap.get(prefix + "rrk_way_cd")))
		{
			template.setNull(ECK0201D010CBSMsg.RRK_WAY_CD);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.RRK_WAY_CD, (String)inMap.get(prefix + "rrk_way_cd"));
		}

		// 連絡先登録マップ.連絡先種別コード → 連絡先種別コード
		if ("".equals(inMap.get(prefix + "rrks_sbt_cd")))
		{
			template.setNull(ECK0201D010CBSMsg.RRKS_SBT_CD);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.RRKS_SBT_CD, (String)inMap.get(prefix + "rrks_sbt_cd"));
		}

		// 連絡先登録マップ.メールアドレス → メールアドレス
		if ("".equals(inMap.get(prefix + "mlad")))
		{
			template.setNull(ECK0201D010CBSMsg.MLAD);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.MLAD, (String)inMap.get(prefix + "mlad"));
		}

		// 連絡先登録マップ.電話番号 → 電話番号
		if ("".equals(inMap.get(prefix + "telno")))
		{
			template.setNull(ECK0201D010CBSMsg.TELNO);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.TELNO, (String)inMap.get(prefix + "telno"));
		}

		// 連絡先登録マップ.内線番号 → 内線番号
		if ("".equals(inMap.get(prefix + "nisnno")))
		{
			template.setNull(ECK0201D010CBSMsg.NISNNO);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.NISNNO, (String)inMap.get(prefix + "nisnno"));
		}

		// 連絡先登録マップ.ＦＡＸ番号 → ＦＡＸ番号
		if ("".equals(inMap.get(prefix + "fax_no")))
		{
			template.setNull(ECK0201D010CBSMsg.FAX_NO);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.FAX_NO, (String)inMap.get(prefix + "fax_no"));
		}

		// 連絡先登録マップ.連絡先分類コード → 連絡先分類コード
		if ("".equals(inMap.get(prefix + "rrks_bunrui_cd")))
		{
			template.setNull(ECK0201D010CBSMsg.RRKS_BUNRUI_CD);
		}
		else
		{
			template.set(ECK0201D010CBSMsg.RRKS_BUNRUI_CD, (String)inMap.get(prefix + "rrks_bunrui_cd"));
		}
		
		// 更新年月日時分秒(更新前)
		if (inMap == null || inMap.get(prefix + "upd_dtm") == null || "".equals(inMap.get(prefix + "upd_dtm")))
		{
			if (workDataMap == null || workDataMap.get("upd_dtm") == null || "".equals(workDataMap.get("upd_dtm")))
			{
				template.setNull(ECK0201D010CBSMsg.UPD_DTM_BF);
			}
			else
			{
				template.set(ECK0201D010CBSMsg.UPD_DTM_BF, (String)workDataMap.get("upd_dtm"));
			}
		}
		else
		{
			template.set(ECK0201D010CBSMsg.UPD_DTM_BF, (String)inMap.get(prefix + "upd_dtm"));
		}

		return template;
	}

	/**
	 * 連絡先登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @param prefix
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0201D010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, 
			String fixedText, String prefix) 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 = iparam.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			iparam.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)iparam.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			iparam.setData(fixedText, dataMap);
		}

		// 連絡先登録マップ.連絡先番号 ← 連絡先番号
		if (template.isNull(ECK0201D010CBSMsg.RRKS_NO))
		{
			dataMap.put(prefix + "rrks_no", "");
		}
		else
		{
			dataMap.put(prefix + "rrks_no", template.getString(ECK0201D010CBSMsg.RRKS_NO));
		}

		// 連絡先登録マップ.登録年月日時分秒 ← 登録年月日時分秒
		if (template.isNull(ECK0201D010CBSMsg.ADD_DTM))
		{
			dataMap.put(prefix + "add_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "add_dtm", template.getString(ECK0201D010CBSMsg.ADD_DTM));
		}

		// 連絡先登録マップ.登録オペレータアカウント ← 登録オペレータアカウント
		if (template.isNull(ECK0201D010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put(prefix + "add_opeacnt", "");
		}
		else
		{
			dataMap.put(prefix + "add_opeacnt", template.getString(ECK0201D010CBSMsg.ADD_OPEACNT));
		}

		// 連絡先登録マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(ECK0201D010CBSMsg.UPD_DTM))
		{
			dataMap.put(prefix + "upd_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "upd_dtm", template.getString(ECK0201D010CBSMsg.UPD_DTM));
		}

		// 連絡先登録マップ.更新オペレータアカウント ← 更新オペレータアカウント
		if (template.isNull(ECK0201D010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put(prefix + "upd_opeacnt", "");
		}
		else
		{
			dataMap.put(prefix + "upd_opeacnt", template.getString(ECK0201D010CBSMsg.UPD_OPEACNT));
		}

		// 連絡先登録マップ.無効フラグ ← 無効フラグ
		if (template.isNull(ECK0201D010CBSMsg.MK_FLG))
		{
			dataMap.put(prefix + "mk_flg", "");
		}
		else
		{
			dataMap.put(prefix + "mk_flg", template.getString(ECK0201D010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0201D010(iparam, template, (Integer)returnCode, fixedText, prefix);

		//エラー情報のマップを取得
		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 prefix
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECK0201D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText,
		String prefix) throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201D010CBSMsg.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(fixedText);

		// 連絡先登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey(prefix + "sysid_err"))
			{
				inMap.put(prefix + "sysid_err", template.getString(ECK0201D010CBSMsg.SYSID_ERR));
			}
		}
		// 連絡先登録マップ.連絡先コード → 連絡先コード のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.RRKS_CD_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_cd_err"))
			{
				inMap.put(prefix + "rrks_cd_err", template.getString(ECK0201D010CBSMsg.RRKS_CD_ERR));
			}
		}
		// 連絡先登録マップ.連絡方法コード → 連絡方法コード のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey(prefix + "rrk_way_cd_err"))
			{
				inMap.put(prefix + "rrk_way_cd_err", template.getString(ECK0201D010CBSMsg.RRK_WAY_CD_ERR));
			}
		}
		// 連絡先登録マップ.連絡先種別コード → 連絡先種別コード のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.RRKS_SBT_CD_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_sbt_cd_err"))
			{
				inMap.put(prefix + "rrks_sbt_cd_err", template.getString(ECK0201D010CBSMsg.RRKS_SBT_CD_ERR));
			}
		}
		// 連絡先登録マップ.連絡先分類コード → 連絡先分類コード のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.RRKS_BUNRUI_CD_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_bunrui_cd_err"))
			{
				inMap.put(prefix + "rrks_bunrui_cd_err", template.getString(ECK0201D010CBSMsg.RRKS_BUNRUI_CD_ERR));
			}
		}
		// 連絡先登録マップ.メールアドレス → メールアドレス のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.MLAD_ERR))
		{
			if (!inMap.containsKey(prefix + "mlad_err"))
			{
				inMap.put(prefix + "mlad_err", template.getString(ECK0201D010CBSMsg.MLAD_ERR));
			}
		}
		// 連絡先登録マップ.電話番号 → 電話番号 のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.TELNO_ERR))
		{
			if (!inMap.containsKey(prefix + "telno_err"))
			{
				inMap.put(prefix + "telno_err", template.getString(ECK0201D010CBSMsg.TELNO_ERR));
			}
		}
		// 連絡先登録マップ.内線番号 → 内線番号 のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.NISNNO_ERR))
		{
			if (!inMap.containsKey(prefix + "nisnno_err"))
			{
				inMap.put(prefix + "nisnno_err", template.getString(ECK0201D010CBSMsg.NISNNO_ERR));
			}
		}
		// 連絡先登録マップ.ＦＡＸ番号 → ＦＡＸ番号 のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.FAX_NO_ERR))
		{
			if (!inMap.containsKey(prefix + "fax_no_err"))
			{
				inMap.put(prefix + "fax_no_err", template.getString(ECK0201D010CBSMsg.FAX_NO_ERR));
			}
		}
		// 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0201D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(prefix + "upd_dtm_bf_err"))
			{
				inMap.put(prefix + "upd_dtm_bf_err", template.getString(ECK0201D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 機器提供サービス契約登録用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

		CAANMsg template = new CAANMsg(EKK0341D010CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0341D010CBSMsg.FUNC_CODE, "1");

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

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

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

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

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

		// 作業領域のマップを取得

		// 機器提供サービスコード
		if (inMap == null || inMap.get("kktk_svc_cd") == null || "".equals(inMap.get("kktk_svc_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SVC_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SVC_CD, (String)inMap.get("kktk_svc_cd"));
		}

		// 料金コースコード
		if (inMap == null || inMap.get("pcrs_cd") == null || "".equals(inMap.get("pcrs_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PCRS_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PCRS_CD, (String)inMap.get("pcrs_cd"));
		}

		// 料金プランコード
		if (inMap == null || inMap.get("pplan_cd") == null || "".equals(inMap.get("pplan_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PPLAN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PPLAN_CD, (String)inMap.get("pplan_cd"));
		}

		// 機器提供種別コード
		if (inMap == null || inMap.get("kktk_sbt_cd") == null || "".equals(inMap.get("kktk_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KKTK_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KKTK_SBT_CD, (String)inMap.get("kktk_sbt_cd"));
		}

		// HDD容量コード
		if (inMap == null || inMap.get("hdd_capa_cd") == null || "".equals(inMap.get("hdd_capa_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HDD_CAPA_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HDD_CAPA_CD, (String)inMap.get("hdd_capa_cd"));
		}

		// サービス利用開始希望年月日
		if (inMap == null || inMap.get("svc_use_sta_kibo_ymd") == null || "".equals(inMap.get("svc_use_sta_kibo_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD, (String)inMap.get("svc_use_sta_kibo_ymd"));
		}

		// 予約適用開始希望年月日
		if (inMap == null || inMap.get("rsv_tsta_kibo_ymd") == null || "".equals(inMap.get("rsv_tsta_kibo_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD, (String)inMap.get("rsv_tsta_kibo_ymd"));
		}

		// 希望メーカーコード
		if (inMap == null || inMap.get("kibo_maker_cd") == null || "".equals(inMap.get("kibo_maker_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIBO_MAKER_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIBO_MAKER_CD, (String)inMap.get("kibo_maker_cd"));
		}

		// 販売種別コード
		if (inMap == null || inMap.get("hambai_sbt_cd") == null || "".equals(inMap.get("hambai_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HAMBAI_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAMBAI_SBT_CD, (String)inMap.get("hambai_sbt_cd"));
		}

		// 通信機器セットコード
		if (inMap == null || inMap.get("tsushin_kiki_set_cd") == null || "".equals(inMap.get("tsushin_kiki_set_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD, (String)inMap.get("tsushin_kiki_set_cd"));
		}

		// 宅内機器種別コード
		if (inMap == null || inMap.get("taknkiki_sbt_cd") == null || "".equals(inMap.get("taknkiki_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD, (String)inMap.get("taknkiki_sbt_cd"));
		}

		// 宅内機器型式コード
		if (inMap == null || inMap.get("taknkiki_model_cd") == null || "".equals(inMap.get("taknkiki_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD, (String)inMap.get("taknkiki_model_cd"));
		}

		// 機器製造番号
		if (inMap == null || inMap.get("kiki_seizo_no") == null || "".equals(inMap.get("kiki_seizo_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SEIZO_NO, (String)inMap.get("kiki_seizo_no"));
		}

		// 宅内機器セット品型コード
		if (inMap == null || inMap.get("taknkiki_sethin_model_cd") == null || "".equals(inMap.get("taknkiki_sethin_model_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD, (String)inMap.get("taknkiki_sethin_model_cd"));
		}

		// 付属品種別コード
		if (inMap == null || inMap.get("huzokuhin_sbt_cd") == null || "".equals(inMap.get("huzokuhin_sbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD, (String)inMap.get("huzokuhin_sbt_cd"));
		}

		// 機器設置先場所番号
		if (inMap == null || inMap.get("kiki_stc_saki_place_no") == null || "".equals(inMap.get("kiki_stc_saki_place_no")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO, (String)inMap.get("kiki_stc_saki_place_no"));
		}

		// 親契約識別コード
		if (inMap == null || inMap.get("oya_kei_skbt_cd") == null || "".equals(inMap.get("oya_kei_skbt_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD, (String)inMap.get("oya_kei_skbt_cd"));
		}

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

		// サービス契約内訳番号
		if (inMap == null || inMap.get("svc_kei_ucwk_no") == null || "".equals(inMap.get("svc_kei_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO, (String)inMap.get("svc_kei_ucwk_no"));
		}

		// サービス契約回線内訳番号
		if (inMap == null || inMap.get("svc_kei_kaisen_ucwk_no") == null || "".equals(inMap.get("svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)inMap.get("svc_kei_kaisen_ucwk_no"));
		}

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

		// SYSID
		if (inMap == null || inMap.get("sysid") == null || "".equals(inMap.get("sysid")))
		{
			template.setNull(EKK0341D010CBSMsg.SYSID);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SYSID, (String)inMap.get("sysid"));
		}

		// 申込明細番号
		if (inMap == null || inMap.get("mskm_dtl_no") == null || "".equals(inMap.get("mskm_dtl_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MSKM_DTL_NO, (String)inMap.get("mskm_dtl_no"));
		}

		// リンクSTBフラグ
		if (inMap == null || inMap.get("link_stb_flg") == null || "".equals(inMap.get("link_stb_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.LINK_STB_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.LINK_STB_FLG, (String)inMap.get("link_stb_flg"));
		}

		// 機器引当指定倉庫コード
		if (inMap == null || inMap.get("kiki_hkat_shitei_soko_cd") == null || "".equals(inMap.get("kiki_hkat_shitei_soko_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD, (String)inMap.get("kiki_hkat_shitei_soko_cd"));
		}

		// 機器引当指定倉庫棚コード
		if (inMap == null || inMap.get("kiki_hkat_shitei_skdn_cd") == null || "".equals(inMap.get("kiki_hkat_shitei_skdn_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD, (String)inMap.get("kiki_hkat_shitei_skdn_cd"));
		}

		// 機器送料有無
		if (inMap == null || inMap.get("kiki_soryo_um") == null || "".equals(inMap.get("kiki_soryo_um")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_UM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_UM, (String)inMap.get("kiki_soryo_um"));
		}

		// 機器送料作成年月日
		if (inMap == null || inMap.get("kiki_soryo_saksei_ymd") == null || "".equals(inMap.get("kiki_soryo_saksei_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD, (String)inMap.get("kiki_soryo_saksei_ymd"));
		}

		// 機器送付先名
		if (inMap == null || inMap.get("kiki_sohus_nm") == null || "".equals(inMap.get("kiki_sohus_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_NM, (String)inMap.get("kiki_sohus_nm"));
		}

		// 機器送付先カナ名
		if (inMap == null || inMap.get("kiki_sohus_kana") == null || "".equals(inMap.get("kiki_sohus_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KANA, (String)inMap.get("kiki_sohus_kana"));
		}

		// 機器送付先住所コード
		if (inMap == null || inMap.get("kiki_sohus_ad_cd") == null || "".equals(inMap.get("kiki_sohus_ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD, (String)inMap.get("kiki_sohus_ad_cd"));
		}

		// 機器送付先郵便番号
		if (inMap == null || inMap.get("kiki_sohus_pcd") == null || "".equals(inMap.get("kiki_sohus_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_PCD, (String)inMap.get("kiki_sohus_pcd"));
		}

		// 機器送付先都道府県名
		if (inMap == null || inMap.get("kiki_sohus_state_nm") == null || "".equals(inMap.get("kiki_sohus_state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM, (String)inMap.get("kiki_sohus_state_nm"));
		}

		// 機器送付先市区町村名
		if (inMap == null || inMap.get("kiki_sohus_city_nm") == null || "".equals(inMap.get("kiki_sohus_city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM, (String)inMap.get("kiki_sohus_city_nm"));
		}

		// 機器送付先大字通称名
		if (inMap == null || inMap.get("kiki_sohus_oaztsu_nm") == null || "".equals(inMap.get("kiki_sohus_oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM, (String)inMap.get("kiki_sohus_oaztsu_nm"));
		}

		// 機器送付先字丁目名
		if (inMap == null || inMap.get("kiki_sohus_azcho_nm") == null || "".equals(inMap.get("kiki_sohus_azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM, (String)inMap.get("kiki_sohus_azcho_nm"));
		}

		// 機器送付先番地号
		if (inMap == null || inMap.get("kiki_sohus_bnchigo") == null || "".equals(inMap.get("kiki_sohus_bnchigo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO, (String)inMap.get("kiki_sohus_bnchigo"));
		}

		// 機器送付先住所補記・建物名
		if (inMap == null || inMap.get("kiki_sohus_adrttm") == null || "".equals(inMap.get("kiki_sohus_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM, (String)inMap.get("kiki_sohus_adrttm"));
		}

		// 機器送付先住所補記・部屋番号
		if (inMap == null || inMap.get("kiki_sohus_adrrm") == null || "".equals(inMap.get("kiki_sohus_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM, (String)inMap.get("kiki_sohus_adrrm"));
		}

		// 機器送付先電話番号
		if (inMap == null || inMap.get("kiki_sohus_telno") == null || "".equals(inMap.get("kiki_sohus_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO, (String)inMap.get("kiki_sohus_telno"));
		}

		// マンション物件番号
		if (inMap == null || inMap.get("mansion_bukken_no") == null || "".equals(inMap.get("mansion_bukken_no")))
		{
			template.setNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.MANSION_BUKKEN_NO, (String)inMap.get("mansion_bukken_no"));
		}

		// 機器送付先_契約者住所差異フラグ
		if (inMap == null || inMap.get("kiki_sohus_ksh_ad_sai_flg") == null || "".equals(inMap.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)inMap.get("kiki_sohus_ksh_ad_sai_flg"));
		}

		// 機器送付先個別指定フラグ
		if (inMap == null || inMap.get("kiki_shs_kbt_shitei_flg") == null || "".equals(inMap.get("kiki_shs_kbt_shitei_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG, (String)inMap.get("kiki_shs_kbt_shitei_flg"));
		}

		// 機器送付先補足コード1
		if (inMap == null || inMap.get("kiki_shs_hsk_cd_1") == null || "".equals(inMap.get("kiki_shs_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1, (String)inMap.get("kiki_shs_hsk_cd_1"));
		}

		// 機器送付先補足コード2
		if (inMap == null || inMap.get("kiki_shs_hsk_cd_2") == null || "".equals(inMap.get("kiki_shs_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2, (String)inMap.get("kiki_shs_hsk_cd_2"));
		}

		// 機器送付先補足メモ
		if (inMap == null || inMap.get("kiki_shs_hsk_memo") == null || "".equals(inMap.get("kiki_shs_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO, (String)inMap.get("kiki_shs_hsk_memo"));
		}

		// 機器設置先名
		if (inMap == null || inMap.get("kiki_stc_saki_nm") == null || "".equals(inMap.get("kiki_stc_saki_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM, (String)inMap.get("kiki_stc_saki_nm"));
		}

		// 機器設置先カナ名
		if (inMap == null || inMap.get("kiki_stc_saki_kana") == null || "".equals(inMap.get("kiki_stc_saki_kana")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA, (String)inMap.get("kiki_stc_saki_kana"));
		}

		// 機器設置先住所コード
		if (inMap == null || inMap.get("kiki_stc_saki_ad_cd") == null || "".equals(inMap.get("kiki_stc_saki_ad_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD, (String)inMap.get("kiki_stc_saki_ad_cd"));
		}

		// 機器設置先郵便番号
		if (inMap == null || inMap.get("kiki_stc_saki_pcd") == null || "".equals(inMap.get("kiki_stc_saki_pcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD, (String)inMap.get("kiki_stc_saki_pcd"));
		}

		// 機器設置先都道府県名
		if (inMap == null || inMap.get("kiki_stc_saki_state_nm") == null || "".equals(inMap.get("kiki_stc_saki_state_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM, (String)inMap.get("kiki_stc_saki_state_nm"));
		}

		// 機器設置先市区町村名
		if (inMap == null || inMap.get("kiki_stc_saki_city_nm") == null || "".equals(inMap.get("kiki_stc_saki_city_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM, (String)inMap.get("kiki_stc_saki_city_nm"));
		}

		// 機器設置先大字通称名
		if (inMap == null || inMap.get("kiki_stc_saki_oaztsu_nm") == null || "".equals(inMap.get("kiki_stc_saki_oaztsu_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM, (String)inMap.get("kiki_stc_saki_oaztsu_nm"));
		}

		// 機器設置先字丁目名
		if (inMap == null || inMap.get("kiki_stc_saki_azcho_nm") == null || "".equals(inMap.get("kiki_stc_saki_azcho_nm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM, (String)inMap.get("kiki_stc_saki_azcho_nm"));
		}

		// 機器設置先番地号
		if (inMap == null || inMap.get("kiki_stc_saki_bnchigo") == null || "".equals(inMap.get("kiki_stc_saki_bnchigo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO, (String)inMap.get("kiki_stc_saki_bnchigo"));
		}

		// 機器設置先住所補記・建物名
		if (inMap == null || inMap.get("kiki_stc_saki_adrttm") == null || "".equals(inMap.get("kiki_stc_saki_adrttm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM, (String)inMap.get("kiki_stc_saki_adrttm"));
		}

		// 機器設置先住所補記・部屋番号
		if (inMap == null || inMap.get("kiki_stc_saki_adrrm") == null || "".equals(inMap.get("kiki_stc_saki_adrrm")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM, (String)inMap.get("kiki_stc_saki_adrrm"));
		}

		// 機器設置先_契約者住所差異フラグ
		if (inMap == null || inMap.get("kiki_stc_sk_ksh_ad_sai_flg") == null || "".equals(inMap.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)inMap.get("kiki_stc_sk_ksh_ad_sai_flg"));
		}

		// 機器設置先電話番号
		if (inMap == null || inMap.get("kiki_stc_sk_telno") == null || "".equals(inMap.get("kiki_stc_sk_telno")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO, (String)inMap.get("kiki_stc_sk_telno"));
		}

		// 機器設置先区画整理中フラグ
		if (inMap == null || inMap.get("kiki_sts_kkk_seiri_chu_flg") == null || "".equals(inMap.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)inMap.get("kiki_sts_kkk_seiri_chu_flg"));
		}

		// 住所未確定フラグ
		if (inMap == null || inMap.get("ad_mi_fix_flg") == null || "".equals(inMap.get("ad_mi_fix_flg")))
		{
			template.setNull(EKK0341D010CBSMsg.AD_MI_FIX_FLG);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.AD_MI_FIX_FLG, (String)inMap.get("ad_mi_fix_flg"));
		}

		// 機器設置先補足コード1
		if (inMap == null || inMap.get("kiki_sts_hsk_cd_1") == null || "".equals(inMap.get("kiki_sts_hsk_cd_1")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1, (String)inMap.get("kiki_sts_hsk_cd_1"));
		}

		// 機器設置先補足コード2
		if (inMap == null || inMap.get("kiki_sts_hsk_cd_2") == null || "".equals(inMap.get("kiki_sts_hsk_cd_2")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2, (String)inMap.get("kiki_sts_hsk_cd_2"));
		}

		// 機器設置先補足メモ
		if (inMap == null || inMap.get("kiki_sts_hsk_memo") == null || "".equals(inMap.get("kiki_sts_hsk_memo")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO, (String)inMap.get("kiki_sts_hsk_memo"));
		}

		// 配送区分
		if (inMap == null || inMap.get("haiso_div") == null || "".equals(inMap.get("haiso_div")))
		{
			template.set(EKK0341D010CBSMsg.HAISO_DIV, "00");
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_DIV, (String)inMap.get("haiso_div"));
		}

		// 試用加入年月日
		if (inMap == null || inMap.get("ftrial_kanyu_ymd") == null || "".equals(inMap.get("ftrial_kanyu_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD, (String)inMap.get("ftrial_kanyu_ymd"));
		}

		// 試用期間終了年月日
		if (inMap == null || inMap.get("ftrial_prd_endymd") == null || "".equals(inMap.get("ftrial_prd_endymd")))
		{
			template.setNull(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD, (String)inMap.get("ftrial_prd_endymd"));
		}

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

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

		// 保証コード
		if (inMap == null || inMap.get("hosho_cd") == null || "".equals(inMap.get("hosho_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_CD, (String)inMap.get("hosho_cd"));
		}

		// 保証開始年月日
		if (inMap == null || inMap.get("hosho_staymd") == null || "".equals(inMap.get("hosho_staymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HOSHO_STAYMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HOSHO_STAYMD, (String)inMap.get("hosho_staymd"));
		}

		// 違約金発生コード
		if (inMap == null || inMap.get("pnlty_hassei_cd") == null || "".equals(inMap.get("pnlty_hassei_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PNLTY_HASSEI_CD, (String)inMap.get("pnlty_hassei_cd"));
		}

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

		// 宅内機器異動コード
		if (inMap == null || inMap.get("taknkiki_ido_cd") == null || "".equals(inMap.get("taknkiki_ido_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD, (String)inMap.get("taknkiki_ido_cd"));
		}

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

		// 機器付加情報コード
		if (inMap == null || inMap.get("kiki_huka_info_cd") == null || "".equals(inMap.get("kiki_huka_info_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD, (String)inMap.get("kiki_huka_info_cd"));
		}

		// 配送方法コード
		if (inMap == null || inMap.get("haiso_way_cd") == null || "".equals(inMap.get("haiso_way_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_WAY_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_WAY_CD, (String)inMap.get("haiso_way_cd"));
		}

		// 機器移転先移動実施者識別コード
		if (inMap == null || inMap.get("kiki_itens_mv_jssis_skcd") == null || "".equals(inMap.get("kiki_itens_mv_jssis_skcd")))
		{
			template.setNull(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD, (String)inMap.get("kiki_itens_mv_jssis_skcd"));
		}

		// 配送依頼指定年月日
		if (inMap == null || inMap.get("haiso_req_shitei_ymd") == null || "".equals(inMap.get("haiso_req_shitei_ymd")))
		{
			template.setNull(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD, (String)inMap.get("haiso_req_shitei_ymd"));
		}

		// 請求契約番号
		if (inMap == null || inMap.get("seiky_kei_no") == null || "".equals(inMap.get("seiky_kei_no")))
		{
			template.setNull(EKK0341D010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}

		// 料金項目コード
		if (inMap == null || inMap.get("prc_kmk_cd") == null || "".equals(inMap.get("prc_kmk_cd")))
		{
			template.setNull(EKK0341D010CBSMsg.PRC_KMK_CD);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.PRC_KMK_CD, (String)inMap.get("prc_kmk_cd"));
		}

		// 更新年月日時分秒(更新前)
		if (inMap == null || inMap.get("upd_dtm_bf") == null || "".equals(inMap.get("upd_dtm_bf")))
		{
			template.setNull(EKK0341D010CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(EKK0341D010CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm_bf"));
		}
		
		// 機器送付先住所手動入力フラグ
		if (inMap == null || inMap.get("kiki_shs_ad_man_input_flg") == null || "".equals(inMap.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)inMap.get("kiki_shs_ad_man_input_flg"));
		}
		
		// 機器送付先住所チェックレベル
		setTemplate(template, EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV, inMap, "", EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV);
		// 機器設置先住所チェックレベル
		setTemplate(template, EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV, inMap, "", EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV);


		return template;
	}

	/**
	 * 機器提供サービス契約登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341D010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, 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);

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

		// 機器提供サービス契約番号
		if (template.isNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO))
		{
			dataMap.put("kktk_svc_kei_no", "");
		}
		else
		{
			dataMap.put("kktk_svc_kei_no", template.getString(EKK0341D010CBSMsg.KKTK_SVC_KEI_NO));
		}
		// 世代登録年月日時分秒
		if (template.isNull(EKK0341D010CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("gene_add_dtm", "");
		}
		else
		{
			dataMap.put("gene_add_dtm", template.getString(EKK0341D010CBSMsg.GENE_ADD_DTM));
		}
		// 機器提供サービス契約ステータス
		if (template.isNull(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT))
		{
			dataMap.put("kktk_svc_kei_stat", "");
		}
		else
		{
			dataMap.put("kktk_svc_kei_stat", template.getString(EKK0341D010CBSMsg.KKTK_SVC_KEI_STAT));
		}
		// 機器変更番号
		if (template.isNull(EKK0341D010CBSMsg.KIKI_CHG_NO))
		{
			dataMap.put("kiki_chg_no", "");
		}
		else
		{
			dataMap.put("kiki_chg_no", template.getString(EKK0341D010CBSMsg.KIKI_CHG_NO));
		}
		// 保証終了年月日
		if (template.isNull(EKK0341D010CBSMsg.HOSHO_END_YMD))
		{
			dataMap.put("hosho_end_ymd", "");
		}
		else
		{
			dataMap.put("hosho_end_ymd", template.getString(EKK0341D010CBSMsg.HOSHO_END_YMD));
		}
		// 予約適用年月日
		if (template.isNull(EKK0341D010CBSMsg.RSV_APLY_YMD))
		{
			dataMap.put("rsv_aply_ymd", "");
		}
		else
		{
			dataMap.put("rsv_aply_ymd", template.getString(EKK0341D010CBSMsg.RSV_APLY_YMD));
		}
		// 予約適用コード
		if (template.isNull(EKK0341D010CBSMsg.RSV_APLY_CD))
		{
			dataMap.put("rsv_aply_cd", "");
		}
		else
		{
			dataMap.put("rsv_aply_cd", template.getString(EKK0341D010CBSMsg.RSV_APLY_CD));
		}
		// 課金先番号
		if (template.isNull(EKK0341D010CBSMsg.KAKINS_NO))
		{
			dataMap.put("kakins_no", "");
		}
		else
		{
			dataMap.put("kakins_no", template.getString(EKK0341D010CBSMsg.KAKINS_NO));
		}
		// 課金先適用開始年月日
		if (template.isNull(EKK0341D010CBSMsg.KAKINS_TSTAYMD))
		{
			dataMap.put("kakins_tstaymd", "");
		}
		else
		{
			dataMap.put("kakins_tstaymd", template.getString(EKK0341D010CBSMsg.KAKINS_TSTAYMD));
		}
		// 課金先適用終了年月日
		if (template.isNull(EKK0341D010CBSMsg.KAKINS_TENDYMD))
		{
			dataMap.put("kakins_tendymd", "");
		}
		else
		{
			dataMap.put("kakins_tendymd", template.getString(EKK0341D010CBSMsg.KAKINS_TENDYMD));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK0341D010CBSMsg.ADD_DTM))
		{
			dataMap.put("add_dtm", "");
		}
		else
		{
			dataMap.put("add_dtm", template.getString(EKK0341D010CBSMsg.ADD_DTM));
		}
		// 登録オペレータアカウント
		if (template.isNull(EKK0341D010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("add_opeacnt", "");
		}
		else
		{
			dataMap.put("add_opeacnt", template.getString(EKK0341D010CBSMsg.ADD_OPEACNT));
		}
		// 更新年月日時分秒
		if (template.isNull(EKK0341D010CBSMsg.UPD_DTM))
		{
			dataMap.put("upd_dtm", "");
		}
		else
		{
			dataMap.put("upd_dtm", template.getString(EKK0341D010CBSMsg.UPD_DTM));
		}
		// 更新オペレータアカウント
		if (template.isNull(EKK0341D010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("upd_opeacnt", "");
		}
		else
		{
			dataMap.put("upd_opeacnt", template.getString(EKK0341D010CBSMsg.UPD_OPEACNT));
		}
		// 無効フラグ
		if (template.isNull(EKK0341D010CBSMsg.MK_FLG))
		{
			dataMap.put("mk_flg", "");
		}
		else
		{
			dataMap.put("mk_flg", template.getString(EKK0341D010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoEKK0341D010(iparam, 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 リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341D010(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(fixedText);

		// 機器提供サービスコード
		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.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.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.OYA_KEI_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("oya_kei_skbt_cd"))
			{
				inMap.put("oya_kei_skbt_cd", template.getString(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD_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_HKAT_SHITEI_SOKO_CD_ERR))
		{
			if (!inMap.containsKey("kiki_hkat_shitei_soko_cd_err"))
			{
				inMap.put("kiki_hkat_shitei_soko_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD_ERR));
			}
		}

		// 機器引当指定倉庫棚コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD_ERR))
		{
			if (!inMap.containsKey("kiki_hkat_shitei_skdn_cd_err"))
			{
				inMap.put("kiki_hkat_shitei_skdn_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD_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));
			}
		}

		// 住所未確定フラグ
		if (!template.isNull(EKK0341D010CBSMsg.AD_MI_FIX_FLG_ERR))
		{
			if (!inMap.containsKey("ad_mi_fix_flg_err"))
			{
				inMap.put("ad_mi_fix_flg_err", template.getString(EKK0341D010CBSMsg.AD_MI_FIX_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.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD_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));
			}
		}

		// 宅内機器異動コード
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_ido_cd_err"))
			{
				inMap.put("taknkiki_ido_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD_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));
			}
		}

		// 機器付加情報コード
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD_ERR))
		{
			if (!inMap.containsKey("kiki_huka_info_cd_err"))
			{
				inMap.put("kiki_huka_info_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD_ERR));
			}
		}

		// 配送方法コード
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_WAY_CD_ERR))
		{
			if (!inMap.containsKey("haiso_way_cd_err"))
			{
				inMap.put("haiso_way_cd_err", template.getString(EKK0341D010CBSMsg.HAISO_WAY_CD));
			}
		}

		// 機器移転先移動実施者識別コード
		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.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK0341D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}

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

		// 機器送付先住所手動入力フラグ
		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));
			}
		}
		
		//機器送付先住所チェックレベル
		setErrInfo(inMap, "", EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV_ERR, template, EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV_ERR);
		//機器設置先住所チェックレベル
		setErrInfo(inMap, "", EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV_ERR, template, EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV_ERR);

		
		return param;
	}

	/**
	 * サービス契約回線内訳登録の上りマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0251D010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0251D010CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0251D010CBSMsg.FUNC_CODE, "1");

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

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

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

		//		HashMap inMap = (HashMap)param.getData("EKK0251D010");
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		if (inMap != null)
		{
			template.set(EKK0251D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		}
		
		// サービス契約回線内訳登録.住所形態コード → 住所形態コード
		if (inMap == null || inMap.get("ad_form_cd") == null || "".equals(inMap.get("ad_form_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.AD_FORM_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.AD_FORM_CD, (String)inMap.get("ad_form_cd"));
		}
		
		// サービス契約回線内訳登録.回線提供会社コード → 回線提供会社コード
		if (inMap == null || inMap.get("kaisen_tk_comp_cd") == null || "".equals(inMap.get("kaisen_tk_comp_cd")))
		{
			template.setNull(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD, (String)inMap.get("kaisen_tk_comp_cd"));
		}
		
		// サービス契約回線内訳登録.請求書送付先住所変更希望年月日 → 請求書送付先住所変更希望年月日
		if (inMap == null || inMap.get("sks_shs_ad_chg_kibo_ymd") == null || "".equals(inMap.get("sks_shs_ad_chg_kibo_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD, (String)inMap.get("sks_shs_ad_chg_kibo_ymd"));
		}
		
		// サービス契約回線内訳登録.契約者住所変更希望年月日 → 契約者住所変更希望年月日
		if (inMap == null || inMap.get("kshad_chg_kibo_ymd") == null || "".equals(inMap.get("kshad_chg_kibo_ymd")))
		{
			template.setNull(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD);
		}
		else
		{
			template.set(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD, (String)inMap.get("kshad_chg_kibo_ymd"));
		}
		
		// サービス契約回線内訳登録.回線場所住所チェックレベル → 回線場所住所チェックレベル
		setTemplate(template, EKK0251D010CBSMsg.KISN_AD_CHK_LV, inMap, "", EKK0251D010CBSMsg.KISN_AD_CHK_LV);
		
		ArrayList dataList = (ArrayList)inMap.get("EKK0251D010CBSMsg1List");
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST);

		if (templateArray == null)
		{
			templateArray = new CAANMsg[dataList.size()];
		}
		
		CAANMsg[] tmpArray = templateArray;
		
		CAANMsg childTemplate = tmpArray[0];
		
		if (childTemplate == null)
		{
			childTemplate = new CAANMsg(EKK0251D010CBSMsg1List.class.getName());
		}
		
		childTemplate.setNull(EKK0251D010CBSMsg1List.SVC_KEI_NO);
		
		tmpArray[0] = childTemplate;
		
		// 回線対象サービス契約のデータを設定
		template.set(EKK0251D010CBSMsg.EKK0251D010CBSMSG1LIST, templateArray);

		return template;
	}

	/**
	 * サービス回線内訳登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0251D010(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);

		// 作業領域のマップを取得

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

		param.setData(fixedText, dataMap);

		// エラー情報の設定
		editErrInfoEKK0251D010(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 リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0251D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(EKK0251D010CBSMsg.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(fixedText);

		// サービス契約回線内訳登録.住所形態コード → 住所形態コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.AD_FORM_CD_ERR))
		{
			if (!inMap.containsKey("ad_form_cd_err"))
			{
				inMap.put("ad_form_cd_err", template.getString(EKK0251D010CBSMsg.AD_FORM_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.回線提供会社コード → 回線提供会社コード のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD_ERR))
		{
			if (!inMap.containsKey("kaisen_tk_comp_cd_err"))
			{
				inMap.put("kaisen_tk_comp_cd_err", template.getString(EKK0251D010CBSMsg.KAISEN_TK_COMP_CD_ERR));
			}
		}

		// サービス契約回線内訳登録.請求書送付先住所変更希望年月日 → 請求書送付先住所変更希望年月日 のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("sks_shs_ad_chg_kibo_ymd_err"))
			{
				inMap.put("sks_shs_ad_chg_kibo_ymd_err", template.getString(EKK0251D010CBSMsg.SKS_SHS_AD_CHG_KIBO_YMD_ERR));
			}
		}
		
		// サービス契約回線内訳登録.契約者住所変更希望年月日 → 契約者住所変更希望年月日のエラー情報返却
		if (!template.isNull(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("kshad_chg_kibo_ymd_err"))
			{
				inMap.put("kshad_chg_kibo_ymd_err", template.getString(EKK0251D010CBSMsg.KSHAD_CHG_KIBO_YMD_ERR));
			}
		}
		
		// サービス契約回線内訳登録.回線場所住所チェックレベル → 回線場所住所チェックレベルのエラー情報返却
		setErrInfo(inMap, "", EKK0251D010CBSMsg.KISN_AD_CHK_LV_ERR, template, EKK0251D010CBSMsg.KISN_AD_CHK_LV_ERR);

		return param;
	}

	/**
	 * エラー情報のマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int i = 0;

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

		// 登録用のCCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		// 契約種別
		String keisha_type_cd = (String)inMap.get("keisha_type_cd");
		// 連絡先メールアドレス
		String mlad = (String)inMap.get("ck020101_mlad");
		// 機器送付先住所コード
		String kikiSohusAdCd = (String)inMap.get("kiki_sohus_ad_cd");
		// 機器提供チェックフラグ
		boolean kktkChkFlg = (inMap.get("kktk_chk_flg") == null ? true : (Boolean)inMap.get("kktk_chk_flg"));

		// 契約種別が個人の場合設定する
		if (KEISHA_TYPE_CD_KOJIN.equals(keisha_type_cd))
		{
			editErrInfoECK0021D010(param, templates[i], returnCode, fixedText); // お客様＜個人＞登録
			i = i + 1;
			editErrInfoECK0201D010(param, templates[i], returnCode, fixedText, PREFIX_KOZIN); // 連絡先登録(個人の電話番号)
			i = i + 1;
		}
		else
		{
			editErrInfoECK0031D010(param, templates[i], returnCode, fixedText); // 連絡先登録(法人の内線番号)
			i = i + 1;
			if(null != (String)inMap.get(PREFIX_HOZIN_TEL + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_TEL + "telno")).length())
			{
				editErrInfoECK0201D010(param, templates[i++], returnCode, fixedText, PREFIX_HOZIN_TEL); // 連絡先登録(法人の電話番号)
			}
			if(null != (String)inMap.get(PREFIX_HOZIN_KEITAI + "telno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_KEITAI + "telno")).length())
			{
				editErrInfoECK0201D010(param, templates[i++], returnCode, fixedText, PREFIX_HOZIN_KEITAI); // 連絡先登録(法人の携帯電話番号)
			}
			if(null != (String)inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")
					&& 0 < ((String)inMap.get(PREFIX_HOZIN_NISNNO + "nisnno")).length())
			{
				editErrInfoECK0201D010(param, templates[i++], returnCode, fixedText, PREFIX_HOZIN_NISNNO); // 連絡先登録
			}
		}

		// メールアドレスが入力されている場合
		if (!"".equals(mlad) && mlad != null)
		{
			editErrInfoECK0201D010(param, templates[i], returnCode, fixedText, PREFIX_MLAD); // 連絡先登録(メールアドレス)
			i = i + 1;
		}

		// 機器送付先住所コード（kiki_sohus_ad_cd）が設定されている且つ、
		// 機器提供チェックフラグ（kktk_chk_flg）がfalseの場合
		if (kikiSohusAdCd != null && !"".equals(kikiSohusAdCd) && kktkChkFlg == false)
		{
			editErrInfoEKK0341D010(param, templates[i], returnCode, fixedText); // 機器提供サービス契約登録
			i = i + 1;
		}
		
		// 契約者住所変更希望年月日がnull以外かつ
		// 契約者住所変更希望年月日が空以外
		if (inMap.get("kshad_chg_kibo_ymd") != null && !"".equals((String)inMap.get("kshad_chg_kibo_ymd")))
		{
			editErrInfoEKK0251D010(param, templates[i], returnCode, fixedText); // サービス回線内訳登録
			i = i + 1;
		}

		return param;
	}

	/**
	 * 請求オプションサービスのワークエリアに値を設定する。。
	 * <br>
	 * @param param  リクエストパラメータ
	 * @param key    キー
	 * @param value  値
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setSiopsvcKeiWork(IRequestParameterReadWrite param, String key, String value) throws RequestParameterException
	{
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		seiopsvcWorkMap.put(key, value);

	}

	/**
	 * 単一CAANMsgのマッピング処理を行います。
	 * <br>
	 * @param paramMap
	 * @param template
	 * @return パラメータマップ
	 * @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 SCの実行ステータス
	 * @throws Exception
	 */
	private int getReturnCode(IRequestParameterReadWrite param) throws Exception
	{
		return Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
	}
	
	/**
	 * CAANMsgに値を設定します。<br>
	 *  �@inMap内にデータが存在する場合、inMap内のデータを設定します。<br>
	 *  �A上記以外の場合、setNullを呼び出します。<br>
	 * @param template 値を設定するメッセージキャリア
	 * @param setKey 設定先メッセージキャリアのキー名
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報より取得する場合に付加するプレフィックス
	 * @param getKey ユーザデータ情報より取得するキー名
	 */
	private void setTemplate(CAANMsg template, String setKey, HashMap<String, Object> inMap, String prefix, String getKey)
	{
		
		if (null == inMap || null == inMap.get(prefix + getKey) || 0 == ((String)inMap.get(prefix + getKey)).length())
		{
			template.setNull(setKey);
		}
		else
		{
			template.set(setKey, (String)inMap.get(prefix + getKey));
		}
	}
	
	/**
	 * エラー情報を設定します。<br>
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	private void setErrInfo(HashMap<String, Object> inMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (!template.isNull(getKey))
		{
			if (!inMap.containsKey(prefix + setKey))
			{
				inMap.put(prefix + setKey, template.getString(getKey));
			}
		}
	}

}