/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKGetSvcKeiNetCC
*   ソースファイル名：JKKGetSvcKeiNetCC.java
*   作成者          ：富士通
*   日付            ：2011年06月13日
*＜機能概要＞
*   契約者情報変更部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/06/13   FJ）松田    新規作成
*   v4.00.00    2012/07/13   FJ）谷口    【ANK-0398-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に向けた取り組み対応
*	v57.00.00	2022/01/13	 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.ECK0011C130CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011C130CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0021C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0031C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0041C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201B506CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201B506CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0201C010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201C030CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201E010CBSMsg;

/**
 * 契約者情報変更部品.
 * <br>
 * @author 富士通
 */
public class JKKUpdKeishaServiceCC extends AbstractCommonComponent
{

	/** テンプレートID */
	public static final String TEMPLATE_ID = "ECK0201D010";
	/** リターンメッセージ */
	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 PREFIX_RRS = "ck0201_";
	/** 契約者タイプ変更用プレフィックス */
	private static final String PREFIX_TYPE_CHG = "ck0011_";
	/** 連絡先登録リストキー名 */
	private static final String KEY_RRS_ADD = "rrs_add_list";
	/** 連絡先変更リストキー名 */
	private static final String KEY_RRS_UPD = "rrs_upd_list";
	/** 連絡先削除リストキー名 */
	private static final String KEY_RRS_DEL = "rrs_del_list";
	/** Blank定数 */
	private static final String BLANK = "";

