/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom, 2013
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKKkopSvcUseKeiUpdCCMapper
*   ソースファイル名：JKKKkopSvcUseKeiUpdCCMapper.java
*   作成者          ：富士通
*   日付            ：2013年11月29日
*＜機能概要＞
*   機器オプションサービス利用機器契約更新CCマッピングクラスです。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v6.00.00    2013/11/29   FJ) 高林    【ANK-1578-00-00】多機能ルータ対応
*   v7.00.00    2014/02/15   FJ) 阮　    【OM-2014-0000652】電話サービス追加時のコース変更対応（自動交換の適正）
*   v8.00.00    2014/04/22   FJ) 藤本    【OM-2014-0001556】サービス契約解約時の多機能ルーターキャンセル処理で排他エラーになる
*   v8.01.00    2014/05/05   FJ)阮       【OM-2014-0001770】多機能ルーター回復処理の不具合対応
*   v8.02.00    2014/05/14   FJ)藤本     【OM-2014-0001693】ネットのコース変更後に交換機器引渡画面で宅内S連携エラーとなる
*   v8.03.00    2014/05/15   FJ)田中　　 【OM-2014-0001848】対応
*   v19.00.00   2015/10/06   FJ)中野     【OM-2015-0002509】機器OP解約時にマッピング項目が不正
*   v39.00.00   2018/11/01   FJ)舘山     【ANK-3412-00-00】５ギガ・１０ギガコース導入対応
*   v40.00.00   2018/11/30   FJ)舘山     【IT1-2018-0000226】多機能ルータの交換ができない
*   v40.01.00	2019/02/01   FJ)舘山     【ANK-3412-15-00】締結済の多機能ルータ交換対応
*   v41.00.00	2019/04/16   FJ)舘山     【OM-2019-0000362】対応横並び
*   v71.00.00	2024/09/03   FJ)奥村     【#84868】EO21H0210J0　電話系解約・消去オーダーが発行されていない
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.constant.JKKSvcConst;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadOnly;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
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 com.sun.enterprise.tools.common.util.StringUtils;

import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B009CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B029CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0241B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0241B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B025CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C050CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C110CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C120CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C130CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C131CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C231CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C330CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C340CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C350CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C380CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C400CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C410CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C420CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C430CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C450CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C530CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0771A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0791A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2101B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2811B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B012CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C050CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C070CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C080CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C090CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C100CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C110CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C120CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C130CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C140CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C150CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C180CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C190CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C200CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C250CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C260CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C290CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0411B030CBSMsg;

/**
 * 物流制御マッピングクラス
 * @author 富士通
 */
public class JKKKkopSvcUseKeiUpdCCMapper
{

	/** 異動区分（強制解約） */
	private static final String IDO_DIV_KSI_DSL = "00064";
	
	/** 異動区分（キャンセル） */
	private static final String IDO_DIV_KSI_CAN = "00008";
	
	// #84868 ADD START
	/** 異動区分（解約） */
	private static final String IDO_DIV_DSL = "00005";
	// #84868 ADD END


	/** 
	 * --------------------------------------------------------------------------------------------
	 * 
	 * 上り情報マッピング処理 START 
	 * 
	 * --------------------------------------------------------------------------------------------
	 */
	/**
	 * ECK0011A010_お客様一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param sysid SYSID
	 * @param geneAddDtm 世代登録年月日時分秒
	 * @param rsvAplyYmd 予約適用年月日
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgECK0011A010(
			IRequestParameterReadWrite param,
			String sysid,
			String geneAddDtm, String rsvAplyYmd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECK0011A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new ECK0011A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(ECK0011A010CBSMsg.TEMPLATEID, "ECK0011A010");

		// 機能コード
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(ECK0011A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
			// ＫＥＹ＿世代登録年月日時分秒
			template.set(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		}
		else
		{
			template.set(ECK0011A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);	//カレント
		}

		// ＫＥＹ＿SYSID
		template.set(ECK0011A010CBSMsg.KEY_SYSID, sysid);

		//予約適用年月日
		if (null != rsvAplyYmd && !"".equals(rsvAplyYmd))
		{
			template.set(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, rsvAplyYmd);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0081A010_サービス契約一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @param geneAddDtm 世代登録年月日時分秒
	 * @param rsvAplyYmd 予約適用年月日
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0081A010(
			IRequestParameterReadWrite param,
			String svcKeiNo,
			String geneAddDtm, String rsvAplyYmd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0081A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0081A010CBSMsg.TEMPLATEID, "EKK0081A010");

		// 機能コード
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(EKK0081A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
			// ＫＥＹ＿世代登録年月日時分秒
			template.set(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		}
		else
		{
			template.set(EKK0081A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);	//カレント
		}

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		//予約適用年月日
		if (null != rsvAplyYmd && !"".equals(rsvAplyYmd))
		{
			template.set(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, rsvAplyYmd);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0081B009_同一場所サービス契約情報照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0081B009(
			IRequestParameterReadWrite param,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B009CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0081B009CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0081B009CBSMsg.TEMPLATEID, "EKK0081B009");

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

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0081B009CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0081B029_同一回線内訳サービス契約一覧照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svc_kei_no サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0081B029(
			IRequestParameterReadWrite param,
			String svc_kei_no)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B029CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0081B029CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0081B029CBSMsg.TEMPLATEID, "EKK0081B029");

		// 機能コード
		template.set(EKK0081B029CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);	// 世代指定

		// ＫＥＹ＿機器サービス契約番号
		template.set(EKK0081B029CBSMsg.KEY_SVC_KEI_NO, svc_kei_no);
		
		String key_kisuw_stdardymd = JCCBPCommon.getOpeDate(null);
		
		// ＫＥＹ＿回線内訳基準年月日
		template.set(EKK0081B029CBSMsg.KEY_KISUW_STDARDYMD, key_kisuw_stdardymd);
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0241B001_機器提供サービス契約一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0241B001(
			IRequestParameterReadWrite param,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0241B001CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0241B001CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0241B001CBSMsg.TEMPLATEID, "EKK0241B001");

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

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0241B001CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	/**
	 * EKK0021B002_申込明細履歴一覧照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0021B002(
			IRequestParameterReadWrite param,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0021B002CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0021B002CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0021B002CBSMsg.TEMPLATEID, "EKK0021B002");

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

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0021B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0321B005_課金先一覧照会（サービス契約番号）
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0321B005(
			IRequestParameterReadWrite param,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0321B005CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0321B005CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0321B005CBSMsg.TEMPLATEID, "EKK0321B005");

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

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0321B005CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341A010_機器提供サービス契約一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param geneAddDtm 世代登録年月日時分秒
	 * @param rsvAplyYmd 予約適用年月日
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341A010(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String geneAddDtm,
			String rsvAplyYmd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341A010CBSMsg.TEMPLATEID, "EKK0341A010");

		// 機能コード
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(EKK0341A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
			// ＫＥＹ＿世代登録年月日時分秒
			template.set(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		}
		else
		{
			template.set(EKK0341A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);	//カレント
		}

		// ＫＥＹ＿機器提供サービス契約番号
		template.set(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		//予約適用年月日
		if (null != rsvAplyYmd && !"".equals(rsvAplyYmd))
		{
			template.set(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD, rsvAplyYmd);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341B002_機器提供サービス契約一覧照会（サービス契約番号）
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341B002(
			IRequestParameterReadWrite param,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B002CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341B002CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341B002CBSMsg.TEMPLATEID, "EKK0341B002");

		// 機能コード
		// IT2-2013-0001719 2013/12/19 START
		template.set(EKK0341B002CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_9);	// 機器提供サービス契約一覧照会（回線対象サービス契約結合）※休止・中断状態も取得
		// IT2-2013-0001719 2013/12/19 END

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0341B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C030_機器提供サービス契約照査
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C030(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String kikiNinshoId,
			String kikiNinshoIdPwd,
			String idoDiv,
			String shosaDslFinCd,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C030CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C030CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C030CBSMsg.TEMPLATEID, "EKK0341C030");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C030CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 機器認証ID
		if (null != kikiNinshoId && !"".equals(kikiNinshoId))
		{
			template.set(EKK0341C030CBSMsg.KIKI_NINSHO_ID, kikiNinshoId);
		}

		// 機器認証IDパスワード
		if (null != kikiNinshoIdPwd && !"".equals(kikiNinshoIdPwd))
		{
			template.set(EKK0341C030CBSMsg.KIKI_NINSHO_ID_PWD, kikiNinshoIdPwd);
		}

		// 異動区分
		template.set(EKK0341C030CBSMsg.IDO_DIV, idoDiv);

		// 照査解約完了コード
		if (null != shosaDslFinCd && !"".equals(shosaDslFinCd))
		{
			template.set(EKK0341C030CBSMsg.SHOSA_DSL_FIN_CD, shosaDslFinCd);
		}

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C030CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C050_機器提供サービス契約照査締結
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C050(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String kikiNinshoId,
			String kikiNinshoIdPwd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C050CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C050CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C050CBSMsg.TEMPLATEID, "EKK0341C050");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C050CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 機器認証ID
		if (null != kikiNinshoId && !"".equals(kikiNinshoId))
		{
			template.set(EKK0341C050CBSMsg.KIKI_NINSHO_ID, kikiNinshoId);
		}

		// 機器認証IDパスワード
		if (null != kikiNinshoIdPwd && !"".equals(kikiNinshoIdPwd))
		{
			template.set(EKK0341C050CBSMsg.KIKI_NINSHO_ID_PWD, kikiNinshoIdPwd);
		}

		// 異動区分
		template.set(EKK0341C050CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C050CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C120_機器提供サービス契約停止
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param svcStpYmd サービス停止年月日
	 * @param svcStpRsnCd サービス停止理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C120(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String svcStpYmd,
			String svcStpRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C120CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C120CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C120CBSMsg.TEMPLATEID, "EKK0341C120");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C120CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// サービス停止年月日
		template.set(EKK0341C120CBSMsg.SVC_STP_YMD, svcStpYmd);

		// サービス停止理由コード
		template.set(EKK0341C120CBSMsg.SVC_STP_RSN_CD, svcStpRsnCd);

		// 異動区分
		template.set(EKK0341C120CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C120CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C130_機器提供サービス契約停止解除
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param svcStpRlsYmd サービス停止解除年月日
	 * @param svcStpRlsRsnCd サービス停止解除理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C130(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String svcStpRlsYmd,
			String svcStpRlsRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C130CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C130CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C130CBSMsg.TEMPLATEID, "EKK0341C130");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C130CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// サービス停止解除年月日
		template.set(EKK0341C130CBSMsg.SVC_STP_RLS_YMD, svcStpRlsYmd);

		// サービス停止解除理由コード
		template.set(EKK0341C130CBSMsg.SVC_STP_RLS_RSN_CD, svcStpRlsRsnCd);

		// 異動区分
		template.set(EKK0341C130CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C130CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C131_休止中機器提供サービス契約停止解除
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param svcStpRlsYmd サービス停止解除年月日
	 * @param svcStpRlsRsnCd サービス停止解除理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C131(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String svcStpRlsYmd,
			String svcStpRlsRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C131CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C131CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C131CBSMsg.TEMPLATEID, "EKK0341C131");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C131CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// サービス停止解除年月日
		template.set(EKK0341C131CBSMsg.SVC_STP_RLS_YMD, svcStpRlsYmd);

		// サービス停止解除理由コード
		template.set(EKK0341C131CBSMsg.SVC_STP_RLS_RSN_CD, svcStpRlsRsnCd);

		// 異動区分
		template.set(EKK0341C131CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C131CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C330_機器提供サービス契約キャンセル
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param svcCancelRsnCd サービスキャンセル理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C330(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String svcCancelRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C330CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C330CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

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

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

		// 機器提供サービス契約番号
		template.set(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);
		
		// IT2-2013-00000853 2013/12/18 STRAT
		// 申込明細番号
		template.set(EKK0341C330CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		
		// サービスキャンセル年月日
		template.set(EKK0341C330CBSMsg.SVC_CANCEL_YMD, (String)JCCBPCommon.getOpeDate(null));
		// IT2-2013-00000853 2013/12/18 EN
		
		// サービスキャンセル理由コード
		template.set(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD, svcCancelRsnCd);

		// 異動区分
		template.set(EKK0341C330CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C330CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C340_機器提供サービス契約解約
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param rsvTstaKiboYmd 予約適用開始希望年月日
	 * @param svcEndymd サービス終了年月日
	 * @param svcChrgEndymd サービス課金終了年月日
	 * @param svcDlreCd サービス解約理由コード
	 * @param svcDlreMemo サービス解約理由メモ
	 * @param zanchiFlg 残置フラグ
	 * @param pnltyHasseiCd 違約金発生コード
	 * @param idoDiv 異動区分
	 * @param taknkikiIdoCd 宅内機器異動コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C340(
			IRequestParameterReadWrite param, 
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String rsvTstaKiboYmd,
			String svcEndymd,
			String svcChrgEndymd,
			String svcDlreCd,
			String svcDlreMemo,
			String zanchiFlg,
			String pnltyHasseiCd,
			String idoDiv,
			String taknkikiIdoCd,
			String updDtmBf,
			String svcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C340CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C340CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C340CBSMsg.TEMPLATEID, "EKK0341C340");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK0341C340CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK0341C340CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		if (mskmDtlNo != null && !"".equals(mskmDtlNo))
		{
			template.set(EKK0341C340CBSMsg.MSKM_DTL_NO, mskmDtlNo);
		}

		// 予約適用開始希望年月日
		if (rsvTstaKiboYmd != null && !"".equals(rsvTstaKiboYmd))
		{
			template.set(EKK0341C340CBSMsg.RSV_TSTA_KIBO_YMD, rsvTstaKiboYmd);
		}

		// サービス終了年月日
		if (svcEndymd != null && !"".equals(svcEndymd))
		{
			template.set(EKK0341C340CBSMsg.SVC_ENDYMD, svcEndymd);
		}

		// サービス課金終了年月日
		if (svcChrgEndymd != null && !"".equals(svcChrgEndymd))
		{
			template.set(EKK0341C340CBSMsg.SVC_CHRG_ENDYMD, svcChrgEndymd);
		}

		// サービス解約理由コード
		if (svcDlreCd != null && !"".equals(svcDlreCd))
		{
			template.set(EKK0341C340CBSMsg.SVC_DLRE_CD, svcDlreCd);
		}

		// サービス解約理由メモ
		if (svcDlreMemo != null && !"".equals(svcDlreMemo))
		{
			template.set(EKK0341C340CBSMsg.SVC_DLRE_MEMO, svcDlreMemo);
		}

		// 残地フラグ
		if (zanchiFlg != null && !"".equals(zanchiFlg))
		{
			template.set(EKK0341C340CBSMsg.ZANCHI_FLG, zanchiFlg);
		}

		// 違約金発生コード
		if (pnltyHasseiCd != null && !"".equals(pnltyHasseiCd))
		{
			template.set(EKK0341C340CBSMsg.PNLTY_HASSEI_CD, pnltyHasseiCd);
		}

		// 異動区分
		if (idoDiv != null && !"".equals(idoDiv))
		{
			template.set(EKK0341C340CBSMsg.IDO_DIV, idoDiv);
		}

		// 宅内機器異動コード
		if (taknkikiIdoCd != null && !"".equals(taknkikiIdoCd))
		{
			template.set(EKK0341C340CBSMsg.TAKNKIKI_IDO_CD, taknkikiIdoCd);
		}

		// 更新年月日時分秒(更新前)
		if (updDtmBf != null && !"".equals(updDtmBf))
		{
			template.set(EKK0341C340CBSMsg.UPD_DTM_BF, updDtmBf);
		}

		// サービス契約番号
		if (svcKeiNo != null && !"".equals(svcKeiNo))
		{
			template.set(EKK0341C340CBSMsg.SVC_KEI_NO, svcKeiNo);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C350_機器提供サービス契約解約確定
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param svcEndymd サービス終了年月日
	 * @param svcChrgEndymd サービス課金終了年月日
	 * @param svcDlreCd サービス解約理由コード
	 * @param svcDlreMemo サービス解約理由メモ
	 * @param zanchiFlg 残置フラグ
	 * @param taknkikiIdoCd 宅内機器異動コード
	 * @param kaishuKikiUm 回収機器有無
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C350(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String svcEndymd,
			String svcChrgEndymd,
			String svcDlreCd,
			String svcDlreMemo,
			String zanchiFlg,
			String taknkikiIdoCd,
			String kaishuKikiUm,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C350CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C350CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C350CBSMsg.TEMPLATEID, "EKK0341C350");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C350CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// サービス終了年月日
		template.set(EKK0341C350CBSMsg.SVC_ENDYMD, svcEndymd);

		// サービス課金終了年月日
		template.set(EKK0341C350CBSMsg.SVC_CHRG_ENDYMD, svcChrgEndymd);

		// サービス解約理由コード
		template.set(EKK0341C350CBSMsg.SVC_DLRE_CD, svcDlreCd);

		// サービス解約理由メモ
		template.set(EKK0341C350CBSMsg.SVC_DLRE_MEMO, svcDlreMemo);

		// 残置フラグ
		template.set(EKK0341C350CBSMsg.ZANCHI_FLG, zanchiFlg);

		// 宅内機器異動コード
		template.set(EKK0341C350CBSMsg.TAKNKIKI_IDO_CD, taknkikiIdoCd);

		// 回収機器有無
		template.set(EKK0341C350CBSMsg.KAISHU_KIKI_UM, kaishuKikiUm);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C350CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C380_機器提供サービス契約回復
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param kaihkYmd 回復年月日
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C380(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String kaihkYmd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C380CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C380CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C380CBSMsg.TEMPLATEID, "EKK0341C380");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		template.set(EKK0341C380CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 回復年月日
		template.set(EKK0341C380CBSMsg.KAIHK_YMD, kaihkYmd);

		// 異動区分
		template.set(EKK0341C380CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C380CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C400_休止中機器提供サービス契約回復
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param kaihkYmd 回復年月日
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C400(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String kaihkYmd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C400CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C400CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C400CBSMsg.TEMPLATEID, "EKK0341C400");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C400CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		template.set(EKK0341C400CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 回復年月日
		template.set(EKK0341C400CBSMsg.KAIHK_YMD, kaihkYmd);

		// 異動区分
		template.set(EKK0341C400CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C400CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C410_照査前機器提供サービス契約キャンセル取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C410(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C410CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C410CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C410CBSMsg.TEMPLATEID, "EKK0341C410");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C410CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		template.set(EKK0341C410CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 異動区分
		template.set(EKK0341C410CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C410CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C420_照査後機器提供サービス契約キャンセル取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C420(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C420CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C420CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C420CBSMsg.TEMPLATEID, "EKK0341C420");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C420CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		template.set(EKK0341C420CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 異動区分
		template.set(EKK0341C420CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C420CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341C430_機器提供サービス契約解約取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C430(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String mskmDtlNo,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C430CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C430CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C430CBSMsg.TEMPLATEID, "EKK0341C430");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C430CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 申込明細番号
		template.set(EKK0341C430CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 異動区分
		template.set(EKK0341C430CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C430CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0341D010_機器提供サービス契約登録
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param eck0011a010Info お客様情報
	 * @param ekk0241b001Info サービス契約回線内訳情報
	 * @param ekk0321b005Info 課金先一覧情報
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341D010(
			IRequestParameterReadWrite param,
			CAANMsg eck0011a010Info, 
			CAANMsg ekk0241b001Info,
			CAANMsg ekk0321b005Info,
			HashMap<String, Object> kkopKeiUpdMap,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341D010CBSMsg.class.getName());

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

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

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

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

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

		// 機器提供サービスコード
		template.set(EKK0341D010CBSMsg.KKTK_SVC_CD, JKKStrConst.KKTK_SVC_CD_TAKINORT);

		// 料金コースコード
		template.set(EKK0341D010CBSMsg.PCRS_CD, JKKStrConst.CD00134_TAKINORT);

		// 料金プランコード
		template.set(EKK0341D010CBSMsg.PPLAN_CD, "P" + JKKStrConst.CD00134_TAKINORT + "01");

		// 機器提供種別コード
		template.set(EKK0341D010CBSMsg.KKTK_SBT_CD, JKKStrConst.CD00212_02);
		
//		// HDD容量コード
//		template.set(EKK0341D010CBSMsg.HDD_CAPA_CD, JFUBPCommon.getOpeDate(null));
//
//		// サービス利用開始希望年月日
//		template.set(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 予約適用開始希望年月日
//		template.set(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 希望メーカーコード
//		template.set(EKK0341D010CBSMsg.KIBO_MAKER_CD, JFUBPCommon.getOpeDate(null));
//
		// IT2-2013-00000853 2013/12/18 STRAT
		// 販売種別コード
		template.set(EKK0341D010CBSMsg.HAMBAI_SBT_CD, "10");
		// IT2-2013-00000853 2013/12/18 END
		
//		// 通信機器セットコード
//		template.set(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD, JFUBPCommon.getOpeDate(null));

		// 宅内機器種別コード
		template.set(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD, "R0");

//		// 宅内機器型式コード
//		template.set(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD, JFUBPCommon.getOpeDate(null));
//
//		// 機器製造番号
//		template.set(EKK0341D010CBSMsg.KIKI_SEIZO_NO, JFUBPCommon.getOpeDate(null));
//
//		// 宅内機器セット品型コード
//		template.set(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD, JFUBPCommon.getOpeDate(null));
//
//		// 付属品種別コード
//		template.set(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD, JFUBPCommon.getOpeDate(null));

		// 機器設置先場所番号
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_NO));

		// 親契約識別コード
		template.set(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD, "02");

//		// サービス契約番号
//		template.set(EKK0341D010CBSMsg.SVC_KEI_NO, JFUBPCommon.getOpeDate(null));
//
//		// サービス契約内訳番号
//		template.set(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO, JFUBPCommon.getOpeDate(null));

		// サービス契約回線内訳番号
		template.set(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));

//		// オプションサービス契約番号
//		template.set(EKK0341D010CBSMsg.OP_SVC_KEI_NO, JFUBPCommon.getOpeDate(null));

		// SYSID
		template.set(EKK0341D010CBSMsg.SYSID, (String)eck0011a010Info.getString(ECK0011A010CBSMsg1List.SYSID));

		// 申込明細番号
		template.set(EKK0341D010CBSMsg.MSKM_DTL_NO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO));

//		// リンクSTBフラグ
//		template.set(EKK0341D010CBSMsg.LINK_STB_FLG, JFUBPCommon.getOpeDate(null));

		// 機器引当指定倉庫コード
		template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD, "000001");

		// 機器引当指定倉庫棚コード
		template.set(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD, "000");

//		// 機器送料有無
//		template.set(EKK0341D010CBSMsg.KIKI_SORYO_UM, JFUBPCommon.getOpeDate(null));
//
//		// 機器送料作成年月日
//		template.set(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD, JFUBPCommon.getOpeDate(null));

		// 機器送付先名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_NM, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_NM));

		// 機器送付先カナ名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KANA, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_KANA));

		// 機器送付先住所コード
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AD_CD));

		// 機器送付先郵便番号
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_PCD, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_PCD));

		// 機器送付先都道府県名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_STATE_NM));

		// 機器送付先市区町村名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_CITY_NM));

		// 機器送付先大字通称名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_OAZTSU_NM));

		// 機器送付先字丁目名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AZCHO_NM));

		// 機器送付先番地号
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_BNCHIGO));

		// 機器送付先住所補記・建物名
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRTTM));

		// 機器送付先住所補記・部屋番号
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRRM));

		// 機器送付先電話番号
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_TELNO));

		// マンション物件番号
		template.set(EKK0341D010CBSMsg.MANSION_BUKKEN_NO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.MANSION_BUKKEN_NO));

		// 機器送付先_契約者住所差異フラグ
		template.set(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLC_KSH_AD_SAI_FLG));

		// 機器送付先個別指定フラグ
		template.set(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG, "1");

		// 機器送付先補足コード1
		template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_CD_1));

		// 機器送付先補足コード2
		template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_CD_2));

		// 機器送付先補足メモ
		template.set(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_MEMO));

		// 機器設置先名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_NM));

		// 機器設置先カナ名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_KANA));

		// 機器設置先住所コード
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AD_CD));

		// 機器設置先郵便番号
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_PCD));

		// 機器設置先都道府県名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_STATE_NM));

		// 機器設置先市区町村名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_CITY_NM));

		// 機器設置先大字通称名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_OAZTSU_NM));

		// 機器設置先字丁目名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AZCHO_NM));

		// 機器設置先番地号
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_BNCHIGO));

		// 機器設置先住所補記・建物名
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRTTM));

		// 機器設置先住所補記・部屋番号
		template.set(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRRM));

		// 機器設置先_契約者住所差異フラグ
		template.set(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLC_KSH_AD_SAI_FLG));

		// 機器設置先電話番号
		template.set(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_TELNO));

		// 機器設置先区画整理中フラグ
		template.set(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_KKK_SEIRI_CHU_FLG));

		// 住所未確定フラグ
		template.set(EKK0341D010CBSMsg.AD_MI_FIX_FLG, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG));

		// 機器設置先補足コード1
		template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_CD_1));

		// 機器設置先補足コード2
		template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_CD_2));

		// 機器設置先補足メモ
		template.set(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO, (String)ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_HSK_MEMO));

		// 配送区分
		template.set(EKK0341D010CBSMsg.HAISO_DIV, "00");

//		// 試用加入年月日
//		template.set(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 試用期間終了年月日
//		template.set(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD, JFUBPCommon.getOpeDate(null));
//
//		// 本加入年月日
//		template.set(EKK0341D010CBSMsg.HONKANYU_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 本加入移行期限年月日
//		template.set(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 保証コード
//		template.set(EKK0341D010CBSMsg.HOSHO_CD, JFUBPCommon.getOpeDate(null));
//
//		// 保証開始年月日
//		template.set(EKK0341D010CBSMsg.HOSHO_STAYMD, JFUBPCommon.getOpeDate(null));

		// 違約金発生コード
		template.set(EKK0341D010CBSMsg.PNLTY_HASSEI_CD, JKKStrConst.CD01375_PNLTY_NASHI);

		// 異動区分
		template.set(EKK0341D010CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));

//		// 宅内機器異動コード
//		template.set(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD, JFUBPCommon.getOpeDate(null));
//
//		// CASカード使用許諾年月日
//		template.set(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD, JFUBPCommon.getOpeDate(null));
//
//		// 機器付加情報コード
//		template.set(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD, JFUBPCommon.getOpeDate(null));
//
//		// 配送方法コード
//		template.set(EKK0341D010CBSMsg.HAISO_WAY_CD, JFUBPCommon.getOpeDate(null));
//
//		// 機器移転先移動実施者識別コード
//		template.set(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD, JFUBPCommon.getOpeDate(null));
//
//		// 配送依頼指定年月日
//		template.set(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD, JFUBPCommon.getOpeDate(null));

		// 請求契約番号
		template.set(EKK0341D010CBSMsg.SEIKY_KEI_NO, (String)ekk0321b005Info.getString(EKK0321B005CBSMsg1List.SEIKY_KEI_NO));

		// 料金項目コード
		template.set(EKK0341D010CBSMsg.PRC_KMK_CD, "00800105601");

		// 更新年月日時分秒(更新前)
		template.set(EKK0341D010CBSMsg.UPD_DTM_BF, updDtmBf);

		// 機器送付先住所手動入力フラグ	
		template.set(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG, "0");
		
//		//機器送付先住所チェックレベル
//			template.set(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV, JFUBPCommon.getOpeDate(null));
//		
//		//機器設置先住所チェックレベル
//			template.set(EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV, JFUBPCommon.getOpeDate(null));

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0771A010_機器提供サービスコース一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcCd 機器提供サービスコード
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0771A010(
			IRequestParameterReadWrite param,
			String kktkSvcCd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0771A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0771A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0771A010CBSMsg.TEMPLATEID, "EKK0771A010");

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

		// ＫＥＹ＿機器提供サービスコード
		template.set(EKK0771A010CBSMsg.KEY_KKTK_SVC_CD, kktkSvcCd);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK0791A010_料金コース一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param pcrsCd 料金コースコード
	 * @param geneAddDtm 世代登録年月日時分秒
	 * @param rsvAplyYmd 予約適用年月日
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0791A010(
			IRequestParameterReadWrite param,
			String pcrsCd,
			String geneAddDtm,
			String rsvAplyYmd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0791A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0791A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0791A010CBSMsg.TEMPLATEID, "EKK0791A010");

		// 機能コード
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(EKK0791A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
			// ＫＥＹ＿世代登録年月日時分秒
			template.set(EKK0791A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		}
		else
		{
			template.set(EKK0791A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);	//カレント
		}

		// ＫＥＹ＿料金コースコード
		template.set(EKK0791A010CBSMsg.KEY_PCRS_CD, pcrsCd);

		// ＫＥＹ＿予約適用年月日
		if (null != rsvAplyYmd && !"".equals(rsvAplyYmd))
		{
			template.set(EKK0791A010CBSMsg.KEY_RSV_APLY_YMD, rsvAplyYmd);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

// IT2-2014-0000074対応 20140121 星野 ADD START
	/**
	 *<DL>
	 *<DT>処理概要:住所変更明細一覧照会（変更前識別番号）
	 *<DD>サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * 
	 * @param	param			(I) 業務データ取得用I/F
	 * @param	fixedText		ユーザ任意文字列
	 * @param	kktkKikiChgNo	機器提供サービス契約．機器変更番号
	 * @return					サービスコンポーネント実行用CAANMsg
	 * @since	2011.09.21
	 */
	public HashMap<String, Object> editInMsgEKK2101B002(
			IRequestParameterReadOnly param,
			String kkOpSvcKeiNo
	) throws Throwable 
	{
		CAANMsg template = new CAANMsg(EKK2101B002CBSMsg.class.getName());

		String funcCode = "1";

		// nullを設定
		fillCAANMSGNullMapping(template, new EKK2101B002CBSMsg().getContents());

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

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

		// 共通情報設定処理
		editInMsgBasicCmn(param, template);

		// 機能コード
		template.set(EKK2101B002CBSMsg.FUNC_CODE, funcCode);

		// "09"（機器オプションサービス契約番号） → ＫＥＹ＿住所変更明細種別コード
		template.set(EKK2101B002CBSMsg.KEY_ADCHG_DTL_SBT_CD, "09");

		// 機器オプションサービス契約番号 → ＫＥＹ＿変更前識別番号
		template.set(EKK2101B002CBSMsg.KEY_CHBF_SKBT_NO, kkOpSvcKeiNo);

		return editInMsgCmn(param, template);
	}

// IT2-2014-0000074対応 20140121 星野 ADD END
	
	
// OM-2014-0001848対応 20140514 田中 ADD START
	/**
	 *<DL>
	 *<DT>処理概要:住所変更明細一覧照会（サービス契約番号）
	 *<DD>サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * 
	 * @param	param			(I) 業務データ取得用I/F
	 * @param	fixedText		ユーザ任意文字列
	 * @param	kktkKikiChgNo	機器提供サービス契約．機器変更番号
	 * @return					サービスコンポーネント実行用CAANMsg
	 * @since	2011.09.21
	 */
	public HashMap<String, Object> editInMsgEKK2101B002_2(
			IRequestParameterReadOnly param,
			String svcKeiNo
	) throws Throwable 
	{
		CAANMsg template = new CAANMsg(EKK2101B002CBSMsg.class.getName());

		String funcCode = "1";

		// nullを設定
		fillCAANMSGNullMapping(template, new EKK2101B002CBSMsg().getContents());

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

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

		// 共通情報設定処理
		editInMsgBasicCmn(param, template);

		// 機能コード
		template.set(EKK2101B002CBSMsg.FUNC_CODE, funcCode);

		// "01"（サービス契約番号） → ＫＥＹ＿住所変更明細種別コード
		template.set(EKK2101B002CBSMsg.KEY_ADCHG_DTL_SBT_CD, "01");

		// サービス契約番号 → ＫＥＹ＿変更前識別番号
		template.set(EKK2101B002CBSMsg.KEY_CHBF_SKBT_NO, svcKeiNo);

		return editInMsgCmn(param, template);
	}
	
// OM-2014-0001848対応 20140514 田中 ADD END

