package com.fujitsu.futurity.bp.custom.common;

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

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

import eo.common.constant.JACStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JCRUtilCommon;
import eo.ejb.cbs.cbsmsg.EAC0171C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0351C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0361C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0371C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0391C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0401C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0421C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0431C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0461C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0551C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0591C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0601C020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg1List;

/**
 * 請求先更新CC部品クラス
 * @author   富士通
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *  v19.00.00   2015/10/19   FJ)中嶋     OM-2015-0001387　処理結果の判定を画面ステータスで行わないようにし、警告でシステムエラーにならないように変更
 */
public class JACSeikyUpdCC extends AbstractCommonComponent
{
	/** マップCCID */
	private static final String MAP_CC_ID = "JACSEIKYUPDCC";
	
	/** 請求先更新依頼リスト */
	private static final String SEIKY_UPD_LIST = "JACseikyupdMsg1List";
	
	/**
	 * 請求先更新チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	public  HashMap<String, Object> getInvokeCBS(SessionHandle handle
			, IRequestParameterReadWrite param, String fixedText) throws RequestParameterException 
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);
	
		HashMap<String, Object> resultMap = null;
		CAANMsg[] templates = null;
		List<CAANMsg> list = new ArrayList<CAANMsg>();
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		
		// 料金スケジュール定義一意照会サービスIFの実行
		inMap.put("key_event_cd", JACStrConst.EVENT_CD_PRC_CALC_DAY);
		inMap.put("key_unyo_day", inMap.get("unyo_day"));
		inMap.put("seiky_ym", "200001");
		resultMap = editInMsgECH0501A010(param, inMap, JPCModelConstant.FUNC_CD_2);
		templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		list.addAll(Arrays.asList(templates));
		
		resultMap = editInMsgECH0501A010(param, inMap, JPCModelConstant.FUNC_CD_3);
		templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		list.addAll(Arrays.asList(templates));
		
		// 請求先更新依頼リスト件数分繰り返す
		ArrayList<HashMap<String, Object>> seikyUpdList = (ArrayList<HashMap<String, Object>>)inMap.get(SEIKY_UPD_LIST);
		for (HashMap<String, Object> seikyUpdMap : seikyUpdList)
		{
			// 取得した請求年月を設定
			seikyUpdMap.put("seiky_ym", inMap.get("seiky_ym"));

			// 一時金請求先更新サービスIFの実行
			resultMap = editInMsgEAC0171C020(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// UQ取込請求先更新サービスIFの実行
			resultMap = editInMsgEAC0351C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eoモバイル明細請求先更新サービスIFの実行
			resultMap = editInMsgEAC0361C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eoモバイル合計請求先更新サービスIFの実行
			resultMap = editInMsgEAC0371C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eo光電話通話明細請求先更新サービスIFの実行
			resultMap = editInMsgEAC0391C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eo光電話通話合計請求先更新サービスIFの実行
			resultMap = editInMsgEAC0401C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eo-netフォン通話明細請求先更新サービスIFの実行
			resultMap = editInMsgEAC0421C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// eo-netフォン通話合計請求先更新サービスIFの実行
			resultMap = editInMsgEAC0431C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 通信量明細請求先更新サービスIFの実行
			paramMap = editInMsgEAC0591C020(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 通信量合計請求先更新サービスIFの実行
			paramMap = editInMsgEAC0601C020(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// サービス契約蓄積請求先更新サービスIFの実行
			paramMap = editInMsgEAC0461C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 課金対象従量サービス契約蓄積請求先更新サービスIFの実行
			paramMap = editInMsgEAC0551C010(param, seikyUpdMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
		}
		
		templates = list.toArray(new CAANMsg[list.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * <p>
	 * 請求先更新処理
	 * </p>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得I/F
	 * @throws Exception
	 */
	public IRequestParameterReadWrite svcifcall(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		
		// 料金スケジュール定義一意照会サービスIFの実行
		// イベントコード（料金計算日）
		inMap.put("key_event_cd", JACStrConst.EVENT_CD_PRC_CALC_DAY);
		inMap.put("key_unyo_day", inMap.get("unyo_day"));
		paramMap = editInMsgECH0501A010(param, inMap, JPCModelConstant.FUNC_CD_2);
		result = scCall.run(paramMap, handle);
		editOutMsgECH0501A010(result, param, inMap);
		
		List<String> seikyYmList = new ArrayList<String>();
		if(!JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			seikyYmList.add((String)inMap.get("seiky_ym"));
		}
		
		// 料金スケジュール定義一意照会サービスIFの実行
		// イベントコード（利用開始日・利用終了日）
		paramMap = editInMsgECH0501A010(param, inMap, JPCModelConstant.FUNC_CD_3);
		result = scCall.run(paramMap, handle);
		editOutMsgECH0501A010(result, param, inMap);
		
		if(!JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			if (!seikyYmList.get(0).equals((String)inMap.get("seiky_ym")))
			{
				seikyYmList.add((String)inMap.get("seiky_ym"));
			}
		}
		
		// 請求先更新依頼リスト件数分繰り返す
		ArrayList<HashMap<String, Object>> seikyUpdList = (ArrayList<HashMap<String, Object>>)inMap.get(SEIKY_UPD_LIST);
		for (HashMap<String, Object> seikyUpdMap : seikyUpdList)
		{
			// 一時金請求先更新サービスIFの実行
			paramMap = editInMsgEAC0171C020(param, seikyUpdMap);
			result = scCall.run(paramMap, handle);
			editOutMsgEAC0171C020(result, param, seikyUpdMap);
		
			for (int i = 0; i < seikyYmList.size(); i++)
			{
				// 取得した請求年月を設定
				seikyUpdMap.put("seiky_ym", seikyYmList.get(i));
				
				// UQ取込請求先更新サービスIFの実行
				paramMap = editInMsgEAC0351C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0351C010(result, param, seikyUpdMap);
				
				// eoモバイル明細請求先更新サービスIFの実行
				paramMap = editInMsgEAC0361C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0361C010(result, param, seikyUpdMap);
				
				// eoモバイル合計請求先更新サービスIFの実行
				paramMap = editInMsgEAC0371C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0371C010(result, param, seikyUpdMap);
				
				// eo光電話通話明細請求先更新サービスIFの実行
				paramMap = editInMsgEAC0391C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0391C010(result, param, seikyUpdMap);
				
				// eo光電話通話合計請求先更新サービスIFの実行
				paramMap = editInMsgEAC0401C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0401C010(result, param, seikyUpdMap);
				
				// eo-netフォン通話明細請求先更新サービスIFの実行
				paramMap = editInMsgEAC0421C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0421C010(result, param, seikyUpdMap);
				
				// eo-netフォン通話合計請求先更新サービスIFの実行
				paramMap = editInMsgEAC0431C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0431C010(result, param, seikyUpdMap);
				
				// 通信量明細請求先更新サービスIFの実行
				paramMap = editInMsgEAC0591C020(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0591C020(result, param, seikyUpdMap);
				
				// 通信量合計請求先更新サービスIFの実行
				paramMap = editInMsgEAC0601C020(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0601C020(result, param, seikyUpdMap);
				
				// サービス契約蓄積請求先更新サービスIFの実行
				paramMap = editInMsgEAC0461C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0461C010(result, param, seikyUpdMap);
				
				// 課金対象従量サービス契約蓄積請求先更新サービスIFの実行
				paramMap = editInMsgEAC0551C010(param, seikyUpdMap);
				result = scCall.run(paramMap, handle);
				editOutMsgEAC0551C010(result, param, seikyUpdMap);
			}
		}
		
		// 結果を返却する
		return param;
	}
	
	/**
	 * IRequestParameterReadWriteにエラー情報をマッピングする。<br>
	 * 
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @throws RequestParameterException
	 * @return パラメータオブジェクト
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
																							throws RequestParameterException
	{
		if (templates == null || templates.length == 0)
		{
			return param;
		}
		
		int index = 0;
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		
		// 請求先更新依頼リスト件数分繰り返す
		ArrayList<HashMap<String, Object>> seikyUpdList = (ArrayList<HashMap<String, Object>>)inMap.get(SEIKY_UPD_LIST);
		for (HashMap<String, Object> seikyUpdMap : seikyUpdList)
		{
			// 一時金請求先更新サービスIFの実行
			editErrorInfoEAC0171C020(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// UQ取込請求先更新サービスIFの実行
			editErrorInfoEAC0351C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eoモバイル明細請求先更新サービスIFの実行
			editErrorInfoEAC0361C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eoモバイル合計請求先更新サービスIFの実行
			editErrorInfoEAC0371C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eo光電話通話明細請求先更新サービスIFの実行
			editErrorInfoEAC0391C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eo光電話通話合計請求先更新サービスIFの実行
			editErrorInfoEAC0401C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eo-netフォン通話明細請求先更新サービスIFの実行
			editErrorInfoEAC0421C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// eo-netフォン通話合計請求先更新サービスIFの実行
			editErrorInfoEAC0431C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// 通信量明細請求先更新サービスIFの実行
			editErrorInfoEAC0591C020(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// 通信量合計請求先更新サービスIFの実行
			editErrorInfoEAC0601C020(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// サービス契約蓄積請求先更新サービスIFの実行
			editErrorInfoEAC0461C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// 課金対象従量サービス契約蓄積請求先更新サービスIFの実行
			editErrorInfoEAC0551C010(param, seikyUpdMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
		}
		return param;
	
	}
	
	/**
	 * 共通領域の設定
	 * 
	 * @param param
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文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 リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgECH0501A010(IRequestParameterReadWrite param, HashMap<String, Object> inMap, String funcCd) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(ECH0501A010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(ECH0501A010CBSMsg.TEMPLATEID, "ECH0501A010");

		// 機能コード
		template.set(ECH0501A010CBSMsg.FUNC_CODE, funcCd);

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

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

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

		if (funcCd.equals(JPCModelConstant.FUNC_CD_2))
		{
			// 料金スケジュール定義.イベントコード → イベントコード
			if (JCRUtilCommon.isNull(inMap.get("key_event_cd")))
			{
				template.setNull(ECH0501A010CBSMsg.KEY_EVENT_CD);
			}
			else
			{
				template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, (String)inMap.get("key_event_cd"));
			}
			
			// 料金スケジュール定義.イベント年月日 → イベント年月日
			if (JCRUtilCommon.isNull(inMap.get("key_event_ymd")))
			{
				template.setNull(ECH0501A010CBSMsg.KEY_EVENT_YMD);
			}
			else
			{
				template.set(ECH0501A010CBSMsg.KEY_EVENT_YMD, (String)inMap.get("key_event_ymd"));
			}
		}

		// 料金スケジュール定義.運用日 → 運用日
		if (JCRUtilCommon.isNull(inMap.get("key_unyo_day")))
		{
			template.setNull(ECH0501A010CBSMsg.KEY_UNYO_DAY);
		}
		else
		{
			template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, (String)inMap.get("key_unyo_day"));
		}

		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 一時金請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0171C020(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0171C020CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0171C020CBSMsg.TEMPLATEID, "EAC0171C020");

		// 機能コード
		template.set(EAC0171C020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// 一時金請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0171C020CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0171C020CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// 一時金請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0171C020CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0171C020CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * UQ取込請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0351C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0351C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0351C010CBSMsg.TEMPLATEID, "EAC0351C010");

		// 機能コード
		template.set(EAC0351C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// UQ取込請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0351C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0351C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// UQ取込請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0351C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0351C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// UQ取込請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0351C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0351C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eoモバイル明細請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0361C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0361C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0361C010CBSMsg.TEMPLATEID, "EAC0361C010");

		// 機能コード
		template.set(EAC0361C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eoモバイル明細請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0361C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0361C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eoモバイル明細請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0361C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0361C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eoモバイル明細請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0361C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0361C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eoモバイル合計請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0371C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0371C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0371C010CBSMsg.TEMPLATEID, "EAC0371C010");

		// 機能コード
		template.set(EAC0371C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eoモバイル合計請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0371C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0371C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eoモバイル合計請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0371C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0371C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eoモバイル合計請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0371C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0371C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eo光電話通話明細請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0391C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0391C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0391C010CBSMsg.TEMPLATEID, "EAC0391C010");

		// 機能コード
		template.set(EAC0391C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eo光電話通話明細請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0391C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0391C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eo光電話通話明細請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0391C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0391C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eo光電話通話明細請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0391C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0391C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eo光電話通話合計請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0401C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0401C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0401C010CBSMsg.TEMPLATEID, "EAC0401C010");

		// 機能コード
		template.set(EAC0401C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eo光電話通話合計請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0401C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0401C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eo光電話通話合計請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0401C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0401C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eo光電話通話合計請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0401C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0401C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eo-netフォン通話明細請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0421C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0421C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0421C010CBSMsg.TEMPLATEID, "EAC0421C010");

		// 機能コード
		template.set(EAC0421C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eo-netフォン通話明細請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0421C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0421C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eo-netフォン通話明細請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0421C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0421C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eo-netフォン通話明細請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0421C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0421C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * eo-netフォン通話合計請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0431C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0431C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0431C010CBSMsg.TEMPLATEID, "EAC0431C010");

		// 機能コード
		template.set(EAC0431C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// eo-netフォン通話合計請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0431C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0431C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// eo-netフォン通話合計請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0431C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0431C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// eo-netフォン通話合計請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0431C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0431C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 通信量明細請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0591C020(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0591C020CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0591C020CBSMsg.TEMPLATEID, "EAC0591C020");

		// 機能コード
		template.set(EAC0591C020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// FTTH通信明細請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0591C020CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0591C020CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// FTTH通信明細請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0591C020CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0591C020CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// FTTH通信明細請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0591C020CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0591C020CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 通信量合計請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0601C020(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0601C020CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0601C020CBSMsg.TEMPLATEID, "EAC0601C020");

		// 機能コード
		template.set(EAC0601C020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// FTTH通信合計請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0601C020CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0601C020CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// FTTH通信合計請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0601C020CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0601C020CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// FTTH通信合計請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0601C020CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0601C020CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * サービス契約蓄積請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0461C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0461C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0461C010CBSMsg.TEMPLATEID, "EAC0461C010");

		// 機能コード
		template.set(EAC0461C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// サービス契約蓄積請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0461C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0461C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// サービス契約蓄積請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0461C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0461C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// サービス契約蓄積請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0461C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0461C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 課金対象従量サービス契約蓄積請求先更新用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEAC0551C010(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		CAANMsg template = new CAANMsg(EAC0551C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EAC0551C010CBSMsg.TEMPLATEID, "EAC0551C010");

		// 機能コード
		template.set(EAC0551C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

		// 課金対象従量サービス契約蓄積請求先更新.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(EAC0551C010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(EAC0551C010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// 課金対象従量サービス契約蓄積請求先更新.請求契約番号 → 請求契約番号
		if (JCRUtilCommon.isNull(inMap.get("seiky_kei_no")))
		{
			template.setNull(EAC0551C010CBSMsg.SEIKY_KEI_NO);
		}
		else
		{
			template.set(EAC0551C010CBSMsg.SEIKY_KEI_NO, (String)inMap.get("seiky_kei_no"));
		}
		
		// 課金対象従量サービス契約蓄積請求先更新.請求年月 → 請求年月
		if (JCRUtilCommon.isNull(inMap.get("seiky_ym")))
		{
			template.setNull(EAC0551C010CBSMsg.SEIKY_YM);
		}
		else
		{
			template.set(EAC0551C010CBSMsg.SEIKY_YM, (String)inMap.get("seiky_ym"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0501A010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoECH0501A010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
//	OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
//		
//		CAANMsg[] resultList = templates[0].getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
//		if (resultList.length > 0)
//		{
//			dataMap.put("seiky_ym", resultList[0].getString(ECH0501A010CBSMsg1List.SEIKY_YM));
//		}
//		else
//		{
//			throw new SCCallException("料金スケジュール定義一意照会取得結果0件", returnCode.toString(), Integer.parseInt(status));
//		}
//
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
		
		CAANMsg[] resultList = templates[0].getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		if (resultList.length > 0)
		{
			dataMap.put("seiky_ym", resultList[0].getString(ECH0501A010CBSMsg1List.SEIKY_YM));
		}
		else
		{
			throw new SCCallException("料金スケジュール定義一意照会取得結果0件", returnCode.toString(), status);
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0171C020(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0171C020(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

//		OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
//		OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0351C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0351C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

//		OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
//		OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0361C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0361C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0371C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0371C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0391C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0391C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0401C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0401C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0421C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0421C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0431C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0431C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0591C020(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0591C020(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0601C020(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0601C020(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0461C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0461C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEAC0551C010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEAC0551C010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
// OM-2015-0001387 MOD STA
//		/* ◇処理結果の判定 */
//		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
//		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
//		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		
//		// 異常の場合、SCCallExceptionを生成してスローする
//		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
//		{
//			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
//			throw scCallEx;
//		}
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg msg = templates[0];
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status)) 
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(rtnCode) && 4 == status)){
				SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, status);
				throw scCallEx;
			}
		}