	/**
	 * 契約者情報変更処理を行います。
	 * <br>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception Exceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite updKeishaService(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 sysid = getMapValue(param, fixedText, PREFIX_TYPE_CHG + ECK0011C130CBSMsg.SYSID);
		if(null != sysid && 0 < sysid.length())
		{
			// 契約者タイプ変更
			template = editInECK0011C130(param, fixedText, PREFIX_TYPE_CHG);	// 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle);		// SC呼び出し
			editRetECK0011C130(result, param, fixedText, PREFIX_TYPE_CHG);		// 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		// 契約種別
		String keisha_type_cd = getMapValue(param, fixedText, "keisha_type_cd");
		// 連絡先番号
		String ck020102RrksNo = getMapValue(param, fixedText, "ck020102_rrks_no");
		
		// 契約種別が個人の場合
		if ("1".equals(keisha_type_cd))
		{
			// お客様＜個人＞内容変更
			template = editInECK0021C010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0021C010(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		// 契約種別が個人以外の場合
		else
		{
			// お客様＜法人＞内容変更
			template = editInECK0031C010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0031C010(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}

			// 法人連絡先変更
			template = editInECK0041C010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0041C010(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		// 契約者情報変更マップ.連絡先番号（ck020102_rrks_no）が設定されている場合
		if (ck020102RrksNo != null && !"".equals(ck020102RrksNo))
		{
			// 連絡先メールアドレス本登録
			template = editInECK0201C030(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0201C030(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		ArrayList<HashMap<String, Object>> rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_ADD); 
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			// 連絡先登録
			template = editInECK0201D010(param, fixedText, PREFIX_RRS, rrsMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0201D010(result, param, fixedText, PREFIX_RRS, rrsMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_UPD);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			// 連絡先変更
			template = editInECK0201C010(param, fixedText, PREFIX_RRS, rrsMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0201C010(result, param, PREFIX_RRS, rrsMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_DEL);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			// 連絡先世代情報一覧照会（連絡先番号）
			template = editInECK0201B506(param, fixedText, PREFIX_RRS, rrsMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0201B506(result, param, fixedText, PREFIX_RRS, rrsMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			ArrayList<HashMap> msg1List = (ArrayList<HashMap>)rrsMap.get(PREFIX_RRS + ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST);
			msg1List = (null == msg1List) ? new ArrayList<HashMap>() : msg1List;
			String updDtmBf = (String)rrsMap.get(PREFIX_RRS + ECK0201E010CBSMsg.UPD_DTM_BF);
			for(HashMap msgMap : msg1List)
			{
				// 連絡先論理削除
				template = editInECK0201E010(param, fixedText, PREFIX_RRS, msgMap, updDtmBf); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetECK0201E010(result, param, fixedText, PREFIX_RRS, msgMap); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}
		
		return param;
	}

	/**
	 * 契約者情報変更処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();

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

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

		String sysid = getMapValue(param, fixedText, PREFIX_TYPE_CHG + ECK0011C130CBSMsg.SYSID);
		if(null != sysid && 0 < sysid.length())
		{
			msgList.add(editInECK0011C130(param, fixedText, PREFIX_TYPE_CHG));	// 契約者タイプ変更
		}
		
		// 契約種別
		String keisha_type_cd = getMapValue(param, fixedText, "keisha_type_cd");
		// 連絡先番号
		String ck020102RrksNo = getMapValue(param, fixedText, "ck020102_rrks_no");

		// 契約種別が個人の場合
		if ("1".equals(keisha_type_cd))
		{
			msgList.add(editInECK0021C010(param, fixedText)); // お客様＜個人＞内容変更
		}
		// 契約種別が個人以外の場合
		else
		{
			msgList.add(editInECK0031C010(param, fixedText)); // // お客様＜法人＞内容変更
			msgList.add(editInECK0041C010(param, fixedText)); // 法人連絡先変更
		}

		// 契約者情報変更マップ.連絡先番号（ck020102_rrks_no）が設定されている場合
		if (ck020102RrksNo != null && "".equals(ck020102RrksNo))
		{
			msgList.add(editInECK0201C030(param, fixedText)); // 連絡先メールアドレス本登録
		}

		ArrayList<HashMap<String, Object>> rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_ADD);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			msgList.add(editInECK0201D010(param, fixedText, PREFIX_RRS, rrsMap)); // 連絡先情報登録
		}
		
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_UPD);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			msgList.add(editInECK0201C010(param, fixedText, PREFIX_RRS, rrsMap)); // 連絡先情報変更
		}
		
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_DEL);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			msgList.add(editInECK0201B506(param, fixedText, PREFIX_RRS, rrsMap)); // 連絡先世代情報一覧照会（連絡先番号）
			
			ArrayList<HashMap> msg1List = (ArrayList<HashMap>)rrsMap.get(PREFIX_RRS + ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST);
			msg1List = (null == msg1List) ? new ArrayList<HashMap>() : msg1List;
			String updDtmBf = (String)rrsMap.get(PREFIX_RRS + ECK0201E010CBSMsg.UPD_DTM_BF);
			for(HashMap msgMap : msg1List)
			{
				msgList.add(editInECK0201E010(param, fixedText, PREFIX_RRS, msgMap, updDtmBf)); // 連絡先論理削除
			}
		}
		
		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 パラメータマップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0021C010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

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

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

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

		// お客様<個人>内容変更.SYSID（お客様＜個人＞内容変更） → SYSID
		if (inMap == null || inMap.get("ck0021_sysid") == null || "".equals(inMap.get("ck0021_sysid")))
		{
			template.setNull(ECK0021C010CBSMsg.SYSID);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SYSID, (String)inMap.get("ck0021_sysid"));
		}

		// お客様<個人>内容変更.お客様名（お客様＜個人＞内容変更） → お客様名
		if (inMap == null || inMap.get("ck0021_cust_nm") == null || "".equals(inMap.get("ck0021_cust_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_NM, (String)inMap.get("ck0021_cust_nm"));
		}

		// お客様<個人>内容変更.お客様カナ名（お客様＜個人＞内容変更） → お客様カナ名
		if (inMap == null || inMap.get("ck0021_cust_kana") == null || "".equals(inMap.get("ck0021_cust_kana")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_KANA);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_KANA, (String)inMap.get("ck0021_cust_kana"));
		}

		// お客様<個人>内容変更.お客様性別コード（お客様＜個人＞内容変更） → お客様性別コード
		if (inMap == null || inMap.get("ck0021_cust_sex_cd") == null || "".equals(inMap.get("ck0021_cust_sex_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_SEX_CD, (String)inMap.get("ck0021_cust_sex_cd"));
		}

		// お客様<個人>内容変更.お客様生年月日（お客様＜個人＞内容変更） → お客様生年月日
		if (inMap == null || inMap.get("ck0021_cust_birthd") == null || "".equals(inMap.get("ck0021_cust_birthd")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_BIRTHD, (String)inMap.get("ck0021_cust_birthd"));
		}

		// お客様<個人>内容変更.氏名敬称（お客様＜個人＞内容変更） → 氏名敬称
		if (inMap == null || inMap.get("ck0021_nm_kisho") == null || "".equals(inMap.get("ck0021_nm_kisho")))
		{
			template.setNull(ECK0021C010CBSMsg.NM_KISHO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.NM_KISHO, (String)inMap.get("ck0021_nm_kisho"));
		}

		// お客様<個人>内容変更.お客様確認備考 → お客様確認備考
		if (inMap == null || inMap.get("ck0021_cust_cfm_biko") == null || "".equals(inMap.get("ck0021_cust_cfm_biko")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_CFM_BIKO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_CFM_BIKO, (String)inMap.get("ck0021_cust_cfm_biko"));
		}

		// お客様<個人>内容変更.契約者住所コード（お客様＜個人＞内容変更） → 契約者住所コード
		if (inMap == null || inMap.get("ck0021_keisha_ad_cd") == null || "".equals(inMap.get("ck0021_keisha_ad_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_AD_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_AD_CD, (String)inMap.get("ck0021_keisha_ad_cd"));
		}

		// お客様<個人>内容変更.契約者郵便番号（お客様＜個人＞内容変更） → 契約者郵便番号
		if (inMap == null || inMap.get("ck0021_keisha_pcd") == null || "".equals(inMap.get("ck0021_keisha_pcd")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_PCD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_PCD, (String)inMap.get("ck0021_keisha_pcd"));
		}

		// お客様<個人>内容変更.契約者都道府県名（お客様＜個人＞内容変更） → 契約者都道府県名
		if (inMap == null || inMap.get("ck0021_keisha_state_nm") == null || "".equals(inMap.get("ck0021_keisha_state_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_STATE_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_STATE_NM, (String)inMap.get("ck0021_keisha_state_nm"));
		}

		// お客様<個人>内容変更.契約者市区町村名（お客様＜個人＞内容変更） → 契約者市区町村名
		if (inMap == null || inMap.get("ck0021_keisha_city_nm") == null || "".equals(inMap.get("ck0021_keisha_city_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_CITY_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_CITY_NM, (String)inMap.get("ck0021_keisha_city_nm"));
		}

		// お客様<個人>内容変更.契約者大字通称名（お客様＜個人＞内容変更） → 契約者大字通称名
		if (inMap == null || inMap.get("ck0021_keisha_oaztsu_nm") == null || "".equals(inMap.get("ck0021_keisha_oaztsu_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_OAZTSU_NM, (String)inMap.get("ck0021_keisha_oaztsu_nm"));
		}

		// お客様<個人>内容変更.契約者字丁目名（お客様＜個人＞内容変更） → 契約者字丁目名
		if (inMap == null || inMap.get("ck0021_keisha_azcho_nm") == null || "".equals(inMap.get("ck0021_keisha_azcho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_AZCHO_NM, (String)inMap.get("ck0021_keisha_azcho_nm"));
		}

		// お客様<個人>内容変更.契約者番地号（お客様＜個人＞内容変更） → 契約者番地号
		if (inMap == null || inMap.get("ck0021_keisha_bnchigo") == null || "".equals(inMap.get("ck0021_keisha_bnchigo")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_BNCHIGO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_BNCHIGO, (String)inMap.get("ck0021_keisha_bnchigo"));
		}

		// お客様<個人>内容変更.契約者住所補記・建物名（お客様＜個人＞内容変更） → 契約者住所補記・建物名
		if (inMap == null || inMap.get("ck0021_keisha_adrttm") == null || "".equals(inMap.get("ck0021_keisha_adrttm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_ADRTTM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_ADRTTM, (String)inMap.get("ck0021_keisha_adrttm"));
		}

		// お客様<個人>内容変更.契約者住所補記・部屋番号（お客様＜個人＞内容変更） → 契約者住所補記・部屋番号
		if (inMap == null || inMap.get("ck0021_keisha_adrrm") == null || "".equals(inMap.get("ck0021_keisha_adrrm")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_ADRRM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_ADRRM, (String)inMap.get("ck0021_keisha_adrrm"));
		}

		// お客様<個人>内容変更.契約者電話番号（お客様＜個人＞内容変更） → 契約者電話番号
		if (inMap == null || inMap.get("ck0021_keisha_telno") == null || "".equals(inMap.get("ck0021_keisha_telno")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_TELNO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_TELNO, (String)inMap.get("ck0021_keisha_telno"));
		}

		// お客様<個人>内容変更.お客様ランクコード（お客様＜個人＞内容変更） → お客様ランクコード
		if (inMap == null || inMap.get("ck0021_cust_rank_cd") == null || "".equals(inMap.get("ck0021_cust_rank_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_RANK_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_RANK_CD, (String)inMap.get("ck0021_cust_rank_cd"));
		}

		// お客様<個人>内容変更.連絡手段コード（お客様＜個人＞内容変更） → 連絡手段コード
		if (inMap == null || inMap.get("ck0021_rrk_way_cd") == null || "".equals(inMap.get("ck0021_rrk_way_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.RRK_WAY_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.RRK_WAY_CD, (String)inMap.get("ck0021_rrk_way_cd"));
		}

		// お客様<個人>内容変更.連絡手段補記（お客様＜個人＞内容変更） → 連絡手段補記
		if (inMap == null || inMap.get("ck0021_rrk_way_hoki") == null || "".equals(inMap.get("ck0021_rrk_way_hoki")))
		{
			template.setNull(ECK0021C010CBSMsg.RRK_WAY_HOKI);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.RRK_WAY_HOKI, (String)inMap.get("ck0021_rrk_way_hoki"));
		}

		// お客様<個人>内容変更.コンテンツお客様名 → コンテンツお客様名
		if (inMap == null || inMap.get("ck0021_cont_cust_nm") == null || "".equals(inMap.get("ck0021_cont_cust_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_CUST_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_CUST_NM, (String)inMap.get("ck0021_cont_cust_nm"));
		}

		// お客様<個人>内容変更.コンテンツお客様カナ名 → コンテンツお客様カナ名
		if (inMap == null || inMap.get("ck0021_cont_cust_kana") == null || "".equals(inMap.get("ck0021_cont_cust_kana")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_CUST_KANA);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_CUST_KANA, (String)inMap.get("ck0021_cont_cust_kana"));
		}

		// お客様<個人>内容変更.コンテンツお客様性別コード → コンテンツお客様性別コード
		if (inMap == null || inMap.get("ck0021_cont_cust_sex_cd") == null || "".equals(inMap.get("ck0021_cont_cust_sex_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_CUST_SEX_CD, (String)inMap.get("ck0021_cont_cust_sex_cd"));
		}

		// お客様<個人>内容変更.コンテンツお客様生年月日 → コンテンツお客様生年月日
		if (inMap == null || inMap.get("ck0021_cont_cust_birthd") == null || "".equals(inMap.get("ck0021_cont_cust_birthd")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_CUST_BIRTHD, (String)inMap.get("ck0021_cont_cust_birthd"));
		}

		// お客様<個人>内容変更.コンテンツ住所コード → コンテンツ住所コード
		if (inMap == null || inMap.get("ck0021_cont_ad_cd") == null || "".equals(inMap.get("ck0021_cont_ad_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_AD_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_AD_CD, (String)inMap.get("ck0021_cont_ad_cd"));
		}

		// お客様<個人>内容変更.コンテンツ郵便番号 → コンテンツ郵便番号
		if (inMap == null || inMap.get("ck0021_cont_pcd") == null || "".equals(inMap.get("ck0021_cont_pcd")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_PCD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_PCD, (String)inMap.get("ck0021_cont_pcd"));
		}

		// お客様<個人>内容変更.コンテンツ都道府県名 → コンテンツ都道府県名
		if (inMap == null || inMap.get("ck0021_cont_state_nm") == null || "".equals(inMap.get("ck0021_cont_state_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_STATE_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_STATE_NM, (String)inMap.get("ck0021_cont_state_nm"));
		}

		// お客様<個人>内容変更.コンテンツ市区町村名 → コンテンツ市区町村名
		if (inMap == null || inMap.get("ck0021_cont_city_nm") == null || "".equals(inMap.get("ck0021_cont_city_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_CITY_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_CITY_NM, (String)inMap.get("ck0021_cont_city_nm"));
		}

		// お客様<個人>内容変更.コンテンツ大字通称名 → コンテンツ大字通称名
		if (inMap == null || inMap.get("ck0021_cont_oaztsu_nm") == null || "".equals(inMap.get("ck0021_cont_oaztsu_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_OAZTSU_NM, (String)inMap.get("ck0021_cont_oaztsu_nm"));
		}

		// お客様<個人>内容変更.コンテンツ字丁目名 → コンテンツ字丁目名
		if (inMap == null || inMap.get("ck0021_cont_azcho_nm") == null || "".equals(inMap.get("ck0021_cont_azcho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_AZCHO_NM, (String)inMap.get("ck0021_cont_azcho_nm"));
		}

		// お客様<個人>内容変更.コンテンツ番地号 → コンテンツ番地号
		if (inMap == null || inMap.get("ck0021_cont_bnchigo") == null || "".equals(inMap.get("ck0021_cont_bnchigo")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_BNCHIGO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_BNCHIGO, (String)inMap.get("ck0021_cont_bnchigo"));
		}

		// お客様<個人>内容変更.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名
		if (inMap == null || inMap.get("ck0021_cont_adrttm") == null || "".equals(inMap.get("ck0021_cont_adrttm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_ADRTTM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_ADRTTM, (String)inMap.get("ck0021_cont_adrttm"));
		}

		// お客様<個人>内容変更.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号
		if (inMap == null || inMap.get("ck0021_cont_adrrm") == null || "".equals(inMap.get("ck0021_cont_adrrm")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_ADRRM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_ADRRM, (String)inMap.get("ck0021_cont_adrrm"));
		}

		// お客様<個人>内容変更.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置
		if (inMap == null || inMap.get("ck0021_cont_ad_bnkt_sta_pst") == null || "".equals(inMap.get("ck0021_cont_ad_bnkt_sta_pst")))
		{
			template.setNull(ECK0021C010CBSMsg.CONT_AD_BNKT_STA_PST);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CONT_AD_BNKT_STA_PST, (String)inMap.get("ck0021_cont_ad_bnkt_sta_pst"));
		}

		// お客様<個人>内容変更.予約適用年月日（お客様＜個人＞内容変更） → 予約適用年月日
		if (inMap == null || inMap.get("ck0021_rsv_aply_ymd") == null || "".equals(inMap.get("ck0021_rsv_aply_ymd")))
		{
			template.set(ECK0021C010CBSMsg.RSV_APLY_YMD, JPCBPCommon.getOpeDate(null));
		}
		else
		{
			template.set(ECK0021C010CBSMsg.RSV_APLY_YMD, (String)inMap.get("ck0021_rsv_aply_ymd"));
		}

		// お客様<個人>内容変更.内販外販コード（お客様＜個人＞内容変更） → 内販外販コード
		if (inMap == null || inMap.get("ck0021_naihan_gaihan_cd") == null || "".equals(inMap.get("ck0021_naihan_gaihan_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.NAIHAN_GAIHAN_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.NAIHAN_GAIHAN_CD, (String)inMap.get("ck0021_naihan_gaihan_cd"));
		}

		// お客様<個人>内容変更.内販企業識別コード（お客様＜個人＞内容変更） → 内販企業識別コード
		if (inMap == null || inMap.get("ck0021_naihan_comp_skbt_cd") == null || "".equals(inMap.get("ck0021_naihan_comp_skbt_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.NAIHAN_COMP_SKBT_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.NAIHAN_COMP_SKBT_CD, (String)inMap.get("ck0021_naihan_comp_skbt_cd"));
		}

		// お客様<個人>内容変更.要補助コード（お客様＜個人＞内容変更） → 要補助コード
		if (inMap == null || inMap.get("ck0021_necessary_hojo_cd") == null || "".equals(inMap.get("ck0021_necessary_hojo_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.NECESSARY_HOJO_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.NECESSARY_HOJO_CD, (String)inMap.get("ck0021_necessary_hojo_cd"));
		}

		// お客様<個人>内容変更.ｅｏｎｅｔＩＤ未移行フラグ（お客様＜個人＞内容変更） → ｅｏｎｅｔＩＤ未移行フラグ
		if (inMap == null || inMap.get("ck0021_eonetid_mi_iko_flg") == null || "".equals(inMap.get("ck0021_eonetid_mi_iko_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.EONETID_MI_IKO_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.EONETID_MI_IKO_FLG, (String)inMap.get("ck0021_eonetid_mi_iko_flg"));
		}

		// お客様<個人>内容変更.ログイン認証可否（お客様＜個人＞内容変更） → ログイン認証可否
		if (inMap == null || inMap.get("ck0021_login_ninsho_kh") == null || "".equals(inMap.get("ck0021_login_ninsho_kh")))
		{
			template.setNull(ECK0021C010CBSMsg.LOGIN_NINSHO_KH);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.LOGIN_NINSHO_KH, (String)inMap.get("ck0021_login_ninsho_kh"));
		}

		// お客様<個人>内容変更.お客様特記事項コード（お客様＜個人＞内容変更） → お客様特記事項コード
		if (inMap == null || inMap.get("ck0021_cust_tkjk_cd") == null || "".equals(inMap.get("ck0021_cust_tkjk_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_TKJK_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_TKJK_CD, (String)inMap.get("ck0021_cust_tkjk_cd"));
		}

		// お客様<個人>内容変更.ログイン認証停止年月日（お客様＜個人＞内容変更） → ログイン認証停止年月日
		if (inMap == null || inMap.get("ck0021_login_ninsho_stp_ymd") == null || "".equals(inMap.get("ck0021_login_ninsho_stp_ymd")))
		{
			template.setNull(ECK0021C010CBSMsg.LOGIN_NINSHO_STP_YMD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.LOGIN_NINSHO_STP_YMD, (String)inMap.get("ck0021_login_ninsho_stp_ymd"));
		}

		// お客様<個人>内容変更.会員種別特定フラグ（お客様＜個人＞内容変更） → 会員種別特定フラグ
		if (inMap == null || inMap.get("ck0021_mmb_sbt_tokut_flg") == null || "".equals(inMap.get("ck0021_mmb_sbt_tokut_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.MMB_SBT_TOKUT_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.MMB_SBT_TOKUT_FLG, (String)inMap.get("ck0021_mmb_sbt_tokut_flg"));
		}

		// お客様<個人>内容変更.旧eonet会員認証用ID → 旧eonet会員認証用ID
		if (inMap == null || inMap.get("ck0021_old_eonetmb_ninsho_id") == null || "".equals(inMap.get("ck0021_old_eonetmb_ninsho_id")))
		{
			template.setNull(ECK0021C010CBSMsg.OLD_EONETMB_NINSHO_ID);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OLD_EONETMB_NINSHO_ID, (String)inMap.get("ck0021_old_eonetmb_ninsho_id"));
		}

		// お客様<個人>内容変更.会員ISP決済状態コード → 会員ISP決済状態コード
		if (inMap == null || inMap.get("ck0021_mmb_isp_kssai_stat_cd") == null || "".equals(inMap.get("ck0021_mmb_isp_kssai_stat_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.MMB_ISP_KSSAI_STAT_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.MMB_ISP_KSSAI_STAT_CD, (String)inMap.get("ck0021_mmb_isp_kssai_stat_cd"));
		}

		// お客様<個人>内容変更.削除対象外フラグ → 削除対象外フラグ
		if (inMap == null || inMap.get("ck0021_del_trgt_gai_flg") == null || "".equals(inMap.get("ck0021_del_trgt_gai_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.DEL_TRGT_GAI_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.DEL_TRGT_GAI_FLG, (String)inMap.get("ck0021_del_trgt_gai_flg"));
		}

		// お客様<個人>内容変更.職業コード（お客様＜個人＞内容変更） → 職業コード
		if (inMap == null || inMap.get("ck0021_shokugyo_cd") == null || "".equals(inMap.get("ck0021_shokugyo_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.SHOKUGYO_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SHOKUGYO_CD, (String)inMap.get("ck0021_shokugyo_cd"));
		}

		// お客様<個人>内容変更.職業その他（お客様＜個人＞内容変更） → 職業その他
		if (inMap == null || inMap.get("ck0021_shokugyo_other") == null || "".equals(inMap.get("ck0021_shokugyo_other")))
		{
			template.setNull(ECK0021C010CBSMsg.SHOKUGYO_OTHER);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SHOKUGYO_OTHER, (String)inMap.get("ck0021_shokugyo_other"));
		}

		// お客様<個人>内容変更.勤務先名（お客様＜個人＞内容変更） → 勤務先名
		if (inMap == null || inMap.get("ck0021_offc_nm") == null || "".equals(inMap.get("ck0021_offc_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_NM, (String)inMap.get("ck0021_offc_nm"));
		}

		// お客様<個人>内容変更.学校名（お客様＜個人＞内容変更） → 学校名
		if (inMap == null || inMap.get("ck0021_school_nm") == null || "".equals(inMap.get("ck0021_school_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SCHOOL_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SCHOOL_NM, (String)inMap.get("ck0021_school_nm"));
		}

		// お客様<個人>内容変更.勤務先業種コード（お客様＜個人＞内容変更） → 勤務先業種コード
		if (inMap == null || inMap.get("ck0021_offc_gshu_cd") == null || "".equals(inMap.get("ck0021_offc_gshu_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_GSHU_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_GSHU_CD, (String)inMap.get("ck0021_offc_gshu_cd"));
		}

		// お客様<個人>内容変更.勤務先部署名（お客様＜個人＞内容変更） → 勤務先部署名
		if (inMap == null || inMap.get("ck0021_offc_busho_nm") == null || "".equals(inMap.get("ck0021_offc_busho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_BUSHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_BUSHO_NM, (String)inMap.get("ck0021_offc_busho_nm"));
		}

		// お客様<個人>内容変更.勤務先住所コード（お客様＜個人＞内容変更） → 勤務先住所コード
		if (inMap == null || inMap.get("ck0021_offc_ad_cd") == null || "".equals(inMap.get("ck0021_offc_ad_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_AD_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_AD_CD, (String)inMap.get("ck0021_offc_ad_cd"));
		}

		// お客様<個人>内容変更.勤務先郵便番号（お客様＜個人＞内容変更） → 勤務先郵便番号
		if (inMap == null || inMap.get("ck0021_offc_pcd") == null || "".equals(inMap.get("ck0021_offc_pcd")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_PCD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_PCD, (String)inMap.get("ck0021_offc_pcd"));
		}

		// お客様<個人>内容変更.勤務先都道府県名（お客様＜個人＞内容変更） → 勤務先都道府県名
		if (inMap == null || inMap.get("ck0021_offc_state_nm") == null || "".equals(inMap.get("ck0021_offc_state_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_STATE_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_STATE_NM, (String)inMap.get("ck0021_offc_state_nm"));
		}

		// お客様<個人>内容変更.勤務先市区町村名（お客様＜個人＞内容変更） → 勤務先市区町村名
		if (inMap == null || inMap.get("ck0021_offc_city_nm") == null || "".equals(inMap.get("ck0021_offc_city_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_CITY_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_CITY_NM, (String)inMap.get("ck0021_offc_city_nm"));
		}

		// お客様<個人>内容変更.勤務先大字通称名（お客様＜個人＞内容変更） → 勤務先大字通称名
		if (inMap == null || inMap.get("ck0021_offc_oaztsu_nm") == null || "".equals(inMap.get("ck0021_offc_oaztsu_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_OAZTSU_NM, (String)inMap.get("ck0021_offc_oaztsu_nm"));
		}

		// お客様<個人>内容変更.勤務先字丁目名（お客様＜個人＞内容変更） → 勤務先字丁目名
		if (inMap == null || inMap.get("ck0021_offc_azcho_nm") == null || "".equals(inMap.get("ck0021_offc_azcho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_AZCHO_NM, (String)inMap.get("ck0021_offc_azcho_nm"));
		}

		// お客様<個人>内容変更.勤務先番地号（お客様＜個人＞内容変更） → 勤務先番地号
		if (inMap == null || inMap.get("ck0021_offc_bnchigo") == null || "".equals(inMap.get("ck0021_offc_bnchigo")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_BNCHIGO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_BNCHIGO, (String)inMap.get("ck0021_offc_bnchigo"));
		}

		// お客様<個人>内容変更.勤務先住所補記・建物名（お客様＜個人＞内容変更） → 勤務先住所補記・建物名
		if (inMap == null || inMap.get("ck0021_offc_adrttm") == null || "".equals(inMap.get("ck0021_offc_adrttm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_ADRTTM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_ADRTTM, (String)inMap.get("ck0021_offc_adrttm"));
		}

		// お客様<個人>内容変更.勤務先住所補記・部屋番号（お客様＜個人＞内容変更） → 勤務先住所補記・部屋番号
		if (inMap == null || inMap.get("ck0021_offc_adrrm") == null || "".equals(inMap.get("ck0021_offc_adrrm")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_ADRRM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_ADRRM, (String)inMap.get("ck0021_offc_adrrm"));
		}

		// お客様<個人>内容変更.勤務先電話番号（お客様＜個人＞内容変更） → 勤務先電話番号
		if (inMap == null || inMap.get("ck0021_offc_telno") == null || "".equals(inMap.get("ck0021_offc_telno")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_TELNO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_TELNO, (String)inMap.get("ck0021_offc_telno"));
		}

		// お客様<個人>内容変更.勤務先内線番号（お客様＜個人＞内容変更） → 勤務先内線番号
		if (inMap == null || inMap.get("ck0021_offc_nisnno") == null || "".equals(inMap.get("ck0021_offc_nisnno")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_NISNNO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_NISNNO, (String)inMap.get("ck0021_offc_nisnno"));
		}

		// お客様<個人>内容変更.勤務先従業員数(規模)（お客様＜個人＞内容変更） → 勤務先従業員数(規模)
		if (inMap == null || inMap.get("ck0021_offc_worker_cnt_scale") == null || "".equals(inMap.get("ck0021_offc_worker_cnt_scale")))
		{
			template.setNull(ECK0021C010CBSMsg.OFFC_WORKER_CNT_SCALE);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.OFFC_WORKER_CNT_SCALE, (String)inMap.get("ck0021_offc_worker_cnt_scale"));
		}

		// お客様<個人>内容変更.お客様年収（お客様＜個人＞内容変更） → お客様年収
		if (inMap == null || inMap.get("ck0021_cust_salary") == null || "".equals(inMap.get("ck0021_cust_salary")))
		{
			template.setNull(ECK0021C010CBSMsg.CUST_SALARY);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CUST_SALARY, (String)inMap.get("ck0021_cust_salary"));
		}

		// お客様<個人>内容変更.親権者名（お客様＜個人＞内容変更） → 親権者名
		if (inMap == null || inMap.get("ck0021_sksha_nm") == null || "".equals(inMap.get("ck0021_sksha_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_NM, (String)inMap.get("ck0021_sksha_nm"));
		}

		// お客様<個人>内容変更.親権者カナ名（お客様＜個人＞内容変更） → 親権者カナ名
		if (inMap == null || inMap.get("ck0021_sksha_kana") == null || "".equals(inMap.get("ck0021_sksha_kana")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_KANA);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_KANA, (String)inMap.get("ck0021_sksha_kana"));
		}

		// お客様<個人>内容変更.親権者生年月日（お客様＜個人＞内容変更） → 親権者生年月日
		if (inMap == null || inMap.get("ck0021_sksha_birthd") == null || "".equals(inMap.get("ck0021_sksha_birthd")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_BIRTHD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_BIRTHD, (String)inMap.get("ck0021_sksha_birthd"));
		}

		// お客様<個人>内容変更.親権者続柄コード（お客様＜個人＞内容変更） → 親権者続柄コード
		if (inMap == null || inMap.get("ck0021_sksha_zokugara_cd") == null || "".equals(inMap.get("ck0021_sksha_zokugara_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_ZOKUGARA_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_ZOKUGARA_CD, (String)inMap.get("ck0021_sksha_zokugara_cd"));
		}

		// お客様<個人>内容変更.続柄その他（お客様＜個人＞内容変更） → 続柄その他
		if (inMap == null || inMap.get("ck0021_zokugara_other") == null || "".equals(inMap.get("ck0021_zokugara_other")))
		{
			template.setNull(ECK0021C010CBSMsg.ZOKUGARA_OTHER);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.ZOKUGARA_OTHER, (String)inMap.get("ck0021_zokugara_other"));
		}

		// お客様<個人>内容変更.親権者住所コード（お客様＜個人＞内容変更） → 親権者住所コード
		if (inMap == null || inMap.get("ck0021_sksha_ad_cd") == null || "".equals(inMap.get("ck0021_sksha_ad_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_AD_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_AD_CD, (String)inMap.get("ck0021_sksha_ad_cd"));
		}

		// お客様<個人>内容変更.親権者郵便番号（お客様＜個人＞内容変更） → 親権者郵便番号
		if (inMap == null || inMap.get("ck0021_sksha_pcd") == null || "".equals(inMap.get("ck0021_sksha_pcd")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_PCD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_PCD, (String)inMap.get("ck0021_sksha_pcd"));
		}

		// お客様<個人>内容変更.親権者都道府県名（お客様＜個人＞内容変更） → 親権者都道府県名
		if (inMap == null || inMap.get("ck0021_sksha_state_nm") == null || "".equals(inMap.get("ck0021_sksha_state_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_STATE_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_STATE_NM, (String)inMap.get("ck0021_sksha_state_nm"));
		}

		// お客様<個人>内容変更.親権者市区町村名（お客様＜個人＞内容変更） → 親権者市区町村名
		if (inMap == null || inMap.get("ck0021_sksha_city_nm") == null || "".equals(inMap.get("ck0021_sksha_city_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_CITY_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_CITY_NM, (String)inMap.get("ck0021_sksha_city_nm"));
		}

		// お客様<個人>内容変更.親権者大字通称名（お客様＜個人＞内容変更） → 親権者大字通称名
		if (inMap == null || inMap.get("ck0021_sksha_oaztsu_nm") == null || "".equals(inMap.get("ck0021_sksha_oaztsu_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_OAZTSU_NM, (String)inMap.get("ck0021_sksha_oaztsu_nm"));
		}

		// お客様<個人>内容変更.親権者字丁目名（お客様＜個人＞内容変更） → 親権者字丁目名
		if (inMap == null || inMap.get("ck0021_sksha_azcho_nm") == null || "".equals(inMap.get("ck0021_sksha_azcho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_AZCHO_NM, (String)inMap.get("ck0021_sksha_azcho_nm"));
		}

		// お客様<個人>内容変更.親権者住所番地号（お客様＜個人＞内容変更） → 親権者住所番地号
		if (inMap == null || inMap.get("ck0021_sksha_ad_bnchigo") == null || "".equals(inMap.get("ck0021_sksha_ad_bnchigo")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_AD_BNCHIGO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_AD_BNCHIGO, (String)inMap.get("ck0021_sksha_ad_bnchigo"));
		}

		// お客様<個人>内容変更.親権者住所補記・建物名（お客様＜個人＞内容変更） → 親権者住所補記・建物名
		if (inMap == null || inMap.get("ck0021_sksha_adrttm") == null || "".equals(inMap.get("ck0021_sksha_adrttm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_ADRTTM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_ADRTTM, (String)inMap.get("ck0021_sksha_adrttm"));
		}

		// お客様<個人>内容変更.親権者住所補記・部屋番号（お客様＜個人＞内容変更） → 親権者住所補記・部屋番号
		if (inMap == null || inMap.get("ck0021_sksha_adrrm") == null || "".equals(inMap.get("ck0021_sksha_adrrm")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_ADRRM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_ADRRM, (String)inMap.get("ck0021_sksha_adrrm"));
		}

		// お客様<個人>内容変更.親権者電話番号（お客様＜個人＞内容変更） → 親権者電話番号
		if (inMap == null || inMap.get("ck0021_sksha_telno") == null || "".equals(inMap.get("ck0021_sksha_telno")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_TELNO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_TELNO, (String)inMap.get("ck0021_sksha_telno"));
		}

		// お客様<個人>内容変更.契約者住所手動入力フラグ（お客様＜個人＞内容変更） → 契約者住所手動入力フラグ
		if (inMap == null || inMap.get("ck0021_keisha_ad_man_input_flg") == null || "".equals(inMap.get("ck0021_keisha_ad_man_input_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG, (String)inMap.get("ck0021_keisha_ad_man_input_flg"));
		}
		
		// お客様<個人>内容変更.親権者住所手動入力フラグ（お客様＜個人＞内容変更） → 親権者住所手動入力フラグ
		if (inMap == null || inMap.get("ck0021_sksha_ad_man_input_flg") == null || "".equals(inMap.get("ck0021_sksha_ad_man_input_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.SKSHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.SKSHA_AD_MAN_INPUT_FLG, (String)inMap.get("ck0021_sksha_ad_man_input_flg"));
		}

		// お客様<個人>内容変更.お客様指定送付先住所コード（お客様＜個人＞内容変更） →お客様指定送付先住所コード
		if (inMap == null || inMap.get("ck0021_cssti_shs_ad_cd") == null || "".equals(inMap.get("ck0021_cssti_shs_ad_cd")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_AD_CD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_AD_CD, (String)inMap.get("ck0021_cssti_shs_ad_cd"));
		}

		// お客様<個人>内容変更.お客様指定送付先郵便番号（お客様＜個人＞内容変更） →お客様指定送付先郵便番号
		if (inMap == null || inMap.get("ck0021_cssti_shs_pcd") == null || "".equals(inMap.get("ck0021_cssti_shs_pcd")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_PCD);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_PCD, (String)inMap.get("ck0021_cssti_shs_pcd"));
		}

		// お客様<個人>内容変更.お客様指定送付先都道府県名（お客様＜個人＞内容変更） →お客様指定送付先都道府県名
		if (inMap == null || inMap.get("ck0021_cssti_shs_state_nm") == null || "".equals(inMap.get("ck0021_cssti_shs_state_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_STATE_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_STATE_NM, (String)inMap.get("ck0021_cssti_shs_state_nm"));
		}

		// お客様<個人>内容変更.お客様指定送付先市区町村名（お客様＜個人＞内容変更） →お客様指定送付先市区町村名
		if (inMap == null || inMap.get("ck0021_cssti_shs_city_nm") == null || "".equals(inMap.get("ck0021_cssti_shs_city_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_CITY_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_CITY_NM, (String)inMap.get("ck0021_cssti_shs_city_nm"));
		}

		// お客様<個人>内容変更.お客様指定送付先大字通称名（お客様＜個人＞内容変更） →お客様指定送付先大字通称名
		if (inMap == null || inMap.get("ck0021_cssti_shs_oaztsu_nm") == null || "".equals(inMap.get("ck0021_cssti_shs_oaztsu_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_OAZTSU_NM, (String)inMap.get("ck0021_cssti_shs_oaztsu_nm"));
		}

		// お客様<個人>内容変更.お客様指定送付先字丁目名（お客様＜個人＞内容変更） →お客様指定送付先字丁目名
		if (inMap == null || inMap.get("ck0021_cssti_shs_azcho_nm") == null || "".equals(inMap.get("ck0021_cssti_shs_azcho_nm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_AZCHO_NM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_AZCHO_NM, (String)inMap.get("ck0021_cssti_shs_azcho_nm"));
		}

		// お客様<個人>内容変更.お客様指定送付先番地号（お客様＜個人＞内容変更） →お客様指定送付先番地号
		if (inMap == null || inMap.get("ck0021_cssti_shs_bnchigo") == null || "".equals(inMap.get("ck0021_cssti_shs_bnchigo")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_BNCHIGO);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_BNCHIGO, (String)inMap.get("ck0021_cssti_shs_bnchigo"));
		}

		// お客様<個人>内容変更.お客様指定送付先住所補記・建物名（お客様＜個人＞内容変更） →お客様指定送付先住所補記・建物名
		if (inMap == null || inMap.get("ck0021_cssti_shs_adrttm") == null || "".equals(inMap.get("ck0021_cssti_shs_adrttm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_ADRTTM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_ADRTTM, (String)inMap.get("ck0021_cssti_shs_adrttm"));
		}

		// お客様<個人>内容変更.お客様指定送付先住所補記・部屋番号（お客様＜個人＞内容変更） →お客様指定送付先住所補記・部屋番号
		if (inMap == null || inMap.get("ck0021_cssti_shs_adrrm") == null || "".equals(inMap.get("ck0021_cssti_shs_adrrm")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_ADRRM);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_ADRRM, (String)inMap.get("ck0021_cssti_shs_adrrm"));
		}

		// お客様<個人>内容変更.お客様指定送付先住所手動入力フラグ（お客様＜個人＞内容変更） →お客様指定送付先住所手動入力フラグ
		if (inMap == null || inMap.get("ck0021_cssti_shs_ad_man_input_flg") == null || "".equals(inMap.get("ck0021_cssti_shs_ad_man_input_flg")))
		{
			template.setNull(ECK0021C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0021C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG, (String)inMap.get("ck0021_cssti_shs_ad_man_input_flg"));
		}

		// お客様<個人>内容変更.更新年月日時分秒(更新前)（お客様＜個人＞内容変更） → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get("ck0021_upd_dtm_bf"));
		template.set(ECK0021C010CBSMsg.UPD_DTM_BF, lastDtm);
		
		//お客様<個人>内容変更.契約者住所チェックレベル → 契約者住所チェックレベル
		setTemplate(template, ECK0021C010CBSMsg.KEISHA_AD_CHK_LV, inMap, "ck0021_", ECK0021C010CBSMsg.KEISHA_AD_CHK_LV);
		//お客様<個人>内容変更.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル
		setTemplate(template, ECK0021C010CBSMsg.CONT_AD_CHK_LV, inMap, "ck0021_", ECK0021C010CBSMsg.CONT_AD_CHK_LV);
		//お客様<個人>内容変更.勤務先住所チェックレベル → 勤務先住所チェックレベル
		setTemplate(template, ECK0021C010CBSMsg.OFFC_AD_CHK_LV, inMap, "ck0021_", ECK0021C010CBSMsg.OFFC_AD_CHK_LV);
		//お客様<個人>内容変更.親権者住所チェックレベル → 親権者住所チェックレベル
		setTemplate(template, ECK0021C010CBSMsg.SKSHA_AD_CHK_LV, inMap, "ck0021_", ECK0021C010CBSMsg.SKSHA_AD_CHK_LV);
		//お客様<個人>内容変更.関電G個人情報取扱同意有無 → 関電G個人情報取扱同意有無
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM);
		//お客様<個人>内容変更.関電G個人情報取扱同意年月日 → 関電G個人情報取扱同意年月日
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ → 関電G個人情報提供不可フラグ
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ変更年月日 → 関電G個人情報提供不可フラグ変更年月日
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ変更受付方法コード → 関電G個人情報提供不可フラグ変更受付方法コード
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD);
		//お客様<個人>内容変更.関電G個人情報提供状況コード → 関電G個人情報提供状況コード
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_JOKYO_CD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_JOKYO_CD);
		//お客様<個人>内容変更.関電G個人情報提供開始年月日 → 関電G個人情報提供開始年月日
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_STAYMD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_STAYMD);
		//お客様<個人>内容変更.関電G個人情報提供連携状態コード → 関電G個人情報提供連携状態コード
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD);
		//お客様<個人>内容変更.関電G個人情報提供連携状態コード変更年月日 → 関電G個人情報提供連携状態コード変更年月日
		setTemplate(template, ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD, inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD);
		// ANK-4075-00-00 ADD START
		//お客様<個人>内容変更.スキームタイプコード → スキームタイプコード
		setTemplate(template, ECK0021C010CBSMsg.SCM_TYPE_CD, inMap, "ck0021_", ECK0021C010CBSMsg.SCM_TYPE_CD);
		//お客様<個人>内容変更.スキームタイプコード → スキームタイプコード
		setTemplate(template, ECK0021C010CBSMsg.SCM_JGS_CD, inMap, "ck0021_", ECK0021C010CBSMsg.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 editRetECK0021C010(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);

		// 作業領域のマップを取得
		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(ECK0021C010CBSMsg.CK0011_GENE_ADD_DTM))
		{
			dataMap.put("ck0011_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0011_gene_add_dtm", template.getString(ECK0021C010CBSMsg.CK0011_GENE_ADD_DTM));
		}

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

		// お客様<個人>内容変更マップ.予約適用コード（お客様＜個人＞内容変更） ← .予約適用コード
		if (template.isNull(ECK0021C010CBSMsg.RSV_APLY_CD))
		{
			dataMap.put("ck0021_rsv_aply_cd", "");
		}
		else
		{
			dataMap.put("ck0021_rsv_aply_cd", template.getString(ECK0021C010CBSMsg.RSV_APLY_CD));
		}

		// お客様<個人>内容変更マップ.登録年月日時分秒（お客様＜個人＞内容変更） ← .登録年月日時分秒
		if (template.isNull(ECK0021C010CBSMsg.ADD_DTM))
		{
			dataMap.put("ck0021_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0021_add_dtm", template.getString(ECK0021C010CBSMsg.ADD_DTM));
		}

		// お客様<個人>内容変更マップ.登録オペレータアカウント（お客様＜個人＞内容変更） ← .登録オペレータアカウント
		if (template.isNull(ECK0021C010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("ck0021_add_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0021_add_opeacnt", template.getString(ECK0021C010CBSMsg.ADD_OPEACNT));
		}

		// お客様<個人>内容変更マップ.更新年月日時分秒（お客様＜個人＞内容変更） ← .更新年月日時分秒
		if (template.isNull(ECK0021C010CBSMsg.UPD_DTM))
		{
			dataMap.put("ck0021_upd_dtm", "");
		}
		else
		{
			dataMap.put("ck0021_upd_dtm", template.getString(ECK0021C010CBSMsg.UPD_DTM));
			
			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0021C010CBSMsg.UPD_DTM));
		}

		// お客様<個人>内容変更マップ.更新オペレータアカウント（お客様＜個人＞内容変更） ← .更新オペレータアカウント
		if (template.isNull(ECK0021C010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("ck0021_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0021_upd_opeacnt", template.getString(ECK0021C010CBSMsg.UPD_OPEACNT));
		}

		// お客様<個人>内容変更マップ.無効フラグ（お客様＜個人＞内容変更） ← .無効フラグ
		if (template.isNull(ECK0021C010CBSMsg.MK_FLG))
		{
			dataMap.put("ck0021_mk_flg", "");
		}
		else
		{
			dataMap.put("ck0021_mk_flg", template.getString(ECK0021C010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0021C010(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 editErrInfoECK0021C010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0021C010CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// お客様<個人>内容変更.SYSID（お客様＜個人＞内容変更） → SYSID のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("ck0021_sysid_err"))
			{
				inMap.put("ck0021_sysid_err", template.getString(ECK0021C010CBSMsg.SYSID_ERR));
			}
		}

		// お客様<個人>内容変更.お客様名（お客様＜個人＞内容変更） → お客様名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_nm_err"))
			{
				inMap.put("ck0021_cust_nm_err", template.getString(ECK0021C010CBSMsg.CUST_NM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様カナ名（お客様＜個人＞内容変更） → お客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_kana_err"))
			{
				inMap.put("ck0021_cust_kana_err", template.getString(ECK0021C010CBSMsg.CUST_KANA_ERR));
			}
		}

		// お客様<個人>内容変更.お客様性別コード（お客様＜個人＞内容変更） → お客様性別コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_sex_cd_err"))
			{
				inMap.put("ck0021_cust_sex_cd_err", template.getString(ECK0021C010CBSMsg.CUST_SEX_CD_ERR));
			}
		}

		// お客様<個人>内容変更.お客様生年月日（お客様＜個人＞内容変更） → お客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_birthd_err"))
			{
				inMap.put("ck0021_cust_birthd_err", template.getString(ECK0021C010CBSMsg.CUST_BIRTHD_ERR));
			}
		}

		// お客様<個人>内容変更.氏名敬称（お客様＜個人＞内容変更） → 氏名敬称 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.NM_KISHO_ERR))
		{
			if (!inMap.containsKey("ck0021_nm_kisho_err"))
			{
				inMap.put("ck0021_nm_kisho_err", template.getString(ECK0021C010CBSMsg.NM_KISHO_ERR));
			}
		}

		// お客様<個人>内容変更.お客様確認備考 → お客様確認備考 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_CFM_BIKO_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_cfm_biko_err"))
			{
				inMap.put("ck0021_cust_cfm_biko_err", template.getString(ECK0021C010CBSMsg.CUST_CFM_BIKO_ERR));
			}
		}

		// お客様<個人>内容変更.契約者住所コード（お客様＜個人＞内容変更） → 契約者住所コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_ad_cd_err"))
			{
				inMap.put("ck0021_keisha_ad_cd_err", template.getString(ECK0021C010CBSMsg.KEISHA_AD_CD_ERR));
			}
		}

		// お客様<個人>内容変更.契約者郵便番号（お客様＜個人＞内容変更） → 契約者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_PCD_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_pcd_err"))
			{
				inMap.put("ck0021_keisha_pcd_err", template.getString(ECK0021C010CBSMsg.KEISHA_PCD_ERR));
			}
		}

		// お客様<個人>内容変更.契約者都道府県名（お客様＜個人＞内容変更） → 契約者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_state_nm_err"))
			{
				inMap.put("ck0021_keisha_state_nm_err", template.getString(ECK0021C010CBSMsg.KEISHA_STATE_NM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者市区町村名（お客様＜個人＞内容変更） → 契約者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_city_nm_err"))
			{
				inMap.put("ck0021_keisha_city_nm_err", template.getString(ECK0021C010CBSMsg.KEISHA_CITY_NM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者大字通称名（お客様＜個人＞内容変更） → 契約者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_oaztsu_nm_err"))
			{
				inMap.put("ck0021_keisha_oaztsu_nm_err", template.getString(ECK0021C010CBSMsg.KEISHA_OAZTSU_NM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者字丁目名（お客様＜個人＞内容変更） → 契約者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_azcho_nm_err"))
			{
				inMap.put("ck0021_keisha_azcho_nm_err", template.getString(ECK0021C010CBSMsg.KEISHA_AZCHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者番地号（お客様＜個人＞内容変更） → 契約者番地号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_bnchigo_err"))
			{
				inMap.put("ck0021_keisha_bnchigo_err", template.getString(ECK0021C010CBSMsg.KEISHA_BNCHIGO_ERR));
			}
		}

		// お客様<個人>内容変更.契約者住所補記・建物名（お客様＜個人＞内容変更） → 契約者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_adrttm_err"))
			{
				inMap.put("ck0021_keisha_adrttm_err", template.getString(ECK0021C010CBSMsg.KEISHA_ADRTTM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者住所補記・部屋番号（お客様＜個人＞内容変更） → 契約者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_adrrm_err"))
			{
				inMap.put("ck0021_keisha_adrrm_err", template.getString(ECK0021C010CBSMsg.KEISHA_ADRRM_ERR));
			}
		}

		// お客様<個人>内容変更.契約者電話番号（お客様＜個人＞内容変更） → 契約者電話番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_TELNO_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_telno_err"))
			{
				inMap.put("ck0021_keisha_telno_err", template.getString(ECK0021C010CBSMsg.KEISHA_TELNO_ERR));
			}
		}

		// お客様<個人>内容変更.お客様ランクコード（お客様＜個人＞内容変更） → お客様ランクコード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_RANK_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_rank_cd_err"))
			{
				inMap.put("ck0021_cust_rank_cd_err", template.getString(ECK0021C010CBSMsg.CUST_RANK_CD_ERR));
			}
		}

		// お客様<個人>内容変更.連絡手段コード（お客様＜個人＞内容変更） → 連絡手段コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_rrk_way_cd_err"))
			{
				inMap.put("ck0021_rrk_way_cd_err", template.getString(ECK0021C010CBSMsg.RRK_WAY_CD_ERR));
			}
		}

		// お客様<個人>内容変更.連絡手段補記（お客様＜個人＞内容変更） → 連絡手段補記 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.RRK_WAY_HOKI_ERR))
		{
			if (!inMap.containsKey("ck0021_rrk_way_hoki_err"))
			{
				inMap.put("ck0021_rrk_way_hoki_err", template.getString(ECK0021C010CBSMsg.RRK_WAY_HOKI_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツお客様名 → コンテンツお客様名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_CUST_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_cust_nm_err"))
			{
				inMap.put("ck0021_cont_cust_nm_err", template.getString(ECK0021C010CBSMsg.CONT_CUST_NM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツお客様カナ名 → コンテンツお客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_CUST_KANA_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_cust_kana_err"))
			{
				inMap.put("ck0021_cont_cust_kana_err", template.getString(ECK0021C010CBSMsg.CONT_CUST_KANA_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツお客様性別コード → コンテンツお客様性別コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_cust_sex_cd_err"))
			{
				inMap.put("ck0021_cont_cust_sex_cd_err", template.getString(ECK0021C010CBSMsg.CONT_CUST_SEX_CD_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツお客様生年月日 → コンテンツお客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_cust_birthd_err"))
			{
				inMap.put("ck0021_cont_cust_birthd_err", template.getString(ECK0021C010CBSMsg.CONT_CUST_BIRTHD_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ住所コード → コンテンツ住所コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_ad_cd_err"))
			{
				inMap.put("ck0021_cont_ad_cd_err", template.getString(ECK0021C010CBSMsg.CONT_AD_CD_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ郵便番号 → コンテンツ郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_PCD_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_pcd_err"))
			{
				inMap.put("ck0021_cont_pcd_err", template.getString(ECK0021C010CBSMsg.CONT_PCD_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ都道府県名 → コンテンツ都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_state_nm_err"))
			{
				inMap.put("ck0021_cont_state_nm_err", template.getString(ECK0021C010CBSMsg.CONT_STATE_NM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ市区町村名 → コンテンツ市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_city_nm_err"))
			{
				inMap.put("ck0021_cont_city_nm_err", template.getString(ECK0021C010CBSMsg.CONT_CITY_NM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ大字通称名 → コンテンツ大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_oaztsu_nm_err"))
			{
				inMap.put("ck0021_cont_oaztsu_nm_err", template.getString(ECK0021C010CBSMsg.CONT_OAZTSU_NM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ字丁目名 → コンテンツ字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_azcho_nm_err"))
			{
				inMap.put("ck0021_cont_azcho_nm_err", template.getString(ECK0021C010CBSMsg.CONT_AZCHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ番地号 → コンテンツ番地号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_bnchigo_err"))
			{
				inMap.put("ck0021_cont_bnchigo_err", template.getString(ECK0021C010CBSMsg.CONT_BNCHIGO_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_adrttm_err"))
			{
				inMap.put("ck0021_cont_adrttm_err", template.getString(ECK0021C010CBSMsg.CONT_ADRTTM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_adrrm_err"))
			{
				inMap.put("ck0021_cont_adrrm_err", template.getString(ECK0021C010CBSMsg.CONT_ADRRM_ERR));
			}
		}

		// お客様<個人>内容変更.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CONT_AD_BNKT_STA_PST_ERR))
		{
			if (!inMap.containsKey("ck0021_cont_ad_bnkt_sta_pst_err"))
			{
				inMap.put("ck0021_cont_ad_bnkt_sta_pst_err", template.getString(ECK0021C010CBSMsg.CONT_AD_BNKT_STA_PST_ERR));
			}
		}

		// お客様<個人>内容変更.予約適用年月日（お客様＜個人＞内容変更） → 予約適用年月日 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("ck0021_rsv_aply_ymd_err"))
			{
				inMap.put("ck0021_rsv_aply_ymd_err", template.getString(ECK0021C010CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// お客様<個人>内容変更.内販外販コード（お客様＜個人＞内容変更） → 内販外販コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.NAIHAN_GAIHAN_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_naihan_gaihan_cd_err"))
			{
				inMap.put("ck0021_naihan_gaihan_cd_err", template.getString(ECK0021C010CBSMsg.NAIHAN_GAIHAN_CD_ERR));
			}
		}

		// お客様<個人>内容変更.内販企業識別コード（お客様＜個人＞内容変更） → 内販企業識別コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_naihan_comp_skbt_cd_err"))
			{
				inMap.put("ck0021_naihan_comp_skbt_cd_err", template.getString(ECK0021C010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR));
			}
		}

		// お客様<個人>内容変更.要補助コード（お客様＜個人＞内容変更） → 要補助コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.NECESSARY_HOJO_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_necessary_hojo_cd_err"))
			{
				inMap.put("ck0021_necessary_hojo_cd_err", template.getString(ECK0021C010CBSMsg.NECESSARY_HOJO_CD_ERR));
			}
		}

		// お客様<個人>内容変更.ｅｏｎｅｔＩＤ未移行フラグ（お客様＜個人＞内容変更） → ｅｏｎｅｔＩＤ未移行フラグ のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.EONETID_MI_IKO_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_eonetid_mi_iko_flg_err"))
			{
				inMap.put("ck0021_eonetid_mi_iko_flg_err", template.getString(ECK0021C010CBSMsg.EONETID_MI_IKO_FLG_ERR));
			}
		}

		// お客様<個人>内容変更.ログイン認証可否（お客様＜個人＞内容変更） → ログイン認証可否 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.LOGIN_NINSHO_KH_ERR))
		{
			if (!inMap.containsKey("ck0021_login_ninsho_kh_err"))
			{
				inMap.put("ck0021_login_ninsho_kh_err", template.getString(ECK0021C010CBSMsg.LOGIN_NINSHO_KH_ERR));
			}
		}

		// お客様<個人>内容変更.お客様特記事項コード（お客様＜個人＞内容変更） → お客様特記事項コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_TKJK_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_tkjk_cd_err"))
			{
				inMap.put("ck0021_cust_tkjk_cd_err", template.getString(ECK0021C010CBSMsg.CUST_TKJK_CD_ERR));
			}
		}

		// お客様<個人>内容変更.ログイン認証停止年月日（お客様＜個人＞内容変更） → ログイン認証停止年月日 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.LOGIN_NINSHO_STP_YMD_ERR))
		{
			if (!inMap.containsKey("ck0021_login_ninsho_stp_ymd_err"))
			{
				inMap.put("ck0021_login_ninsho_stp_ymd_err", template.getString(ECK0021C010CBSMsg.LOGIN_NINSHO_STP_YMD_ERR));
			}
		}

		// お客様<個人>内容変更.会員種別特定フラグ（お客様＜個人＞内容変更） → 会員種別特定フラグ のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.MMB_SBT_TOKUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_mmb_sbt_tokut_flg_err"))
			{
				inMap.put("ck0021_mmb_sbt_tokut_flg_err", template.getString(ECK0021C010CBSMsg.MMB_SBT_TOKUT_FLG_ERR));
			}
		}

		// お客様<個人>内容変更.旧eonet会員認証用ID → 旧eonet会員認証用ID のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("ck0021_old_eonetmb_ninsho_id_err"))
			{
				inMap.put("ck0021_old_eonetmb_ninsho_id_err", template.getString(ECK0021C010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR));
			}
		}

		// お客様<個人>内容変更.会員ISP決済状態コード → 会員ISP決済状態コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_mmb_isp_kssai_stat_cd_err"))
			{
				inMap.put("ck0021_mmb_isp_kssai_stat_cd_err", template.getString(ECK0021C010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR));
			}
		}

		// お客様<個人>内容変更.削除対象外フラグ → 削除対象外フラグ のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.DEL_TRGT_GAI_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_del_trgt_gai_flg_err"))
			{
				inMap.put("ck0021_del_trgt_gai_flg_err", template.getString(ECK0021C010CBSMsg.DEL_TRGT_GAI_FLG_ERR));
			}
		}

		// お客様<個人>内容変更.職業コード（お客様＜個人＞内容変更） → 職業コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SHOKUGYO_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_shokugyo_cd_err"))
			{
				inMap.put("ck0021_shokugyo_cd_err", template.getString(ECK0021C010CBSMsg.SHOKUGYO_CD_ERR));
			}
		}

		// お客様<個人>内容変更.職業その他（お客様＜個人＞内容変更） → 職業その他 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SHOKUGYO_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_shokugyo_other_err"))
			{
				inMap.put("ck0021_shokugyo_other_err", template.getString(ECK0021C010CBSMsg.SHOKUGYO_OTHER_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先名（お客様＜個人＞内容変更） → 勤務先名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_nm_err"))
			{
				inMap.put("ck0021_offc_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_NM_ERR));
			}
		}

		// お客様<個人>内容変更.学校名（お客様＜個人＞内容変更） → 学校名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SCHOOL_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_school_nm_err"))
			{
				inMap.put("ck0021_school_nm_err", template.getString(ECK0021C010CBSMsg.SCHOOL_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先業種コード（お客様＜個人＞内容変更） → 勤務先業種コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_GSHU_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_gshu_cd_err"))
			{
				inMap.put("ck0021_offc_gshu_cd_err", template.getString(ECK0021C010CBSMsg.OFFC_GSHU_CD_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先部署名（お客様＜個人＞内容変更） → 勤務先部署名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_BUSHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_busho_nm_err"))
			{
				inMap.put("ck0021_offc_busho_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_BUSHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先住所コード（お客様＜個人＞内容変更） → 勤務先住所コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_ad_cd_err"))
			{
				inMap.put("ck0021_offc_ad_cd_err", template.getString(ECK0021C010CBSMsg.OFFC_AD_CD_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先郵便番号（お客様＜個人＞内容変更） → 勤務先郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_PCD_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_pcd_err"))
			{
				inMap.put("ck0021_offc_pcd_err", template.getString(ECK0021C010CBSMsg.OFFC_PCD_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先都道府県名（お客様＜個人＞内容変更） → 勤務先都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_state_nm_err"))
			{
				inMap.put("ck0021_offc_state_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_STATE_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先市区町村名（お客様＜個人＞内容変更） → 勤務先市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_city_nm_err"))
			{
				inMap.put("ck0021_offc_city_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_CITY_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先大字通称名（お客様＜個人＞内容変更） → 勤務先大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_oaztsu_nm_err"))
			{
				inMap.put("ck0021_offc_oaztsu_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_OAZTSU_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先字丁目名（お客様＜個人＞内容変更） → 勤務先字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_azcho_nm_err"))
			{
				inMap.put("ck0021_offc_azcho_nm_err", template.getString(ECK0021C010CBSMsg.OFFC_AZCHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先番地号（お客様＜個人＞内容変更） → 勤務先番地号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_bnchigo_err"))
			{
				inMap.put("ck0021_offc_bnchigo_err", template.getString(ECK0021C010CBSMsg.OFFC_BNCHIGO_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先住所補記・建物名（お客様＜個人＞内容変更） → 勤務先住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_adrttm_err"))
			{
				inMap.put("ck0021_offc_adrttm_err", template.getString(ECK0021C010CBSMsg.OFFC_ADRTTM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先住所補記・部屋番号（お客様＜個人＞内容変更） → 勤務先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_adrrm_err"))
			{
				inMap.put("ck0021_offc_adrrm_err", template.getString(ECK0021C010CBSMsg.OFFC_ADRRM_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先電話番号（お客様＜個人＞内容変更） → 勤務先電話番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_TELNO_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_telno_err"))
			{
				inMap.put("ck0021_offc_telno_err", template.getString(ECK0021C010CBSMsg.OFFC_TELNO_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先内線番号（お客様＜個人＞内容変更） → 勤務先内線番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_NISNNO_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_nisnno_err"))
			{
				inMap.put("ck0021_offc_nisnno_err", template.getString(ECK0021C010CBSMsg.OFFC_NISNNO_ERR));
			}
		}

		// お客様<個人>内容変更.勤務先従業員数(規模)（お客様＜個人＞内容変更） → 勤務先従業員数(規模) のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.OFFC_WORKER_CNT_SCALE_ERR))
		{
			if (!inMap.containsKey("ck0021_offc_worker_cnt_scale_err"))
			{
				inMap.put("ck0021_offc_worker_cnt_scale_err", template.getString(ECK0021C010CBSMsg.OFFC_WORKER_CNT_SCALE_ERR));
			}
		}

		// お客様<個人>内容変更.お客様年収（お客様＜個人＞内容変更） → お客様年収 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CUST_SALARY_ERR))
		{
			if (!inMap.containsKey("ck0021_cust_salary_err"))
			{
				inMap.put("ck0021_cust_salary_err", template.getString(ECK0021C010CBSMsg.CUST_SALARY_ERR));
			}
		}

		// お客様<個人>内容変更.親権者名（お客様＜個人＞内容変更） → 親権者名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_nm_err"))
			{
				inMap.put("ck0021_sksha_nm_err", template.getString(ECK0021C010CBSMsg.SKSHA_NM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者カナ名（お客様＜個人＞内容変更） → 親権者カナ名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_KANA_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_kana_err"))
			{
				inMap.put("ck0021_sksha_kana_err", template.getString(ECK0021C010CBSMsg.SKSHA_KANA_ERR));
			}
		}

		// お客様<個人>内容変更.親権者生年月日（お客様＜個人＞内容変更） → 親権者生年月日 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_BIRTHD_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_birthd_err"))
			{
				inMap.put("ck0021_sksha_birthd_err", template.getString(ECK0021C010CBSMsg.SKSHA_BIRTHD_ERR));
			}
		}

		// お客様<個人>内容変更.親権者続柄コード（お客様＜個人＞内容変更） → 親権者続柄コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_ZOKUGARA_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_zokugara_cd_err"))
			{
				inMap.put("ck0021_sksha_zokugara_cd_err", template.getString(ECK0021C010CBSMsg.SKSHA_ZOKUGARA_CD_ERR));
			}
		}

		// お客様<個人>内容変更.続柄その他（お客様＜個人＞内容変更） → 続柄その他 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.ZOKUGARA_OTHER_ERR))
		{
			if (!inMap.containsKey("ck0021_zokugara_other_err"))
			{
				inMap.put("ck0021_zokugara_other_err", template.getString(ECK0021C010CBSMsg.ZOKUGARA_OTHER_ERR));
			}
		}

		// お客様<個人>内容変更.親権者住所コード（お客様＜個人＞内容変更） → 親権者住所コード のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_ad_cd_err"))
			{
				inMap.put("ck0021_sksha_ad_cd_err", template.getString(ECK0021C010CBSMsg.SKSHA_AD_CD_ERR));
			}
		}

		// お客様<個人>内容変更.親権者郵便番号（お客様＜個人＞内容変更） → 親権者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_PCD_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_pcd_err"))
			{
				inMap.put("ck0021_sksha_pcd_err", template.getString(ECK0021C010CBSMsg.SKSHA_PCD_ERR));
			}
		}

		// お客様<個人>内容変更.親権者都道府県名（お客様＜個人＞内容変更） → 親権者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_state_nm_err"))
			{
				inMap.put("ck0021_sksha_state_nm_err", template.getString(ECK0021C010CBSMsg.SKSHA_STATE_NM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者市区町村名（お客様＜個人＞内容変更） → 親権者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_city_nm_err"))
			{
				inMap.put("ck0021_sksha_city_nm_err", template.getString(ECK0021C010CBSMsg.SKSHA_CITY_NM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者大字通称名（お客様＜個人＞内容変更） → 親権者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_oaztsu_nm_err"))
			{
				inMap.put("ck0021_sksha_oaztsu_nm_err", template.getString(ECK0021C010CBSMsg.SKSHA_OAZTSU_NM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者字丁目名（お客様＜個人＞内容変更） → 親権者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_azcho_nm_err"))
			{
				inMap.put("ck0021_sksha_azcho_nm_err", template.getString(ECK0021C010CBSMsg.SKSHA_AZCHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者住所番地号（お客様＜個人＞内容変更） → 親権者住所番地号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_AD_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_ad_bnchigo_err"))
			{
				inMap.put("ck0021_sksha_ad_bnchigo_err", template.getString(ECK0021C010CBSMsg.SKSHA_AD_BNCHIGO_ERR));
			}
		}

		// お客様<個人>内容変更.親権者住所補記・建物名（お客様＜個人＞内容変更） → 親権者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_adrttm_err"))
			{
				inMap.put("ck0021_sksha_adrttm_err", template.getString(ECK0021C010CBSMsg.SKSHA_ADRTTM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者住所補記・部屋番号（お客様＜個人＞内容変更） → 親権者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_adrrm_err"))
			{
				inMap.put("ck0021_sksha_adrrm_err", template.getString(ECK0021C010CBSMsg.SKSHA_ADRRM_ERR));
			}
		}

		// お客様<個人>内容変更.親権者電話番号（お客様＜個人＞内容変更） → 親権者電話番号 のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_TELNO_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_telno_err"))
			{
				inMap.put("ck0021_sksha_telno_err", template.getString(ECK0021C010CBSMsg.SKSHA_TELNO_ERR));
			}
		}

		// お客様<個人>内容変更.更新年月日時分秒(更新前)（お客様＜個人＞内容変更） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("ck0021_upd_dtm_bf_err"))
			{
				inMap.put("ck0021_upd_dtm_bf_err", template.getString(ECK0021C010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		// お客様<個人>内容変更.契約者住所手動入力フラグ（お客様＜個人＞内容変更） → 契約者住所手動入力フラグのエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_keisha_ad_man_input_flg_err"))
			{
				inMap.put("ck0021_keisha_ad_man_input_flg_err", template.getString(ECK0021C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR));
			}
		}

		// お客様<個人>内容変更.親権者住所手動入力フラグ（お客様＜個人＞内容変更） → 親権者住所手動入力フラグ のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_sksha_ad_man_input_flg_err"))
			{
				inMap.put("ck0021_sksha_ad_man_input_flg_err", template.getString(ECK0021C010CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先住所コード（お客様＜個人＞内容変更） → お客様指定送付先住所コードのエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_ad_cd_err"))
			{
				inMap.put("ck0021_cssti_shs_ad_cd_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_AD_CD_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先郵便番号（お客様＜個人＞内容変更） → お客様指定送付先郵便番号のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_PCD_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_pcd_err"))
			{
				inMap.put("ck0021_cssti_shs_pcd_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_PCD_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先都道府県名（お客様＜個人＞内容変更） → お客様指定送付先都道府県名のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_state_nm_err"))
			{
				inMap.put("ck0021_cssti_shs_state_nm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_STATE_NM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先市区町村名（お客様＜個人＞内容変更） → お客様指定送付先市区町村名のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_city_nm_err"))
			{
				inMap.put("ck0021_cssti_shs_city_nm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_CITY_NM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先大字通称名（お客様＜個人＞内容変更） → お客様指定送付先大字通称名のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_oaztsu_nm_err"))
			{
				inMap.put("ck0021_cssti_shs_oaztsu_nm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_OAZTSU_NM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先字丁目名（お客様＜個人＞内容変更） → お客様指定送付先字丁目名のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_azcho_nm_err"))
			{
				inMap.put("ck0021_cssti_shs_azcho_nm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_AZCHO_NM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先番地号（お客様＜個人＞内容変更） → お客様指定送付先番地号のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_bnchigo_err"))
			{
				inMap.put("ck0021_cssti_shs_bnchigo_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_BNCHIGO_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先住所補記・建物名（お客様＜個人＞内容変更） → お客様指定送付先住所補記・建物名のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_adrttm_err"))
			{
				inMap.put("ck0021_cssti_shs_adrttm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_ADRTTM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先住所補記・部屋番号（お客様＜個人＞内容変更） → お客様指定送付先住所補記・部屋番号のエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_adrrm_err"))
			{
				inMap.put("ck0021_cssti_shs_adrrm_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_ADRRM_ERR));
			}
		}

		// お客様<個人>内容変更.お客様指定送付先住所手動入力フラグ（お客様＜個人＞内容変更） → お客様指定送付先住所手動入力フラグのエラー情報返却
		if (!template.isNull(ECK0021C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0021_cssti_shs_ad_man_input_flg_err"))
			{
				inMap.put("ck0021_cssti_shs_ad_man_input_flg_err", template.getString(ECK0021C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG_ERR));
			}
		}

		//お客様<個人>内容変更.契約者住所チェックレベル（お客様＜個人＞内容変更） → 契約者住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEISHA_AD_CHK_LV_ERR, template, ECK0021C010CBSMsg.KEISHA_AD_CHK_LV_ERR);
		//お客様<個人>内容変更.コンテンツ住所チェックレベル（お客様＜個人＞内容変更） → コンテンツ住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.CONT_AD_CHK_LV_ERR, template, ECK0021C010CBSMsg.CONT_AD_CHK_LV_ERR);
		//お客様<個人>内容変更.勤務先住所チェックレベル（お客様＜個人＞内容変更） → 勤務先住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.OFFC_AD_CHK_LV_ERR, template, ECK0021C010CBSMsg.OFFC_AD_CHK_LV_ERR);
		//お客様<個人>内容変更.親権者住所チェックレベル（お客様＜個人＞内容変更） → 親権者住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.SKSHA_AD_CHK_LV_ERR, template, ECK0021C010CBSMsg.SKSHA_AD_CHK_LV_ERR);
		//お客様<個人>内容変更.関電G個人情報取扱同意有無（お客様＜個人＞内容変更） → 関電G個人情報取扱同意有無 のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM_ERR);
		//お客様<個人>内容変更.関電G個人情報取扱同意年月日（お客様＜個人＞内容変更） → 関電G個人情報取扱同意年月日 のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ（お客様＜個人＞内容変更） → 関電G個人情報提供不可フラグ のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_ERR);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ変更年月日（お客様＜個人＞内容変更） → 関電G個人情報提供不可フラグ変更年月日 のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供不可フラグ変更受付方法コード（お客様＜個人＞内容変更）
		//→ 関電G個人情報提供不可フラグ変更受付方法コード のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供状況コード（お客様＜個人＞内容変更） → 関電G個人情報提供状況コード のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_JOKYO_CD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_JOKYO_CD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供開始年月日（お客様＜個人＞内容変更） → 関電G個人情報提供開始年月日 のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_STAYMD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_STAYMD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供連携状態コード（お客様＜個人＞内容変更） → 関電G個人情報提供連携状態コード のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_ERR);
		//お客様<個人>内容変更.関電G個人情報提供連携状態コード変更年月日（お客様＜個人＞内容変更）
		//→ 関電G個人情報提供連携状態コード変更年月日 のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD_ERR, template, ECK0021C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD_ERR);
		// ANK-4075-00-00 ADD START
		//お客様<個人>内容変更.スキームタイプコード → スキームタイプコード のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.SCM_TYPE_CD_ERR, template, ECK0021C010CBSMsg.SCM_TYPE_CD_ERR);
		//お客様<個人>内容変更.スキーム事業者コード → スキーム事業者コード のエラー情報返却
		setErrInfo(inMap, "ck0021_", ECK0021C010CBSMsg.SCM_JGS_CD_ERR, template, ECK0021C010CBSMsg.SCM_JGS_CD_ERR);
		// ANK-4075-00-00 ADD END
		return param;
	}

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

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

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

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

		// お客様<法人>内容変更.SYSID → SYSID
		if (inMap == null || inMap.get("ck0031_sysid") == null || "".equals(inMap.get("ck0031_sysid")))
		{
			template.setNull(ECK0031C010CBSMsg.SYSID);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.SYSID, (String)inMap.get("ck0031_sysid"));
		}

		// お客様<法人>内容変更.お客様名 → お客様名
		if (inMap == null || inMap.get("ck0031_cust_nm") == null || "".equals(inMap.get("ck0031_cust_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_NM, (String)inMap.get("ck0031_cust_nm"));
		}

		// お客様<法人>内容変更.お客様カナ名 → お客様カナ名
		if (inMap == null || inMap.get("ck0031_cust_kana") == null || "".equals(inMap.get("ck0031_cust_kana")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_KANA);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_KANA, (String)inMap.get("ck0031_cust_kana"));
		}

		// お客様<法人>内容変更.お客様性別コード → お客様性別コード
		if (inMap == null || inMap.get("ck0031_cust_sex_cd") == null || "".equals(inMap.get("ck0031_cust_sex_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_SEX_CD, (String)inMap.get("ck0031_cust_sex_cd"));
		}

		// お客様<法人>内容変更.お客様生年月日 → お客様生年月日
		if (inMap == null || inMap.get("ck0031_cust_birthd") == null || "".equals(inMap.get("ck0031_cust_birthd")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_BIRTHD, (String)inMap.get("ck0031_cust_birthd"));
		}

		// お客様<法人>内容変更.氏名敬称 → 氏名敬称
		if (inMap == null || inMap.get("ck0031_nm_kisho") == null || "".equals(inMap.get("ck0031_nm_kisho")))
		{
			template.setNull(ECK0031C010CBSMsg.NM_KISHO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.NM_KISHO, (String)inMap.get("ck0031_nm_kisho"));
		}

		// お客様<法人>内容変更.お客様確認備考 → お客様確認備考
		if (inMap == null || inMap.get("ck0031_cust_cfm_biko") == null || "".equals(inMap.get("ck0031_cust_cfm_biko")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_CFM_BIKO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_CFM_BIKO, (String)inMap.get("ck0031_cust_cfm_biko"));
		}

		// お客様<法人>内容変更.契約者住所コード → 契約者住所コード
		if (inMap == null || inMap.get("ck0031_keisha_ad_cd") == null || "".equals(inMap.get("ck0031_keisha_ad_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_AD_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_AD_CD, (String)inMap.get("ck0031_keisha_ad_cd"));
		}

		// お客様<法人>内容変更.契約者郵便番号 → 契約者郵便番号
		if (inMap == null || inMap.get("ck0031_keisha_pcd") == null || "".equals(inMap.get("ck0031_keisha_pcd")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_PCD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_PCD, (String)inMap.get("ck0031_keisha_pcd"));
		}

		// お客様<法人>内容変更.契約者都道府県名 → 契約者都道府県名
		if (inMap == null || inMap.get("ck0031_keisha_state_nm") == null || "".equals(inMap.get("ck0031_keisha_state_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_STATE_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_STATE_NM, (String)inMap.get("ck0031_keisha_state_nm"));
		}

		// お客様<法人>内容変更.契約者市区町村名 → 契約者市区町村名
		if (inMap == null || inMap.get("ck0031_keisha_city_nm") == null || "".equals(inMap.get("ck0031_keisha_city_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_CITY_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_CITY_NM, (String)inMap.get("ck0031_keisha_city_nm"));
		}

		// お客様<法人>内容変更.契約者大字通称名 → 契約者大字通称名
		if (inMap == null || inMap.get("ck0031_keisha_oaztsu_nm") == null || "".equals(inMap.get("ck0031_keisha_oaztsu_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_OAZTSU_NM, (String)inMap.get("ck0031_keisha_oaztsu_nm"));
		}

		// お客様<法人>内容変更.契約者字丁目名 → 契約者字丁目名
		if (inMap == null || inMap.get("ck0031_keisha_azcho_nm") == null || "".equals(inMap.get("ck0031_keisha_azcho_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_AZCHO_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_AZCHO_NM, (String)inMap.get("ck0031_keisha_azcho_nm"));
		}

		// お客様<法人>内容変更.契約者番地号 → 契約者番地号
		if (inMap == null || inMap.get("ck0031_keisha_bnchigo") == null || "".equals(inMap.get("ck0031_keisha_bnchigo")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_BNCHIGO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_BNCHIGO, (String)inMap.get("ck0031_keisha_bnchigo"));
		}

		// お客様<法人>内容変更.契約者住所補記・建物名 → 契約者住所補記・建物名
		if (inMap == null || inMap.get("ck0031_keisha_adrttm") == null || "".equals(inMap.get("ck0031_keisha_adrttm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_ADRTTM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_ADRTTM, (String)inMap.get("ck0031_keisha_adrttm"));
		}

		// お客様<法人>内容変更.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号
		if (inMap == null || inMap.get("ck0031_keisha_adrrm") == null || "".equals(inMap.get("ck0031_keisha_adrrm")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_ADRRM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_ADRRM, (String)inMap.get("ck0031_keisha_adrrm"));
		}

		// お客様<法人>内容変更.契約者電話番号 → 契約者電話番号
		if (inMap == null || inMap.get("ck0031_keisha_telno") == null || "".equals(inMap.get("ck0031_keisha_telno")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_TELNO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_TELNO, (String)inMap.get("ck0031_keisha_telno"));
		}

		// お客様<法人>内容変更.お客様ランクコード → お客様ランクコード
		if (inMap == null || inMap.get("ck0031_cust_rank_cd") == null || "".equals(inMap.get("ck0031_cust_rank_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_RANK_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_RANK_CD, (String)inMap.get("ck0031_cust_rank_cd"));
		}

		// お客様<法人>内容変更.連絡手段コード → 連絡手段コード
		if (inMap == null || inMap.get("ck0031_rrk_way_cd") == null || "".equals(inMap.get("ck0031_rrk_way_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.RRK_WAY_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.RRK_WAY_CD, (String)inMap.get("ck0031_rrk_way_cd"));
		}

		// お客様<法人>内容変更.連絡手段補記 → 連絡手段補記
		if (inMap == null || inMap.get("ck0031_rrk_way_hoki") == null || "".equals(inMap.get("ck0031_rrk_way_hoki")))
		{
			template.setNull(ECK0031C010CBSMsg.RRK_WAY_HOKI);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.RRK_WAY_HOKI, (String)inMap.get("ck0031_rrk_way_hoki"));
		}

		// お客様<法人>内容変更.コンテンツお客様名 → コンテンツお客様名
		if (inMap == null || inMap.get("ck0031_cont_cust_nm") == null || "".equals(inMap.get("ck0031_cont_cust_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_CUST_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_CUST_NM, (String)inMap.get("ck0031_cont_cust_nm"));
		}

		// お客様<法人>内容変更.コンテンツお客様カナ名 → コンテンツお客様カナ名
		if (inMap == null || inMap.get("ck0031_cont_cust_kana") == null || "".equals(inMap.get("ck0031_cont_cust_kana")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_CUST_KANA);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_CUST_KANA, (String)inMap.get("ck0031_cont_cust_kana"));
		}

		// お客様<法人>内容変更.コンテンツお客様性別コード → コンテンツお客様性別コード
		if (inMap == null || inMap.get("ck0031_cont_cust_sex_cd") == null || "".equals(inMap.get("ck0031_cont_cust_sex_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_CUST_SEX_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_CUST_SEX_CD, (String)inMap.get("ck0031_cont_cust_sex_cd"));
		}

		// お客様<法人>内容変更.コンテンツお客様生年月日 → コンテンツお客様生年月日
		if (inMap == null || inMap.get("ck0031_cont_cust_birthd") == null || "".equals(inMap.get("ck0031_cont_cust_birthd")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_CUST_BIRTHD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_CUST_BIRTHD, (String)inMap.get("ck0031_cont_cust_birthd"));
		}

		// お客様<法人>内容変更.コンテンツ住所コード → コンテンツ住所コード
		if (inMap == null || inMap.get("ck0031_cont_ad_cd") == null || "".equals(inMap.get("ck0031_cont_ad_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_AD_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_AD_CD, (String)inMap.get("ck0031_cont_ad_cd"));
		}

		// お客様<法人>内容変更.コンテンツ郵便番号 → コンテンツ郵便番号
		if (inMap == null || inMap.get("ck0031_cont_pcd") == null || "".equals(inMap.get("ck0031_cont_pcd")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_PCD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_PCD, (String)inMap.get("ck0031_cont_pcd"));
		}

		// お客様<法人>内容変更.コンテンツ都道府県名 → コンテンツ都道府県名
		if (inMap == null || inMap.get("ck0031_cont_state_nm") == null || "".equals(inMap.get("ck0031_cont_state_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_STATE_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_STATE_NM, (String)inMap.get("ck0031_cont_state_nm"));
		}

		// お客様<法人>内容変更.コンテンツ市区町村名 → コンテンツ市区町村名
		if (inMap == null || inMap.get("ck0031_cont_city_nm") == null || "".equals(inMap.get("ck0031_cont_city_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_CITY_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_CITY_NM, (String)inMap.get("ck0031_cont_city_nm"));
		}

		// お客様<法人>内容変更.コンテンツ大字通称名 → コンテンツ大字通称名
		if (inMap == null || inMap.get("ck0031_cont_oaztsu_nm") == null || "".equals(inMap.get("ck0031_cont_oaztsu_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_OAZTSU_NM, (String)inMap.get("ck0031_cont_oaztsu_nm"));
		}

		// お客様<法人>内容変更.コンテンツ字丁目名 → コンテンツ字丁目名
		if (inMap == null || inMap.get("ck0031_cont_azcho_nm") == null || "".equals(inMap.get("ck0031_cont_azcho_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_AZCHO_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_AZCHO_NM, (String)inMap.get("ck0031_cont_azcho_nm"));
		}

		// お客様<法人>内容変更.コンテンツ番地号 → コンテンツ番地号
		if (inMap == null || inMap.get("ck0031_cont_bnchigo") == null || "".equals(inMap.get("ck0031_cont_bnchigo")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_BNCHIGO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_BNCHIGO, (String)inMap.get("ck0031_cont_bnchigo"));
		}

		// お客様<法人>内容変更.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名
		if (inMap == null || inMap.get("ck0031_cont_adrttm") == null || "".equals(inMap.get("ck0031_cont_adrttm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_ADRTTM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_ADRTTM, (String)inMap.get("ck0031_cont_adrttm"));
		}

		// お客様<法人>内容変更.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号
		if (inMap == null || inMap.get("ck0031_cont_adrrm") == null || "".equals(inMap.get("ck0031_cont_adrrm")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_ADRRM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_ADRRM, (String)inMap.get("ck0031_cont_adrrm"));
		}


		// お客様<法人>内容変更.コンテンツ住所分割開始位置 → コンテンツ住所分割開始位置
		if (inMap == null || inMap.get("ck0031_cont_ad_bnkt_sta_pst") == null || "".equals(inMap.get("ck0031_cont_ad_bnkt_sta_pst")))
		{
			template.setNull(ECK0031C010CBSMsg.CONT_AD_BNKT_STA_PST);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CONT_AD_BNKT_STA_PST, (String)inMap.get("ck0031_cont_ad_bnkt_sta_pst"));
		}

		// お客様<法人>内容変更.予約適用年月日 → 予約適用年月日
		if (inMap == null || inMap.get("ck0031_rsv_aply_ymd") == null || "".equals(inMap.get("ck0031_rsv_aply_ymd")))
		{
			template.setNull(ECK0031C010CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.RSV_APLY_YMD, (String)inMap.get("ck0031_rsv_aply_ymd"));
		}

		// お客様<法人>内容変更.内販外販コード → 内販外販コード
		if (inMap == null || inMap.get("ck0031_naihan_gaihan_cd") == null || "".equals(inMap.get("ck0031_naihan_gaihan_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.NAIHAN_GAIHAN_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.NAIHAN_GAIHAN_CD, (String)inMap.get("ck0031_naihan_gaihan_cd"));
		}

		// お客様<法人>内容変更.内販企業識別コード → 内販企業識別コード
		if (inMap == null || inMap.get("ck0031_naihan_comp_skbt_cd") == null || "".equals(inMap.get("ck0031_naihan_comp_skbt_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.NAIHAN_COMP_SKBT_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.NAIHAN_COMP_SKBT_CD, (String)inMap.get("ck0031_naihan_comp_skbt_cd"));
		}

		// お客様<法人>内容変更.要補助コード → 要補助コード
		if (inMap == null || inMap.get("ck0031_necessary_hojo_cd") == null || "".equals(inMap.get("ck0031_necessary_hojo_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.NECESSARY_HOJO_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.NECESSARY_HOJO_CD, (String)inMap.get("ck0031_necessary_hojo_cd"));
		}

		// お客様<法人>内容変更.ログイン認証可否 → ログイン認証可否
		if (inMap == null || inMap.get("ck0031_login_ninsho_kh") == null || "".equals(inMap.get("ck0031_login_ninsho_kh")))
		{
			template.setNull(ECK0031C010CBSMsg.LOGIN_NINSHO_KH);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.LOGIN_NINSHO_KH, (String)inMap.get("ck0031_login_ninsho_kh"));
		}

		// お客様<法人>内容変更.お客様特記事項コード → お客様特記事項コード
		if (inMap == null || inMap.get("ck0031_cust_tkjk_cd") == null || "".equals(inMap.get("ck0031_cust_tkjk_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CUST_TKJK_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CUST_TKJK_CD, (String)inMap.get("ck0031_cust_tkjk_cd"));
		}

		// お客様<法人>内容変更.ログイン認証停止年月日 → ログイン認証停止年月日
		if (inMap == null || inMap.get("ck0031_login_ninsho_stp_ymd") == null || "".equals(inMap.get("ck0031_login_ninsho_stp_ymd")))
		{
			template.setNull(ECK0031C010CBSMsg.LOGIN_NINSHO_STP_YMD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.LOGIN_NINSHO_STP_YMD, (String)inMap.get("ck0031_login_ninsho_stp_ymd"));
		}

		// お客様<法人>内容変更.会員種別特定フラグ → 会員種別特定フラグ
		if (inMap == null || inMap.get("ck0031_mmb_sbt_tokut_flg") == null || "".equals(inMap.get("ck0031_mmb_sbt_tokut_flg")))
		{
			template.setNull(ECK0031C010CBSMsg.MMB_SBT_TOKUT_FLG);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.MMB_SBT_TOKUT_FLG, (String)inMap.get("ck0031_mmb_sbt_tokut_flg"));
		}

		// お客様<法人>内容変更.旧eonet会員認証用ID → 旧eonet会員認証用ID
		if (inMap == null || inMap.get("ck0031_old_eonetmb_ninsho_id") == null || "".equals(inMap.get("ck0031_old_eonetmb_ninsho_id")))
		{
			template.setNull(ECK0031C010CBSMsg.OLD_EONETMB_NINSHO_ID);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.OLD_EONETMB_NINSHO_ID, (String)inMap.get("ck0031_old_eonetmb_ninsho_id"));
		}

		// お客様<法人>内容変更.会員ISP決済状態コード → 会員ISP決済状態コード
		if (inMap == null || inMap.get("ck0031_mmb_isp_kssai_stat_cd") == null || "".equals(inMap.get("ck0031_mmb_isp_kssai_stat_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.MMB_ISP_KSSAI_STAT_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.MMB_ISP_KSSAI_STAT_CD, (String)inMap.get("ck0031_mmb_isp_kssai_stat_cd"));
		}

		// お客様<法人>内容変更.削除対象外フラグ → 削除対象外フラグ
		if (inMap == null || inMap.get("ck0031_del_trgt_gai_flg") == null || "".equals(inMap.get("ck0031_del_trgt_gai_flg")))
		{
			template.setNull(ECK0031C010CBSMsg.DEL_TRGT_GAI_FLG);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.DEL_TRGT_GAI_FLG, (String)inMap.get("ck0031_del_trgt_gai_flg"));
		}

		// お客様<法人>内容変更.法人格種別コード → 法人格種別コード
		if (inMap == null || inMap.get("ck0031_hojin_sbt_cd") == null || "".equals(inMap.get("ck0031_hojin_sbt_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.HOJIN_SBT_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.HOJIN_SBT_CD, (String)inMap.get("ck0031_hojin_sbt_cd"));
		}

		// お客様<法人>内容変更.法人格前後指定コード → 法人格前後指定コード
		if (inMap == null || inMap.get("ck0031_hojin_zengo_shitei_cd") == null || "".equals(inMap.get("ck0031_hojin_zengo_shitei_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.HOJIN_ZENGO_SHITEI_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.HOJIN_ZENGO_SHITEI_CD, (String)inMap.get("ck0031_hojin_zengo_shitei_cd"));
		}

		// お客様<法人>内容変更.会社名 → 会社名
		if (inMap == null || inMap.get("ck0031_comp_nm") == null || "".equals(inMap.get("ck0031_comp_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.COMP_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.COMP_NM, (String)inMap.get("ck0031_comp_nm"));
		}

		// お客様<法人>内容変更.会社カナ名 → 会社カナ名
		if (inMap == null || inMap.get("ck0031_comp_kana") == null || "".equals(inMap.get("ck0031_comp_kana")))
		{
			template.setNull(ECK0031C010CBSMsg.COMP_KANA);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.COMP_KANA, (String)inMap.get("ck0031_comp_kana"));
		}

		// お客様<法人>内容変更.代表者役職名 → 代表者役職名
		if (inMap == null || inMap.get("ck0031_dihysha_post_nm") == null || "".equals(inMap.get("ck0031_dihysha_post_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.DIHYSHA_POST_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.DIHYSHA_POST_NM, (String)inMap.get("ck0031_dihysha_post_nm"));
		}

		// お客様<法人>内容変更.業種コード → 業種コード
		if (inMap == null || inMap.get("ck0031_gshu_cd") == null || "".equals(inMap.get("ck0031_gshu_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.GSHU_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.GSHU_CD, (String)inMap.get("ck0031_gshu_cd"));
		}
		
		// お客様<法人>内容変更.法人連絡先住所手動入力フラグ → 契約者住所手動入力フラグ
		if (inMap == null || inMap.get("ck0031_keisha_ad_man_input_flg") == null || "".equals(inMap.get("ck0031_hjrrks_ad_man_input_flg")))
		{
			template.setNull(ECK0031C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG, (String)inMap.get("ck0031_keisha_ad_man_input_flg"));
		}


		// お客様<法人>内容変更.お客様指定送付先住所コード（お客様＜法人＞内容変更） →お客様指定送付先住所コード
		if (inMap == null || inMap.get("ck0031_cssti_shs_ad_cd") == null || "".equals(inMap.get("ck0031_cssti_shs_ad_cd")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_AD_CD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_AD_CD, (String)inMap.get("ck0031_cssti_shs_ad_cd"));
		}

		// お客様<法人>内容変更.お客様指定送付先郵便番号（お客様＜法人＞内容変更） →お客様指定送付先郵便番号
		if (inMap == null || inMap.get("ck0031_cssti_shs_pcd") == null || "".equals(inMap.get("ck0031_cssti_shs_pcd")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_PCD);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_PCD, (String)inMap.get("ck0031_cssti_shs_pcd"));
		}

		// お客様<法人>内容変更.お客様指定送付先都道府県名（お客様＜法人＞内容変更） →お客様指定送付先都道府県名
		if (inMap == null || inMap.get("ck0031_cssti_shs_state_nm") == null || "".equals(inMap.get("ck0031_cssti_shs_state_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_STATE_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_STATE_NM, (String)inMap.get("ck0031_cssti_shs_state_nm"));
		}

		// お客様<法人>内容変更.お客様指定送付先市区町村名（お客様＜法人＞内容変更） →お客様指定送付先市区町村名
		if (inMap == null || inMap.get("ck0031_cssti_shs_city_nm") == null || "".equals(inMap.get("ck0031_cssti_shs_city_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_CITY_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_CITY_NM, (String)inMap.get("ck0031_cssti_shs_city_nm"));
		}

		// お客様<個人>内容変更.お客様指定送付先大字通称名（お客様＜法人＞内容変更） →お客様指定送付先大字通称名
		if (inMap == null || inMap.get("ck0031_cssti_shs_oaztsu_nm") == null || "".equals(inMap.get("ck0031_cssti_shs_oaztsu_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_OAZTSU_NM, (String)inMap.get("ck0031_cssti_shs_oaztsu_nm"));
		}

		// お客様<法人>内容変更.お客様指定送付先字丁目名（お客様＜法人＞内容変更） →お客様指定送付先字丁目名
		if (inMap == null || inMap.get("ck0031_cssti_shs_azcho_nm") == null || "".equals(inMap.get("ck0031_cssti_shs_azcho_nm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_AZCHO_NM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_AZCHO_NM, (String)inMap.get("ck0031_cssti_shs_azcho_nm"));
		}

		// お客様<法人>内容変更.お客様指定送付先番地号（お客様＜法人＞内容変更） →お客様指定送付先番地号
		if (inMap == null || inMap.get("ck0031_cssti_shs_bnchigo") == null || "".equals(inMap.get("ck0031_cssti_shs_bnchigo")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_BNCHIGO);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_BNCHIGO, (String)inMap.get("ck0031_cssti_shs_bnchigo"));
		}

		// お客様<法人>内容変更.お客様指定送付先住所補記・建物名（お客様＜法人＞内容変更） →お客様指定送付先住所補記・建物名
		if (inMap == null || inMap.get("ck0031_cssti_shs_adrttm") == null || "".equals(inMap.get("ck0031_cssti_shs_adrttm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_ADRTTM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_ADRTTM, (String)inMap.get("ck0031_cssti_shs_adrttm"));
		}

		// お客様<法人>内容変更.お客様指定送付先住所補記・部屋番号（お客様＜法人＞内容変更） →お客様指定送付先住所補記・部屋番号
		if (inMap == null || inMap.get("ck0031_cssti_shs_adrrm") == null || "".equals(inMap.get("ck0031_cssti_shs_adrrm")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_ADRRM);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_ADRRM, (String)inMap.get("ck0031_cssti_shs_adrrm"));
		}

		// お客様<法人>内容変更.お客様指定送付先住所手動入力フラグ（お客様＜法人＞内容変更） →お客様指定送付先住所手動入力フラグ
		if (inMap == null || inMap.get("ck0031_cssti_shs_ad_man_input_flg") == null || "".equals(inMap.get("ck0031_cssti_shs_ad_man_input_flg")))
		{
			template.setNull(ECK0031C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG);
		}
		else
		{
			template.set(ECK0031C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG, (String)inMap.get("ck0031_cssti_shs_ad_man_input_flg"));
		}


		// お客様<法人>内容変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get("ck0031_upd_dtm_bf"));
		template.set(ECK0031C010CBSMsg.UPD_DTM_BF, lastDtm);
		
		//お客様<法人>内容変更.契約者住所チェックレベル → 契約者住所チェックレベル
		setTemplate(template, ECK0031C010CBSMsg.KEISHA_AD_CHK_LV, inMap, "ck0031_", ECK0031C010CBSMsg.KEISHA_AD_CHK_LV);
		//お客様<法人>内容変更.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル
		setTemplate(template, ECK0031C010CBSMsg.CONT_AD_CHK_LV, inMap, "ck0031_", ECK0031C010CBSMsg.CONT_AD_CHK_LV);
		
		//お客様<法人>内容変更.代表者名 → 代表者名
		setTemplate(template, ECK0031C010CBSMsg.DIHYSHA_NM, inMap, "ck0031_", ECK0031C010CBSMsg.DIHYSHA_NM);
		//お客様<法人>内容変更.代表者カナ名 → 代表者カナ名
		setTemplate(template, ECK0031C010CBSMsg.DIHYSHA_KANA, inMap, "ck0031_", ECK0031C010CBSMsg.DIHYSHA_KANA);
		//お客様<法人>内容変更.関電G個人情報取扱同意有無 → 関電G個人情報取扱同意有無
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM);
		//お客様<法人>内容変更.関電G個人情報取扱同意年月日 → 関電G個人情報取扱同意年月日
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ → 関電G個人情報提供不可フラグ
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ変更年月日 → 関電G個人情報提供不可フラグ変更年月日
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ変更受付方法コード → 関電G個人情報提供不可フラグ変更受付方法コード
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD);
		//お客様<法人>内容変更.関電G個人情報提供状況コード → 関電G個人情報提供状況コード
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_JOKYO_CD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_JOKYO_CD);
		//お客様<法人>内容変更.関電G個人情報提供開始年月日 → 関電G個人情報提供開始年月日
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_STAYMD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_STAYMD);
		//お客様<法人>内容変更.関電G個人情報提供連携状態コード → 関電G個人情報提供連携状態コード
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD);
		//お客様<法人>内容変更.関電G個人情報提供連携状態コード変更年月日 → 関電G個人情報提供連携状態コード変更年月日
		setTemplate(template, ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD, inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD);
		// ANK-4075-00-00 ADD START
		//お客様<法人>内容変更.スキームタイプコード → スキームタイプコード
		setTemplate(template, ECK0031C010CBSMsg.SCM_TYPE_CD, inMap, "ck0031_", ECK0031C010CBSMsg.SCM_TYPE_CD);
		//お客様<法人>内容変更.スキーム事業者コード → スキーム事業者コード
		setTemplate(template, ECK0031C010CBSMsg.SCM_JGS_CD, inMap, "ck0031_", ECK0031C010CBSMsg.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 editRetECK0031C010(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);

		// 作業領域のマップを取得
		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(ECK0031C010CBSMsg.CK0011_GENE_ADD_DTM))
		{
			dataMap.put("ck0011_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0011_gene_add_dtm", template.getString(ECK0031C010CBSMsg.CK0011_GENE_ADD_DTM));
		}

		// お客様<法人>内容変更マップ.世代登録年月日時分秒(お客様<法人>) ← .世代登録年月日時分秒(お客様<法人>)
		if (template.isNull(ECK0031C010CBSMsg.CK0031_GENE_ADD_DTM))
		{
			dataMap.put("ck0031_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0031_gene_add_dtm", template.getString(ECK0031C010CBSMsg.CK0031_GENE_ADD_DTM));
		}

		// お客様<法人>内容変更マップ.予約適用コード ← .予約適用コード
		if (template.isNull(ECK0031C010CBSMsg.RSV_APLY_CD))
		{
			dataMap.put("ck0031_rsv_aply_cd", "");
		}
		else
		{
			dataMap.put("ck0031_rsv_aply_cd", template.getString(ECK0031C010CBSMsg.RSV_APLY_CD));
		}

		// お客様<法人>内容変更マップ.登録オペレータアカウント ← .登録オペレータアカウント
		if (template.isNull(ECK0031C010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("ck0031_add_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0031_add_opeacnt", template.getString(ECK0031C010CBSMsg.ADD_OPEACNT));
		}

		// お客様<法人>内容変更マップ.更新年月日時分秒 ← .更新年月日時分秒
		if (template.isNull(ECK0031C010CBSMsg.UPD_DTM))
		{
			dataMap.put("ck0031_upd_dtm", "");
		}
		else
		{
			dataMap.put("ck0031_upd_dtm", template.getString(ECK0031C010CBSMsg.UPD_DTM));
			
			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0031C010CBSMsg.UPD_DTM));
		}

		// お客様<法人>内容変更マップ.更新オペレータアカウント ← .更新オペレータアカウント
		if (template.isNull(ECK0031C010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("ck0031_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0031_upd_opeacnt", template.getString(ECK0031C010CBSMsg.UPD_OPEACNT));
		}

		// お客様<法人>内容変更マップ.無効フラグ ← .無効フラグ
		if (template.isNull(ECK0031C010CBSMsg.MK_FLG))
		{
			dataMap.put("ck0031_mk_flg", "");
		}
		else
		{
			dataMap.put("ck0031_mk_flg", template.getString(ECK0031C010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0031C010(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 editErrInfoECK0031C010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0031C010CBSMsg.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);

		// お客様<法人>内容変更.SYSID → SYSID のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("ck0031_sysid_err"))
			{
				inMap.put("ck0031_sysid_err", template.getString(ECK0031C010CBSMsg.SYSID_ERR));
			}
		}

		// お客様<法人>内容変更.お客様名 → お客様名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_nm_err"))
			{
				inMap.put("ck0031_cust_nm_err", template.getString(ECK0031C010CBSMsg.CUST_NM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様カナ名 → お客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_KANA_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_kana_err"))
			{
				inMap.put("ck0031_cust_kana_err", template.getString(ECK0031C010CBSMsg.CUST_KANA_ERR));
			}
		}

		// お客様<法人>内容変更.お客様性別コード → お客様性別コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_sex_cd_err"))
			{
				inMap.put("ck0031_cust_sex_cd_err", template.getString(ECK0031C010CBSMsg.CUST_SEX_CD_ERR));
			}
		}

		// お客様<法人>内容変更.お客様生年月日 → お客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_birthd_err"))
			{
				inMap.put("ck0031_cust_birthd_err", template.getString(ECK0031C010CBSMsg.CUST_BIRTHD_ERR));
			}
		}

		// お客様<法人>内容変更.氏名敬称 → 氏名敬称 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.NM_KISHO_ERR))
		{
			if (!inMap.containsKey("ck0031_nm_kisho_err"))
			{
				inMap.put("ck0031_nm_kisho_err", template.getString(ECK0031C010CBSMsg.NM_KISHO_ERR));
			}
		}

		// お客様<法人>内容変更.お客様確認備考 → お客様確認備考 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_CFM_BIKO_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_cfm_biko_err"))
			{
				inMap.put("ck0031_cust_cfm_biko_err", template.getString(ECK0031C010CBSMsg.CUST_CFM_BIKO_ERR));
			}
		}

		// お客様<法人>内容変更.契約者住所コード → 契約者住所コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_ad_cd_err"))
			{
				inMap.put("ck0031_keisha_ad_cd_err", template.getString(ECK0031C010CBSMsg.KEISHA_AD_CD_ERR));
			}
		}

		// お客様<法人>内容変更.契約者郵便番号 → 契約者郵便番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_PCD_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_pcd_err"))
			{
				inMap.put("ck0031_keisha_pcd_err", template.getString(ECK0031C010CBSMsg.KEISHA_PCD_ERR));
			}
		}

		// お客様<法人>内容変更.契約者都道府県名 → 契約者都道府県名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_state_nm_err"))
			{
				inMap.put("ck0031_keisha_state_nm_err", template.getString(ECK0031C010CBSMsg.KEISHA_STATE_NM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者市区町村名 → 契約者市区町村名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_city_nm_err"))
			{
				inMap.put("ck0031_keisha_city_nm_err", template.getString(ECK0031C010CBSMsg.KEISHA_CITY_NM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者大字通称名 → 契約者大字通称名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_oaztsu_nm_err"))
			{
				inMap.put("ck0031_keisha_oaztsu_nm_err", template.getString(ECK0031C010CBSMsg.KEISHA_OAZTSU_NM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者字丁目名 → 契約者字丁目名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_azcho_nm_err"))
			{
				inMap.put("ck0031_keisha_azcho_nm_err", template.getString(ECK0031C010CBSMsg.KEISHA_AZCHO_NM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者番地号 → 契約者番地号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_bnchigo_err"))
			{
				inMap.put("ck0031_keisha_bnchigo_err", template.getString(ECK0031C010CBSMsg.KEISHA_BNCHIGO_ERR));
			}
		}

		// お客様<法人>内容変更.契約者住所補記・建物名 → 契約者住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_adrttm_err"))
			{
				inMap.put("ck0031_keisha_adrttm_err", template.getString(ECK0031C010CBSMsg.KEISHA_ADRTTM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者住所補記・部屋番号 → 契約者住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_adrrm_err"))
			{
				inMap.put("ck0031_keisha_adrrm_err", template.getString(ECK0031C010CBSMsg.KEISHA_ADRRM_ERR));
			}
		}

		// お客様<法人>内容変更.契約者電話番号 → 契約者電話番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_TELNO_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_telno_err"))
			{
				inMap.put("ck0031_keisha_telno_err", template.getString(ECK0031C010CBSMsg.KEISHA_TELNO_ERR));
			}
		}

		// お客様<法人>内容変更.お客様ランクコード → お客様ランクコード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_RANK_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_rank_cd_err"))
			{
				inMap.put("ck0031_cust_rank_cd_err", template.getString(ECK0031C010CBSMsg.CUST_RANK_CD_ERR));
			}
		}

		// お客様<法人>内容変更.連絡手段コード → 連絡手段コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_rrk_way_cd_err"))
			{
				inMap.put("ck0031_rrk_way_cd_err", template.getString(ECK0031C010CBSMsg.RRK_WAY_CD_ERR));
			}
		}

		// お客様<法人>内容変更.連絡手段補記 → 連絡手段補記 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.RRK_WAY_HOKI_ERR))
		{
			if (!inMap.containsKey("ck0031_rrk_way_hoki_err"))
			{
				inMap.put("ck0031_rrk_way_hoki_err", template.getString(ECK0031C010CBSMsg.RRK_WAY_HOKI_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツお客様名 → コンテンツお客様名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_CUST_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_cust_nm_err"))
			{
				inMap.put("ck0031_cont_cust_nm_err", template.getString(ECK0031C010CBSMsg.CONT_CUST_NM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツお客様カナ名 → コンテンツお客様カナ名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_CUST_KANA_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_cust_kana_err"))
			{
				inMap.put("ck0031_cont_cust_kana_err", template.getString(ECK0031C010CBSMsg.CONT_CUST_KANA_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツお客様性別コード → コンテンツお客様性別コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_CUST_SEX_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_cust_sex_cd_err"))
			{
				inMap.put("ck0031_cont_cust_sex_cd_err", template.getString(ECK0031C010CBSMsg.CONT_CUST_SEX_CD_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツお客様生年月日 → コンテンツお客様生年月日 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_CUST_BIRTHD_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_cust_birthd_err"))
			{
				inMap.put("ck0031_cont_cust_birthd_err", template.getString(ECK0031C010CBSMsg.CONT_CUST_BIRTHD_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ住所コード → コンテンツ住所コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_ad_cd_err"))
			{
				inMap.put("ck0031_cont_ad_cd_err", template.getString(ECK0031C010CBSMsg.CONT_AD_CD_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ郵便番号 → コンテンツ郵便番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_PCD_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_pcd_err"))
			{
				inMap.put("ck0031_cont_pcd_err", template.getString(ECK0031C010CBSMsg.CONT_PCD_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ都道府県名 → コンテンツ都道府県名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_state_nm_err"))
			{
				inMap.put("ck0031_cont_state_nm_err", template.getString(ECK0031C010CBSMsg.CONT_STATE_NM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ市区町村名 → コンテンツ市区町村名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_city_nm_err"))
			{
				inMap.put("ck0031_cont_city_nm_err", template.getString(ECK0031C010CBSMsg.CONT_CITY_NM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ大字通称名 → コンテンツ大字通称名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_oaztsu_nm_err"))
			{
				inMap.put("ck0031_cont_oaztsu_nm_err", template.getString(ECK0031C010CBSMsg.CONT_OAZTSU_NM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ字丁目名 → コンテンツ字丁目名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_azcho_nm_err"))
			{
				inMap.put("ck0031_cont_azcho_nm_err", template.getString(ECK0031C010CBSMsg.CONT_AZCHO_NM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ番地号 → コンテンツ番地号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_bnchigo_err"))
			{
				inMap.put("ck0031_cont_bnchigo_err", template.getString(ECK0031C010CBSMsg.CONT_BNCHIGO_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ住所補記・建物名 → コンテンツ住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_adrttm_err"))
			{
				inMap.put("ck0031_cont_adrttm_err", template.getString(ECK0031C010CBSMsg.CONT_ADRTTM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ住所補記・部屋番号 → コンテンツ住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_adrrm_err"))
			{
				inMap.put("ck0031_cont_adrrm_err", template.getString(ECK0031C010CBSMsg.CONT_ADRRM_ERR));
			}
		}

		// お客様<法人>内容変更.コンテンツ住所分割開始位置 → コンテンツ住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CONT_AD_BNKT_STA_PST_ERR))
		{
			if (!inMap.containsKey("ck0031_cont_ad_bnkt_sta_pst_err"))
			{
				inMap.put("ck0031_cont_ad_bnkt_sta_pst_err", template.getString(ECK0031C010CBSMsg.CONT_AD_BNKT_STA_PST_ERR));
			}
		}

		// お客様<法人>内容変更.予約適用年月日 → 予約適用年月日 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("ck0031_rsv_aply_ymd_err"))
			{
				inMap.put("ck0031_rsv_aply_ymd_err", template.getString(ECK0031C010CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// お客様<法人>内容変更.内販外販コード → 内販外販コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.NAIHAN_GAIHAN_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_naihan_gaihan_cd_err"))
			{
				inMap.put("ck0031_naihan_gaihan_cd_err", template.getString(ECK0031C010CBSMsg.NAIHAN_GAIHAN_CD_ERR));
			}
		}

		// お客様<法人>内容変更.内販企業識別コード → 内販企業識別コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_naihan_comp_skbt_cd_err"))
			{
				inMap.put("ck0031_naihan_comp_skbt_cd_err", template.getString(ECK0031C010CBSMsg.NAIHAN_COMP_SKBT_CD_ERR));
			}
		}

		// お客様<法人>内容変更.要補助コード → 要補助コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.NECESSARY_HOJO_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_necessary_hojo_cd_err"))
			{
				inMap.put("ck0031_necessary_hojo_cd_err", template.getString(ECK0031C010CBSMsg.NECESSARY_HOJO_CD_ERR));
			}
		}

		// お客様<法人>内容変更.ログイン認証可否 → ログイン認証可否 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.LOGIN_NINSHO_KH_ERR))
		{
			if (!inMap.containsKey("ck0031_login_ninsho_kh_err"))
			{
				inMap.put("ck0031_login_ninsho_kh_err", template.getString(ECK0031C010CBSMsg.LOGIN_NINSHO_KH_ERR));
			}
		}

		// お客様<法人>内容変更.お客様特記事項コード → お客様特記事項コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CUST_TKJK_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cust_tkjk_cd_err"))
			{
				inMap.put("ck0031_cust_tkjk_cd_err", template.getString(ECK0031C010CBSMsg.CUST_TKJK_CD_ERR));
			}
		}

		// お客様<法人>内容変更.ログイン認証停止年月日 → ログイン認証停止年月日 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.LOGIN_NINSHO_STP_YMD_ERR))
		{
			if (!inMap.containsKey("ck0031_login_ninsho_stp_ymd_err"))
			{
				inMap.put("ck0031_login_ninsho_stp_ymd_err", template.getString(ECK0031C010CBSMsg.LOGIN_NINSHO_STP_YMD_ERR));
			}
		}

		// お客様<法人>内容変更.会員種別特定フラグ → 会員種別特定フラグ のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.MMB_SBT_TOKUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0031_mmb_sbt_tokut_flg_err"))
			{
				inMap.put("ck0031_mmb_sbt_tokut_flg_err", template.getString(ECK0031C010CBSMsg.MMB_SBT_TOKUT_FLG_ERR));
			}
		}

		// お客様<法人>内容変更.旧eonet会員認証用ID → 旧eonet会員認証用ID のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("ck0031_old_eonetmb_ninsho_id_err"))
			{
				inMap.put("ck0031_old_eonetmb_ninsho_id_err", template.getString(ECK0031C010CBSMsg.OLD_EONETMB_NINSHO_ID_ERR));
			}
		}

		// お客様<法人>内容変更.会員ISP決済状態コード → 会員ISP決済状態コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_mmb_isp_kssai_stat_cd_err"))
			{
				inMap.put("ck0031_mmb_isp_kssai_stat_cd_err", template.getString(ECK0031C010CBSMsg.MMB_ISP_KSSAI_STAT_CD_ERR));
			}
		}

		// お客様<法人>内容変更.削除対象外フラグ → 削除対象外フラグ のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.DEL_TRGT_GAI_FLG_ERR))
		{
			if (!inMap.containsKey("ck0031_del_trgt_gai_flg_err"))
			{
				inMap.put("ck0031_del_trgt_gai_flg_err", template.getString(ECK0031C010CBSMsg.DEL_TRGT_GAI_FLG_ERR));
			}
		}

		// お客様<法人>内容変更.法人格種別コード → 法人格種別コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.HOJIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_hojin_sbt_cd_err"))
			{
				inMap.put("ck0031_hojin_sbt_cd_err", template.getString(ECK0031C010CBSMsg.HOJIN_SBT_CD_ERR));
			}
		}

		// お客様<法人>内容変更.法人格前後指定コード → 法人格前後指定コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_hojin_zengo_shitei_cd_err"))
			{
				inMap.put("ck0031_hojin_zengo_shitei_cd_err", template.getString(ECK0031C010CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR));
			}
		}

		// お客様<法人>内容変更.会社名 → 会社名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.COMP_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_comp_nm_err"))
			{
				inMap.put("ck0031_comp_nm_err", template.getString(ECK0031C010CBSMsg.COMP_NM_ERR));
			}
		}

		// お客様<法人>内容変更.会社カナ名 → 会社カナ名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.COMP_KANA_ERR))
		{
			if (!inMap.containsKey("ck0031_comp_kana_err"))
			{
				inMap.put("ck0031_comp_kana_err", template.getString(ECK0031C010CBSMsg.COMP_KANA_ERR));
			}
		}

		// お客様<法人>内容変更.代表者役職名 → 代表者役職名 のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.DIHYSHA_POST_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_dihysha_post_nm_err"))
			{
				inMap.put("ck0031_dihysha_post_nm_err", template.getString(ECK0031C010CBSMsg.DIHYSHA_POST_NM_ERR));
			}
		}

		// お客様<法人>内容変更.業種コード → 業種コード のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.GSHU_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_gshu_cd_err"))
			{
				inMap.put("ck0031_gshu_cd_err", template.getString(ECK0031C010CBSMsg.GSHU_CD_ERR));
			}
		}

		// お客様<法人>内容変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("ck0031_upd_dtm_bf_err"))
			{
				inMap.put("ck0031_upd_dtm_bf_err", template.getString(ECK0031C010CBSMsg.UPD_DTM_BF_ERR));
			}
		}


		// お客様<法人>内容変更.法人連絡先住所手動入力フラグ → 契約者住所手動入力フラグ のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0031_keisha_ad_man_input_flg"))
			{
				inMap.put("ck0031_keisha_ad_man_input_flg", template.getString(ECK0031C010CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR));
			}
		}
		

		// お客様<法人>内容変更.お客様指定送付先住所コード（お客様＜法人＞内容変更） → お客様指定送付先住所コードのエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_ad_cd_err"))
			{
				inMap.put("ck0031_cssti_shs_ad_cd_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_AD_CD_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先郵便番号（お客様＜法人＞内容変更） → お客様指定送付先郵便番号のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_PCD_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_pcd_err"))
			{
				inMap.put("ck0031_cssti_shs_pcd_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_PCD_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先都道府県名（お客様＜法人＞内容変更） → お客様指定送付先都道府県名のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_state_nm_err"))
			{
				inMap.put("ck0031_cssti_shs_state_nm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_STATE_NM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先市区町村名（お客様＜法人＞内容変更） → お客様指定送付先市区町村名のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_city_nm_err"))
			{
				inMap.put("ck0031_cssti_shs_city_nm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_CITY_NM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先大字通称名（お客様＜法人＞内容変更） → お客様指定送付先大字通称名のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_oaztsu_nm_err"))
			{
				inMap.put("ck0031_cssti_shs_oaztsu_nm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_OAZTSU_NM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先字丁目名（お客様＜法人＞内容変更） → お客様指定送付先字丁目名のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_azcho_nm_err"))
			{
				inMap.put("ck0031_cssti_shs_azcho_nm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_AZCHO_NM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先番地号（お客様＜法人＞内容変更） → お客様指定送付先番地号のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_bnchigo_err"))
			{
				inMap.put("ck0031_cssti_shs_bnchigo_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_BNCHIGO_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先住所補記・建物名（お客様＜法人＞内容変更） → お客様指定送付先住所補記・建物名のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_adrttm_err"))
			{
				inMap.put("ck0031_cssti_shs_adrttm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_ADRTTM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先住所補記・部屋番号（お客様＜法人＞内容変更） → お客様指定送付先住所補記・部屋番号のエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_adrrm_err"))
			{
				inMap.put("ck0031_cssti_shs_adrrm_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_ADRRM_ERR));
			}
		}

		// お客様<法人>内容変更.お客様指定送付先住所手動入力フラグ（お客様＜法人＞内容変更） → お客様指定送付先住所手動入力フラグのエラー情報返却
		if (!template.isNull(ECK0031C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("ck0031_cssti_shs_ad_man_input_flg_err"))
			{
				inMap.put("ck0031_cssti_shs_ad_man_input_flg_err", template.getString(ECK0031C010CBSMsg.CSSTI_SHS_AD_MAN_INPUT_FLG_ERR));
			}
		}


		//お客様<法人>内容変更.法人連絡先住所手動入力フラグ → 契約者住所手動入力フラグ のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEISHA_AD_CHK_LV_ERR, template, ECK0031C010CBSMsg.KEISHA_AD_CHK_LV_ERR);
		//お客様<法人>内容変更.コンテンツ住所チェックレベル → コンテンツ住所チェックレベル のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.CONT_AD_CHK_LV_ERR, template, ECK0031C010CBSMsg.CONT_AD_CHK_LV_ERR);
		//お客様<法人>内容変更.関電G個人情報取扱同意有無 → 関電G個人情報取扱同意有無 のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_UM_ERR);
		//お客様<法人>内容変更.関電G個人情報取扱同意年月日 → 関電G個人情報取扱同意年月日 のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD, template, ECK0031C010CBSMsg.KEPG_KJNIF_TRAT_DOI_YMD);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ → 関電G個人情報提供不可フラグ のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_ERR);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ変更年月日 → 関電G個人情報提供不可フラグ変更年月日 のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_YMD_ERR);
		//お客様<法人>内容変更.関電G個人情報提供不可フラグ変更受付方法コード → 関電G個人情報提供不可フラグ変更受付方法コード のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_FFG_CHG_UWY_CD_ERR);
		//お客様<法人>内容変更.関電G個人情報提供状況コード → 関電G個人情報提供状況コード のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_JOKYO_CD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_JOKYO_CD_ERR);
		//お客様<法人>内容変更.関電G個人情報提供開始年月日 → 関電G個人情報提供開始年月日 のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_STAYMD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_STAYMD_ERR);
		//お客様<法人>内容変更.関電G個人情報提供連携状態コード → 関電G個人情報提供連携状態コード のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_ERR);
		//お客様<法人>内容変更.関電G個人情報提供連携状態コード変更年月日 → 関電G個人情報提供連携状態コード変更年月日 のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD_ERR, template, ECK0031C010CBSMsg.KEPG_KJNIFT_RSCD_CHG_YMD_ERR);
		// ANK-4075-00-00 ADD START
		//お客様<法人>内容変更.スキームタイプコード → スキームタイプコード のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.SCM_TYPE_CD_ERR, template, ECK0031C010CBSMsg.SCM_TYPE_CD_ERR);
		//お客様<法人>内容変更.スキーム事業者コード → スキーム事業者コード のエラー情報返却
		setErrInfo(inMap, "ck0031_", ECK0031C010CBSMsg.SCM_JGS_CD_ERR, template, ECK0031C010CBSMsg.SCM_JGS_CD_ERR);
		// ANK-4075-00-00 ADD END
		return param;
	}

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

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

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

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

		// 法人連絡先変更.SYSID（法人連絡先変更） → SYSID
		if (inMap == null || inMap.get("ck0041_sysid") == null || "".equals(inMap.get("ck0041_sysid")))
		{
			template.setNull(ECK0041C010CBSMsg.SYSID);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.SYSID, (String)inMap.get("ck0041_sysid"));
		}

		// 法人連絡先変更.連絡先コード（法人連絡先変更） → 連絡先コード
		if (inMap == null || inMap.get("ck0041_rrks_cd") == null || "".equals(inMap.get("ck0041_rrks_cd")))
		{
			template.setNull(ECK0041C010CBSMsg.RRKS_CD);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.RRKS_CD, (String)inMap.get("ck0041_rrks_cd"));
		}

		// 法人連絡先変更.法人連絡先名（法人連絡先変更） → 法人連絡先名
		if (inMap == null || inMap.get("ck0041_hjrrks_nm") == null || "".equals(inMap.get("ck0041_hjrrks_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_NM, (String)inMap.get("ck0041_hjrrks_nm"));
		}

		// 法人連絡先変更.法人連絡先住所コード（法人連絡先変更） → 法人連絡先住所コード
		if (inMap == null || inMap.get("ck0041_hjrrks_ad_cd") == null || "".equals(inMap.get("ck0041_hjrrks_ad_cd")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_AD_CD);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_AD_CD, (String)inMap.get("ck0041_hjrrks_ad_cd"));
		}

		// 法人連絡先変更.法人連絡先郵便番号（法人連絡先変更） → 法人連絡先郵便番号
		if (inMap == null || inMap.get("ck0041_hjrrks_pcd") == null || "".equals(inMap.get("ck0041_hjrrks_pcd")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_PCD);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_PCD, (String)inMap.get("ck0041_hjrrks_pcd"));
		}

		// 法人連絡先変更.法人連絡先都道府県名（法人連絡先変更） → 法人連絡先都道府県名
		if (inMap == null || inMap.get("ck0041_hjrrks_state_nm") == null || "".equals(inMap.get("ck0041_hjrrks_state_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_STATE_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_STATE_NM, (String)inMap.get("ck0041_hjrrks_state_nm"));
		}

		// 法人連絡先変更.法人連絡先市区町村名（法人連絡先変更） → 法人連絡先市区町村名
		if (inMap == null || inMap.get("ck0041_hjrrks_city_nm") == null || "".equals(inMap.get("ck0041_hjrrks_city_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_CITY_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_CITY_NM, (String)inMap.get("ck0041_hjrrks_city_nm"));
		}

		// 法人連絡先変更.法人連絡先大字通称名（法人連絡先変更） → 法人連絡先大字通称名
		if (inMap == null || inMap.get("ck0041_hjrrks_oaztsu_nm") == null || "".equals(inMap.get("ck0041_hjrrks_oaztsu_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_OAZTSU_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_OAZTSU_NM, (String)inMap.get("ck0041_hjrrks_oaztsu_nm"));
		}

		// 法人連絡先変更.法人連絡先字丁目名（法人連絡先変更） → 法人連絡先字丁目名
		if (inMap == null || inMap.get("ck0041_hjrrks_azcho_nm") == null || "".equals(inMap.get("ck0041_hjrrks_azcho_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_AZCHO_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_AZCHO_NM, (String)inMap.get("ck0041_hjrrks_azcho_nm"));
		}

		// 法人連絡先変更.法人連絡先番地号（法人連絡先変更） → 法人連絡先番地号
		if (inMap == null || inMap.get("ck0041_hjrrks_bnchigo") == null || "".equals(inMap.get("ck0041_hjrrks_bnchigo")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_BNCHIGO);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_BNCHIGO, (String)inMap.get("ck0041_hjrrks_bnchigo"));
		}

		// 法人連絡先変更.法人連絡先住所補記・建物名（法人連絡先変更） → 法人連絡先住所補記・建物名
		if (inMap == null || inMap.get("ck0041_hjrrks_adrttm") == null || "".equals(inMap.get("ck0041_hjrrks_adrttm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_ADRTTM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_ADRTTM, (String)inMap.get("ck0041_hjrrks_adrttm"));
		}

		// 法人連絡先変更.法人連絡先住所補記・部屋番号（法人連絡先変更） → 法人連絡先住所補記・部屋番号
		if (inMap == null || inMap.get("ck0041_hjrrks_adrrm") == null || "".equals(inMap.get("ck0041_hjrrks_adrrm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_ADRRM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_ADRRM, (String)inMap.get("ck0041_hjrrks_adrrm"));
		}

		// 法人連絡先変更.法人連絡先担当者名（法人連絡先変更） → 法人連絡先担当者名
		if (inMap == null || inMap.get("ck0041_hjrrks_tntsha_nm") == null || "".equals(inMap.get("ck0041_hjrrks_tntsha_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_TNTSHA_NM, (String)inMap.get("ck0041_hjrrks_tntsha_nm"));
		}

		// 法人連絡先変更.法人連絡先担当者カナ名（法人連絡先変更） → 法人連絡先担当者カナ名
		if (inMap == null || inMap.get("ck0041_hjrrks_tntsha_kana") == null || "".equals(inMap.get("ck0041_hjrrks_tntsha_kana")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_KANA);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_TNTSHA_KANA, (String)inMap.get("ck0041_hjrrks_tntsha_kana"));
		}

		// 法人連絡先変更.法人連絡先担当者所属部署名（法人連絡先変更） → 法人連絡先担当者所属部署名
		if (inMap == null || inMap.get("ck0041_hjrrks_tntsha_shozkbsho_nm") == null || "".equals(inMap.get("ck0041_hjrrks_tntsha_shozkbsho_nm")))
		{
			template.setNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_SHOZKBSHO_NM);
		}
		else
		{
			template.set(ECK0041C010CBSMsg.HJRRKS_TNTSHA_SHOZKBSHO_NM, (String)inMap.get("ck0041_hjrrks_tntsha_shozkbsho_nm"));
		}

		// 法人連絡先変更.更新年月日時分秒(更新前)（法人連絡先変更） → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get("ck0041_upd_dtm_bf"));
		template.set(ECK0041C010CBSMsg.UPD_DTM_BF, lastDtm);
		
		//法人連絡先変更.法人連絡先住所チェックレベル → 法人連絡先住所チェックレベル
		setTemplate(template, ECK0041C010CBSMsg.HJRRKS_AD_CHK_LV, inMap, "ck0041_", ECK0041C010CBSMsg.HJRRKS_AD_CHK_LV);

		return template;
	}

	/**
	 * 法人連絡先変更の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0041C010(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);

		// 作業領域のマップを取得
		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(ECK0041C010CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("ck0041_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0041_gene_add_dtm", template.getString(ECK0041C010CBSMsg.GENE_ADD_DTM));
		}

		// 法人連絡先変更マップ.登録年月日時分秒（法人連絡先変更） ← .登録年月日時分秒
		if (template.isNull(ECK0041C010CBSMsg.ADD_DTM))
		{
			dataMap.put("ck0041_add_dtm", "");
		}
		else
		{
			dataMap.put("ck0041_add_dtm", template.getString(ECK0041C010CBSMsg.ADD_DTM));
		}

		// 法人連絡先変更マップ.登録オペレータアカウント（法人連絡先変更） ← .登録オペレータアカウント
		if (template.isNull(ECK0041C010CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("ck0041_add_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0041_add_opeacnt", template.getString(ECK0041C010CBSMsg.ADD_OPEACNT));
		}

		// 法人連絡先変更マップ.更新年月日時分秒（法人連絡先変更） ← .更新年月日時分秒
		if (template.isNull(ECK0041C010CBSMsg.UPD_DTM))
		{
			dataMap.put("ck0041_upd_dtm", "");
		}
		else
		{
			dataMap.put("ck0041_upd_dtm", template.getString(ECK0041C010CBSMsg.UPD_DTM));

			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0041C010CBSMsg.UPD_DTM));
		}

		// 法人連絡先変更マップ.更新オペレータアカウント（法人連絡先変更） ← .更新オペレータアカウント
		if (template.isNull(ECK0041C010CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("ck0041_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("ck0041_upd_opeacnt", template.getString(ECK0041C010CBSMsg.UPD_OPEACNT));
		}

		// 法人連絡先変更マップ.無効フラグ（法人連絡先変更） ← .無効フラグ
		if (template.isNull(ECK0041C010CBSMsg.MK_FLG))
		{
			dataMap.put("ck0041_mk_flg", "");
		}
		else
		{
			dataMap.put("ck0041_mk_flg", template.getString(ECK0041C010CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0041C010(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 editErrInfoECK0041C010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0041C010CBSMsg.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);

		// 法人連絡先変更.SYSID（法人連絡先変更） → SYSID のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("ck0041_sysid_err"))
			{
				inMap.put("ck0041_sysid_err", template.getString(ECK0041C010CBSMsg.SYSID_ERR));
			}
		}

		// 法人連絡先変更.連絡先コード（法人連絡先変更） → 連絡先コード のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.RRKS_CD_ERR))
		{
			if (!inMap.containsKey("ck0041_rrks_cd_err"))
			{
				inMap.put("ck0041_rrks_cd_err", template.getString(ECK0041C010CBSMsg.RRKS_CD_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先名（法人連絡先変更） → 法人連絡先名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_nm_err"))
			{
				inMap.put("ck0041_hjrrks_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先住所コード（法人連絡先変更） → 法人連絡先住所コード のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_AD_CD_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_ad_cd_err"))
			{
				inMap.put("ck0041_hjrrks_ad_cd_err", template.getString(ECK0041C010CBSMsg.HJRRKS_AD_CD_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先郵便番号（法人連絡先変更） → 法人連絡先郵便番号 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_PCD_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_pcd_err"))
			{
				inMap.put("ck0041_hjrrks_pcd_err", template.getString(ECK0041C010CBSMsg.HJRRKS_PCD_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先都道府県名（法人連絡先変更） → 法人連絡先都道府県名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_state_nm_err"))
			{
				inMap.put("ck0041_hjrrks_state_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_STATE_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先市区町村名（法人連絡先変更） → 法人連絡先市区町村名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_city_nm_err"))
			{
				inMap.put("ck0041_hjrrks_city_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_CITY_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先大字通称名（法人連絡先変更） → 法人連絡先大字通称名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_oaztsu_nm_err"))
			{
				inMap.put("ck0041_hjrrks_oaztsu_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_OAZTSU_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先字丁目名（法人連絡先変更） → 法人連絡先字丁目名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_azcho_nm_err"))
			{
				inMap.put("ck0041_hjrrks_azcho_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_AZCHO_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先番地号（法人連絡先変更） → 法人連絡先番地号 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_bnchigo_err"))
			{
				inMap.put("ck0041_hjrrks_bnchigo_err", template.getString(ECK0041C010CBSMsg.HJRRKS_BNCHIGO_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先住所補記・建物名（法人連絡先変更） → 法人連絡先住所補記・建物名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_adrttm_err"))
			{
				inMap.put("ck0041_hjrrks_adrttm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_ADRTTM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先住所補記・部屋番号（法人連絡先変更） → 法人連絡先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_ADRRM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_adrrm_err"))
			{
				inMap.put("ck0041_hjrrks_adrrm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_ADRRM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先担当者名（法人連絡先変更） → 法人連絡先担当者名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_tntsha_nm_err"))
			{
				inMap.put("ck0041_hjrrks_tntsha_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_TNTSHA_NM_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先担当者カナ名（法人連絡先変更） → 法人連絡先担当者カナ名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_KANA_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_tntsha_kana_err"))
			{
				inMap.put("ck0041_hjrrks_tntsha_kana_err", template.getString(ECK0041C010CBSMsg.HJRRKS_TNTSHA_KANA_ERR));
			}
		}

		// 法人連絡先変更.法人連絡先担当者所属部署名（法人連絡先変更） → 法人連絡先担当者所属部署名 のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR))
		{
			if (!inMap.containsKey("ck0041_hjrrks_tntsha_shozkbsho_nm_err"))
			{
				inMap.put("ck0041_hjrrks_tntsha_shozkbsho_nm_err", template.getString(ECK0041C010CBSMsg.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR));
			}
		}

		// 法人連絡先変更.更新年月日時分秒(更新前)（法人連絡先変更） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0041C010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("ck0041_upd_dtm_bf_err"))
			{
				inMap.put("ck0041_upd_dtm_bf_err", template.getString(ECK0041C010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		
		// 法人連絡先変更.法人連絡先住所チェックレベル → 法人連絡先住所チェックレベルのエラー情報返却
		setErrInfo(inMap, "ck0041_", ECK0041C010CBSMsg.HJRRKS_AD_CHK_LV_ERR, template, ECK0041C010CBSMsg.HJRRKS_AD_CHK_LV_ERR);

		return param;
	}

	/**
	 * 連絡先情報変更用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param prefix プレフィックス
	 * @param inMap 変更対象データマップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0201C010(IRequestParameterReadWrite param, String fixedText, String prefix
			, HashMap<String, Object> inMap) throws RequestParameterException
	{

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

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

		// 機能コード（デフォルト：１）
		template.set(ECK0201C010CBSMsg.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> mp = (HashMap<String, Object>)param.getData(fixedText);
		
		// 機能コード
		template.set(ECK0201C010CBSMsg.FUNC_CODE, mp.get(JCMConstants.FUNC_CODE_KEY));

		// 連絡先情報変更.連絡先番号 → 連絡先番号
		if (inMap == null || inMap.get(prefix + "rrks_no") == null || "".equals(inMap.get(prefix + "rrks_no")))
		{
			template.setNull(ECK0201C010CBSMsg.RRKS_NO);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.RRKS_NO, (String)inMap.get(prefix + "rrks_no"));
		}

		// 連絡先情報変更.連絡先種別コード → 連絡先種別コード
		if (inMap == null || inMap.get(prefix + "rrks_sbt_cd") == null || "".equals(inMap.get(prefix + "rrks_sbt_cd")))
		{
			template.setNull(ECK0201C010CBSMsg.RRKS_SBT_CD);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.RRKS_SBT_CD, (String)inMap.get(prefix + "rrks_sbt_cd"));
		}
		
		// 連絡先情報変更.電話番号 → 電話番号
		if (inMap == null || inMap.get(prefix + "telno") == null || "".equals(inMap.get(prefix + "telno")))
		{
			template.setNull(ECK0201C010CBSMsg.TELNO);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.TELNO, (String)inMap.get(prefix + "telno"));
		}

		// 連絡先情報変更.内線番号 → 内線番号
		if (inMap == null || inMap.get(prefix + "nisnno") == null || "".equals(inMap.get(prefix + "nisnno")))
		{
			template.setNull(ECK0201C010CBSMsg.NISNNO);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.NISNNO, (String)inMap.get(prefix + "nisnno"));
		}

		// 連絡先情報変更.FAX番号 → FAX番号
		if (inMap == null || inMap.get(prefix + "fax_no") == null || "".equals(inMap.get(prefix + "fax_no")))
		{
			template.setNull(ECK0201C010CBSMsg.FAX_NO);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.FAX_NO, (String)inMap.get(prefix + "fax_no"));
		}

		// 連絡先情報変更.予約適用年月日 → 予約適用年月日
		if (inMap == null || inMap.get(prefix + "rsv_aply_ymd") == null || "".equals(inMap.get(prefix + "rsv_aply_ymd")))
		{
			template.setNull(ECK0201C010CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(ECK0201C010CBSMsg.RSV_APLY_YMD, (String)inMap.get(prefix + "rsv_aply_ymd"));
		}

		// 連絡先情報変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get(prefix + "upd_dtm_bf"));
		template.set(ECK0201C010CBSMsg.UPD_DTM_BF, lastDtm);

		return template;
	}

	/**
	 * 連絡先情報変更の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param prefix プレフィックス
	 * @param dataMap 変更用データマップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0201C010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, String prefix
			, HashMap<String, Object> dataMap) 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);
		}

		// 連絡先情報変更マップ.世代登録年月日時分秒 ← .世代登録年月日時分秒
		if (template.isNull(ECK0201C010CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put(prefix + "gene_add_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "gene_add_dtm", template.getString(ECK0201C010CBSMsg.GENE_ADD_DTM));
		}

		// 連絡先情報変更マップ.予約適用コード ← .予約適用コード
		if (template.isNull(ECK0201C010CBSMsg.RSV_APLY_CD))
		{
			dataMap.put(prefix + "rsv_aply_cd", "");
		}
		else
		{
			dataMap.put(prefix + "rsv_aply_cd", template.getString(ECK0201C010CBSMsg.RSV_APLY_CD));
		}

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

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

		// 連絡先情報変更マップ.更新年月日時分秒 ← .更新年月日時分秒
		if (template.isNull(ECK0201C010CBSMsg.UPD_DTM))
		{
			dataMap.put(prefix + "upd_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "upd_dtm", template.getString(ECK0201C010CBSMsg.UPD_DTM));
			
			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0201C010CBSMsg.UPD_DTM));
		}

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

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

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

		//エラー情報のマップを取得
		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 prefix プレフィックス
	 * @param inMap 変更用データマップ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfoECK0201C010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String prefix
			, HashMap<String, Object> inMap) throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201C010CBSMsg.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);
		}

		// 連絡先情報変更.連絡先番号 → 連絡先番号 のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.RRKS_NO_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_no_err"))
			{
				inMap.put(prefix + "rrks_no_err", template.getString(ECK0201C010CBSMsg.RRKS_NO_ERR));
			}
		}
		
		// 連絡先情報変更.連絡先種別コード → 連絡先種別コード のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.RRKS_SBT_CD_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_sbt_cd_err"))
			{
				inMap.put(prefix + "rrks_sbt_cd_err", template.getString(ECK0201C010CBSMsg.RRKS_SBT_CD_ERR));
			}
		}
		
		// 連絡先情報変更.電話番号 → 電話番号 のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.TELNO_ERR))
		{
			if (!inMap.containsKey(prefix + "telno_err"))
			{
				inMap.put(prefix + "telno_err", template.getString(ECK0201C010CBSMsg.TELNO_ERR));
			}
		}

		// 連絡先情報変更.内線番号 → 内線番号 のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.NISNNO_ERR))
		{
			if (!inMap.containsKey(prefix + "nisnno_err"))
			{
				inMap.put(prefix + "nisnno_err", template.getString(ECK0201C010CBSMsg.NISNNO_ERR));
			}
		}

		// 連絡先情報変更.FAX番号 → FAX番号 のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.FAX_NO_ERR))
		{
			if (!inMap.containsKey(prefix + "fax_no_err"))
			{
				inMap.put(prefix + "fax_no_err", template.getString(ECK0201C010CBSMsg.FAX_NO_ERR));
			}
		}

		// 連絡先情報変更.予約適用年月日 → 予約適用年月日 のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey(prefix + "rsv_aply_ymd_err"))
			{
				inMap.put(prefix + "rsv_aply_ymd_err", template.getString(ECK0201C010CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// 連絡先情報変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0201C010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(prefix + "upd_dtm_bf_err"))
			{
				inMap.put(prefix + "upd_dtm_bf_err", template.getString(ECK0201C010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}

	/**
	 * 連絡先登録用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param prefix プレフィックス
	 * @param inMap 連絡先登録用マップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0201D010(IRequestParameterReadWrite param, String fixedText, String prefix
			, HashMap<String, Object> inMap) 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> mp = (HashMap<String, Object>)param.getData(fixedText);

		// 機能コード
		template.set(ECK0201D010CBSMsg.FUNC_CODE, mp.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"));
		}

		// 連絡先登録マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get(prefix + "upd_dtm_bf"));
		template.set(ECK0201D010CBSMsg.UPD_DTM_BF, lastDtm);

		return template;
	}

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

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

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

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

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

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

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

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

		//エラー情報のマップを取得
		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
	 * @param inMap
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfoECK0201D010(IRequestParameterReadWrite param, CAANMsg template, int returnCode
			, String fixedText, String prefix, HashMap<String, Object> inMap) 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);
		}

		// 連絡先登録マップ.ＳＹＳＩＤ → ＳＹＳＩＤ のエラー情報返却
		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 editInECK0201C030(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

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

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

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

		// 連絡先メールアドレス本登録.連絡先番号 → 連絡先番号
		if (inMap == null || inMap.get("ck020102_rrks_no") == null || "".equals(inMap.get("ck020102_rrks_no")))
		{
			template.setNull(ECK0201C030CBSMsg.RRKS_NO);
		}
		else
		{
			template.set(ECK0201C030CBSMsg.RRKS_NO, (String)inMap.get("ck020102_rrks_no"));
		}

		// 連絡先メールアドレス本登録.メールアドレス → メールアドレス
		if (inMap == null || inMap.get("ck020102_mlad") == null || "".equals(inMap.get("ck020102_mlad")))
		{
			template.setNull(ECK0201C030CBSMsg.MLAD);
		}
		else
		{
			template.set(ECK0201C030CBSMsg.MLAD, (String)inMap.get("ck020102_mlad"));
		}

		// 連絡先メールアドレス本登録.メールアドレス変更年月日 → メールアドレス変更年月日
		if (inMap == null || inMap.get("ck020102_mlad_chge_ymd") == null || "".equals(inMap.get("ck020102_mlad_chge_ymd")))
		{
			template.setNull(ECK0201C030CBSMsg.MLAD_CHGE_YMD);
		}
		else
		{
			template.set(ECK0201C030CBSMsg.MLAD_CHGE_YMD, (String)inMap.get("ck020102_mlad_chge_ymd"));
		}

		// 連絡先メールアドレス本登録.予約適用年月日 → 予約適用年月日
		if (inMap == null || inMap.get("ck020102_rsv_aply_ymd") == null || "".equals(inMap.get("ck020102_rsv_aply_ymd")))
		{
			template.setNull(ECK0201C030CBSMsg.RSV_APLY_YMD);
		}
		else
		{
			template.set(ECK0201C030CBSMsg.RSV_APLY_YMD, (String)inMap.get("ck020102_rsv_aply_ymd"));
		}

		// 連絡先メールアドレス本登録.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get("ck020102_upd_dtm_bf"));
		template.set(ECK0201C030CBSMsg.UPD_DTM_BF, lastDtm);

		return template;
	}

	/**
	 * 連絡先メールアドレス本登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0201C030(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);

		// 作業領域のマップを取得
		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(ECK0201C030CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("ck020102_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("ck020102_gene_add_dtm", template.getString(ECK0201C030CBSMsg.GENE_ADD_DTM));
		}

		// 連絡先メールアドレス本登録マップ.メールアドレス変更受付年月日 ← .メールアドレス変更受付年月日
		if (template.isNull(ECK0201C030CBSMsg.MLAD_CHGE_UK_YMD))
		{
			dataMap.put("ck020102_mlad_chge_uk_ymd", "");
		}
		else
		{
			dataMap.put("ck020102_mlad_chge_uk_ymd", template.getString(ECK0201C030CBSMsg.MLAD_CHGE_UK_YMD));
		}

		// 連絡先メールアドレス本登録マップ.予約適用コード ← .予約適用コード
		if (template.isNull(ECK0201C030CBSMsg.RSV_APLY_CD))
		{
			dataMap.put("ck020102_rsv_aply_cd", "");
		}
		else
		{
			dataMap.put("ck020102_rsv_aply_cd", template.getString(ECK0201C030CBSMsg.RSV_APLY_CD));
		}

		// 連絡先メールアドレス本登録マップ.登録年月日時分秒 ← .登録年月日時分秒
		if (template.isNull(ECK0201C030CBSMsg.ADD_DTM))
		{
			dataMap.put("ck020102_add_dtm", "");
		}
		else
		{
			dataMap.put("ck020102_add_dtm", template.getString(ECK0201C030CBSMsg.ADD_DTM));
		}

		// 連絡先メールアドレス本登録マップ.登録オペレータアカウント ← .登録オペレータアカウント
		if (template.isNull(ECK0201C030CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("ck020102_add_opeacnt", "");
		}
		else
		{
			dataMap.put("ck020102_add_opeacnt", template.getString(ECK0201C030CBSMsg.ADD_OPEACNT));
		}

		// 連絡先メールアドレス本登録マップ.更新年月日時分秒 ← .更新年月日時分秒
		if (template.isNull(ECK0201C030CBSMsg.UPD_DTM))
		{
			dataMap.put("ck020102_upd_dtm", "");
		}
		else
		{
			dataMap.put("ck020102_upd_dtm", template.getString(ECK0201C030CBSMsg.UPD_DTM));
			
			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0201C030CBSMsg.UPD_DTM));
		}

		// 連絡先メールアドレス本登録マップ.更新オペレータアカウント ← .更新オペレータアカウント
		if (template.isNull(ECK0201C030CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("ck020102_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("ck020102_upd_opeacnt", template.getString(ECK0201C030CBSMsg.UPD_OPEACNT));
		}

		// 連絡先メールアドレス本登録マップ.無効フラグ ← .無効フラグ
		if (template.isNull(ECK0201C030CBSMsg.MK_FLG))
		{
			dataMap.put("ck020102_mk_flg", "");
		}
		else
		{
			dataMap.put("ck020102_mk_flg", template.getString(ECK0201C030CBSMsg.MK_FLG));
		}

		iparam.setData(fixedText, dataMap);

		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0201C030(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 editErrInfoECK0201C030(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201C030CBSMsg.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(ECK0201C030CBSMsg.RRKS_NO_ERR))
		{
			if (!inMap.containsKey("ck020102_rrks_no_err"))
			{
				inMap.put("ck020102_rrks_no_err", template.getString(ECK0201C030CBSMsg.RRKS_NO_ERR));
			}
		}

		// 連絡先メールアドレス本登録.メールアドレス → メールアドレス のエラー情報返却
		if (!template.isNull(ECK0201C030CBSMsg.MLAD_ERR))
		{
			if (!inMap.containsKey("ck020102_mlad_err"))
			{
				inMap.put("ck020102_mlad_err", template.getString(ECK0201C030CBSMsg.MLAD_ERR));
			}
		}

		// 連絡先メールアドレス本登録.メールアドレス変更年月日 → メールアドレス変更年月日 のエラー情報返却
		if (!template.isNull(ECK0201C030CBSMsg.MLAD_CHGE_YMD_ERR))
		{
			if (!inMap.containsKey("ck020102_mlad_chge_ymd_err"))
			{
				inMap.put("ck020102_mlad_chge_ymd_err", template.getString(ECK0201C030CBSMsg.MLAD_CHGE_YMD_ERR));
			}
		}

		// 連絡先メールアドレス本登録.予約適用年月日 → 予約適用年月日 のエラー情報返却
		if (!template.isNull(ECK0201C030CBSMsg.RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("ck020102_rsv_aply_ymd"))
			{
				inMap.put("ck020102_rsv_aply_ymd", template.getString(ECK0201C030CBSMsg.RSV_APLY_YMD_ERR));
			}
		}

		// 連絡先メールアドレス本登録.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0201C030CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("ck020102_upd_dtm_bf_err"))
			{
				inMap.put("ck020102_upd_dtm_bf_err", template.getString(ECK0201C030CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 連絡先論理削除用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param prefix
	 * @param inMap
	 * @param updDtmBf
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0201E010(IRequestParameterReadWrite param, String fixedText, String prefix
			, HashMap<String, Object> inMap, String updDtmBf) throws RequestParameterException
	{

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

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

		// 機能コード（デフォルト：１）
		template.set(ECK0201E010CBSMsg.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> mp = (HashMap<String, Object>)param.getData(fixedText);

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

		// 連絡先論理削除.連絡先番号 → 連絡先番号
		if (inMap == null || inMap.get(prefix + "rrks_no") == null || "".equals(inMap.get(prefix + "rrks_no")))
		{
			template.setNull(ECK0201E010CBSMsg.RRKS_NO);
		}
		else
		{
			template.set(ECK0201E010CBSMsg.RRKS_NO, (String)inMap.get(prefix + "rrks_no"));
		}

		// 連絡先論理削除.世代登録年月日時分秒 → 世代登録年月日時分秒
		if (inMap == null || inMap.get(prefix + "gene_add_dtm") == null || "".equals(inMap.get(prefix + "gene_add_dtm")))
		{
			template.setNull(ECK0201E010CBSMsg.GENE_ADD_DTM);
		}
		else
		{
			template.set(ECK0201E010CBSMsg.GENE_ADD_DTM, (String)inMap.get(prefix + "gene_add_dtm"));
		}

		// 連絡先論理削除.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, updDtmBf);
		template.set(ECK0201E010CBSMsg.UPD_DTM_BF, lastDtm);

		return template;
	}

	/**
	 * 連絡先論理削除の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @param prefix プレフィックス
	 * @param dataMap 論理削除用データマップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0201E010(Map<?, ?> msgList, IRequestParameterReadWrite iparam, String fixedText, String prefix
			, HashMap<String, Object> dataMap) 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);
		}

		// 連絡先論理削除マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (template.isNull(ECK0201E010CBSMsg.UPD_DTM))
		{
			dataMap.put(prefix + "upd_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "upd_dtm", template.getString(ECK0201E010CBSMsg.UPD_DTM));
			
			JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0201E010CBSMsg.UPD_DTM));
		}

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

		// 連絡先論理削除マップ.削除年月日時分秒 ← 削除年月日時分秒
		if (template.isNull(ECK0201E010CBSMsg.DEL_DTM))
		{
			dataMap.put(prefix + "del_dtm", "");
		}
		else
		{
			dataMap.put(prefix + "del_dtm", template.getString(ECK0201E010CBSMsg.DEL_DTM));
		}

		// 連絡先論理削除マップ.削除オペレータアカウント ← 削除オペレータアカウント
		if (template.isNull(ECK0201E010CBSMsg.DEL_OPEACNT))
		{
			dataMap.put(prefix + "del_opeacnt", "");
		}
		else
		{
			dataMap.put(prefix + "del_opeacnt", template.getString(ECK0201E010CBSMsg.DEL_OPEACNT));
		}

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

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

		//エラー情報のマップを取得
		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 プレフィックス
	 * @param inMap 論理削除用データマップ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfoECK0201E010(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText
			, String prefix, HashMap<String, Object> inMap) throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201E010CBSMsg.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);
		}

		// 連絡先論理削除.連絡先番号 → 連絡先番号 のエラー情報返却
		if (!template.isNull(ECK0201E010CBSMsg.RRKS_NO_ERR))
		{
			if (!inMap.containsKey(prefix + "rrks_no_err"))
			{
				inMap.put(prefix + "rrks_no_err", template.getString(ECK0201E010CBSMsg.RRKS_NO_ERR));
			}
		}

		// 連絡先論理削除.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(ECK0201E010CBSMsg.GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(prefix + "gene_add_dtm_err"))
			{
				inMap.put(prefix + "gene_add_dtm_err", template.getString(ECK0201E010CBSMsg.GENE_ADD_DTM_ERR));
			}
		}

		// 連絡先論理削除.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(ECK0201E010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(prefix + "upd_dtm_bf_err"))
			{
				inMap.put(prefix + "upd_dtm_bf_err", template.getString(ECK0201E010CBSMsg.UPD_DTM_BF_ERR));
			}
		}

		return param;
	}
	
	/**
	 * 連絡先世代情報一覧照会（連絡先番号）用メッセージ設定処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param prefix
	 * @param inMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0201B506(IRequestParameterReadWrite param, String fixedText, String prefix
			, HashMap<String, Object> inMap) throws RequestParameterException
	{

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

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

		// 機能コード（デフォルト：１）
		template.set(ECK0201B506CBSMsg.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> mp = (HashMap<String, Object>)param.getData(fixedText);

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

		// 連絡先世代情報一覧照会（連絡先番号）.連絡先番号 → 連絡先番号
		setTemplate(template, ECK0201B506CBSMsg.KEY_RRKS_NO, inMap, prefix, "rrks_no");

		return template;
	}

	/**
	 * 連絡先世代情報一覧照会（連絡先番号）の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param iparam
	 * @param fixedText
	 * @param prefix プレフィックス
	 * @param dataMap 論理削除用データマップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0201B506(Map<?, ?> msgList, IRequestParameterReadWrite iparam, String fixedText, String prefix
			, HashMap<String, Object> dataMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		CAANMsg[] templateArray = template.getCAANMsgList(ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST);
		ArrayList<HashMap> msg1List = (ArrayList<HashMap>)dataMap.get(prefix + ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST);
		if(null == msg1List)
		{
			msg1List = new ArrayList<HashMap>();
			dataMap.put(prefix + ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST, msg1List);
		}
		HashMap<String, Object> childMap = null;
		
		if(null != templateArray)
		{
			int i = 0;
			for(CAANMsg childTemplate : templateArray)
			{
				if(msg1List.size() <= i)
				{
					msg1List.add(new HashMap());
				}
				childMap = msg1List.get(i++);
				
				// 連絡先番号 ← 連絡先世代情報一覧照会（連絡先番号）.連絡先番号
				setDataMap(childMap, prefix, ECK0201B506CBSMsg1List.RRKS_NO, childTemplate, ECK0201B506CBSMsg1List.RRKS_NO);
				// 世代登録年月日時分秒 ← 連絡先世代情報一覧照会（連絡先番号）.世代登録年月日時分秒
				setDataMap(childMap, prefix, ECK0201B506CBSMsg1List.GENE_ADD_DTM, childTemplate, ECK0201B506CBSMsg1List.GENE_ADD_DTM);
			}
		}
		
		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0201B506(iparam, template, (Integer)returnCode, fixedText, prefix, dataMap);

		//エラー情報のマップを取得
		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 プレフィックス
	 * @param inMap 論理削除用データマップ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfoECK0201B506(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText
			, String prefix, HashMap<String, Object> inMap) throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201E010CBSMsg.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);
		}

		// 連絡先世代情報一覧照会（連絡先番号）.連絡先番号 → 連絡先番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0201B506CBSMsg.KEY_RRKS_NO_ERR, template, ECK0201B506CBSMsg.KEY_RRKS_NO_ERR);

		return param;
	}

	/**
	 * 契約者タイプ変更の上りマッピングを行います。
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param prefix プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInECK0011C130(IRequestParameterReadWrite param, String fixedText, String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECK0011C130CBSMsg.class.getName());
		// テンプレートID
		template.set(ECK0011C130CBSMsg.TEMPLATEID, "ECK0011C130");
		// 機能コード（デフォルト：１）
		template.set(ECK0011C130CBSMsg.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(ECK0011C130CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// 契約者タイプ変更.SYSID → SYSID
		setTemplate(template, ECK0011C130CBSMsg.SYSID, inMap, prefix, ECK0011C130CBSMsg.SYSID);
		// 契約者タイプ変更.契約者タイプコード → 契約者タイプコード
		setTemplate(template, ECK0011C130CBSMsg.KEISHA_TYPE_CD, inMap, prefix, ECK0011C130CBSMsg.KEISHA_TYPE_CD);
		// 契約者タイプ変更.会員種別コード → 会員種別コード
		setTemplate(template, ECK0011C130CBSMsg.MEMBER_SBT_CD, inMap, prefix, ECK0011C130CBSMsg.MEMBER_SBT_CD);
		// 契約者タイプ変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String lastDtm = JKKBpCommon.getLastDtmByCust(param, (String)inMap.get(prefix + ECK0011C130CBSMsg.UPD_DTM_BF));
		template.set(ECK0011C130CBSMsg.UPD_DTM_BF, lastDtm);
		// 契約者タイプ変更.職業コード → 職業コード
		setTemplate(template, ECK0011C130CBSMsg.SHOKUGYO_CD, inMap, prefix, ECK0011C130CBSMsg.SHOKUGYO_CD);
		// 契約者タイプ変更.職業その他 → 職業その他
		setTemplate(template, ECK0011C130CBSMsg.SHOKUGYO_OTHER, inMap, prefix, ECK0011C130CBSMsg.SHOKUGYO_OTHER);
		// 契約者タイプ変更.勤務先名 → 勤務先名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_NM);
		// 契約者タイプ変更.学校名 → 学校名
		setTemplate(template, ECK0011C130CBSMsg.SCHOOL_NM, inMap, prefix, ECK0011C130CBSMsg.SCHOOL_NM);
		// 契約者タイプ変更.勤務先業種コード → 勤務先業種コード
		setTemplate(template, ECK0011C130CBSMsg.OFFC_GSHU_CD, inMap, prefix, ECK0011C130CBSMsg.OFFC_GSHU_CD);
		// 契約者タイプ変更.勤務先部署名 → 勤務先部署名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_BUSHO_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_BUSHO_NM);
		// 契約者タイプ変更.勤務先住所コード → 勤務先住所コード
		setTemplate(template, ECK0011C130CBSMsg.OFFC_AD_CD, inMap, prefix, ECK0011C130CBSMsg.OFFC_AD_CD);
		// 契約者タイプ変更.勤務先郵便番号 → 勤務先郵便番号
		setTemplate(template, ECK0011C130CBSMsg.OFFC_PCD, inMap, prefix, ECK0011C130CBSMsg.OFFC_PCD);
		// 契約者タイプ変更.勤務先都道府県名 → 勤務先都道府県名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_STATE_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_STATE_NM);
		// 契約者タイプ変更.勤務先市区町村名 → 勤務先市区町村名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_CITY_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_CITY_NM);
		// 契約者タイプ変更.勤務先大字通称名 → 勤務先大字通称名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_OAZTSU_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_OAZTSU_NM);
		// 契約者タイプ変更.勤務先字丁目名 → 勤務先字丁目名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_AZCHO_NM, inMap, prefix, ECK0011C130CBSMsg.OFFC_AZCHO_NM);
		// 契約者タイプ変更.勤務先番地号 → 勤務先番地号
		setTemplate(template, ECK0011C130CBSMsg.OFFC_BNCHIGO, inMap, prefix, ECK0011C130CBSMsg.OFFC_BNCHIGO);
		// 契約者タイプ変更.勤務先住所補記・建物名 → 勤務先住所補記・建物名
		setTemplate(template, ECK0011C130CBSMsg.OFFC_ADRTTM, inMap, prefix, ECK0011C130CBSMsg.OFFC_ADRTTM);
		// 契約者タイプ変更.勤務先住所補記・部屋番号 → 勤務先住所補記・部屋番号
		setTemplate(template, ECK0011C130CBSMsg.OFFC_ADRRM, inMap, prefix, ECK0011C130CBSMsg.OFFC_ADRRM);
		// 契約者タイプ変更.勤務先電話番号 → 勤務先電話番号
		setTemplate(template, ECK0011C130CBSMsg.OFFC_TELNO, inMap, prefix, ECK0011C130CBSMsg.OFFC_TELNO);
		// 契約者タイプ変更.勤務先内線番号 → 勤務先内線番号
		setTemplate(template, ECK0011C130CBSMsg.OFFC_NISNNO, inMap, prefix, ECK0011C130CBSMsg.OFFC_NISNNO);
		// 契約者タイプ変更.勤務先従業員数(規模) → 勤務先従業員数(規模)
		setTemplate(template, ECK0011C130CBSMsg.OFFC_WORKER_CNT_SCALE, inMap, prefix, ECK0011C130CBSMsg.OFFC_WORKER_CNT_SCALE);
		// 契約者タイプ変更.お客様年収 → お客様年収
		setTemplate(template, ECK0011C130CBSMsg.CUST_SALARY, inMap, prefix, ECK0011C130CBSMsg.CUST_SALARY);
		// 契約者タイプ変更.親権者名 → 親権者名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_NM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_NM);
		// 契約者タイプ変更.親権者カナ名 → 親権者カナ名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_KANA, inMap, prefix, ECK0011C130CBSMsg.SKSHA_KANA);
		// 契約者タイプ変更.親権者生年月日 → 親権者生年月日
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_BIRTHD, inMap, prefix, ECK0011C130CBSMsg.SKSHA_BIRTHD);
		// 契約者タイプ変更.親権者続柄コード → 親権者続柄コード
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_ZOKUGARA_CD, inMap, prefix, ECK0011C130CBSMsg.SKSHA_ZOKUGARA_CD);
		// 契約者タイプ変更.続柄その他 → 続柄その他
		setTemplate(template, ECK0011C130CBSMsg.ZOKUGARA_OTHER, inMap, prefix, ECK0011C130CBSMsg.ZOKUGARA_OTHER);
		// 契約者タイプ変更.親権者住所コード → 親権者住所コード
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_AD_CD, inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_CD);
		// 契約者タイプ変更.親権者郵便番号 → 親権者郵便番号
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_PCD, inMap, prefix, ECK0011C130CBSMsg.SKSHA_PCD);
		// 契約者タイプ変更.親権者都道府県名 → 親権者都道府県名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_STATE_NM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_STATE_NM);
		// 契約者タイプ変更.親権者市区町村名 → 親権者市区町村名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_CITY_NM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_CITY_NM);
		// 契約者タイプ変更.親権者大字通称名 → 親権者大字通称名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_OAZTSU_NM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_OAZTSU_NM);
		// 契約者タイプ変更.親権者字丁目名 → 親権者字丁目名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_AZCHO_NM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_AZCHO_NM);
		// 契約者タイプ変更.親権者住所番地号 → 親権者住所番地号
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_AD_BNCHIGO, inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_BNCHIGO);
		// 契約者タイプ変更.親権者住所補記・建物名 → 親権者住所補記・建物名
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_ADRTTM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_ADRTTM);
		// 契約者タイプ変更.親権者住所補記・部屋番号 → 親権者住所補記・部屋番号
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_ADRRM, inMap, prefix, ECK0011C130CBSMsg.SKSHA_ADRRM);
		// 契約者タイプ変更.親権者住所手動入力フラグ → 親権者住所手動入力フラグ
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_AD_MAN_INPUT_FLG, inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_MAN_INPUT_FLG);
		// 契約者タイプ変更.親権者電話番号 → 親権者電話番号
		setTemplate(template, ECK0011C130CBSMsg.SKSHA_TELNO, inMap, prefix, ECK0011C130CBSMsg.SKSHA_TELNO);
		// 契約者タイプ変更.法人格種別コード → 法人格種別コード
		setTemplate(template, ECK0011C130CBSMsg.HOJIN_SBT_CD, inMap, prefix, ECK0011C130CBSMsg.HOJIN_SBT_CD);
		// 契約者タイプ変更.法人格前後指定コード → 法人格前後指定コード
		setTemplate(template, ECK0011C130CBSMsg.HOJIN_ZENGO_SHITEI_CD, inMap, prefix, ECK0011C130CBSMsg.HOJIN_ZENGO_SHITEI_CD);
		// 契約者タイプ変更.会社名 → 会社名
		setTemplate(template, ECK0011C130CBSMsg.COMP_NM, inMap, prefix, ECK0011C130CBSMsg.COMP_NM);
		// 契約者タイプ変更.会社カナ名 → 会社カナ名
		setTemplate(template, ECK0011C130CBSMsg.COMP_KANA, inMap, prefix, ECK0011C130CBSMsg.COMP_KANA);
		// 契約者タイプ変更.代表者役職名 → 代表者役職名
		setTemplate(template, ECK0011C130CBSMsg.DIHYSHA_POST_NM, inMap, prefix, ECK0011C130CBSMsg.DIHYSHA_POST_NM);
		// 契約者タイプ変更.業種コード → 業種コード
		setTemplate(template, ECK0011C130CBSMsg.GSHU_CD, inMap, prefix, ECK0011C130CBSMsg.GSHU_CD);
		// 契約者タイプ変更.代表者名 → 代表者名
		setTemplate(template, ECK0011C130CBSMsg.DIHYSHA_NM, inMap, prefix, ECK0011C130CBSMsg.DIHYSHA_NM);
		// 契約者タイプ変更.代表者カナ名 → 代表者カナ名
		setTemplate(template, ECK0011C130CBSMsg.DIHYSHA_KANA, inMap, prefix, ECK0011C130CBSMsg.DIHYSHA_KANA);
		
		ArrayList<HashMap<String, Object>> msg1List = (ArrayList<HashMap<String, Object>>)inMap.get(prefix + ECK0011C130CBSMsg.ECK0011C130CBSMSG1LIST);
		msg1List = null == msg1List ? new ArrayList<HashMap<String, Object>>() : msg1List;
		CAANMsg[] templateArray = new CAANMsg[msg1List.size()];
		template.set(ECK0011C130CBSMsg.ECK0011C130CBSMSG1LIST, templateArray);
		
		int i = 0;
		CAANMsg childTemplate = null;
		for(HashMap<String, Object> childMap : msg1List)
		{
			childTemplate = templateArray[i];
			
			if (null == childTemplate)
			{
				childTemplate = new CAANMsg(ECK0011C130CBSMsg1List.class.getName());
				templateArray[i] = childTemplate;
			}
			
			i++;
			
			// 契約者タイプ変更.連絡先コード → 連絡先コード
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.RRKS_CD, childMap, prefix, ECK0011C130CBSMsg1List.RRKS_CD);
			// 契約者タイプ変更.法人連絡先名 → 法人連絡先名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_NM);
			// 契約者タイプ変更.法人連絡先住所コード → 法人連絡先住所コード
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AD_CD, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AD_CD);
			// 契約者タイプ変更.法人連絡先郵便番号 → 法人連絡先郵便番号
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_PCD, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_PCD);
			// 契約者タイプ変更.法人連絡先都道府県名 → 法人連絡先都道府県名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_STATE_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_STATE_NM);
			// 契約者タイプ変更.法人連絡先市区町村名 → 法人連絡先市区町村名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM);
			// 契約者タイプ変更.法人連絡先大字通称名 → 法人連絡先大字通称名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM);
			// 契約者タイプ変更.法人連絡先字丁目名 → 法人連絡先字丁目名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM);
			// 契約者タイプ変更.法人連絡先番地号 → 法人連絡先番地号
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO);
			// 契約者タイプ変更.法人連絡先住所補記・建物名 → 法人連絡先住所補記・建物名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM);
			// 契約者タイプ変更.法人連絡先住所補記・部屋番号 → 法人連絡先住所補記・部屋番号
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRRM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRRM);
			// 契約者タイプ変更.法人連絡先担当者名 → 法人連絡先担当者名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM);
			// 契約者タイプ変更.法人連絡先担当者カナ名 → 法人連絡先担当者カナ名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA);
			// 契約者タイプ変更.法人連絡先担当者所属部署名 → 法人連絡先担当者所属部署名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM);
			// 契約者タイプ変更.法人連絡先市区町村名 → 法人連絡先市区町村名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM);
			// 契約者タイプ変更.法人連絡先大字通称名 → 法人連絡先大字通称名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM);
			// 契約者タイプ変更.法人連絡先字丁目名 → 法人連絡先字丁目名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM);
			// 契約者タイプ変更.法人連絡先番地号 → 法人連絡先番地号
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO);
			// 契約者タイプ変更.法人連絡先住所補記・建物名 → 法人連絡先住所補記・建物名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM);
			// 契約者タイプ変更.法人連絡先住所補記・部屋番号 → 法人連絡先住所補記・部屋番号
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRRM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRRM);
			// 契約者タイプ変更.法人連絡先担当者名 → 法人連絡先担当者名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM);
			// 契約者タイプ変更.法人連絡先担当者カナ名 → 法人連絡先担当者カナ名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA);
			// 契約者タイプ変更.法人連絡先担当者所属部署名 → 法人連絡先担当者所属部署名
			setTemplate(childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM, childMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM);
		}
		
		return template;
	}

	/**
	 * 契約者タイプ変更の下りマッピングを行います。
	 * @param msgList
	 * @param iparam
	 * @param fixedText ユーザ定義文字列
	 * @param prefix プレフィックス
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0011C130(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);
		
		HashMap dataMap = (HashMap)iparam.getData(fixedText);
		if (null == dataMap)
		{
			dataMap = new HashMap();
			iparam.setData(fixedText, dataMap);
		}
		
		// 世代登録年月日時分秒 ← 契約者タイプ変更.世代登録年月日時分秒
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.GENE_ADD_DTM, template, ECK0011C130CBSMsg.GENE_ADD_DTM);
		// 予約適用年月日 ← 契約者タイプ変更.予約適用年月日
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.RSV_APLY_YMD, template, ECK0011C130CBSMsg.RSV_APLY_YMD);
		// 予約適用コード ← 契約者タイプ変更.予約適用コード
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.RSV_APLY_CD, template, ECK0011C130CBSMsg.RSV_APLY_CD);
		// 登録年月日時分秒 ← 契約者タイプ変更.登録年月日時分秒
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.ADD_DTM, template, ECK0011C130CBSMsg.ADD_DTM);
		// 登録オペレータアカウント ← 契約者タイプ変更.登録オペレータアカウント
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.ADD_OPEACNT, template, ECK0011C130CBSMsg.ADD_OPEACNT);
		// 更新年月日時分秒 ← 契約者タイプ変更.更新年月日時分秒
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.UPD_DTM, template, ECK0011C130CBSMsg.UPD_DTM);
		JKKBpCommon.setLastDtmByCust(iparam, template.getString(ECK0011C130CBSMsg.UPD_DTM));
		// 更新オペレータアカウント ← 契約者タイプ変更.更新オペレータアカウント
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.UPD_OPEACNT, template, ECK0011C130CBSMsg.UPD_OPEACNT);
		// 無効フラグ ← 契約者タイプ変更.無効フラグ
		setDataMap(dataMap, prefix, ECK0011C130CBSMsg.MK_FLG, template, ECK0011C130CBSMsg.MK_FLG);
		
		// エラー情報の設定
		IRequestParameterReadWrite param = editErrInfoECK0011C130(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;
	}

	/**
	 * 契約者タイプ変更のエラー情報をマッピングします。
	 * @param param
	 * @param template
	 * @param returnCode
	 * @param fixedText ユーザ定義文字列
	 * @param prefix プレフィックス
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECK0011C130(IRequestParameterReadWrite param, CAANMsg template, int returnCode, String fixedText
			, String prefix) throws RequestParameterException
	{
		int templateStatus = template.getInt(ECK0201E010CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 契約者タイプ変更.SYSID → SYSIDのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SYSID_ERR, template, ECK0011C130CBSMsg.SYSID_ERR);
		// 契約者タイプ変更.契約者タイプコード → 契約者タイプコードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.KEISHA_TYPE_CD_ERR, template, ECK0011C130CBSMsg.KEISHA_TYPE_CD_ERR);
		// 契約者タイプ変更.会員種別コード → 会員種別コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.MEMBER_SBT_CD_ERR, template, ECK0011C130CBSMsg.MEMBER_SBT_CD_ERR);
		// 契約者タイプ変更.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.UPD_DTM_BF_ERR, template, ECK0011C130CBSMsg.UPD_DTM_BF_ERR);
		// 契約者タイプ変更.職業コード → 職業コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SHOKUGYO_CD_ERR, template, ECK0011C130CBSMsg.SHOKUGYO_CD_ERR);
		// 契約者タイプ変更.職業その他 → 職業その他のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SHOKUGYO_OTHER_ERR, template, ECK0011C130CBSMsg.SHOKUGYO_OTHER_ERR);
		// 契約者タイプ変更.勤務先名 → 勤務先名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_NM_ERR, template, ECK0011C130CBSMsg.OFFC_NM_ERR);
		// 契約者タイプ変更.学校名 → 学校名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SCHOOL_NM_ERR, template, ECK0011C130CBSMsg.SCHOOL_NM_ERR);
		// 契約者タイプ変更.勤務先業種コード → 勤務先業種コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_GSHU_CD_ERR, template, ECK0011C130CBSMsg.OFFC_GSHU_CD_ERR);
		// 契約者タイプ変更.勤務先部署名 → 勤務先部署名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_BUSHO_NM_ERR, template, ECK0011C130CBSMsg.OFFC_BUSHO_NM_ERR);
		// 契約者タイプ変更.勤務先住所コード → 勤務先住所コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_AD_CD_ERR, template, ECK0011C130CBSMsg.OFFC_AD_CD_ERR);
		// 契約者タイプ変更.勤務先郵便番号 → 勤務先郵便番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_PCD_ERR, template, ECK0011C130CBSMsg.OFFC_PCD_ERR);
		// 契約者タイプ変更.勤務先都道府県名 → 勤務先都道府県名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_STATE_NM_ERR, template, ECK0011C130CBSMsg.OFFC_STATE_NM_ERR);
		// 契約者タイプ変更.勤務先市区町村名 → 勤務先市区町村名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_CITY_NM_ERR, template, ECK0011C130CBSMsg.OFFC_CITY_NM_ERR);
		// 契約者タイプ変更.勤務先大字通称名 → 勤務先大字通称名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_OAZTSU_NM_ERR, template, ECK0011C130CBSMsg.OFFC_OAZTSU_NM_ERR);
		// 契約者タイプ変更.勤務先字丁目名 → 勤務先字丁目名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_AZCHO_NM_ERR, template, ECK0011C130CBSMsg.OFFC_AZCHO_NM_ERR);
		// 契約者タイプ変更.勤務先番地号 → 勤務先番地号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_BNCHIGO_ERR, template, ECK0011C130CBSMsg.OFFC_BNCHIGO_ERR);
		// 契約者タイプ変更.勤務先住所補記・建物名 → 勤務先住所補記・建物名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_ADRTTM_ERR, template, ECK0011C130CBSMsg.OFFC_ADRTTM_ERR);
		// 契約者タイプ変更.勤務先住所補記・部屋番号 → 勤務先住所補記・部屋番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_ADRRM_ERR, template, ECK0011C130CBSMsg.OFFC_ADRRM_ERR);
		// 契約者タイプ変更.勤務先電話番号 → 勤務先電話番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_TELNO_ERR, template, ECK0011C130CBSMsg.OFFC_TELNO_ERR);
		// 契約者タイプ変更.勤務先内線番号 → 勤務先内線番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_NISNNO_ERR, template, ECK0011C130CBSMsg.OFFC_NISNNO_ERR);
		// 契約者タイプ変更.勤務先従業員数(規模) → 勤務先従業員数(規模)のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.OFFC_WORKER_CNT_SCALE_ERR, template, ECK0011C130CBSMsg.OFFC_WORKER_CNT_SCALE_ERR);
		// 契約者タイプ変更.お客様年収 → お客様年収のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.CUST_SALARY_ERR, template, ECK0011C130CBSMsg.CUST_SALARY_ERR);
		// 契約者タイプ変更.親権者名 → 親権者名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_NM_ERR, template, ECK0011C130CBSMsg.SKSHA_NM_ERR);
		// 契約者タイプ変更.親権者カナ名 → 親権者カナ名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_KANA_ERR, template, ECK0011C130CBSMsg.SKSHA_KANA_ERR);
		// 契約者タイプ変更.親権者生年月日 → 親権者生年月日のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_BIRTHD_ERR, template, ECK0011C130CBSMsg.SKSHA_BIRTHD_ERR);
		// 契約者タイプ変更.親権者続柄コード → 親権者続柄コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_ZOKUGARA_CD_ERR, template, ECK0011C130CBSMsg.SKSHA_ZOKUGARA_CD_ERR);
		// 契約者タイプ変更.続柄その他 → 続柄その他のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.ZOKUGARA_OTHER_ERR, template, ECK0011C130CBSMsg.ZOKUGARA_OTHER_ERR);
		// 契約者タイプ変更.親権者住所コード → 親権者住所コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_CD_ERR, template, ECK0011C130CBSMsg.SKSHA_AD_CD_ERR);
		// 契約者タイプ変更.親権者郵便番号 → 親権者郵便番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_PCD_ERR, template, ECK0011C130CBSMsg.SKSHA_PCD_ERR);
		// 契約者タイプ変更.親権者都道府県名 → 親権者都道府県名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_STATE_NM_ERR, template, ECK0011C130CBSMsg.SKSHA_STATE_NM_ERR);
		// 契約者タイプ変更.親権者市区町村名 → 親権者市区町村名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_CITY_NM_ERR, template, ECK0011C130CBSMsg.SKSHA_CITY_NM_ERR);
		// 契約者タイプ変更.親権者大字通称名 → 親権者大字通称名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_OAZTSU_NM_ERR, template, ECK0011C130CBSMsg.SKSHA_OAZTSU_NM_ERR);
		// 契約者タイプ変更.親権者字丁目名 → 親権者字丁目名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_AZCHO_NM_ERR, template, ECK0011C130CBSMsg.SKSHA_AZCHO_NM_ERR);
		// 契約者タイプ変更.親権者住所番地号 → 親権者住所番地号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_BNCHIGO_ERR, template, ECK0011C130CBSMsg.SKSHA_AD_BNCHIGO_ERR);
		// 契約者タイプ変更.親権者住所補記・建物名 → 親権者住所補記・建物名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_ADRTTM_ERR, template, ECK0011C130CBSMsg.SKSHA_ADRTTM_ERR);
		// 契約者タイプ変更.親権者住所補記・部屋番号 → 親権者住所補記・部屋番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_ADRRM_ERR, template, ECK0011C130CBSMsg.SKSHA_ADRRM_ERR);
		// 契約者タイプ変更.親権者住所手動入力フラグ → 親権者住所手動入力フラグのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR, template, ECK0011C130CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR);
		// 契約者タイプ変更.親権者電話番号 → 親権者電話番号のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.SKSHA_TELNO_ERR, template, ECK0011C130CBSMsg.SKSHA_TELNO_ERR);
		// 契約者タイプ変更.法人格種別コード → 法人格種別コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.HOJIN_SBT_CD_ERR, template, ECK0011C130CBSMsg.HOJIN_SBT_CD_ERR);
		// 契約者タイプ変更.法人格前後指定コード → 法人格前後指定コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR, template, ECK0011C130CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR);
		// 契約者タイプ変更.会社名 → 会社名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.COMP_NM_ERR, template, ECK0011C130CBSMsg.COMP_NM_ERR);
		// 契約者タイプ変更.会社カナ名 → 会社カナ名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.COMP_KANA_ERR, template, ECK0011C130CBSMsg.COMP_KANA_ERR);
		// 契約者タイプ変更.代表者役職名 → 代表者役職名のエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.DIHYSHA_POST_NM_ERR, template, ECK0011C130CBSMsg.DIHYSHA_POST_NM_ERR);
		// 契約者タイプ変更.業種コード → 業種コードのエラー情報返却
		setErrInfo(inMap, prefix, ECK0011C130CBSMsg.GSHU_CD_ERR, template, ECK0011C130CBSMsg.GSHU_CD_ERR);
		
		ArrayList<HashMap<String, Object>> msg1List = (ArrayList<HashMap<String, Object>>)inMap.get(prefix + ECK0011C130CBSMsg.ECK0011C130CBSMSG1LIST);
		CAANMsg[] templateArray = template.getCAANMsgList(ECK0011C130CBSMsg.ECK0011C130CBSMSG1LIST);

		if (null == templateArray)
		{
			templateArray = new CAANMsg[1];
		}
		
		int i = 0;
		HashMap<String, Object> childMap = null;
		for(CAANMsg childTemplate : templateArray)
		{
			if (null == childTemplate)
			{
				childTemplate = new CAANMsg(ECK0011C130CBSMsg1List.class.getName());
			}
			
			if(msg1List.size() <= i)
			{
				childMap = new HashMap<String, Object>();
				msg1List.add(childMap);
				i++;
			}
			else
			{
				childMap = msg1List.get(i++);
			}
			
			// 契約者タイプ変更.連絡先コード → 連絡先コードのエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.RRKS_CD_ERR, childTemplate, ECK0011C130CBSMsg1List.RRKS_CD_ERR);
			// 契約者タイプ変更.法人連絡先名 → 法人連絡先名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_NM_ERR);
			// 契約者タイプ変更.法人連絡先住所コード → 法人連絡先住所コードのエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AD_CD_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AD_CD_ERR);
			// 契約者タイプ変更.法人連絡先郵便番号 → 法人連絡先郵便番号のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_PCD_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_PCD_ERR);
			// 契約者タイプ変更.法人連絡先都道府県名 → 法人連絡先都道府県名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_STATE_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_STATE_NM_ERR);
			// 契約者タイプ変更.法人連絡先市区町村名 → 法人連絡先市区町村名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM_ERR);
			// 契約者タイプ変更.法人連絡先大字通称名 → 法人連絡先大字通称名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM_ERR);
			// 契約者タイプ変更.法人連絡先字丁目名 → 法人連絡先字丁目名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM_ERR);
			// 契約者タイプ変更.法人連絡先番地号 → 法人連絡先番地号のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO_ERR);
			// 契約者タイプ変更.法人連絡先住所補記・建物名 → 法人連絡先住所補記・建物名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM_ERR);
			// 契約者タイプ変更.法人連絡先住所補記・部屋番号 → 法人連絡先住所補記・部屋番号のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRRM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRRM_ERR);
			// 契約者タイプ変更.法人連絡先担当者名 → 法人連絡先担当者名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM_ERR);
			// 契約者タイプ変更.法人連絡先担当者カナ名 → 法人連絡先担当者カナ名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR);
			// 契約者タイプ変更.法人連絡先担当者所属部署名 → 法人連絡先担当者所属部署名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR
					, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR);
			// 契約者タイプ変更.法人連絡先市区町村名 → 法人連絡先市区町村名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_CITY_NM_ERR);
			// 契約者タイプ変更.法人連絡先大字通称名 → 法人連絡先大字通称名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_OAZTSU_NM_ERR);
			// 契約者タイプ変更.法人連絡先字丁目名 → 法人連絡先字丁目名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_AZCHO_NM_ERR);
			// 契約者タイプ変更.法人連絡先番地号 → 法人連絡先番地号のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_BNCHIGO_ERR);
			// 契約者タイプ変更.法人連絡先住所補記・建物名 → 法人連絡先住所補記・建物名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRTTM_ERR);
			// 契約者タイプ変更.法人連絡先住所補記・部屋番号 → 法人連絡先住所補記・部屋番号のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_ADRRM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_ADRRM_ERR);
			// 契約者タイプ変更.法人連絡先担当者名 → 法人連絡先担当者名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_NM_ERR);
			// 契約者タイプ変更.法人連絡先担当者カナ名 → 法人連絡先担当者カナ名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_KANA_ERR);
			// 契約者タイプ変更.法人連絡先担当者所属部署名 → 法人連絡先担当者所属部署名のエラー情報返却
			setErrInfo(inMap, prefix, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_ERR
					, childTemplate, ECK0011C130CBSMsg1List.HJRRKS_TNTSHA_SHOZKBSHO_NM_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
	{
		HashMap inMap = (HashMap)param.getData(fixedText);

		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}
		
		int i = 0;

		String sysid = getMapValue(param, fixedText, PREFIX_TYPE_CHG + ECK0011C130CBSMsg.SYSID);
		if(null != sysid && 0 < sysid.length())
		{
			editErrInfoECK0011C130(param, templates[i++], returnCode, fixedText, PREFIX_TYPE_CHG); // 契約者タイプ変更
		}
		
		// 契約種別
		String keisha_type_cd = getMapValue(param, fixedText, "keisha_type_cd");
		// 連絡先番号
		String ck020102RrksNo = getMapValue(param, fixedText, "ck020102_rrks_no");

		// 契約種別が個人の場合
		if ("1".equals(keisha_type_cd))
		{
			editErrInfoECK0021C010(param, templates[i++], returnCode, fixedText); // お客様<個人>内容変更
		}
		// 契約種別が個人以外の場合
		else
		{
			editErrInfoECK0031C010(param, templates[i++], returnCode, fixedText); // お客様<法人>内容変更
			editErrInfoECK0041C010(param, templates[i++], returnCode, fixedText); // 法人連絡先変更
		}

		// 契約者情報変更マップ.連絡先番号（ck020102_rrks_no）が設定されている場合
		if (ck020102RrksNo != null && "".equals(ck020102RrksNo))
		{
			editErrInfoECK0201C030(param, templates[i++], returnCode, fixedText); // 連絡先メメールアドレス本登録
		}
		
		ArrayList<HashMap<String, Object>> rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_ADD);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			editErrInfoECK0201D010(param, templates[i++], returnCode, fixedText, PREFIX_RRS, rrsMap); // 連絡先情報登録
		}
		
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_UPD);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			editErrInfoECK0201C010(param, templates[i++], returnCode, PREFIX_RRS, rrsMap); // 連絡先情報変更
		}
		rrsList = (ArrayList<HashMap<String, Object>>)inMap.get(KEY_RRS_DEL);
		rrsList = (null == rrsList) ? new ArrayList<HashMap<String, Object>>() : rrsList;
		for(HashMap<String, Object> rrsMap : rrsList)
		{
			editErrInfoECK0201B506(param, templates[i++], returnCode, fixedText, PREFIX_RRS, rrsMap); // 連絡先世代情報一覧照会（連絡先番号）
			
			ArrayList<HashMap> msg1List = (ArrayList<HashMap>)rrsMap.get(PREFIX_RRS + ECK0201B506CBSMsg.ECK0201B506CBSMSG1LIST);
			msg1List = (null == msg1List) ? new ArrayList<HashMap>() : msg1List;
			for(HashMap msgMap : msg1List)
			{
				editErrInfoECK0201E010(param, templates[i++], returnCode, fixedText, PREFIX_RRS, msgMap); // 連絡先論理削除
			}
		}
		
		return param;
	}

	/**
	 * 単一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));
	}

	/**
	 * リクエストパラメータのインプットマップの要素を取得します。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param key
	 * @return 取得したマップ要素
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getMapValue(IRequestParameterReadWrite param, String fixedText, String key) throws RequestParameterException
	{
		HashMap inMap = (HashMap)(param.getData(fixedText));
		String result = (String)inMap.get(key);
		if ("".equals(result))
		{
			result = null;
		}

		return result;
	}
	
	/**
	 * 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>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getString(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));
			}
		}
	}
}