	/**
	 * EKK2811A010_機器オプションサービス契約一意照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param geneAddDtm 世代登録年月日時分秒
	 * @param rsvAplyYmd 予約適用年月日
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811A010(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String geneAddDtm, String rsvAplyYmd)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811A010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811A010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811A010CBSMsg.TEMPLATEID, "EKK2811A010");

		// 機能コード
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(EKK2811A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);	// 世代指定
			// ＫＥＹ＿世代登録年月日時分秒
			template.set(EKK2811A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		}
		else
		{
			template.set(EKK2811A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);	//カレント
		}

		// ＫＥＹ＿機器オプションサービス契約番号
		template.set(EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		
		// ＫＥＹ＿世代登録年月日時分秒
		if (null != geneAddDtm && !"".equals(geneAddDtm))
		{
			template.set(EKK2811A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
		} else {
			template.setNull(EKK2811A010CBSMsg.KEY_GENE_ADD_DTM);
		}
		
		// ＫＥＹ＿予約適用年月日
		if (null != rsvAplyYmd && !"".equals(rsvAplyYmd))
		{
			template.set(EKK2811A010CBSMsg.KEY_RSV_APLY_YMD, rsvAplyYmd);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811B010_機器オプションサービス契約一覧照会（機器提供ＳＶ）
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kkopSvcStat 機器オプションステータス
	 * @param kkopSvcCd 機器オプションコード
	 * @param mskmMeisaiNo 申込明細番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811B010(
			IRequestParameterReadWrite param, String kktkSvcKeiNo, String kkopSvcStat, String kkopSvcCd, String mskmMeisaiNo) 
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811B010CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811B010CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811B010CBSMsg.TEMPLATEID, "EKK2811B010");

		template.set(EKK2811B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// ＫＥＹ＿サービス契約番号
		template.set(EKK2811B010CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// ＫＥＹ＿機器オプションステータス
		if (null != kkopSvcStat && !"".equals(kkopSvcStat))
		{
			template.set(EKK2811B010CBSMsg.KEY_KKOP_SVC_STAT, kkopSvcStat);
		}

		// ＫＥＹ＿機器オプションコード
		if (null != kkopSvcCd && !"".equals(kkopSvcCd))
		{
			template.set(EKK2811B010CBSMsg.KEY_KKOP_SVC_CD, kkopSvcCd);
		}

		// ＫＥＹ＿申込明細番号
		if (null != mskmMeisaiNo && !"".equals(mskmMeisaiNo))
		{
			// 申込明細番号
			template.set(EKK2811B010CBSMsg.KEY_MSKM_DTL_NO, mskmMeisaiNo);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811B012_機器オプションサービス契約履歴一覧照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811B012(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811B012CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811B012CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811B012CBSMsg.TEMPLATEID, "EKK2811B012");

		// 機能コード
		template.set(EKK2811B012CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);	// 世代指定

		// ＫＥＹ＿機器オプションサービス契約番号
		template.set(EKK2811B012CBSMsg.KEY_KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C080_機器オプションサービス契約停止
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param svcStpYmd サービス停止年月日
	 * @param svcStpRsnCd サービス停止理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C080(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo, 
			String svcStpYmd,
			String svcStpRsnCd, 
			String idoDiv, 
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C080CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C080CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C080CBSMsg.TEMPLATEID, "EKK2811C080");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C080CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK2811C080CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// サービス停止年月日
		if (null != svcStpYmd && !"".equals(svcStpYmd))
		{
			template.set(EKK2811C080CBSMsg.SVC_STP_YMD, svcStpYmd);
		}
		// サービス停止理由コード
		if (null != svcStpRsnCd && !"".equals(svcStpRsnCd))
		{
			template.set(EKK2811C080CBSMsg.SVC_STP_RSN_CD, svcStpRsnCd);
		}
		// 異動区分
		if (null != idoDiv && !"".equals(idoDiv))
		{
			template.set(EKK2811C080CBSMsg.IDO_DIV, idoDiv);
		}
		// 更新年月日時分秒(更新前)
		if (null != updDtmBf && !"".equals(updDtmBf))
		{
			template.set(EKK2811C080CBSMsg.UPD_DTM_BF, updDtmBf);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C090_機器オプションサービス契約停止解除
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param svcStpRlsYmd サービス停止解除年月日
	 * @param svcStpRlsRsnCd サービス停止解除理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C090(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo,
			String svcStpRlsYmd,
			String svcStpRlsRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C090CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C090CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C090CBSMsg.TEMPLATEID, "EKK2811C090");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C090CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK2811C090CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// サービス停止解除年月日
		if (null != svcStpRlsYmd && !"".equals(svcStpRlsYmd))
		{
			template.set(EKK2811C090CBSMsg.SVC_STP_RLS_YMD, svcStpRlsYmd);
		}
		// サービス停止解除理由コード
		if (null != svcStpRlsRsnCd && !"".equals(svcStpRlsRsnCd))
		{
			template.set(EKK2811C090CBSMsg.SVC_STP_RLS_RSN_CD, svcStpRlsRsnCd);
		}
		// 異動区分
		if (null != idoDiv && !"".equals(idoDiv))
		{
			template.set(EKK2811C090CBSMsg.IDO_DIV, idoDiv);
		}
		// 更新年月日時分秒(更新前)
		if (null != updDtmBf && !"".equals(updDtmBf))
		{
			template.set(EKK2811C090CBSMsg.UPD_DTM_BF, updDtmBf);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C100_休止中機器オプションサービス契約停止解除
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param svcStpRlsYmd サービス停止解除年月日
	 * @param svcStpRlsRsnCd サービス停止解除理由コード
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C100(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo,
			String svcStpRlsYmd,
			String svcStpRlsRsnCd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C100CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C100CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C100CBSMsg.TEMPLATEID, "EKK2811C100");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C100CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK2811C100CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// サービス停止解除年月日
		if (null != svcStpRlsYmd && !"".equals(svcStpRlsYmd))
		{
			template.set(EKK2811C100CBSMsg.SVC_STP_RLS_YMD, svcStpRlsYmd);
		}
		// サービス停止解除理由コード
		if (null != svcStpRlsRsnCd && !"".equals(svcStpRlsRsnCd))
		{
			template.set(EKK2811C100CBSMsg.SVC_STP_RLS_RSN_CD, svcStpRlsRsnCd);
		}
		// 異動区分
		if (null != idoDiv && !"".equals(idoDiv))
		{
			template.set(EKK2811C100CBSMsg.IDO_DIV, idoDiv);
		}
		// 更新年月日時分秒(更新前)
		if (null != updDtmBf && !"".equals(updDtmBf))
		{
			template.set(EKK2811C100CBSMsg.UPD_DTM_BF, updDtmBf);
		}

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C110_機器オプションサービス契約キャンセル
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param ekk2811a010Msg 機器オプションサービス契約一意照会Msg
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C110(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo,
			HashMap<String, Object> kkopKeiUpdMap,
			// OM-2014-0001556 サービス契約解約時の多機能ルーターキャンセル処理で排他エラーになる 2014/04/22 START
			CAANMsg ekk2811a010Msg
			// OM-2014-0001556 サービス契約解約時の多機能ルーターキャンセル処理で排他エラーになる 2014/04/22 END
			)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C110CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C110CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C110CBSMsg.TEMPLATEID, "EKK2811C110");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C110CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(
				EKK2811C110CBSMsg.KKOP_SVC_KEI_NO,
				kkopSvcKeiNo);

		// 申込明細番号
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO) != null)
		{
			template.set(EKK2811C110CBSMsg.MSKM_DTL_NO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO));
		}

		// サービスキャンセル理由コード
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CANCEL_RSN_CD) != null)
		{
			template.set(EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CANCEL_RSN_CD));
		}
		else
		{
			template.set(EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD, JKKSvcConst.SVC_CANCEL_RSN_CD_01);
		}
		
		// 異動区分
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV) != null)
		{
			template.set(EKK2811C110CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));
		}

		// 更新年月日時分秒(更新前)
		// OM-2014-0001556 サービス契約解約時の多機能ルーターキャンセル処理で排他エラーになる 2014/04/22 START
		// 機器オプションサービス契約一意照会結果の最終更新年月日時分秒を設定する。※機器オプションサービス契約解約と同様に設定
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_UPD_DTM_BF) != null )
//		{
//			template.set(EKK2811C110CBSMsg.UPD_DTM_BF, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_UPD_DTM_BF));
//		}
		if (ekk2811a010Msg != null)
		{
			// 住変中の場合、自動切換日（入居予定日）を過ぎると、回線機器は転居先の回線に紐付いている事を考慮
			// サービス契約が転居元回線に紐付いている場合は最終更新年月日時分秒はNULLとなる
			String lastUpdDtm = ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.LAST_UPD_DTM);
			if (StringUtils.isEmpty(lastUpdDtm))
			{
				lastUpdDtm = ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.UPD_DTM);
			}
			template.set(EKK2811C110CBSMsg.UPD_DTM_BF, lastUpdDtm);
		}
		// OM-2014-0001556 サービス契約解約時の多機能ルーターキャンセル処理で排他エラーになる 2014/04/22 END

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C120_照査前機器オプションサービス契約キャンセル取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param tgRirekiMap 
	 * @param hikitsugiMap 
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param ekk2811a010Msg 機器オプションサービス契約一意照会Msg
	 * @return S/I上り情報
	 * @throws RequestParameterException 例editInMsgEKK2811C120外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C120(
			IRequestParameterReadWrite param, 
			CAANMsg tgRirekiMap,
			HashMap<String, Object> hikitsugiMap)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C120CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C120CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);
		
		// 機器提供サービス契約番号
		String kkopSvcKeiNo = tgRirekiMap.getString(EKK2811C120CBSMsg.KKOP_SVC_KEI_NO);
		// 申込番号
		String mskmDtlNo = (String)hikitsugiMap.get(EKK2811C120CBSMsg.MSKM_DTL_NO);
		// 異動区分
		String ido_div = (String)hikitsugiMap.get(EKK2811C120CBSMsg.IDO_DIV);
		// 更新年月日時分秒(更新前)
		String updDtmBf = (String)hikitsugiMap.get(EKK2811C120CBSMsg.UPD_DTM_BF);
		
		// テンプレートID(SIFのID)
		template.set(EKK2811C120CBSMsg.TEMPLATEID, "EKK2811C120");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C120CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		if (kkopSvcKeiNo != null && !"".equals(kkopSvcKeiNo)) 
		{
			template.set(EKK2811C120CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		}
		else
		{
			template.setNull(EKK2811C120CBSMsg.KKOP_SVC_KEI_NO);
		}

		// 申込明細番号
		if ( mskmDtlNo != null && !"".equals(mskmDtlNo))
		{
			template.set(EKK2811C120CBSMsg.MSKM_DTL_NO, mskmDtlNo );
		} else 
		{
			template.setNull(EKK2811C120CBSMsg.MSKM_DTL_NO);
		}

		// 異動区分
		if (ido_div != null && !"".equals(ido_div))
		{
			template.set(EKK2811C120CBSMsg.IDO_DIV, ido_div );
		} else
		{
			template.setNull(EKK2811C120CBSMsg.IDO_DIV);
		}

		// 更新年月日時分秒(更新前)
		if (updDtmBf != null && !"".equals(updDtmBf))
		{
			template.set(EKK2811C120CBSMsg.UPD_DTM_BF, updDtmBf);
		} else
		{
			template.setNull(EKK2811C120CBSMsg.UPD_DTM_BF);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C130 照査後機器オプションサービス契約キャンセル取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param tgRirekiMap 
	 * @param hikitsugiMap 
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param ekk2811a010Msg 機器オプションサービス契約一意照会Msg
	 * @return S/I上り情報
	 * @throws RequestParameterException 例editInMsgEKK2811C120外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C130(
			IRequestParameterReadWrite param, 
			CAANMsg tgRirekiMap,
			HashMap<String, Object> hikitsugiMap)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C130CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C130CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);
		
		// 機器提供サービス契約番号
		String kkopSvcKeiNo = tgRirekiMap.getString(EKK2811C130CBSMsg.KKOP_SVC_KEI_NO);
		// 申込番号
		String mskmDtlNo = (String)hikitsugiMap.get(EKK2811C130CBSMsg.MSKM_DTL_NO);
		// 異動区分
		String ido_div = (String)hikitsugiMap.get(EKK2811C130CBSMsg.IDO_DIV);
		// 更新年月日時分秒(更新前)
		String updDtmBf = (String)hikitsugiMap.get(EKK2811C130CBSMsg.UPD_DTM_BF);
		
		// テンプレートID(SIFのID)
		template.set(EKK2811C130CBSMsg.TEMPLATEID, "EKK2811C130");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C130CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		if (kkopSvcKeiNo != null && !"".equals(kkopSvcKeiNo)) 
		{
			template.set(EKK2811C130CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		}
		else
		{
			template.setNull(EKK2811C130CBSMsg.KKOP_SVC_KEI_NO);
		}

		// 申込明細番号
		if ( mskmDtlNo != null && !"".equals(mskmDtlNo))
		{
			template.set(EKK2811C130CBSMsg.MSKM_DTL_NO, mskmDtlNo );
		} else 
		{
			template.setNull(EKK2811C130CBSMsg.MSKM_DTL_NO);
		}

		// 異動区分
		if (ido_div != null && !"".equals(ido_div))
		{
			template.set(EKK2811C130CBSMsg.IDO_DIV, ido_div );
		} else
		{
			template.setNull(EKK2811C130CBSMsg.IDO_DIV);
		}

		// 更新年月日時分秒(更新前)
		if (updDtmBf != null && !"".equals(updDtmBf))
		{
			template.set(EKK2811C130CBSMsg.UPD_DTM_BF, updDtmBf);
		} else
		{
			template.setNull(EKK2811C130CBSMsg.UPD_DTM_BF);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C140_機器オプションサービス契約解約
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param ekk2811a010Msg 機器オプションサービス契約一意照会Msg
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C140(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo,
			HashMap<String, Object> kkopKeiUpdMap, 
			CAANMsg ekk2811a010Msg)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C140CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C140CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C140CBSMsg.TEMPLATEID, "EKK2811C140");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C140CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK2811C140CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 申込明細番号
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO) != null)
		{
			template.set(EKK2811C140CBSMsg.MSKM_DTL_NO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO));
		}

		// 予約適用開始希望年月日
//		if (ekk2811a010Msg != null 
//				&& ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.RSV_TSTA_KIBO_YMD) != null)
//		{
//			template.set(EKK2811C140CBSMsg.RSV_TSTA_KIBO_YMD, ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.RSV_TSTA_KIBO_YMD));
//		}

		// サービス終了年月日
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_ENDYMD) != null)
		{
			template.set(EKK2811C140CBSMsg.SVC_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_ENDYMD));
		}
		else
		{
			template.set(EKK2811C140CBSMsg.SVC_ENDYMD, JCCBPCommon.getOpeDate(null));
		}

		// サービス課金終了年月日
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_ENDYMD) != null)
		{
			template.set(EKK2811C140CBSMsg.SVC_CHRG_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_ENDYMD));
		}
		else
		{
			template.set(EKK2811C140CBSMsg.SVC_CHRG_ENDYMD, JCCBPCommon.getOpeDate(null));
		}

		// サービス解約理由メモ
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_DLRE_MEMO) != null)
		{
			template.set(EKK2811C140CBSMsg.SVC_DLRE_MEMO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_DLRE_MEMO));
		}

		// 違約金発生コード
		// 20140121 IT1-2014-0000030 違約金発生コードはINPUT項目を設定するよう変更 MOD START
//		if (ekk2811a010Msg != null 
//				&& ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.PNLTY_HASSEI_CD) != null)
//		{
//			template.set(EKK2811C140CBSMsg.PNLTY_HASSEI_CD, ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.PNLTY_HASSEI_CD));
//		}
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PNLTY_HASSEI_CD) != null)
		{
			template.set(EKK2811C140CBSMsg.PNLTY_HASSEI_CD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PNLTY_HASSEI_CD));
		}
		// 20140121 IT1-2014-0000030 違約金発生コードはINPUT項目を設定するよう変更 MOD END

		// 異動区分
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV) != null)
		{
			// #84868 MOD START
//			String idoDiv = (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV);
//			template.set(EKK2811C140CBSMsg.IDO_DIV, idoDiv);
//			// サービス解約理由コード
//			String svcDlreCd;
//			if(IDO_DIV_KSI_DSL.equals(idoDiv))
//			{
//				// 異動区分が「強制解約」の場合のみ「強制解約」
//				svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_KSI_DSL;
//			}
//			else
//			{
//				// その他の異動区分は「通常解約」
//				svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_NORMAL;
//			}
//			template.set(EKK2811C140CBSMsg.SVC_DLRE_CD, svcDlreCd);
			String idoDiv = (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV);
			// サービス解約理由コード
			String svcDlreCd;
			if (IDO_DIV_KSI_CAN.equals(idoDiv))
			{
				// IN.異動区分が「キャンセル」の場合のみ異動区分を「解約」
				idoDiv = IDO_DIV_DSL;
				// サービス解約理由コードを「キャンセルによる解約」
				svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_KSI_CAN;
			}
			else
			{
				if(IDO_DIV_KSI_DSL.equals(idoDiv))
				{
					// 異動区分が「強制解約」の場合のみ「強制解約」
					svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_KSI_DSL;
				}
				else
				{
					// その他の異動区分は「通常解約」
					svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_NORMAL;
				}
			}
			template.set(EKK2811C140CBSMsg.IDO_DIV, idoDiv);
			template.set(EKK2811C140CBSMsg.SVC_DLRE_CD, svcDlreCd);
			// #84868 MOD END
		}

		// IT2-2013-0000870対応 高林 Update Start
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_UPD_DTM_BF) != null )
//		{
//			template.set(EKK2811C140CBSMsg.UPD_DTM_BF, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_UPD_DTM_BF));
//		}
// IT2-2014-0000096 2014.01.30 MOD START
//		if (ekk2811a010Msg != null 
//				&& ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.LAST_UPD_DTM) != null
//				&& !"".equals((String)ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.LAST_UPD_DTM)))
//		{
//			template.set(EKK2811C140CBSMsg.UPD_DTM_BF, (String)ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.LAST_UPD_DTM));
//		}
		if (ekk2811a010Msg != null) {
			// 住変中の場合、自動切換日（入居予定日）を過ぎると、回線機器は転居先の回線に紐付いている事を考慮
			// サービス契約が転居元回線に紐付いている場合は最終更新年月日時分秒はNULLとなる
			String lastUpdDtm = ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.LAST_UPD_DTM);
			if (StringUtils.isEmpty(lastUpdDtm)) {
				lastUpdDtm = ekk2811a010Msg.getString(EKK2811A010CBSMsg1List.UPD_DTM);
			}
			template.set(EKK2811C140CBSMsg.UPD_DTM_BF, lastUpdDtm);
		}
// IT2-2014-0000096 2014.01.30 MOD END
		// IT2-2013-0000870対応 高林 Update End

		// サービス契約番号
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_KEI_NO) != null )
		{
			template.set(EKK2811C140CBSMsg.SVC_KEI_NO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_KEI_NO));
		}

		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C150_機器オプションサービス契約解約確定
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param ekk2811a010Msg 機器オプションサービス契約一意照会Msg
	 * @param upYmd 更新年月日時分秒(更新前)
	 * @param dslJiChrg 解約時課金のフラグ(0：非課金、1：課金)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C150(
			IRequestParameterReadWrite param, 
			String kkopSvcKeiNo,
			HashMap<String, Object> kkopKeiUpdMap, 
			CAANMsg ekk2811a010Msg,String upYmd,
			// ▼▼▼▼▼ OM-2015-0002509 2015/10/06 MOD START ▼▼▼▼▼
			String dslJiChrg
			// ▲▲▲▲▲ OM-2015-0002509 2015/10/06 MOD END   ▲▲▲▲▲
			)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C150CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C150CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C150CBSMsg.TEMPLATEID, "EKK2811C150");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C150CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		template.set(EKK2811C150CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// サービス終了年月日
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_ENDYMD) != null)
		{
			template.set(EKK2811C150CBSMsg.SVC_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_ENDYMD));
		}

		// サービス課金終了年月日
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_ENDYMD) != null)
		{
			template.set(EKK2811C150CBSMsg.SVC_CHRG_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_ENDYMD));
		}

//		// プラン課金開始年月日
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_CHRG_STAYMD) != null)
//		{
//			template.set(EKK2811C150CBSMsg.PLAN_CHRG_STAYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_CHRG_STAYMD));
//		}

//		// プラン終了年月日
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_ENDYMD) != null)
//		{
//			template.set(EKK2811C150CBSMsg.PLAN_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_ENDYMD));
//		}

//		// プラン課金終了年月日
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_CHRG_ENDYMD) != null)
//		{
//			template.set(EKK2811C150CBSMsg.PLAN_CHRG_ENDYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PLAN_CHRG_ENDYMD));
//		}

		// サービス解約理由コード
		String svcDlreCd;
		if(IDO_DIV_KSI_DSL.equals((String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV)))
		{
			// 異動区分が「強制解約」の場合のみ「強制解約」
			svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_KSI_DSL;
		}
		else if (IDO_DIV_KSI_CAN.equals((String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV))) 
		{
			// その他の異動区分は「キャンセル」
			svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_KSI_CAN;
		}
		else {
			// その他の異動区分は「通常解約」
			svcDlreCd = JKKKkopSvcUseKeiUpdCC.SVC_DLRE_CD_NORMAL;
		}
		
		template.set(EKK2811C150CBSMsg.SVC_DLRE_CD, svcDlreCd);

		// サービス解約理由メモ
		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_DLRE_MEMO) != null)
		{
			template.set(EKK2811C150CBSMsg.SVC_DLRE_MEMO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_DLRE_MEMO));
		}

		// 更新年月日時分秒(更新前) ← 解約時処理時の更新日時
		template.set(EKK2811C150CBSMsg.UPD_DTM_BF, upYmd);

//		// サービス課金開始年月日
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_STAYMD) != null)
//		{
//			template.set(EKK2811C150CBSMsg.SVC_CHRG_STAYMD, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_SVC_CHRG_STAYMD));
//		}

		// ▼▼▼▼▼ OM-2015-0002509 2015/10/06 MOD START ▼▼▼▼▼
		// 引き渡ってきている解約時課金の値を設定
		
//		// 解約時課金(違約金発生コードと同値)
//		if (kkopKeiUpdMap != null && kkopKeiUpdMap.size() > 0
//				&& kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PNLTY_HASSEI_CD) != null)
//		{
//			template.set(EKK2811C150CBSMsg.DSL_JI_CHRG, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_PNLTY_HASSEI_CD));
//		}
		
		// 解約時課金
		if (dslJiChrg != null)
		{
			template.set(EKK2811C150CBSMsg.DSL_JI_CHRG, dslJiChrg);
		}
		// ▲▲▲▲▲ OM-2015-0002509 2015/10/06 MOD END   ▲▲▲▲▲
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C180_機器オプションサービス契約回復
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param tgRirekiMap 対象機器オプションサービス契約の履歴データ
	 * @param hikitsugiMap 機器オプションサービス契約更新マップ
	 * @return S/I上り情報
	 * @throws RequestParameterException 例editInMsgEKK2811C120外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C180(
			IRequestParameterReadWrite param, 
			CAANMsg tgRirekiMap,
			HashMap<String, Object> hikitsugiMap)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C180CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C180CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);
		
		// 機器提供サービス契約番号
		String kkopSvcKeiNo = tgRirekiMap.getString(EKK2811C180CBSMsg.KKOP_SVC_KEI_NO);
		// 申込番号
		String mskmDtlNo = (String)hikitsugiMap.get(EKK2811C180CBSMsg.MSKM_DTL_NO);
		// 異動区分
		String ido_div = (String)hikitsugiMap.get(EKK2811C180CBSMsg.IDO_DIV);
		// 更新年月日時分秒(更新前)
		String updDtmBf = (String)hikitsugiMap.get(EKK2811C180CBSMsg.UPD_DTM_BF);
		
		String khkYmd = JCCBPCommon.getOpeDate(null);
		
		// テンプレートID(SIFのID)
		template.set(EKK2811C180CBSMsg.TEMPLATEID, "EKK2811C180");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C180CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		if (kkopSvcKeiNo != null && !"".equals(kkopSvcKeiNo)) 
		{
			template.set(EKK2811C180CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		}
		else
		{
			template.setNull(EKK2811C180CBSMsg.KKOP_SVC_KEI_NO);
		}

		// 申込明細番号
		if ( mskmDtlNo != null && !"".equals(mskmDtlNo))
		{
			template.set(EKK2811C180CBSMsg.MSKM_DTL_NO, mskmDtlNo );
		} else 
		{
			template.setNull(EKK2811C180CBSMsg.MSKM_DTL_NO);
		}
		
		// 回復年月日
		if ( khkYmd != null && !"".equals(khkYmd))
		{
			template.set(EKK2811C180CBSMsg.KAIHK_YMD, khkYmd );
		} else 
		{
			template.setNull(EKK2811C180CBSMsg.KAIHK_YMD);
		}

		// 異動区分
		if (ido_div != null && !"".equals(ido_div))
		{
			template.set(EKK2811C180CBSMsg.IDO_DIV, ido_div );
		} else
		{
			template.setNull(EKK2811C180CBSMsg.IDO_DIV);
		}

		// 更新年月日時分秒(更新前)
		if (updDtmBf != null && !"".equals(updDtmBf))
		{
			template.set(EKK2811C180CBSMsg.UPD_DTM_BF, updDtmBf);
		} else
		{
			template.setNull(EKK2811C180CBSMsg.UPD_DTM_BF);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C190_休止中機器オプションサービス契約回復
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param tgRirekiMap 対象機器オプションサービス契約の履歴データ
	 * @param hikitsugiMap 機器オプションサービス契約更新マップ
	 * @return S/I上り情報
	 * @throws RequestParameterException 例editInMsgEKK2811C120外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C190(
			IRequestParameterReadWrite param, 
			CAANMsg tgRirekiMap,
			HashMap<String, Object> hikitsugiMap)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C190CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C190CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);
		
		// 機器提供サービス契約番号
		String kkopSvcKeiNo = tgRirekiMap.getString(EKK2811C190CBSMsg.KKOP_SVC_KEI_NO);
		// 申込番号
		String mskmDtlNo = (String)hikitsugiMap.get(EKK2811C190CBSMsg.MSKM_DTL_NO);
		// 異動区分
		String ido_div = (String)hikitsugiMap.get(EKK2811C190CBSMsg.IDO_DIV);
		// 更新年月日時分秒(更新前)
		String updDtmBf = (String)hikitsugiMap.get(EKK2811C190CBSMsg.UPD_DTM_BF);
		
		String khkYmd = JCCBPCommon.getOpeDate(null);
		
		// テンプレートID(SIFのID)
		template.set(EKK2811C190CBSMsg.TEMPLATEID, "EKK2811C190");

		// 機能コード(チェック＆登録または更新)
		template.set(EKK2811C120CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 機器オプションサービス契約番号
		if (kkopSvcKeiNo != null && !"".equals(kkopSvcKeiNo)) 
		{
			template.set(EKK2811C190CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		}
		else
		{
			template.setNull(EKK2811C190CBSMsg.KKOP_SVC_KEI_NO);
		}

		// 申込明細番号
		if ( mskmDtlNo != null && !"".equals(mskmDtlNo))
		{
			template.set(EKK2811C190CBSMsg.MSKM_DTL_NO, mskmDtlNo );
		} else 
		{
			template.setNull(EKK2811C190CBSMsg.MSKM_DTL_NO);
		}
		
		// 回復年月日
		if ( khkYmd != null && !"".equals(khkYmd))
		{
			template.set(EKK2811C190CBSMsg.KAIHK_YMD, khkYmd );
		} else 
		{
			template.setNull(EKK2811C190CBSMsg.KAIHK_YMD);
		}

		// 異動区分
		if (ido_div != null && !"".equals(ido_div))
		{
			template.set(EKK2811C190CBSMsg.IDO_DIV, ido_div );
		} else
		{
			template.setNull(EKK2811C190CBSMsg.IDO_DIV);
		}

		// 更新年月日時分秒(更新前)
		if (updDtmBf != null && !"".equals(updDtmBf))
		{
			template.set(EKK2811C190CBSMsg.UPD_DTM_BF, updDtmBf);
		} else
		{
			template.setNull(EKK2811C190CBSMsg.UPD_DTM_BF);
		}
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811C200_機器オプションサービス契約解約取消
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcKeiNo 機器オプションサービス契約番号
	 * @param mskmDtlNo 申込明細番号
	 * @param idoDiv 異動区分
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C200(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String mskmDtlNo,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C200CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C200CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C200CBSMsg.TEMPLATEID, "EKK2811C200");

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

		// 機器オプションサービス契約番号
		template.set(EKK2811C200CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 申込明細番号
		template.set(EKK2811C200CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 異動区分
		template.set(EKK2811C200CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C200CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EKK2811D010_機器オプションサービス契約登録
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kkopSvcCd 機器オプションサービスコード
	 * @param pcrsCd 料金コースコード
	 * @param pplanCd 料金プランコード
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param sysid SYSID
	 * @param mskmDtlNo 申込明細番号
	 * @param ftrialKanyuYmd 試用加入年月日
	 * @param ftrialPrdEndymd 試用期間終了年月日
	 * @param honkanyuYmd 本加入年月日
	 * @param honkanyuIkoKigenYmd 本加入移行期限年月日
	 * @param svcUseStaKiboYmd サービス利用開始希望年月日
	 * @param rsvTstaKiboYmd 予約適用開始希望年月日
	 * @param idoDiv 異動区分
	 * @param kikiRntaiKeiChgechuFlg 機器連帯契約変更中フラグ
	 * @param seikyKeiNo 請求契約番号
	 * @param prcKmkCd 料金項目コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811D010(
			IRequestParameterReadWrite param,
			String kkopSvcCd,
			String pcrsCd,
			String pplanCd,
			String kktkSvcKeiNo,
			String sysid,
			String mskmDtlNo,
			String ftrialKanyuYmd,
			String ftrialPrdEndymd,
			String honkanyuYmd,
			String honkanyuIkoKigenYmd,
			String svcUseStaKiboYmd,
			String rsvTstaKiboYmd,
			String idoDiv,
			String kikiRntaiKeiChgechuFlg, String seikyKeiNo, String prcKmkCd, String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811D010CBSMsg.class.getName());

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

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

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

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

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

		// 機器提供サービスコード
		template.set(EKK2811D010CBSMsg.KKOP_SVC_CD, kkopSvcCd);

		// 料金コースコード
		template.set(EKK2811D010CBSMsg.PCRS_CD, pcrsCd);

		// 料金プランコード
		template.set(EKK2811D010CBSMsg.PPLAN_CD, pplanCd);

		// 機器提供サービス契約番号
		template.set(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// SYSID
		template.set(EKK2811D010CBSMsg.SYSID, sysid);

		// 申込明細番号
		template.set(EKK2811D010CBSMsg.MSKM_DTL_NO, mskmDtlNo);

		// 試用加入年月日
		template.set(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD, ftrialKanyuYmd);

		// 試用期間終了年月日
		template.set(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD, ftrialPrdEndymd);

		// 本加入年月日
		template.set(EKK2811D010CBSMsg.HONKANYU_YMD, honkanyuYmd);

		// 本加入移行期限年月日
		template.set(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, honkanyuIkoKigenYmd);

		// サービス利用開始希望年月日
		template.set(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD, svcUseStaKiboYmd);

		// 予約適用開始希望年月日
		template.set(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD, rsvTstaKiboYmd);

		// 違約金発生コード
		template.set(EKK2811D010CBSMsg.PNLTY_HASSEI_CD, JKKStrConst.CD01375_PNLTY_NASHI);

		// 異動区分
		template.set(EKK2811D010CBSMsg.IDO_DIV, idoDiv);

		// 機器連帯契約変更手続中フラグ
		template.set(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG, kikiRntaiKeiChgechuFlg);

		// 請求契約番号
		template.set(EKK2811D010CBSMsg.SEIKY_KEI_NO, seikyKeiNo);

		// 料金項目コード
		template.set(EKK2811D010CBSMsg.PRC_KMK_CD, prcKmkCd);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811D010CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 * EZM0411B030_宅内機器型式一覧照会（保有ルーターコード）
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param routerSbt 保有ルーター種別コード
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEZM0411B030(IRequestParameterReadWrite param, String routerSbt)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EZM0411B030CBSMsg.class.getName());

		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EZM0411B030CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EZM0411B030CBSMsg.TEMPLATEID, "EZM041B030");

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

		// ＫＥＹ＿保有ルーター種別コード
		template.set(EZM0411B030CBSMsg.KEY_HOYU_ROUTER_CD, routerSbt);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}

	/**
	 *<DL>
	 *<DT>処理概要:ECK0011A010_お客様一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPECK0011A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoECK0011A010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081A010_サービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0081A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0081A010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0241B001_サービス契約回線内訳一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0241B001(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0241B001(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	/**
	 *<DL>
	 *<DT>処理概要:EKK0021B002_申込明細履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0021B002(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0021B002(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	/**
	 *<DL>
	 *<DT>処理概要:EKK0321B005_課金先一覧照会（サービス契約番号）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0321B005(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0321B005(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341A010_機器提供サービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341A010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341B002_機器提供サービス契約一覧照会（サービス契約番号）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341B002(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341B002(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C030_機器提供サービス契約照査
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C030(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C030(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C050(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C050(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C120_機器提供サービス契約停止
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C120(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C120(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C130_機器提供サービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C130(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C130(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C131_休止中機器提供サービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C131(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C131(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C330_機器提供サービス契約キャンセル
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C330(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C330(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C340_機器提供サービス契約解約
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C340(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C340(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C350_機器提供サービス契約解約確定
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C350(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C350(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C380_機器提供サービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C380(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C380(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C400_休止中機器提供サービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C400(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C400(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C410_照査前機器提供サービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C410(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C410(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C420_照査後機器提供サービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C420(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C420(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C430_機器提供サービス契約解約取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C430(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C430(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341D010_機器提供サービス契約登録
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341D010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341D010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0791A010_料金コース一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0791A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0791A010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

// IT2-2014-0000074対応 20140121 星野 ADD START
	/**
	 *<DL>
	 *<DT>処理概要:住所変更明細一覧照会（変更前識別番号）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * 
	 * @param	msgList		(I) CAANMsgクラス
	 * @param	param		(I) 業務データ取得・書込用I/F
	 * @param	fixedText	ユーザ任意文字列
	 * @return				業務データ取得・書込用I/F
	 * @since	2011.09.21
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2101B002(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText
	) throws Throwable 
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		ArrayList<Object> errList = new ArrayList();

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

		int templateStatus = template.getInt(EKK2101B002CBSMsg.STATUS);
		if (returnCode != 0) {
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) {
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

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

		// ＫＥＹ＿住所変更明細種別コード のエラー情報返却
		if (!template.isNull(EKK2101B002CBSMsg.KEY_ADCHG_DTL_SBT_CD_ERR)) {
			if (!inMap.containsKey("key_adchg_dtl_sbt_cd_err")) {
				inMap.put("key_adchg_dtl_sbt_cd_err", template.getString(EKK2101B002CBSMsg.KEY_ADCHG_DTL_SBT_CD_ERR));
			}
		}

		//  ＫＥＹ＿変更前識別番号 のエラー情報返却
		if (!template.isNull(EKK2101B002CBSMsg.KEY_CHBF_SKBT_NO_ERR)) {
			if (!inMap.containsKey("key_chbf_skbt_no_err")) {
				inMap.put("key_chbf_skbt_no_err", template.getString(EKK2101B002CBSMsg.KEY_CHBF_SKBT_NO_ERR));
			}
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}
// IT2-2014-0000074対応 20140121 星野 ADD END
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811A010_機器オプションサービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811A010(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811A010(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081B009_同一場所サービス契約情報照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param result 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedTextGlobal 
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0081B009(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK0081B009(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081B029_同一回線内訳サービス契約一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0081B029(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK0081B029(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811B011_機器オプションサービス契約一覧照会（機器提供ＳＶ）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811B010(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable 
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811B010(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811B012_機器オプションサービス契約履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811B012(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811B012(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C080_機器オプションサービス契約停止
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C080(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C080(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C090_機器オプションサービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.13
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C090(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C090(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C100_休止中機器オプションサービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.13
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C100(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C100(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C110_機器オプションサービス契約キャンセル
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C110(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C110(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C120_照査前機器オプションサービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C120(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C120(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C130_照査後機器オプションサービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C130(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C130(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C140_機器オプションサービス契約解約
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C140(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C140(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C150_機器オプションサービス契約解約確定
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C150(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C150(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C180_機器オプションサービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C180(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C180(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C190_休止中機器オプションサービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C190(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable {
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK2811C190(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C200_機器オプションサービス契約解約取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C200(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C200(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811D010_機器オプションサービス契約登録
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811D010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811D010(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EZM0411B030_宅内機器型式一覧照会（保有ルーターコード）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEZM0411B030(Map<?, ?> msgList, IRequestParameterReadWrite param,
			String fixedText) throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

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

		// エラー情報の設定
		param = editErrorInfoEZM0411B030(param, templates, (Integer)return_code, fixedText);

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:ECK0011A010_サービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoECK0011A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(ECK0011A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿SYSID → ＫＥＹ＿SYSID のエラー情報返却
		if (!template.isNull(ECK0011A010CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey("key_sysid_err"))
			{
				inMap.put("key_sysid_err", template.getString(ECK0011A010CBSMsg.KEY_SYSID_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿予約適用年月日 → ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081A010_サービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0081A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿予約適用年月日 → ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0241B001_サービス契約回線内訳一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0241B001(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0241B001CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0241B001CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0241B001CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0021B002_申込明細履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0021B002(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0021B002CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0021B002CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0021B002CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0321B005_課金先一覧照会（サービス契約番号）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0321B005(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0321B005CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341A010_機器提供サービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿機器提供サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kktk_svc_kei_no_err"))
			{
				inMap.put("key_kktk_svc_kei_no_err", template.getString(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿予約適用年月日 → ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341B002_機器提供サービス契約一覧照会（サービス契約番号）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341B002(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341B002CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341B002CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0341B002CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿機器提供サービスコード → ＫＥＹ＿機器提供サービスコード のエラー情報返却
		if (!template.isNull(EKK0341B002CBSMsg.KEY_KKTK_SVC_CD_ERR))
		{
			if (!inMap.containsKey("key_kktk_svc_cd_err"))
			{
				inMap.put("key_kktk_svc_cd_err", template.getString(EKK0341B002CBSMsg.KEY_KKTK_SVC_CD_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿機器提供サービス契約番号 → ＫＥＹ＿機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341B002CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kktk_svc_kei_no_err"))
			{
				inMap.put("key_kktk_svc_kei_no_err", template.getString(EKK0341B002CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿ソート区分 → ＫＥＹ＿ソート区分 のエラー情報返却
		if (!template.isNull(EKK0341B002CBSMsg.KEY_SORT_KBN_ERR))
		{
			if (!inMap.containsKey("key_sort_kbn_err"))
			{
				inMap.put("key_sort_kbn_err", template.getString(EKK0341B002CBSMsg.KEY_SORT_KBN_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C030_機器提供サービス契約照査
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C030(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C030CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C030CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.機器認証ID → 機器認証ID のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.KIKI_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_err"))
			{
				inMap.put("kiki_ninsho_id_err", template.getString(EKK0341C030CBSMsg.KIKI_NINSHO_ID_ERR));
			}
		}
		// 対象データ.機器認証IDパスワード → 機器認証IDパスワード のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.KIKI_NINSHO_ID_PWD_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_pwd_err"))
			{
				inMap.put("kiki_ninsho_id_pwd_err", template.getString(EKK0341C030CBSMsg.KIKI_NINSHO_ID_PWD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C030CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.照査解約完了コード → 照査解約完了コード のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.SHOSA_DSL_FIN_CD_ERR))
		{
			if (!inMap.containsKey("shosa_dsl_fin_cd_err"))
			{
				inMap.put("shosa_dsl_fin_cd_err", template.getString(EKK0341C030CBSMsg.SHOSA_DSL_FIN_CD_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C030CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C030CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C050(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C050CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C050CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C050CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.機器認証ID → 機器認証ID のエラー情報返却
		if (!template.isNull(EKK0341C050CBSMsg.KIKI_NINSHO_ID_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_err"))
			{
				inMap.put("kiki_ninsho_id_err", template.getString(EKK0341C050CBSMsg.KIKI_NINSHO_ID_ERR));
			}
		}
		// 対象データ.機器認証IDパスワード → 機器認証IDパスワード のエラー情報返却
		if (!template.isNull(EKK0341C050CBSMsg.KIKI_NINSHO_ID_PWD_ERR))
		{
			if (!inMap.containsKey("kiki_ninsho_id_pwd_err"))
			{
				inMap.put("kiki_ninsho_id_pwd_err", template.getString(EKK0341C050CBSMsg.KIKI_NINSHO_ID_PWD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C050CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C050CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C050CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C050CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C120_機器提供サービス契約停止
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C120(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C120CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C120CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C120CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止年月日 → サービス停止年月日 のエラー情報返却
		if (!template.isNull(EKK0341C120CBSMsg.SVC_STP_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_ymd_err"))
			{
				inMap.put("svc_stp_ymd_err", template.getString(EKK0341C120CBSMsg.SVC_STP_YMD_ERR));
			}
		}
		// 対象データ.サービス停止理由コード → サービス停止理由コード のエラー情報返却
		if (!template.isNull(EKK0341C120CBSMsg.SVC_STP_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rsn_cd_err"))
			{
				inMap.put("svc_stp_rsn_cd_err", template.getString(EKK0341C120CBSMsg.SVC_STP_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C120CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C120CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C120CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C120CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C130_機器提供サービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C130(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C130CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C130CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C130CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止解除年月日 → サービス停止解除年月日 のエラー情報返却
		if (!template.isNull(EKK0341C130CBSMsg.SVC_STP_RLS_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_ymd_err"))
			{
				inMap.put("svc_stp_rls_ymd_err", template.getString(EKK0341C130CBSMsg.SVC_STP_RLS_YMD_ERR));
			}
		}
		// 対象データ.サービス停止解除理由コード → サービス停止解除理由コード のエラー情報返却
		if (!template.isNull(EKK0341C130CBSMsg.SVC_STP_RLS_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_rsn_cd_err"))
			{
				inMap.put("svc_stp_rls_rsn_cd_err", template.getString(EKK0341C130CBSMsg.SVC_STP_RLS_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C130CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C130CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C130CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C130CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C131_休止中機器提供サービス契約停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C131(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C131CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C131CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C131CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止解除年月日 → サービス停止解除年月日 のエラー情報返却
		if (!template.isNull(EKK0341C131CBSMsg.SVC_STP_RLS_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_ymd_err"))
			{
				inMap.put("svc_stp_rls_ymd_err", template.getString(EKK0341C131CBSMsg.SVC_STP_RLS_YMD_ERR));
			}
		}
		// 対象データ.サービス停止解除理由コード → サービス停止解除理由コード のエラー情報返却
		if (!template.isNull(EKK0341C131CBSMsg.SVC_STP_RLS_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_rsn_cd_err"))
			{
				inMap.put("svc_stp_rls_rsn_cd_err", template.getString(EKK0341C131CBSMsg.SVC_STP_RLS_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C131CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C131CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C131CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C131CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C330_機器提供サービス契約キャンセル
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C330(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C330CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C330CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C330CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.サービスキャンセル理由コード → サービスキャンセル理由コード のエラー情報返却
		if (!template.isNull(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_cancel_rsn_cd_err"))
			{
				inMap.put("svc_cancel_rsn_cd_err", template.getString(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C330CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C330CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C330CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C330CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C340_機器提供サービス契約解約
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C340(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C340CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C340CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C340CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0341C340CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.サービス終了年月日 → サービス終了年月日 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.SVC_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_endymd_err"))
			{
				inMap.put("svc_endymd_err", template.getString(EKK0341C340CBSMsg.SVC_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.SVC_CHRG_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_chrg_endymd_err"))
			{
				inMap.put("svc_chrg_endymd_err", template.getString(EKK0341C340CBSMsg.SVC_CHRG_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス解約理由コード → サービス解約理由コード のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.SVC_DLRE_CD_ERR))
		{
			if (!inMap.containsKey("svc_dlre_cd_err"))
			{
				inMap.put("svc_dlre_cd_err", template.getString(EKK0341C340CBSMsg.SVC_DLRE_CD_ERR));
			}
		}
		// 対象データ.サービス解約理由メモ → サービス解約理由メモ のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.SVC_DLRE_MEMO_ERR))
		{
			if (!inMap.containsKey("svc_dlre_memo_err"))
			{
				inMap.put("svc_dlre_memo_err", template.getString(EKK0341C340CBSMsg.SVC_DLRE_MEMO_ERR));
			}
		}
		// 対象データ.残置フラグ → 残置フラグ のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.ZANCHI_FLG_ERR))
		{
			if (!inMap.containsKey("zanchi_flg_err"))
			{
				inMap.put("zanchi_flg_err", template.getString(EKK0341C340CBSMsg.ZANCHI_FLG_ERR));
			}
		}
		// 対象データ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0341C340CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C340CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.宅内機器異動コード → 宅内機器異動コード のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.TAKNKIKI_IDO_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_ido_cd_err"))
			{
				inMap.put("taknkiki_ido_cd_err", template.getString(EKK0341C340CBSMsg.TAKNKIKI_IDO_CD_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C340CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 対象データ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C340CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK0341C340CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C350_機器提供サービス契約解約確定
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C350(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C350CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C350CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス終了年月日 → サービス終了年月日 のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.SVC_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_endymd_err"))
			{
				inMap.put("svc_endymd_err", template.getString(EKK0341C350CBSMsg.SVC_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.SVC_CHRG_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_chrg_endymd_err"))
			{
				inMap.put("svc_chrg_endymd_err", template.getString(EKK0341C350CBSMsg.SVC_CHRG_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス解約理由コード → サービス解約理由コード のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.SVC_DLRE_CD_ERR))
		{
			if (!inMap.containsKey("svc_dlre_cd_err"))
			{
				inMap.put("svc_dlre_cd_err", template.getString(EKK0341C350CBSMsg.SVC_DLRE_CD_ERR));
			}
		}
		// 対象データ.サービス解約理由メモ → サービス解約理由メモ のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.SVC_DLRE_MEMO_ERR))
		{
			if (!inMap.containsKey("svc_dlre_memo_err"))
			{
				inMap.put("svc_dlre_memo_err", template.getString(EKK0341C350CBSMsg.SVC_DLRE_MEMO_ERR));
			}
		}
		// 対象データ.残置フラグ → 残置フラグ のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.ZANCHI_FLG_ERR))
		{
			if (!inMap.containsKey("zanchi_flg_err"))
			{
				inMap.put("zanchi_flg_err", template.getString(EKK0341C350CBSMsg.ZANCHI_FLG_ERR));
			}
		}
		// 対象データ.宅内機器異動コード → 宅内機器異動コード のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.TAKNKIKI_IDO_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_ido_cd_err"))
			{
				inMap.put("taknkiki_ido_cd_err", template.getString(EKK0341C350CBSMsg.TAKNKIKI_IDO_CD_ERR));
			}
		}
		// 対象データ.回収機器有無 → 回収機器有無 のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.KAISHU_KIKI_UM_ERR))
		{
			if (!inMap.containsKey("kaishu_kiki_um_err"))
			{
				inMap.put("kaishu_kiki_um_err", template.getString(EKK0341C350CBSMsg.KAISHU_KIKI_UM_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C350CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C350CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C380_機器提供サービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C380(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C380CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C380CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C380CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C380CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.回復年月日 → 回復年月日 のエラー情報返却
		if (!template.isNull(EKK0341C380CBSMsg.KAIHK_YMD_ERR))
		{
			if (!inMap.containsKey("kaihk_ymd_err"))
			{
				inMap.put("kaihk_ymd_err", template.getString(EKK0341C380CBSMsg.KAIHK_YMD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C380CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C380CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C380CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C380CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C400_休止中機器提供サービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C400(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C400CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C400CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C400CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C400CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C400CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.回復年月日 → 回復年月日 のエラー情報返却
		if (!template.isNull(EKK0341C400CBSMsg.KAIHK_YMD_ERR))
		{
			if (!inMap.containsKey("kaihk_ymd_err"))
			{
				inMap.put("kaihk_ymd_err", template.getString(EKK0341C400CBSMsg.KAIHK_YMD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C400CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C400CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C400CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C400CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C410_照査前機器提供サービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C410(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C410CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C410CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C410CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C410CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C410CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C410CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C410CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C410CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C410CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C420_照査後機器提供サービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C420(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C420CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C420CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C420CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C420CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C420CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C420CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C420CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C420CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C420CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C430_機器提供サービス契約解約取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C430(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C430CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C430CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C430CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C430CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C430CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C430CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341C430CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C430CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341C430CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0341D010_機器提供サービス契約登録
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341D010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器提供サービスコード → 機器提供サービスコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kktk_svc_cd_err"))
			{
				inMap.put("kktk_svc_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SVC_CD_ERR));
			}
		}
		// 対象データ.料金コースコード → 料金コースコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.PCRS_CD_ERR))
			{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK0341D010CBSMsg.PCRS_CD_ERR));
			}
		}
		// 対象データ.料金プランコード → 料金プランコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.PPLAN_CD_ERR))
			{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK0341D010CBSMsg.PPLAN_CD_ERR));
			}
		}
		// 対象データ.機器提供種別コード → 機器提供種別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR))
		{
			if (!inMap.containsKey("kktk_sbt_cd_err"))
			{
				inMap.put("kktk_sbt_cd_err", template.getString(EKK0341D010CBSMsg.KKTK_SBT_CD_ERR));
			}
		}
		// 対象データ.HDD容量コード → HDD容量コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR))
		{
			if (!inMap.containsKey("hdd_capa_cd_err"))
			{
				inMap.put("hdd_capa_cd_err", template.getString(EKK0341D010CBSMsg.HDD_CAPA_CD_ERR));
			}
		}
		// 対象データ.サービス利用開始希望年月日 → サービス利用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK0341D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.希望メーカーコード → 希望メーカーコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR))
		{
			if (!inMap.containsKey("kibo_maker_cd_err"))
			{
				inMap.put("kibo_maker_cd_err", template.getString(EKK0341D010CBSMsg.KIBO_MAKER_CD_ERR));
			}
		}
		// 対象データ.販売種別コード → 販売種別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("hambai_sbt_cd_err"))
			{
				inMap.put("hambai_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HAMBAI_SBT_CD_ERR));
			}
		}
		// 対象データ.通信機器セットコード → 通信機器セットコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR))
		{
			if (!inMap.containsKey("tsushin_kiki_set_cd_err"))
			{
				inMap.put("tsushin_kiki_set_cd_err", template.getString(EKK0341D010CBSMsg.TSUSHIN_KIKI_SET_CD_ERR));
			}
		}
		// 対象データ.宅内機器種別コード → 宅内機器種別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sbt_cd_err"))
			{
				inMap.put("taknkiki_sbt_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SBT_CD_ERR));
			}
		}
		// 対象データ.宅内機器型式コード → 宅内機器型式コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_model_cd_err"))
			{
				inMap.put("taknkiki_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_MODEL_CD_ERR));
			}
		}
		// 対象データ.機器製造番号 → 機器製造番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR))
		{
			if (!inMap.containsKey("kiki_seizo_no_err"))
			{
				inMap.put("kiki_seizo_no_err", template.getString(EKK0341D010CBSMsg.KIKI_SEIZO_NO_ERR));
			}
		}
		// 対象データ.宅内機器セット品型コード → 宅内機器セット品型コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_sethin_model_cd_err"))
			{
				inMap.put("taknkiki_sethin_model_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_SETHIN_MODEL_CD_ERR));
			}
		}
		// 対象データ.付属品種別コード → 付属品種別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR))
		{
			if (!inMap.containsKey("huzokuhin_sbt_cd_err"))
			{
				inMap.put("huzokuhin_sbt_cd_err", template.getString(EKK0341D010CBSMsg.HUZOKUHIN_SBT_CD_ERR));
			}
		}
		// 対象データ.機器設置先場所番号 → 機器設置先場所番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_place_no_err"))
			{
				inMap.put("kiki_stc_saki_place_no_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PLACE_NO_ERR));
			}
		}
		// 対象データ.親契約識別コード → 親契約識別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD_ERR))
		{
			if (!inMap.containsKey("oya_kei_skbt_cd_err"))
			{
				inMap.put("oya_kei_skbt_cd_err", template.getString(EKK0341D010CBSMsg.OYA_KEI_SKBT_CD_ERR));
			}
		}
		// 対象データ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK0341D010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_ucwk_no_err"))
			{
				inMap.put("svc_kei_ucwk_no_err", template.getString(EKK0341D010CBSMsg.SVC_KEI_UCWK_NO_ERR));
			}
		}
		// 対象データ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("svc_kei_kaisen_ucwk_no_err", template.getString(EKK0341D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}
		// 対象データ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("op_svc_kei_no_err"))
			{
				inMap.put("op_svc_kei_no_err", template.getString(EKK0341D010CBSMsg.OP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.SYSID → SYSID のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK0341D010CBSMsg.SYSID_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.リンクSTBフラグ → リンクSTBフラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.LINK_STB_FLG_ERR))
		{
			if (!inMap.containsKey("link_stb_flg_err"))
			{
				inMap.put("link_stb_flg_err", template.getString(EKK0341D010CBSMsg.LINK_STB_FLG_ERR));
			}
		}
		// 対象データ.機器引当指定倉庫コード → 機器引当指定倉庫コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD_ERR))
		{
			if (!inMap.containsKey("kiki_hkat_shitei_soko_cd_err"))
			{
				inMap.put("kiki_hkat_shitei_soko_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD_ERR));
			}
		}
		// 対象データ.機器引当指定倉庫棚コード → 機器引当指定倉庫棚コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD_ERR))
		{
			if (!inMap.containsKey("kiki_hkat_shitei_skdn_cd_err"))
			{
				inMap.put("kiki_hkat_shitei_skdn_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD_ERR));
			}
		}
		// 対象データ.機器送料有無 → 機器送料有無 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_um_err"))
			{
				inMap.put("kiki_soryo_um_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_UM_ERR));
			}
		}
		// 対象データ.機器送料作成年月日 → 機器送料作成年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR))
		{
			if (!inMap.containsKey("kiki_soryo_saksei_ymd_err"))
			{
				inMap.put("kiki_soryo_saksei_ymd_err", template.getString(EKK0341D010CBSMsg.KIKI_SORYO_SAKSEI_YMD_ERR));
			}
		}
		// 対象データ.機器送付先名 → 機器送付先名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_nm_err"))
			{
				inMap.put("kiki_sohus_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_NM_ERR));
			}
		}
		// 対象データ.機器送付先カナ名 → 機器送付先カナ名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_kana_err"))
			{
				inMap.put("kiki_sohus_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KANA_ERR));
			}
		}
		// 対象データ.機器送付先住所コード → 機器送付先住所コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ad_cd_err"))
			{
				inMap.put("kiki_sohus_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CD_ERR));
			}
		}
		// 対象データ.機器送付先郵便番号 → 機器送付先郵便番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_pcd_err"))
			{
				inMap.put("kiki_sohus_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_PCD_ERR));
			}
		}
		// 対象データ.機器送付先都道府県名 → 機器送付先都道府県名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_state_nm_err"))
			{
				inMap.put("kiki_sohus_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_STATE_NM_ERR));
			}
		}
		// 対象データ.機器送付先市区町村名 → 機器送付先市区町村名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_city_nm_err"))
			{
				inMap.put("kiki_sohus_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_CITY_NM_ERR));
			}
		}
		// 対象データ.機器送付先大字通称名 → 機器送付先大字通称名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_oaztsu_nm_err"))
			{
				inMap.put("kiki_sohus_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_OAZTSU_NM_ERR));
			}
		}
		// 対象データ.機器送付先字丁目名 → 機器送付先字丁目名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_azcho_nm_err"))
			{
				inMap.put("kiki_sohus_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AZCHO_NM_ERR));
			}
		}
		// 対象データ.機器送付先番地号 → 機器送付先番地号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_bnchigo_err"))
			{
				inMap.put("kiki_sohus_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_BNCHIGO_ERR));
			}
		}
		// 対象データ.機器送付先住所補記・建物名 → 機器送付先住所補記・建物名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrttm_err"))
			{
				inMap.put("kiki_sohus_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRTTM_ERR));
			}
		}
		// 対象データ.機器送付先住所補記・部屋番号 → 機器送付先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_adrrm_err"))
			{
				inMap.put("kiki_sohus_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_ADRRM_ERR));
			}
		}
		// 対象データ.機器送付先電話番号 → 機器送付先電話番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_telno_err"))
			{
				inMap.put("kiki_sohus_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_TELNO_ERR));
			}
		}
		// 対象データ.マンション物件番号 → マンション物件番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR))
		{
			if (!inMap.containsKey("mansion_bukken_no_err"))
			{
				inMap.put("mansion_bukken_no_err", template.getString(EKK0341D010CBSMsg.MANSION_BUKKEN_NO_ERR));
			}
		}
		// 対象データ.機器送付先_契約者住所差異フラグ → 機器送付先_契約者住所差異フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_sohus_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG_ERR));
			}
		}
		// 対象データ.機器送付先個別指定フラグ → 機器送付先個別指定フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_shs_kbt_shitei_flg_err"))
			{
				inMap.put("kiki_shs_kbt_shitei_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_KBT_SHITEI_FLG_ERR));
			}
		}
		// 対象データ.機器送付先補足コード1 → 機器送付先補足コード1 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_1_err"))
			{
				inMap.put("kiki_shs_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_1_ERR));
			}
		}
		// 対象データ.機器送付先補足コード2 → 機器送付先補足コード2 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_cd_2_err"))
			{
				inMap.put("kiki_shs_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_CD_2_ERR));
			}
		}
		// 対象データ.機器送付先補足メモ → 機器送付先補足メモ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_shs_hsk_memo_err"))
			{
				inMap.put("kiki_shs_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_HSK_MEMO_ERR));
			}
		}
		// 対象データ.機器設置先名 → 機器設置先名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_nm_err"))
			{
				inMap.put("kiki_stc_saki_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_NM_ERR));
			}
		}
		// 対象データ.機器設置先カナ名 → 機器設置先カナ名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_kana_err"))
			{
				inMap.put("kiki_stc_saki_kana_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_KANA_ERR));
			}
		}
		// 対象データ.機器設置先住所コード → 機器設置先住所コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_ad_cd_err"))
			{
				inMap.put("kiki_stc_saki_ad_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AD_CD_ERR));
			}
		}
		// 対象データ.機器設置先郵便番号 → 機器設置先郵便番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_pcd_err"))
			{
				inMap.put("kiki_stc_saki_pcd_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_PCD_ERR));
			}
		}
		// 対象データ.機器設置先都道府県名 → 機器設置先都道府県名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_state_nm_err"))
			{
				inMap.put("kiki_stc_saki_state_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_STATE_NM_ERR));
			}
		}
		// 対象データ.機器設置先市区町村名 → 機器設置先市区町村名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_city_nm_err"))
			{
				inMap.put("kiki_stc_saki_city_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_CITY_NM_ERR));
			}
		}
		// 対象データ.機器設置先大字通称名 → 機器設置先大字通称名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_oaztsu_nm_err"))
			{
				inMap.put("kiki_stc_saki_oaztsu_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_OAZTSU_NM_ERR));
			}
		}
		// 対象データ.機器設置先字丁目名 → 機器設置先字丁目名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_azcho_nm_err"))
			{
				inMap.put("kiki_stc_saki_azcho_nm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_AZCHO_NM_ERR));
			}
		}
		// 対象データ.機器設置先番地号 → 機器設置先番地号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_bnchigo_err"))
			{
				inMap.put("kiki_stc_saki_bnchigo_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_BNCHIGO_ERR));
			}
		}
		// 対象データ.機器設置先住所補記・建物名 → 機器設置先住所補記・建物名 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrttm_err"))
			{
				inMap.put("kiki_stc_saki_adrttm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRTTM_ERR));
			}
		}
		// 対象データ.機器設置先住所補記・部屋番号 → 機器設置先住所補記・部屋番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR))
		{
			if (!inMap.containsKey("kiki_stc_saki_adrrm_err"))
			{
				inMap.put("kiki_stc_saki_adrrm_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SAKI_ADRRM_ERR));
			}
		}
		// 対象データ.機器設置先_契約者住所差異フラグ → 機器設置先_契約者住所差異フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_ksh_ad_sai_flg_err"))
			{
				inMap.put("kiki_stc_sk_ksh_ad_sai_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG_ERR));
			}
		}
		// 対象データ.機器設置先電話番号 → 機器設置先電話番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR))
		{
			if (!inMap.containsKey("kiki_stc_sk_telno_err"))
			{
				inMap.put("kiki_stc_sk_telno_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_SK_TELNO_ERR));
			}
		}
		// 対象データ.機器設置先区画整理中フラグ → 機器設置先区画整理中フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_sts_kkk_seiri_chu_flg_err"))
			{
				inMap.put("kiki_sts_kkk_seiri_chu_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG_ERR));
			}
		}
		// 対象データ.住所未確定フラグ → 住所未確定フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.AD_MI_FIX_FLG_ERR))
		{
			if (!inMap.containsKey("ad_mi_fix_flg_err"))
			{
				inMap.put("ad_mi_fix_flg_err", template.getString(EKK0341D010CBSMsg.AD_MI_FIX_FLG_ERR));
			}
		}
		// 対象データ.機器設置先補足コード1 → 機器設置先補足コード1 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_1_err"))
			{
				inMap.put("kiki_sts_hsk_cd_1_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_1_ERR));
			}
		}
		// 対象データ.機器設置先補足コード2 → 機器設置先補足コード2 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_cd_2_err"))
			{
				inMap.put("kiki_sts_hsk_cd_2_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_CD_2_ERR));
			}
		}
		// 対象データ.機器設置先補足メモ → 機器設置先補足メモ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR))
		{
			if (!inMap.containsKey("kiki_sts_hsk_memo_err"))
			{
				inMap.put("kiki_sts_hsk_memo_err", template.getString(EKK0341D010CBSMsg.KIKI_STS_HSK_MEMO_ERR));
			}
		}
		// 対象データ.配送区分 → 配送区分 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_DIV_ERR))
		{
			if (!inMap.containsKey("haiso_div_err"))
			{
				inMap.put("haiso_div_err", template.getString(EKK0341D010CBSMsg.HAISO_DIV_ERR));
			}
		}
		// 対象データ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK0341D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}
		// 対象データ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK0341D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}
		// 対象データ.本加入年月日 → 本加入年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}
		// 対象データ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK0341D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}
		// 対象データ.保証コード → 保証コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_CD_ERR))
		{
			if (!inMap.containsKey("hosho_cd_err"))
			{
				inMap.put("hosho_cd_err", template.getString(EKK0341D010CBSMsg.HOSHO_CD_ERR));
			}
		}
		// 対象データ.保証開始年月日 → 保証開始年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR))
		{
			if (!inMap.containsKey("hosho_staymd_err"))
			{
				inMap.put("hosho_staymd_err", template.getString(EKK0341D010CBSMsg.HOSHO_STAYMD_ERR));
			}
		}
		// 対象データ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK0341D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK0341D010CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.宅内機器異動コード → 宅内機器異動コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD_ERR))
		{
			if (!inMap.containsKey("taknkiki_ido_cd_err"))
			{
				inMap.put("taknkiki_ido_cd_err", template.getString(EKK0341D010CBSMsg.TAKNKIKI_IDO_CD_ERR));
			}
		}
		// 対象データ.CASカード使用許諾年月日 → CASカード使用許諾年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR))
		{
			if (!inMap.containsKey("cas_card_use_kyodak_ymd_err"))
			{
				inMap.put("cas_card_use_kyodak_ymd_err", template.getString(EKK0341D010CBSMsg.CAS_CARD_USE_KYODAK_YMD_ERR));
			}
		}
		// 対象データ.機器付加情報コード → 機器付加情報コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD_ERR))
		{
			if (!inMap.containsKey("kiki_huka_info_cd_err"))
			{
				inMap.put("kiki_huka_info_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_HUKA_INFO_CD_ERR));
			}
		}
		// 対象データ.配送方法コード → 配送方法コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_WAY_CD_ERR))
		{
			if (!inMap.containsKey("haiso_way_cd_err"))
			{
				inMap.put("haiso_way_cd_err", template.getString(EKK0341D010CBSMsg.HAISO_WAY_CD_ERR));
			}
		}
		// 対象データ.機器移転先移動実施者識別コード → 機器移転先移動実施者識別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR))
		{
			if (!inMap.containsKey("kiki_itens_mv_jssis_skcd_err"))
			{
				inMap.put("kiki_itens_mv_jssis_skcd_err", template.getString(EKK0341D010CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD_ERR));
			}
		}
		// 対象データ.配送依頼指定年月日 → 配送依頼指定年月日 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR))
		{
			if (!inMap.containsKey("haiso_req_shitei_ymd_err"))
			{
				inMap.put("haiso_req_shitei_ymd_err", template.getString(EKK0341D010CBSMsg.HAISO_REQ_SHITEI_YMD_ERR));
			}
		}
		// 対象データ.機器送付先住所手動入力フラグ → 機器送付先住所手動入力フラグ のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_shs_ad_man_input_flg_err"))
			{
				inMap.put("kiki_shs_ad_man_input_flg_err", template.getString(EKK0341D010CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG_ERR));
			}
		}
		// 対象データ.請求契約番号 → 請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK0341D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 対象データ.料金項目コード → 料金項目コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK0341D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK0341D010CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 対象データ.機器送付先住所チェックレベル → 機器送付先住所チェックレベル のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV_ERR))
		{
			if (!inMap.containsKey("kiki_sohus_ad_chk_lv_err"))
			{
				inMap.put("kiki_sohus_ad_chk_lv_err", template.getString(EKK0341D010CBSMsg.KIKI_SOHUS_AD_CHK_LV_ERR));
			}
		}
		// 対象データ.機器設置先住所チェックレベル → 機器設置先住所チェックレベル のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV_ERR))
		{
			if (!inMap.containsKey("kiki_stc_ad_chk_lv_err"))
			{
				inMap.put("kiki_stc_ad_chk_lv_err", template.getString(EKK0341D010CBSMsg.KIKI_STC_AD_CHK_LV_ERR));
			}
		}
		// 対象データ.機器指定時管理場所識別コード → 機器指定時管理場所識別コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STI_JI_KRIPLACE_SKCD_ERR))
		{
			if (!inMap.containsKey("kiki_sti_ji_kriplace_skcd_err"))
			{
				inMap.put("kiki_sti_ji_kriplace_skcd_err", template.getString(EKK0341D010CBSMsg.KIKI_STI_JI_KRIPLACE_SKCD_ERR));
			}
		}
		// 対象データ.機器指定時工事会社コード → 機器指定時工事会社コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STI_JI_KOCOMP_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sti_ji_kocomp_cd_err"))
			{
				inMap.put("kiki_sti_ji_kocomp_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STI_JI_KOCOMP_CD_ERR));
			}
		}
		// 対象データ.機器指定時工事会社棚コード → 機器指定時工事会社棚コード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STI_JI_KOCOMP_SLF_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sti_ji_kocomp_slf_cd_err"))
			{
				inMap.put("kiki_sti_ji_kocomp_slf_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STI_JI_KOCOMP_SLF_CD_ERR));
			}
		}
		// 対象データ.機器指定時預託先オフィスコード → 機器指定時預託先オフィスコード のエラー情報返却
		if (!template.isNull(EKK0341D010CBSMsg.KIKI_STI_JI_YTKSKOF_CD_ERR))
		{
			if (!inMap.containsKey("kiki_sti_ji_ytkskof_cd_err"))
			{
				inMap.put("kiki_sti_ji_ytkskof_cd_err", template.getString(EKK0341D010CBSMsg.KIKI_STI_JI_YTKSKOF_CD_ERR));
			}
		}

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0791A010_料金コース一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0791A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0791A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿料金コースコード → ＫＥＹ＿料金コースコード のエラー情報返却
		if (!template.isNull(EKK0791A010CBSMsg.KEY_PCRS_CD_ERR))
		{
			if (!inMap.containsKey("key_pcrs_cd_err"))
			{
				inMap.put("key_pcrs_cd_err", template.getString(EKK0791A010CBSMsg.KEY_PCRS_CD_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0791A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK0791A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿予約適用年月日 → ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK0791A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(EKK0791A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811A010_機器オプションサービス契約一意照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811A010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿機器オプションサービス契約番号 → ＫＥＹ＿機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kkop_svc_kei_no_err"))
			{
				inMap.put("key_kkop_svc_kei_no_err", template.getString(EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK2811A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK2811A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿予約適用年月日 → ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK2811A010CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put("key_rsv_aply_ymd_err", template.getString(EKK2811A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081B009_同一場所サービス契約情報照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0081B009(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081B009CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

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

		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK0081B029_同一回線内訳サービス契約一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0081B029(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081B029CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		
		// 対象データ.ＫＥＹ＿回線内訳基準年月日エラー → ＫＥＹ＿回線内訳基準年月日エラー情報返却
		if (!template.isNull(EKK0081B029CBSMsg.KEY_KISUW_STDARDYMD_ERR))
		{
			if (!inMap.containsKey("key_kisuw_stdardymd_err"))
			{
				inMap.put("key_kisuw_stdardymd_err", template.getString(EKK0081B029CBSMsg.KEY_KISUW_STDARDYMD_ERR));
			}
		}
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811B010_機器オプションサービス契約一覧照会（機器提供ＳＶ）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811B010(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811B010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿機器提供サービス契約番号 → ＫＥＹ＿機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811B010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kktk_svc_kei_no_err"))
			{
				inMap.put("key_kktk_svc_kei_no_err", template.getString(EKK2811B010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿機器オプションステータス → ＫＥＹ＿機器オプションステータス のエラー情報返却
		if (!template.isNull(EKK2811B010CBSMsg.KEY_KKOP_SVC_STAT_ERR))
		{
			if (!inMap.containsKey("key_kkop_svc_stat_err"))
			{
				inMap.put("key_kkop_svc_stat_err", template.getString(EKK2811B010CBSMsg.KEY_KKOP_SVC_STAT_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿機器オプションコード → ＫＥＹ＿機器オプションコード のエラー情報返却
		if (!template.isNull(EKK2811B010CBSMsg.KEY_KKOP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("key_kkop_svc_cd_err"))
			{
				inMap.put("key_kkop_svc_cd_err", template.getString(EKK2811B010CBSMsg.KEY_KKOP_SVC_CD_ERR));
			}
		}
		// 対象データ.ＫＥＹ＿申込明細番号 → ＫＥＹ＿申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811B010CBSMsg.KEY_KKOP_SVC_STAT_ERR))
		{
			if (!inMap.containsKey("key_kkop_svc_stat_err"))
			{
				inMap.put("key_kkop_svc_stat_err", template.getString(EKK2811B010CBSMsg.KEY_KKOP_SVC_STAT_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811B012_機器オプションサービス契約履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811B012(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811B012CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿機器オプションサービス契約番号 → ＫＥＹ＿機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811B012CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_kkop_svc_kei_no_err"))
			{
				inMap.put("key_kkop_svc_kei_no_err", template.getString(EKK2811B012CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C080_機器オプションサービス停止
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.13
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C080(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C080CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C080CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C080CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止年月日 → サービス停止年月日 のエラー情報返却
		if (!template.isNull(EKK2811C080CBSMsg.SVC_STP_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_ymd_err"))
			{
				inMap.put("svc_stp_ymd_err", template.getString(EKK2811C080CBSMsg.SVC_STP_YMD_ERR));
			}
		}
		// 対象データ.サービス停止理由コード → サービス停止理由コード のエラー情報返却
		if (!template.isNull(EKK2811C080CBSMsg.SVC_STP_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rsn_cd_err"))
			{
				inMap.put("svc_stp_rsn_cd_err", template.getString(EKK2811C080CBSMsg.SVC_STP_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C080CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C080CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C080CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C080CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C090_機器オプションサービス停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.13
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C090(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C090CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C090CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C090CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止解除年月日 → サービス停止解除年月日 のエラー情報返却
		if (!template.isNull(EKK2811C090CBSMsg.SVC_STP_RLS_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_ymd_err"))
			{
				inMap.put("svc_stp_rls_ymd_err", template.getString(EKK2811C090CBSMsg.SVC_STP_RLS_YMD_ERR));
			}
		}
		// 対象データ.サービス停止解除理由コード → サービス停止解除理由コード のエラー情報返却
		if (!template.isNull(EKK2811C090CBSMsg.SVC_STP_RLS_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_rsn_cd_err"))
			{
				inMap.put("svc_stp_rls_rsn_cd_err", template.getString(EKK2811C090CBSMsg.SVC_STP_RLS_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C090CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C090CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C090CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C090CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C100_休止中機器オプションサービス停止解除
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.13
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C100(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C100CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C100CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C100CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス停止解除年月日 → サービス停止解除年月日 のエラー情報返却
		if (!template.isNull(EKK2811C100CBSMsg.SVC_STP_RLS_YMD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_ymd_err"))
			{
				inMap.put("svc_stp_rls_ymd_err", template.getString(EKK2811C100CBSMsg.SVC_STP_RLS_YMD_ERR));
			}
		}
		// 対象データ.サービス停止解除理由コード → サービス停止解除理由コード のエラー情報返却
		if (!template.isNull(EKK2811C100CBSMsg.SVC_STP_RLS_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_stp_rls_rsn_cd_err"))
			{
				inMap.put("svc_stp_rls_rsn_cd_err", template.getString(EKK2811C100CBSMsg.SVC_STP_RLS_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C100CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C100CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C100CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C100CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C110_機器オプションサービスキャンセル
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C110(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C110CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C110CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C110CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C110CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C110CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.サービスキャンセル理由コード → サービスキャンセル理由コード のエラー情報返却
		if (!template.isNull(EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD_ERR))
		{
			if (!inMap.containsKey("svc_cancel_rsn_cd_err"))
			{
				inMap.put("svc_cancel_rsn_cd_err", template.getString(EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C110CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C110CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C110CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C110CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C120_照査前機器オプションサービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C120(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C120CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C120CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C120CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C120CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C120CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C120CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C120CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C120CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C120CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C130_照査後機器オプションサービス契約キャンセル取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C130(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C120CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C130CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C130CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C130CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C130CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C130CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C130CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C130CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C130CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C140_機器オプションサービス解約
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C140(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C140CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C140CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C140CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK2811C140CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.サービス終了年月日 → サービス終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.SVC_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_endymd_err"))
			{
				inMap.put("svc_endymd_err", template.getString(EKK2811C140CBSMsg.SVC_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.SVC_CHRG_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_chrg_endymd_err"))
			{
				inMap.put("svc_chrg_endymd_err", template.getString(EKK2811C140CBSMsg.SVC_CHRG_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス解約理由コード → サービス解約理由コード のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.SVC_DLRE_CD_ERR))
		{
			if (!inMap.containsKey("svc_dlre_cd_err"))
			{
				inMap.put("svc_dlre_cd_err", template.getString(EKK2811C140CBSMsg.SVC_DLRE_CD_ERR));
			}
		}
		// 対象データ.サービス解約理由メモ → サービス解約理由メモ のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.SVC_DLRE_MEMO_ERR))
		{
			if (!inMap.containsKey("svc_dlre_memo_err"))
			{
				inMap.put("svc_dlre_memo_err", template.getString(EKK2811C140CBSMsg.SVC_DLRE_MEMO_ERR));
			}
		}
		// 対象データ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK2811C140CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C140CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C140CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 対象データ.サービス契約番号 → サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C140CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("svc_kei_no_err"))
			{
				inMap.put("svc_kei_no_err", template.getString(EKK2811C140CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C150_機器オプションサービス解約確定
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C150(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C150CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C150CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.サービス終了年月日 → サービス終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.SVC_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_endymd_err"))
			{
				inMap.put("svc_endymd_err", template.getString(EKK2811C150CBSMsg.SVC_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.SVC_CHRG_ENDYMD_ERR))
		{
			if (!inMap.containsKey("svc_chrg_endymd_err"))
			{
				inMap.put("svc_chrg_endymd_err", template.getString(EKK2811C150CBSMsg.SVC_CHRG_ENDYMD_ERR));
			}
		}
		// 対象データ.プラン課金開始年月日 → プラン課金開始年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.PLAN_CHRG_STAYMD_ERR))
		{
			if (!inMap.containsKey("plan_chrg_staymd_err"))
			{
				inMap.put("plan_chrg_staymd_err", template.getString(EKK2811C150CBSMsg.PLAN_CHRG_STAYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.PLAN_ENDYMD_ERR))
		{
			if (!inMap.containsKey("plan_endymd_err"))
			{
				inMap.put("plan_endymd_err", template.getString(EKK2811C150CBSMsg.PLAN_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス課金終了年月日 → サービス課金終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.PLAN_CHRG_ENDYMD_ERR))
		{
			if (!inMap.containsKey("plan_chrg_endymd_err"))
			{
				inMap.put("plan_chrg_endymd_err", template.getString(EKK2811C150CBSMsg.PLAN_CHRG_ENDYMD_ERR));
			}
		}
		// 対象データ.サービス解約理由コード → サービス解約理由コード のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.SVC_DLRE_CD_ERR))
		{
			if (!inMap.containsKey("svc_dlre_cd_err"))
			{
				inMap.put("svc_dlre_cd_err", template.getString(EKK2811C150CBSMsg.SVC_DLRE_CD_ERR));
			}
		}
		// 対象データ.サービス解約理由メモ → サービス解約理由メモ のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.SVC_DLRE_MEMO_ERR))
		{
			if (!inMap.containsKey("svc_dlre_memo_err"))
			{
				inMap.put("svc_dlre_memo_err", template.getString(EKK2811C150CBSMsg.SVC_DLRE_MEMO_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C150CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 対象データ.サービス課金開始年月日 → サービス課金開始年月日 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.SVC_CHRG_STAYMD_ERR))
		{
			if (!inMap.containsKey("svc_chrg_staymd_err"))
			{
				inMap.put("svc_chrg_staymd_err", template.getString(EKK2811C150CBSMsg.SVC_CHRG_STAYMD_ERR));
			}
		}
		// 対象データ.解約時課金 → 解約時課金 のエラー情報返却
		if (!template.isNull(EKK2811C150CBSMsg.DSL_JI_CHRG_ERR))
		{
			if (!inMap.containsKey("dsl_ji_chrg_err"))
			{
				inMap.put("dsl_ji_chrg_err", template.getString(EKK2811C150CBSMsg.DSL_JI_CHRG_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C180_機器オプションサービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C180(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C180CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C180CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C180CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C180CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C180CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		
		// 対象データ.回復年月日 → 回復年月日のエラー情報返却
		if (!template.isNull(EKK2811C180CBSMsg.KAIHK_YMD_ERR))
		{
			if (!inMap.containsKey("kaihk_ymd_err"))
			{
				inMap.put("kaihk_ymd_err", template.getString(EKK2811C180CBSMsg.KAIHK_YMD_ERR));
			}
		}
		
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C180CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C180CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C180CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C180CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C190_休止中機器オプションサービス契約回復
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C190(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C190CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C190CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C190CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C190CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C190CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		
		// 対象データ.回復年月日 → 回復年月日のエラー情報返却
		if (!template.isNull(EKK2811C190CBSMsg.KAIHK_YMD_ERR))
		{
			if (!inMap.containsKey("kaihk_ymd_err"))
			{
				inMap.put("kaihk_ymd_err", template.getString(EKK2811C190CBSMsg.KAIHK_YMD_ERR));
			}
		}
		
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C190CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C190CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C190CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C190CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C200_機器オプションサービス契約解約取消
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C200(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C200CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C200CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C200CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811C200CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811C200CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C200CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C200CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C200CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C200CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811D010_機器オプションサービス契約登録
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811D010(
			IRequestParameterReadWrite param, CAANMsg[] templates,
			Integer returnCode, String fixedTextGlobal)
			throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811D010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedTextGlobal);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedTextGlobal, inMap);
		}

		// 対象データ.機器オプションサービスコード → 機器オプションサービスコード のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR))
		{
			if (!inMap.containsKey("kkop_svc_cd_err"))
			{
				inMap.put("kkop_svc_cd_err", template.getString(EKK2811D010CBSMsg.KKOP_SVC_CD_ERR));
			}
		}
		// 対象データ.料金コースコード → 料金コースコード のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.PCRS_CD_ERR))
		{
			if (!inMap.containsKey("pcrs_cd_err"))
			{
				inMap.put("pcrs_cd_err", template.getString(EKK2811D010CBSMsg.PCRS_CD_ERR));
			}
		}
		// 対象データ.料金プランコード → 料金プランコード のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.PPLAN_CD_ERR))
		{
			if (!inMap.containsKey("pplan_cd_err"))
			{
				inMap.put("pplan_cd_err", template.getString(EKK2811D010CBSMsg.PPLAN_CD_ERR));
			}
		}
		// 対象データ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err"))
			{
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK2811D010CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.SYSID → SYSID のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.SYSID_ERR))
		{
			if (!inMap.containsKey("sysid_err"))
			{
				inMap.put("sysid_err", template.getString(EKK2811D010CBSMsg.SYSID_ERR));
			}
		}
		// 対象データ.申込明細番号 → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("mskm_dtl_no_err"))
			{
				inMap.put("mskm_dtl_no_err", template.getString(EKK2811D010CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 対象データ.試用加入年月日 → 試用加入年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR))
		{
			if (!inMap.containsKey("ftrial_kanyu_ymd_err"))
			{
				inMap.put("ftrial_kanyu_ymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_KANYU_YMD_ERR));
			}
		}
		// 対象データ.試用期間終了年月日 → 試用期間終了年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR))
		{
			if (!inMap.containsKey("ftrial_prd_endymd_err"))
			{
				inMap.put("ftrial_prd_endymd_err", template.getString(EKK2811D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR));
			}
		}
		// 対象データ.本加入年月日 → 本加入年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_ymd_err"))
			{
				inMap.put("honkanyu_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_YMD_ERR));
			}
		}
		// 対象データ.本加入移行期限年月日 → 本加入移行期限年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR))
		{
			if (!inMap.containsKey("honkanyu_iko_kigen_ymd_err"))
			{
				inMap.put("honkanyu_iko_kigen_ymd_err", template.getString(EKK2811D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR));
			}
		}
		// 対象データ.サービス利用開始希望年月日 → サービス利用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("svc_use_sta_kibo_ymd_err"))
			{
				inMap.put("svc_use_sta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.予約適用開始希望年月日 → 予約適用開始希望年月日 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR))
		{
			if (!inMap.containsKey("rsv_tsta_kibo_ymd_err"))
			{
				inMap.put("rsv_tsta_kibo_ymd_err", template.getString(EKK2811D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR));
			}
		}
		// 対象データ.違約金発生コード → 違約金発生コード のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR))
		{
			if (!inMap.containsKey("pnlty_hassei_cd_err"))
			{
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK2811D010CBSMsg.PNLTY_HASSEI_CD_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811D010CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.機器連帯契約変更手続中フラグ → 機器連帯契約変更手続中フラグ のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_rntai_kei_chgechu_flg_err"))
			{
				inMap.put("kiki_rntai_kei_chgechu_flg_err", template.getString(EKK2811D010CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR));
			}
		}
		// 対象データ.請求契約番号 → 請求契約番号 のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("seiky_kei_no_err"))
			{
				inMap.put("seiky_kei_no_err", template.getString(EKK2811D010CBSMsg.SEIKY_KEI_NO_ERR));
			}
		}
		// 対象データ.料金項目コード → 料金項目コード のエラー情報返却
		if (!template.isNull(EKK2811D010CBSMsg.PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("prc_kmk_cd_err"))
			{
				inMap.put("prc_kmk_cd_err", template.getString(EKK2811D010CBSMsg.PRC_KMK_CD_ERR));
			}
		}
		// TODO ModelのEKK2811D010CBSMsgが改修されてUPD_DTM_BFが利用可能になったら非コメント化する
//		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
//		if (!template.isNull(EKK2811D010CBSMsg.UPD_DTM_BF_ERR))
//		{
//			if (!inMap.containsKey("upd_dtm_bf_err"))
//			{
//				inMap.put("upd_dtm_bf_err", template.getString(EKK2811D010CBSMsg.UPD_DTM_BF_ERR));
//			}
//		}
		return param;
	}

	/**
	 *<DL>
	 *<DT>EZM0411B030_宅内機器型式一覧照会（保有ルーターコード）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEZM0411B030(IRequestParameterReadWrite param, CAANMsg[] templates,
			int returnCode, String fixedText) throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EZM0411B030CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap inMap = null;

		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

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

		// 対象データ.ＫＥＹ＿保有ルーター種別コード → ＫＥＹ＿保有ルーター種別コード のエラー情報返却
		if (!template.isNull(EZM0411B030CBSMsg.KEY_HOYU_ROUTER_CD_ERR))
		{
			if (!inMap.containsKey("key_hoyu_router_cd_err"))
			{
				inMap.put("key_hoyu_router_cd_err", template.getString(EZM0411B030CBSMsg.KEY_HOYU_ROUTER_CD_ERR));
			}
		}
		return param;

	}
	
	// IT2-2013-00000853 2013/12/18 STRAT
	/**
	 * EKK0341C050_機器提供サービス契約照査
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C050(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String kikiNinshoId,
			String kikiNinshoIdPwd,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C050CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C050CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C050CBSMsg.TEMPLATEID, "EKK2811C050");

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

		// 機器提供サービス契約番号
		template.set(EKK2811C050CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 異動区分
		template.set(EKK2811C050CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C050CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	// IT2-2013-0000858 2013/12/21 START
	/**
	 * EKK0341C050_機器提供サービス契約照査
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C250(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String idoDiv,
			String tgRsv_aply_ymd,
			String tgMskmDtlNo,
			String chgPrcsCd,
			String chgPplanCd,
			String pnltyhasseiCd,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C250CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C250CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C250CBSMsg.TEMPLATEID, "EKK2811C250");

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

		// 機器提供サービス契約番号
		template.set(EKK2811C250CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 異動区分
		template.set(EKK2811C250CBSMsg.IDO_DIV, idoDiv);
		
		// 予約適用年月日
		template.set(EKK2811C250CBSMsg.RSV_APLY_YMD, tgRsv_aply_ymd);
		
		// 申込明細番号
		template.set(EKK2811C250CBSMsg.MSKM_DTL_NO, tgMskmDtlNo);
		
		// 料金コースコード
		template.set(EKK2811C250CBSMsg.PCRS_CD, chgPrcsCd);
		
		// 料金プランコード
		template.set(EKK2811C250CBSMsg.PPLAN_CD, chgPplanCd);
		
		// 違約金発生コード
		template.set(EKK2811C250CBSMsg.PNLTY_HASSEI_CD, pnltyhasseiCd);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C250CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	/**
	 * EKK0341C050_機器提供サービス契約照査
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C260(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String idoDiv,
			String tgRsv_aply_ymd,
			String tgMskmDtlNo,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C260CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C260CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C260CBSMsg.TEMPLATEID, "EKK2811C260");

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

		// 機器提供サービス契約番号
		template.set(EKK2811C260CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 異動区分
		template.set(EKK2811C260CBSMsg.IDO_DIV, idoDiv);
		
		// 予約適用年月日
		template.set(EKK2811C260CBSMsg.RSV_APLY_YMD, tgRsv_aply_ymd);
		
		// 申込明細番号
		template.set(EKK2811C260CBSMsg.MSKM_DTL_NO, tgMskmDtlNo);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C260CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	// IT2-2013-0000858 2013/12/21 END
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器オプションサービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C050(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C050CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器提供オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C050CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C050CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C050CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C050CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C050CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C050CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}
	
	//IT2-2013-0000858 2013/12/21 START 
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器オプションサービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C250(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C250CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器提供オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C250CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C250CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 異動区分エラー情報
		if (!template.isNull(EKK2811C250CBSMsg.IDO_DIV_ERR)) {
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK2811C250CBSMsg.IDO_DIV_ERR));
			}
		}
		// 予約年月日エラー情報
		if (!template.isNull(EKK2811C250CBSMsg.RSV_APLY_YMD_ERR)) {
			if (!inMap.containsKey("rsv_aply_ymd_err")) {
				inMap.put("rsv_aply_ymd_err", template.getString(EKK2811C250CBSMsg.RSV_APLY_YMD_ERR));
			}
		}
		
		// 申込明細番号エラー情報
		if (!template.isNull(EKK2811C250CBSMsg.MSKM_DTL_NO_ERR)) {
			if (!inMap.containsKey("mskm_dtl_no_err")) {
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C340CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 料金コースエラー情報
		if (!template.isNull(EKK2811C250CBSMsg.PCRS_CD_ERR)) {
			if (!inMap.containsKey("pcrs_cd_err")) {
				inMap.put("pcrs_cd_err", template.getString(EKK2811C250CBSMsg.PCRS_CD_ERR));
			}
		}
		// 料金プランエラー情報
		if (!template.isNull(EKK2811C250CBSMsg.PPLAN_CD_ERR)) {
			if (!inMap.containsKey("pplan_cd_err")) {
				inMap.put("pplan_cd_err", template.getString(EKK2811C250CBSMsg.PPLAN_CD_ERR));
			}
		}
		// 違約金発生コードエラー情報
		if (!template.isNull(EKK2811C250CBSMsg.PNLTY_HASSEI_CD)) {
			if (!inMap.containsKey("pnlty_hassei_cd_err")) {
				inMap.put("pnlty_hassei_cd_err", template.getString(EKK2811C250CBSMsg.PNLTY_HASSEI_CD));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C250CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C250CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器オプションサービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C260(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C260CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器提供オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C260CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C260CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 予約年月日エラー情報
		if (!template.isNull(EKK2811C260CBSMsg.RSV_APLY_YMD_ERR)) {
			if (!inMap.containsKey("rsv_aply_ymd_err")) {
				inMap.put("rsv_aply_ymd_err", template.getString(EKK2811C260CBSMsg.RSV_APLY_YMD_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C260CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C260CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}
	//IT2-2013-0000858 2013/12/21 END
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C050(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C050(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	// IT2-2013-0000858 2013/12/21 START
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C250_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C250(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C250(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C260(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C260(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	// IT2-2013-0000858 2013/12/21 END

	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C030_機器提供サービス契約照査
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C030(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C030(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C030_機器オプションサービス契約照査
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C030(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C030CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器提供オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C030CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C030CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C030CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C030CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.照査解約完了コード → 照査解約完了コード のエラー情報返却
		if (!template.isNull(EKK2811C030CBSMsg.SHOSA_DSL_FIN_CD_ERR))
		{
			if (!inMap.containsKey("shosa_dsl_fin_cd_err"))
			{
				inMap.put("shosa_dsl_fin_cd_err", template.getString(EKK2811C030CBSMsg.SHOSA_DSL_FIN_CD_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C030CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C030CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}
	
	/**
	 * EKK0341C030_機器提供サービス契約照査
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C030(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String kikiNinshoId,
			String kikiNinshoIdPwd,
			String idoDiv,
			String shosaDslFinCd,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C030CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C030CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C030CBSMsg.TEMPLATEID, "EKK2811C030");

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

		// 機器提供サービス契約番号
		template.set(EKK2811C030CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);

		// 異動区分
		template.set(EKK2811C030CBSMsg.IDO_DIV, idoDiv);

		// 照査解約完了コード
		if (null != shosaDslFinCd && !"".equals(shosaDslFinCd))
		{
			template.set(EKK2811C030CBSMsg.SHOSA_DSL_FIN_CD, shosaDslFinCd);
		}

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C030CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	// IT2-2013-00000853 2013/12/18 END
	

	/**
	 * 条件部の共通する項目の設定する
	 * 
	 * @param param リクエストパラメータ
	 * @param template template 条件の設定先
	 * @throws RequestParameterException
	 */
	private void editInMsgBasicCmn(IRequestParameterReadOnly param, CAANMsg template)
	throws RequestParameterException
	{
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
	}
	