// OM-2015-0001387 MOD END
		
		return retParam;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0501A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0501A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// イベントコードエラー → 料金スケジュール定義.イベントコードエラー
		if (!template.isNull(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR, template.getString(ECH0501A010CBSMsg.KEY_EVENT_CD_ERR));
			}
		}
		
		// 運用日エラー → 料金スケジュール定義.運用日エラー
		if (!template.isNull(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR))
		{
			if (!inMap.containsKey(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR))
			{
				inMap.put(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR, template.getString(ECH0501A010CBSMsg.KEY_UNYO_DAY_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0171C020(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0171C020CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → 一時金請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0171C020CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0171C020CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0171C020CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0171C020CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求契約番号エラー → 一時金請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0171C020CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0171C020CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0171C020CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0171C020CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0351C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0351C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → UQ取込請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0351C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0351C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0351C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0171C020CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → UQ取込請求先更新.請求年月エラー
		if (!template.isNull(EAC0351C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0351C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0351C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0351C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → UQ取込請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0351C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0351C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0351C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0351C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0361C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0361C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eoモバイル明細請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0361C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0361C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0361C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0361C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eoモバイル請求先更新.請求年月エラー
		if (!template.isNull(EAC0361C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0361C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0361C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0361C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eoモバイル請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0361C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0361C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0361C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0361C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0371C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0371C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eoモバイル合計請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0371C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0371C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0371C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0371C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eoモバイル合計請求先更新.請求年月エラー
		if (!template.isNull(EAC0371C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0371C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0371C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0371C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eoモバイル合計請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0371C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0371C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0371C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0371C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0391C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0391C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eo光電話明細請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0391C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0391C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0391C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0391C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eo光電話明細請求先更新.請求年月エラー
		if (!template.isNull(EAC0391C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0391C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0391C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0391C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eo光電話明細請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0391C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0391C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0391C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0391C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0401C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0401C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eo光電話合計請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0401C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0401C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0401C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0401C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eo光電話合計請求先更新.請求年月エラー
		if (!template.isNull(EAC0401C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0401C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0401C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0401C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eo光電話合計請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0401C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0401C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0401C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0401C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0421C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0421C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eo-netフォン明細請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0421C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0421C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0421C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0421C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eo-netフォン明細請求先更新.請求年月エラー
		if (!template.isNull(EAC0421C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0421C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0421C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0421C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eo-netフォン明細請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0421C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0421C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0421C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0421C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0431C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0431C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → eo-netフォン合計請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0431C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0431C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0431C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0431C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → eo-netフォン合計請求先更新.請求年月エラー
		if (!template.isNull(EAC0431C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0431C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0431C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0431C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → eo-netフォン合計請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0431C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0431C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0431C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0431C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0591C020(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0591C020CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → 通信量明細請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0591C020CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0591C020CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0591C020CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0591C020CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → 通信量明細請求先更新.請求年月エラー
		if (!template.isNull(EAC0591C020CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0591C020CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0591C020CBSMsg.SEIKY_YM_ERR, template.getString(EAC0591C020CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → 通信量明細請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0591C020CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0591C020CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0591C020CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0591C020CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0601C020(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0601C020CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → 通信量合計請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0601C020CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0601C020CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0601C020CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0601C020CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → 通信量合計請求先更新.請求年月エラー
		if (!template.isNull(EAC0601C020CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0601C020CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0601C020CBSMsg.SEIKY_YM_ERR, template.getString(EAC0601C020CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → 通信量合計請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0601C020CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0601C020CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0601C020CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0601C020CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0461C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0461C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → サービス契約蓄積請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0461C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0461C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0461C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0461C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → サービス契約蓄積請求先更新.請求年月エラー
		if (!template.isNull(EAC0461C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0461C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0461C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0461C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → サービス契約蓄積請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0461C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0461C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0461C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0461C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEAC0551C010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EAC0551C010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// サービス契約番号エラー → 課金対象従量サービス契約蓄積請求先更新.サービス契約番号エラー
		if (!template.isNull(EAC0551C010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0551C010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(EAC0551C010CBSMsg.SVC_KEI_NO_ERR, template.getString(EAC0551C010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// 請求年月エラー → 課金対象従量サービス契約蓄積請求先更新.請求年月エラー
		if (!template.isNull(EAC0551C010CBSMsg.SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(EAC0551C010CBSMsg.SEIKY_YM_ERR))
			{
				inMap.put(EAC0551C010CBSMsg.SEIKY_YM_ERR, template.getString(EAC0551C010CBSMsg.SEIKY_YM_ERR));
			}
		}
		
		// 請求契約番号エラー → 課金対象従量サービス契約蓄積請求先更新.請求契約番号エラー
		if (!template.isNull(EAC0551C010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EAC0551C010CBSMsg.SEIKY_KEI_NO_ERR))
			{
				inMap.put(EAC0551C010CBSMsg.SEIKY_KEI_NO_ERR, template.getString(EAC0551C010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
}