	/**
	 * サービスI/F実行用の上り情報を生成する
	 * 
	 * @param param リクエストパラメータ
	 * @param template 条件の設定先
	 * @return S/I上り情報
	 * @throws RequestParameterException
	 * @exception RequestParameterExceptionがスローされます
	 *                。
	 */
	private HashMap<String, Object> editInMsgCmn(IRequestParameterReadOnly param, CAANMsg template)
	throws RequestParameterException 
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

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

		return paramMap;

	}

	/**
	 * 持ちうるフィールドにNullマッピングで埋める
	 * 
	 * @param msg 対象クラス
	 * @param contents 対応クラスのフィールド列挙
	 */
	private void fillCAANMSGNullMapping(CAANMsg msg, Object[][] contents)
	{
		
		// 要素ごとのループ
		for(int i = 0 ; i < contents.length ; i++)
		{
			
			Object element = null;
			
			// キーに該当する箇所の取得
			element = contents[i][0];

			// Nullでマッピング
			msg.setNull((String)element);
			
		}
		
	}

	// OM-2014-0000652 2014/02/15 ADD START
	/**
	 * EKK2811C290_機器オプションサービス契約情報変更
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiNinshoId 機器認証ID
	 * @param kikiNinshoIdPwd 機器認証IDパスワード
	 * @param idoDiv 異動区分
	 * @param shosaDslFinCd 照査解約完了コード
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C290(
			IRequestParameterReadWrite param,
			String kkopSvcKeiNo,
			String kikiRntaiKeiChgechuFlg,
			String idoDiv,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C290CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK2811C290CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK2811C290CBSMsg.TEMPLATEID, "EKK2811C290");

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

		// 機器提供サービス契約番号
		template.set(EKK2811C290CBSMsg.KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		
		// 機器連帯契約変更手続中フラグ
		template.set(EKK2811C290CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG, kikiRntaiKeiChgechuFlg);

		// 異動区分
		template.set(EKK2811C290CBSMsg.IDO_DIV, idoDiv);

		// 更新年月日時分秒(更新前)
		template.set(EKK2811C290CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C00(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C050(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器提供サービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C290(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C290(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C050_機器オプションサービス契約照査締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C290(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C290CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.機器オプションサービス契約番号 → 機器提供オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C290CBSMsg.KKOP_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err"))
			{
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C290CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		
		// 対象データ.機器連帯契約変更手続中フラグエラー → 機器連帯契約変更手続中フラグエラー のエラー情報返却
		if (!template.isNull(EKK2811C290CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR))
		{
			if (!inMap.containsKey("kiki_rntai_kei_chgechu_flg_err"))
			{
				inMap.put("kiki_rntai_kei_chgechu_flg_err", template.getString(EKK2811C290CBSMsg.KIKI_RNTAI_KEI_CHGECHU_FLG_ERR));
			}
		}
		
		// 対象データ.異動区分 → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C290CBSMsg.IDO_DIV_ERR))
		{
			if (!inMap.containsKey("ido_div_err"))
			{
				inMap.put("ido_div_err", template.getString(EKK2811C290CBSMsg.IDO_DIV_ERR));
			}
		}
		// 対象データ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C290CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey("upd_dtm_bf_err"))
			{
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C290CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		return param;
	}
	// OM-2014-0000652 2014/02/15 ADD END
	// OM-2014-0001770 2015/05/05 ADD START
	/**
	 * EKK0341B025_機器提供サービス契約履歴一覧照会
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param svcKeiNo サービス契約番号
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341B025(
			IRequestParameterReadWrite param, String svcKeiNo) 
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B025CBSMsg.class.getName());
		
		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341B025CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341B025CBSMsg.TEMPLATEID, "EKK0341B025");

		template.set(EKK0341B025CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0341B025CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK0341B025_機器提供サービス契約履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341B025(Map<?, ?> result,
			IRequestParameterReadWrite param, String fixedTextGlobal) throws Throwable 
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);

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

        // エラー情報の設定
        param = editErrorInfoEKK0341B025(param, templates, (Integer)return_code, fixedTextGlobal);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK0341B025_機器提供サービス契約履歴一覧照会
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341B025(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341B025CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 対象データ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341B025CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put("key_svc_kei_no_err", template.getString(EKK0341B025CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	// OM-2014-0001770 2015/05/05 ADD END

	// OM-2014-0001693 ネットのコース変更後に交換機器引渡画面で宅内S連携エラーとなる 2014/05/14 START
	/**
	 * EKK0341C450_機器設置先場所反映<br>
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする<br>
	 * <br>
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param kikiStcSakiPlaceNo 機器設置先場所番号
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C450(
			IRequestParameterReadWrite param,
			String kktkSvcKeiNo,
			String kikiStcSakiPlaceNo,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C450CBSMsg.class.getName());

		// nullマッピングを実施
		fillCAANMSGNullMapping(template, new EKK0341C450CBSMsg().getContents());

		// 共通部を設定
		editInMsgBasicCmn(param, template);

		// テンプレートID(SIFのID)
		template.set(EKK0341C450CBSMsg.TEMPLATEID, "EKK0341C450");

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

		// 機器提供サービス契約番号
		template.set(EKK0341C450CBSMsg.KKTK_SVC_KEI_NO, kktkSvcKeiNo);

		// 機器設置先場所番号
		template.set(EKK0341C450CBSMsg.KIKI_STC_SAKI_PLACE_NO, kikiStcSakiPlaceNo);

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C450CBSMsg.UPD_DTM_BF, updDtmBf);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	// OM-2014-0001693 ネットのコース変更後に交換機器引渡画面で宅内S連携エラーとなる 2014/05/14 END

	// OM-2014-0001693 ネットのコース変更後に交換機器引渡画面で宅内S連携エラーとなる 2014/05/14 START
	// サービスIFごとの処理結果・エラー情報マッピング処理は冗長なので、他のマッピングクラスと同様にeditResultRPにまとめる。
	// ※サービスIFの呼び出しを追加する場合は使用してください。（既存のサービスIFについてはそのまま）
	/** 
	 * --------------------------------------------------------------------------------------------
	 * 
	 * エラーマッピング処理 START 
	 * 
	 * --------------------------------------------------------------------------------------------
	 */
	/**
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 * 
	 * @param msgList CAANMsgクラス
	 * @param param 業務データ取得・書込用I/F
	 * @param fixedText ユーザ任意文字列
	 * @param contents サービスインターフェースのテンプレート項目の配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRP(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			Object[][] contents) 
			throws Throwable 
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// ステータス取得
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_"
				+ String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

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

		// ユーザデータ情報にエラー情報をマッピング
		for(int i = 0 ; contents != null && i < contents.length ; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inMap.containsKey(element))
					{
						inMap.put(element, template.getString(element));
					}
				}
			}
		}

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return param;
	}
	/** 
	 * --------------------------------------------------------------------------------------------
	 * 
	 * エラーマッピング処理 END 
	 * 
	 * --------------------------------------------------------------------------------------------
	 */
	// OM-2014-0001693 ネットのコース変更後に交換機器引渡画面で宅内S連携エラーとなる 2014/05/14 END
// ▽▽▽ ANK-3412-00-00 ADD START
	/**
	 * EKK0341D010_機器提供サービス契約変更
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param eck0011a010Info お客様情報
	 * @param ekk0241b001Info サービス契約回線内訳情報
	 * @param ekk0321b005Info 課金先一覧情報
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C530(
			IRequestParameterReadWrite param,
			CAANMsg ekk0341a010Info, 
			HashMap<String, Object> kkopKeiUpdMap,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C530CBSMsg.class.getName());

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

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

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

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

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

		// 機器提供サービス契約番号
		template.set(EKK0341C530CBSMsg.KKTK_SVC_KEI_NO, ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));

		// 宅内機器型式コード
		template.set(EKK0341C530CBSMsg.TAKNKIKI_MODEL_CD,  "");

		// 申込明細番号
		template.set(EKK0341C530CBSMsg.MSKM_DTL_NO, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_MSKM_DTL_NO));

		// 予約適用年月日
		template.set(EKK0341C530CBSMsg.RSV_APLY_YMD, "20991231");

		// 予約適用コード
		template.set(EKK0341C530CBSMsg.RSV_APLY_CD, "1");

		// 更新年月日時分秒(更新前)
		template.set(EKK0341C530CBSMsg.UPD_DTM_BF, updDtmBf);

		// 異動区分
		template.set(EKK0341C530CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));

		// 宅内機器セット品型コード
		template.set(EKK0341C530CBSMsg.TAKNKIKI_SETHIN_MODEL_CD, "");

		// 機器変更理由コード
// ▽▽▽ OM-2019-0000362 Modify START
//		template.set(EKK0341C530CBSMsg.KIKI_CHG_RSN_CD, "30");
		template.set(EKK0341C530CBSMsg.KIKI_CHG_RSN_CD, "");
// △△△ OM-2019-0000362 Modify END

		// 新機器使用開始希望年月日	
		template.set(EKK0341C530CBSMsg.NEW_KIKI_USE_STA_KIBO_YMD, "");
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
// ▲▲▲ ANK-3412-00-00 ADD END
// ▽▽▽ IT1-2018-0000226 ADD START
	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C530_機器提供サービス契約機器変更手続開始
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C530(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C530(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C231_機器提供サービス契約情報変更（契約変更中）
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C231(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C231(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	/**
	 * EKK0341C231_機器提供サービス契約情報変更（契約変更中）
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param eck0011a010Info お客様情報
	 * @param ekk0241b001Info サービス契約回線内訳情報
	 * @param ekk0321b005Info 課金先一覧情報
	 * @param kkopKeiUpdMap 機器オプションサービス契約更新マップ
	 * @param geneAddDtm 世代登録年月日（予約）
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C231(
			IRequestParameterReadWrite param,
			CAANMsg ekk0341a010Info, 
// ▽▽▽ OM-2019-0000362 ADD START
			CAANMsg eck0011a010Info, 
			CAANMsg ekk0241b001Info, 
// △△△ OM-2019-0000362 ADD END
			HashMap<String, Object> kkopKeiUpdMap,
			String geneAddDtm,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C231CBSMsg.class.getName());

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

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

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

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

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

		// 機器提供サービス契約番号
		template.set(EKK0341C231CBSMsg.KKTK_SVC_KEI_NO,            ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));
		// 世代登録年月日時分秒
		template.set(EKK0341C231CBSMsg.GENE_ADD_DTM,               geneAddDtm);
		// 機器提供種別コード
		template.set(EKK0341C231CBSMsg.KKTK_SBT_CD,                ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KKTK_SBT_CD));
		// 販売種別コード
		template.set(EKK0341C231CBSMsg.HAMBAI_SBT_CD,              ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HAMBAI_SBT_CD));
		// 宅内機器型式コード
		template.setNull(EKK0341C231CBSMsg.TAKNKIKI_MODEL_CD);
		// 機器製造番号
		template.setNull(EKK0341C231CBSMsg.KIKI_SEIZO_NO);
		// ＨＤＤ容量コード
		template.set(EKK0341C231CBSMsg.HDD_CAPA_CD,                ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HDD_CAPA_CD));
		// 通信機器セットコード
		template.set(EKK0341C231CBSMsg.TSUSHIN_KIKI_SET_CD,        ekk0341a010Info.getString(EKK0341A010CBSMsg1List.TSUSHIN_KIKI_SET_CD));
		// リンクＳＴＢフラグ
		template.set(EKK0341C231CBSMsg.LINK_STB_FLG,               ekk0341a010Info.getString(EKK0341A010CBSMsg1List.LINK_STB_FLG));
		// 機器引当指定倉庫コード
		template.set(EKK0341C231CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD,   "000001");
		// 機器引当指定倉庫棚コード
		template.set(EKK0341C231CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD,   "000");
		// 機器送料有無
		template.setNull(EKK0341C231CBSMsg.KIKI_SORYO_UM);
// ▽▽▽ OM-2019-0000362 Modify START
//		// 機器送付先名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_NM,              ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_NM));
//		// 機器送付先カナ名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_KANA,            ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_KANA));
//		// 機器送付先住所コード
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_AD_CD,           ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_AD_CD));
//		// 機器送付先郵便番号
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_PCD,             ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_PCD));
//		// 機器送付先都道府県名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_STATE_NM,        ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_STATE_NM));
//		// 機器送付先市区町村名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_CITY_NM,         ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_CITY_NM));
//		// 機器送付先大字通称名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_OAZTSU_NM,       ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_OAZTSU_NM));
//		// 機器送付先字丁目名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_AZCHO_NM,        ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_AZCHO_NM));
//		// 機器送付先番地号
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_BNCHIGO,         ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_BNCHIGO));
//		// 機器送付先住所補記・建物名
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_ADRTTM,          ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_ADRTTM));
//		// 機器送付先住所補記・部屋番号
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_ADRRM,           ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_ADRRM));
//		// 機器送付先電話番号
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_TELNO,           ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_TELNO));
//		// 機器送付先_契約者住所差異フラグ
//		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG,  ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_KSH_AD_SAI_FLG));
//		// 機器送付先個別指定フラグ
//		template.set(EKK0341C231CBSMsg.KIKI_SHS_KBT_SHITEI_FLG,    ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SHS_KBT_SHITEI_FLG));
//		// 住所未確定フラグ
//		template.set(EKK0341C231CBSMsg.AD_MI_FIX_FLG,              ekk0341a010Info.getString(EKK0341A010CBSMsg1List.AD_MI_FIX_FLG));

		// 機器送付先名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_NM, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_NM));
		// 機器送付先カナ名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_KANA, eck0011a010Info.getString(ECK0011A010CBSMsg1List.CUST_KANA));
		// 機器送付先住所コード★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_AD_CD, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AD_CD));
		// 機器送付先郵便番号★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_PCD, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_PCD));
		// 機器送付先都道府県名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_STATE_NM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_STATE_NM));
		// 機器送付先市区町村名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_CITY_NM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_CITY_NM));
		// 機器送付先大字通称名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_OAZTSU_NM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_OAZTSU_NM));
		// 機器送付先字丁目名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_AZCHO_NM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_AZCHO_NM));
		// 機器送付先番地号★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_BNCHIGO, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_BNCHIGO));
		// 機器送付先住所補記・建物名★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_ADRTTM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRTTM));
		// 機器送付先住所補記・部屋番号★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_ADRRM, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_ADRRM));
		// 機器送付先電話番号★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_TELNO, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLACE_TELNO));
		// 機器送付先_契約者住所差異フラグ★
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KAISEN_PLC_KSH_AD_SAI_FLG));
		// 機器送付先個別指定フラグ★
		template.set(EKK0341C231CBSMsg.KIKI_SHS_KBT_SHITEI_FLG, "1");
		// 機器送付先住所手動入力フラグ	★
		template.set(EKK0341C231CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG, "0");
		// 住所未確定フラグ★
		template.set(EKK0341D010CBSMsg.AD_MI_FIX_FLG, ekk0241b001Info.getString(EKK0241B001CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG));

// △△△ OM-2019-0000362 Modify END
		// 配送区分
		template.set(EKK0341C231CBSMsg.HAISO_DIV,                  "00");
		// 試用加入年月日
		template.set(EKK0341C231CBSMsg.FTRIAL_KANYU_YMD,           ekk0341a010Info.getString(EKK0341A010CBSMsg1List.FTRIAL_KANYU_YMD));
		// 試用期間終了年月日
		template.set(EKK0341C231CBSMsg.FTRIAL_PRD_ENDYMD,          ekk0341a010Info.getString(EKK0341A010CBSMsg1List.FTRIAL_PRD_ENDYMD));
		// 本加入年月日
		template.set(EKK0341C231CBSMsg.HONKANYU_YMD,               ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HONKANYU_YMD));
		// 本加入移行期限年月日
		template.set(EKK0341C231CBSMsg.HONKANYU_IKO_KIGEN_YMD,     ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD));
		// 保証コード
		template.set(EKK0341C231CBSMsg.HOSHO_CD,                   ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HOSHO_CD));
		// 違約金発生コード
		template.setNull(EKK0341C231CBSMsg.PNLTY_HASSEI_CD);
		// 異動区分
		template.set(EKK0341C231CBSMsg.IDO_DIV,                    (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));
		// ＣＡＳカード使用許諾年月日
		template.set(EKK0341C231CBSMsg.CAS_CARD_USE_KYODAK_YMD,    ekk0341a010Info.getString(EKK0341A010CBSMsg1List.CAS_CARD_USE_KYODAK_YMD));
		// 機器付加情報コード
		template.setNull(EKK0341C231CBSMsg.KIKI_HUKA_INFO_CD);
		// 配送方法コード
// ▽▽▽ OM-2019-0000362 Modify START
//		template.set(EKK0341C231CBSMsg.HAISO_WAY_CD,               ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HAISO_WAY_CD));
		template.setNull(EKK0341C231CBSMsg.HAISO_WAY_CD);
// △△△ OM-2019-0000362 Modify END
		// 配送依頼指定年月日
// ▽▽▽ OM-2019-0000362 Modify START
//		template.set(EKK0341C231CBSMsg.HAISO_REQ_SHITEI_YMD,       ekk0341a010Info.getString(EKK0341A010CBSMsg1List.HAISO_REQ_SHITEI_YMD));
		template.setNull(EKK0341C231CBSMsg.HAISO_REQ_SHITEI_YMD);
// △△△ OM-2019-0000362 Modify END
		// 更新年月日時分秒(更新前)
		template.set(EKK0341C231CBSMsg.UPD_DTM_BF,                 updDtmBf);
		// 機器送付先住所手動入力フラグ
		template.set(EKK0341C231CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG,  ekk0341a010Info.getString(EKK0341A010CBSMsg1List.KIKI_SHS_AD_MAN_INPUT_FLG));
		// 機器送付先住所チェックレベル
		template.set(EKK0341C231CBSMsg.KIKI_SOHUS_AD_CHK_LV,       "1");
		// 宅内機器異動コード
		template.setNull(EKK0341C231CBSMsg.TAKNKIKI_IDO_CD);
		
		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	/**
	 * EKK0341C530_機器提供サービス契約機器変更手続開始 エラー情報取得
	 * @param param リクエストパラメータ
	 * @param templates SIF実行結果
	 * @param returnCode リターンコード
	 * @param fixedText 固定文字
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C530(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C530CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 作業項目リスト.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C530CBSMsg.KKTK_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err")) {
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C530CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 作業項目リスト.更新年月日時分秒（機器提供サービス契約） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C530CBSMsg.UPD_DTM_BF_ERR)) 
		{
			if (!inMap.containsKey("upd_dtm_kktk_svc_kei_err")) {
				inMap.put("upd_dtm_kktk_svc_kei_err", template.getString(EKK0341C530CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 作業項目リスト.申込明細番号（機器提供サービス契約） → 申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0341C530CBSMsg.MSKM_DTL_NO_ERR)) 
		{
			if (!inMap.containsKey("mskm_dtl_no_err")) {
				inMap.put("mskm_dtl_no_err", template.getString(EKK0341C530CBSMsg.MSKM_DTL_NO_ERR));
			}
		}
		// 作業項目リスト.異動区分（機器提供サービス契約） → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C530CBSMsg.IDO_DIV_ERR)) 
		{
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK0341C530CBSMsg.IDO_DIV_ERR));
			}
		}

		return param;
	}
	/**
	 * EKK0341C231_機器提供サービス契約情報変更（契約変更中）エラー情報取得
	 * @param param リクエストパラメータ
	 * @param templates SIF実行結果
	 * @param returnCode リターンコード
	 * @param fixedText 固定文字
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C231(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C231CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 作業項目リスト.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C231CBSMsg.KKTK_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err")) {
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C231CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 作業項目リスト.登録年月日時分秒 → 登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0341C231CBSMsg.GENE_ADD_DTM_ERR)) 
		{
			if (!inMap.containsKey("gene_add_dtm_err")) {
				inMap.put("gene_add_dtm_err", template.getString(EKK0341C231CBSMsg.GENE_ADD_DTM_ERR));
			}
		}
		// 作業項目リスト.更新年月日時分秒（機器提供サービス契約） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C231CBSMsg.UPD_DTM_BF_ERR)) 
		{
			if (!inMap.containsKey("upd_dtm_kktk_svc_kei_err")) {
				inMap.put("upd_dtm_kktk_svc_kei_err", template.getString(EKK0341C231CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 作業項目リスト.異動区分（機器提供サービス契約） → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C231CBSMsg.IDO_DIV_ERR)) 
		{
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK0341C231CBSMsg.IDO_DIV_ERR));
			}
		}

		return param;
	}
// ▲▲▲ IT1-2018-0000226 ADD START
// ▽▽▽ ANK-3412-15-00 ADD START
	/**
	 * EKK0341C110_機器提供サービス契約機器設置完了
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * <p>
	 * @param param リクエストパラメータ
	 * @param ekk0341a010 機器提供サービス一意照会
	 * @param svcStaYmd サービス開始日
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK0341C110(
			IRequestParameterReadWrite param, 
			CAANMsg ekk0341a010,
			HashMap<String, Object> kkopKeiUpdMap,
			String svcStaYmd,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C110CBSMsg.class.getName());

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

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

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

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

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

		// 機器提供サービス契約番号	kktk_svc_kei_no
		template.set(EKK0341C110CBSMsg.KKTK_SVC_KEI_NO, ekk0341a010.getString(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));

		// 機器製造番号	kiki_seizo_no
		template.set(EKK0341C110CBSMsg.KIKI_SEIZO_NO, ekk0341a010.getString(EKK0341A010CBSMsg1List.KIKI_SEIZO_NO));

		// 宅内機器型式コード	taknkiki_model_cd
		template.set(EKK0341C110CBSMsg.TAKNKIKI_MODEL_CD, ekk0341a010.getString(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD));

		// 付属品型式コード	huzokuhin_model_cd
		template.set(EKK0341C110CBSMsg.HUZOKUHIN_MODEL_CD, ekk0341a010.getString(EKK0341A010CBSMsg1List.HUZOKUHIN_MODEL_CD));

		// 保証開始年月日	hosho_staymd
		template.set(EKK0341C110CBSMsg.HOSHO_STAYMD, ekk0341a010.getString(EKK0341A010CBSMsg1List.HOSHO_STAYMD));
		
		// サービス開始年月日	svc_sta_ymd
		template.set(EKK0341C110CBSMsg.SVC_STA_YMD, svcStaYmd);

		// サービス課金開始年月日	svc_chrg_staymd
		template.set(EKK0341C110CBSMsg.SVC_CHRG_STAYMD, "");
		
		// 異動区分	ido_div
		template.set(EKK0341C110CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));
		
		// 更新年月日時分秒(更新前)	upd_dtm_bf
		template.set(EKK0341C110CBSMsg.UPD_DTM_BF, updDtmBf);

		// 即時/翌月	skj_ykjt
		template.set(EKK0341C110CBSMsg.SKJ_YKJT,  "01");
		
		// サービス開始起算年月日	svc_sta_kisan_ymd
		template.set(EKK0341C110CBSMsg.SVC_STA_KISAN_YMD,  svcStaYmd);

		// 上り情報を生成
		return editInMsgCmn(param, template);
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK0341C110_機器提供サービス契約機器設置完了
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK0341C110(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK0341C110(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 * EKK0341C110_機器提供サービス契約機器設置完了エラー情報取得
	 * @param param リクエストパラメータ
	 * @param templates SIF実行結果
	 * @param returnCode リターンコード
	 * @param fixedText 固定文字
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0341C110(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0341C110CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 作業項目リスト.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.KKTK_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey("kktk_svc_kei_no_err")) {
				inMap.put("kktk_svc_kei_no_err", template.getString(EKK0341C110CBSMsg.KKTK_SVC_KEI_NO_ERR));
			}
		}
		// 作業項目リスト.更新年月日時分秒（機器提供サービス契約） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.UPD_DTM_BF_ERR)) 
		{
			if (!inMap.containsKey("upd_dtm_kktk_svc_kei_err")) {
				inMap.put("upd_dtm_kktk_svc_kei_err", template.getString(EKK0341C110CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 作業項目リスト.異動区分（機器提供サービス契約） → 異動区分 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.IDO_DIV_ERR)) 
		{
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK0341C110CBSMsg.IDO_DIV_ERR));
			}
		}
		
		// 作業項目リスト.機器製造番号 → 機器製造番号 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.KIKI_SEIZO_NO_ERR)) 
		{
			if (!inMap.containsKey("kiki_seizo_no_err")) {
				inMap.put("kiki_seizo_no_err", template.getString(EKK0341C110CBSMsg.KIKI_SEIZO_NO_ERR));
			}
		}
		
		// 作業項目リスト.宅内機器型式コード → 宅内機器型式コード のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.TAKNKIKI_MODEL_CD_ERR)) 
		{
			if (!inMap.containsKey("taknkiki_model_cd_err")) {
				inMap.put("taknkiki_model_cd_err", template.getString(EKK0341C110CBSMsg.TAKNKIKI_MODEL_CD_ERR));
			}
		}
		
		// 作業項目リスト.付属品型式コード → 付属品型式コード のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.HUZOKUHIN_MODEL_CD_ERR)) 
		{
			if (!inMap.containsKey("huzokuhin_model_cd_err")) {
				inMap.put("huzokuhin_model_cd_err", template.getString(EKK0341C110CBSMsg.HUZOKUHIN_MODEL_CD_ERR));
			}
		}
		
		// 作業項目リスト.保証開始年月日 → 保証開始年月日 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.HOSHO_STAYMD_ERR)) 
		{
			if (!inMap.containsKey("hosho_staymd_err")) {
				inMap.put("hosho_staymd_err", template.getString(EKK0341C110CBSMsg.HOSHO_STAYMD_ERR));
			}
		}
		
		// 作業項目リスト.サービス開始年月日 → サービス開始年月日 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.SVC_STA_YMD_ERR)) 
		{
			if (!inMap.containsKey("svc_sta_ymd_err")) {
				inMap.put("svc_sta_ymd_err", template.getString(EKK0341C110CBSMsg.SVC_STA_YMD_ERR));
			}
		}
		
		// 作業項目リスト.サービス課金開始年月日 → サービス課金開始年月日 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.SVC_CHRG_STAYMD_ERR)) 
		{
			if (!inMap.containsKey("svc_chrg_staymd_err")) {
				inMap.put("svc_chrg_staymd_err", template.getString(EKK0341C110CBSMsg.SVC_CHRG_STAYMD_ERR));
			}
		}
		
		// 作業項目リスト.即時/翌月 → 即時/翌月 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.SKJ_YKJT_ERR)) 
		{
			if (!inMap.containsKey("skj_ykjt_err")) {
				inMap.put("skj_ykjt_err", template.getString(EKK0341C110CBSMsg.SKJ_YKJT_ERR));
			}
		}
		
		// 作業項目リスト.サービス開始起算年月日 → サービス開始起算年月日 のエラー情報返却
		if (!template.isNull(EKK0341C110CBSMsg.SVC_STA_KISAN_YMD_ERR)) 
		{
			if (!inMap.containsKey("svc_sta_kisan_ymd_err")) {
				inMap.put("svc_sta_kisan_ymd_err", template.getString(EKK0341C110CBSMsg.SVC_STA_KISAN_YMD_ERR));
			}
		}

		return param;
	}
	
	/**
	 * EKK2811C040_機器オプションサービス契約締結
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * <p>
	 * @param param リクエストパラメータ
	 * @param ekk2811a010 機器オプションサービス一意照会
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C040(
			IRequestParameterReadWrite param, 
			CAANMsg ekk2811a010,
			HashMap<String, Object> kkopKeiUpdMap,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C040CBSMsg.class.getName());

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

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

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

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

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

		// 機器オプションサービス契約番号	kkop_svc_kei_no
		template.set(EKK2811C040CBSMsg.KKOP_SVC_KEI_NO, ekk2811a010.getString(EKK2811A010CBSMsg1List.KKOP_SVC_KEI_NO));

		// 異動区分	ido_div
		template.set(EKK2811C040CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));
		
		// 更新年月日時分秒(更新前)	upd_dtm_bf
		template.set(EKK2811C040CBSMsg.UPD_DTM_BF, updDtmBf);
		
		// 上り情報を生成
		return editInMsgCmn(param, template);

	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C040_機器オプションサービス契約締結
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C040(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C040(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 * EKK2811C040_機器オプションサービス契約締結エラー情報取得
	 * @param param リクエストパラメータ
	 * @param templates SIF実行結果
	 * @param returnCode リターンコード
	 * @param fixedText 固定文字
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C040(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C040CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 作業項目リスト.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C040CBSMsg.KKOP_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err")) {
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C040CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 作業項目リスト.更新年月日時分秒（機器オプションサービス契約） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C040CBSMsg.UPD_DTM_BF_ERR)) 
		{
			if (!inMap.containsKey("upd_dtm_bf_err")) {
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C040CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 作業項目リスト.異動区分（機器提供サービス契約） → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C040CBSMsg.IDO_DIV_ERR)) 
		{
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK2811C040CBSMsg.IDO_DIV_ERR));
			}
		}

		return param;
	}

	/**
	 * EKK2811C070_機器オプションサービス契約開始
	 * サービスコンポーネント実行前に、CAANMsgに必要なデータをマッピングする
	 * <p>
	 * @param param リクエストパラメータ
	 * @param ekk2811a010 機器オプションサービス一意照会
	 * @param updDtmBf 更新年月日時分秒(更新前)
	 * @return S/I上り情報
	 * @throws RequestParameterException 例外時にスローされます
	 */
	public HashMap<String, Object> editInMsgEKK2811C070(
			IRequestParameterReadWrite param, 
			CAANMsg ekk2811a010,
			HashMap<String, Object> kkopKeiUpdMap,
			String updDtmBf)
			throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C070CBSMsg.class.getName());

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

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

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

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

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

		// 機器オプションサービス契約番号	kkop_svc_kei_no
		template.set(EKK2811C070CBSMsg.KKOP_SVC_KEI_NO, ekk2811a010.getString(EKK2811A010CBSMsg1List.KKOP_SVC_KEI_NO));

		// 異動区分	ido_div
		template.set(EKK2811C070CBSMsg.IDO_DIV, (String)kkopKeiUpdMap.get(JKKKkopSvcUseKeiUpdCC.KEY_IDO_DIV));
		
		// 更新年月日時分秒(更新前)	upd_dtm_bf
		template.set(EKK2811C070CBSMsg.UPD_DTM_BF, updDtmBf);

		// 同時開始有無	doji_sta_umu
		template.set(EKK2811C070CBSMsg.DOJI_STA_UMU,  "");

		// サービス開始年月日（入力）	svc_staymd_i
		template.set(EKK2811C070CBSMsg.SVC_STAYMD_I,  "");

		// サービス課金開始年月日（入力）	svc_chrg_staymd_i
		template.set(EKK2811C070CBSMsg.SVC_CHRG_STAYMD_I, "");
		
		// 上り情報を生成
		return editInMsgCmn(param, template);

	}
	
	/**
	 *<DL>
	 *<DT>処理概要:EKK2811C070_機器オプションサービス契約開始
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.12.02
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRPEKK2811C070(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// エラー情報の設定
		param = editErrorInfoEKK2811C070(param, templates, (Integer)return_code, fixedText);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}

	/**
	 * EKK2811C070_機器オプションサービス契約開始エラー情報取得
	 * @param param リクエストパラメータ
	 * @param templates SIF実行結果
	 * @param returnCode リターンコード
	 * @param fixedText 固定文字
	 * @return
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK2811C070(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
	throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK2811C070CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(fixedText);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(fixedText, inMap);
		}

		// 作業項目リスト.機器オプションサービス契約番号 → 機器オプションサービス契約番号 のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.KKOP_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey("kkop_svc_kei_no_err")) {
				inMap.put("kkop_svc_kei_no_err", template.getString(EKK2811C070CBSMsg.KKOP_SVC_KEI_NO_ERR));
			}
		}
		// 作業項目リスト.更新年月日時分秒（機器オプションサービス契約） → 更新年月日時分秒(更新前) のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.UPD_DTM_BF_ERR)) 
		{
			if (!inMap.containsKey("upd_dtm_bf_err")) {
				inMap.put("upd_dtm_bf_err", template.getString(EKK2811C070CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		// 作業項目リスト.異動区分（機器提供サービス契約） → 異動区分 のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.IDO_DIV_ERR)) 
		{
			if (!inMap.containsKey("ido_div_err")) {
				inMap.put("ido_div_err", template.getString(EKK2811C070CBSMsg.IDO_DIV_ERR));
			}
		}
		// 作業項目リスト.同時開始有無 → 同時開始有無 のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.DOJI_STA_UMU_ERR)) 
		{
			if (!inMap.containsKey("doji_sta_umu_err")) {
				inMap.put("doji_sta_umu_err", template.getString(EKK2811C070CBSMsg.DOJI_STA_UMU_ERR));
			}
		}
		// 作業項目リスト.サービス開始年月日（入力） → サービス開始年月日（入力） のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.SVC_STAYMD_I_ERR)) 
		{
			if (!inMap.containsKey("svc_staymd_i_err")) {
				inMap.put("svc_staymd_i_err", template.getString(EKK2811C070CBSMsg.SVC_STAYMD_I_ERR));
			}
		}
		// 作業項目リスト.サービス課金開始年月日（入力） → サービス課金開始年月日（入力） のエラー情報返却
		if (!template.isNull(EKK2811C070CBSMsg.SVC_CHRG_STAYMD_I_ERR)) 
		{
			if (!inMap.containsKey("svc_chrg_staymd_i_err")) {
				inMap.put("svc_chrg_staymd_i_err", template.getString(EKK2811C070CBSMsg.SVC_CHRG_STAYMD_I_ERR));
			}
		}

		return param;
	}
// ▲▲▲ ANK-3412-15-00 ADD END
}